1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
7 This file is part of GAS, the GNU Assembler.
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "safe-ctype.h"
27 #include "dw2gencfi.h"
28 #include "opcode/ppc.h"
32 #include "dwarf2dbg.h"
40 #include "coff/xcoff.h"
44 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
46 /* Tell the main code what the endianness is. */
47 extern int target_big_endian
;
49 /* Whether or not, we've set target_big_endian. */
50 static int set_target_endian
= 0;
52 /* Whether to use user friendly register names. */
53 #ifndef TARGET_REG_NAMES_P
55 #define TARGET_REG_NAMES_P TRUE
57 #define TARGET_REG_NAMES_P FALSE
61 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
64 /* #lo(value) denotes the least significant 16 bits of the indicated. */
65 #define PPC_LO(v) ((v) & 0xffff)
67 /* Split the indicated value with the msbs in bits 11-15
68 and the lsbs in bits 21-31. */
69 #define PPC_VLE_SPLIT16A(v) ((v & 0xf800) << 11) | (v & 0x7ff)
71 /* Split the indicated value with the msbs in bits 6-10
72 and the lsbs in bits 21-31. */
73 #define PPC_VLE_SPLIT16D(v) ((v & 0xf800) << 5) | (v & 0x7ff)
75 /* #lo(value) denotes the lsb 16 bits in split16a format. */
76 #define PPC_VLE_LO16A(v) PPC_VLE_SPLIT16A(PPC_LO(v))
78 /* #lo(value) denotes the lsb 16 bits in split16d format. */
79 #define PPC_VLE_LO16D(v) PPC_VLE_SPLIT16D(PPC_LO(v))
81 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
82 #define PPC_HI(v) (((v) >> 16) & 0xffff)
84 /* #lo(value) denotes the msb 16 bits in split16a format. */
85 #define PPC_VLE_HI16A(v) PPC_VLE_SPLIT16A(PPC_HI(v))
87 /* #lo(value) denotes the msb 16 bits in split16d format. */
88 #define PPC_VLE_HI16D(v) PPC_VLE_SPLIT16D(PPC_HI(v))
90 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
91 the indicated value, compensating for #lo() being treated as a
93 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
95 /* #ha(value) denotes the high adjusted value in split16a format. */
96 #define PPC_VLE_HA16A(v) PPC_VLE_SPLIT16A(PPC_HA(v))
98 /* #ha(value) denotes the high adjusted value in split16d format. */
99 #define PPC_VLE_HA16D(v) PPC_VLE_SPLIT16D(PPC_HA(v))
101 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
102 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
104 /* #highera(value) denotes bits 32 through 47 of the indicated value,
105 compensating for #lo() being treated as a signed number. */
106 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
108 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
109 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
111 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
112 compensating for #lo being treated as a signed number. */
113 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
115 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
117 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
119 static void ppc_macro (char *, const struct powerpc_macro
*);
120 static void ppc_byte (int);
122 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
123 static void ppc_tc (int);
124 static void ppc_machine (int);
128 static void ppc_comm (int);
129 static void ppc_bb (int);
130 static void ppc_bc (int);
131 static void ppc_bf (int);
132 static void ppc_biei (int);
133 static void ppc_bs (int);
134 static void ppc_eb (int);
135 static void ppc_ec (int);
136 static void ppc_ef (int);
137 static void ppc_es (int);
138 static void ppc_csect (int);
139 static void ppc_dwsect (int);
140 static void ppc_change_csect (symbolS
*, offsetT
);
141 static void ppc_function (int);
142 static void ppc_extern (int);
143 static void ppc_lglobl (int);
144 static void ppc_ref (int);
145 static void ppc_section (int);
146 static void ppc_named_section (int);
147 static void ppc_stabx (int);
148 static void ppc_rename (int);
149 static void ppc_toc (int);
150 static void ppc_xcoff_cons (int);
151 static void ppc_vbyte (int);
155 static void ppc_elf_cons (int);
156 static void ppc_elf_rdata (int);
157 static void ppc_elf_lcomm (int);
161 static void ppc_previous (int);
162 static void ppc_pdata (int);
163 static void ppc_ydata (int);
164 static void ppc_reldata (int);
165 static void ppc_rdata (int);
166 static void ppc_ualong (int);
167 static void ppc_znop (int);
168 static void ppc_pe_comm (int);
169 static void ppc_pe_section (int);
170 static void ppc_pe_function (int);
171 static void ppc_pe_tocd (int);
174 /* Generic assembler global variables which must be defined by all
178 /* This string holds the chars that always start a comment. If the
179 pre-processor is disabled, these aren't very useful. The macro
180 tc_comment_chars points to this. We use this, rather than the
181 usual comment_chars, so that we can switch for Solaris conventions. */
182 static const char ppc_solaris_comment_chars
[] = "#!";
183 static const char ppc_eabi_comment_chars
[] = "#";
185 #ifdef TARGET_SOLARIS_COMMENT
186 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
188 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
191 const char comment_chars
[] = "#";
194 /* Characters which start a comment at the beginning of a line. */
195 const char line_comment_chars
[] = "#";
197 /* Characters which may be used to separate multiple commands on a
199 const char line_separator_chars
[] = ";";
201 /* Characters which are used to indicate an exponent in a floating
203 const char EXP_CHARS
[] = "eE";
205 /* Characters which mean that a number is a floating point constant,
207 const char FLT_CHARS
[] = "dD";
209 /* Anything that can start an operand needs to be mentioned here,
210 to stop the input scrubber eating whitespace. */
211 const char ppc_symbol_chars
[] = "%[";
213 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
214 int ppc_cie_data_alignment
;
216 /* The dwarf2 minimum instruction length. */
217 int ppc_dwarf2_line_min_insn_length
;
219 /* More than this number of nops in an alignment op gets a branch
221 unsigned long nop_limit
= 4;
223 /* The type of processor we are assembling for. This is one or more
224 of the PPC_OPCODE flags defined in opcode/ppc.h. */
225 ppc_cpu_t ppc_cpu
= 0;
226 ppc_cpu_t sticky
= 0;
228 /* Flags set on encountering toc relocs. */
230 has_large_toc_reloc
= 1,
231 has_small_toc_reloc
= 2
234 /* The target specific pseudo-ops which we support. */
236 const pseudo_typeS md_pseudo_table
[] =
238 /* Pseudo-ops which must be overridden. */
239 { "byte", ppc_byte
, 0 },
242 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
243 legitimately belong in the obj-*.c file. However, XCOFF is based
244 on COFF, and is only implemented for the RS/6000. We just use
245 obj-coff.c, and add what we need here. */
246 { "comm", ppc_comm
, 0 },
247 { "lcomm", ppc_comm
, 1 },
251 { "bi", ppc_biei
, 0 },
253 { "csect", ppc_csect
, 0 },
254 { "dwsect", ppc_dwsect
, 0 },
255 { "data", ppc_section
, 'd' },
259 { "ei", ppc_biei
, 1 },
261 { "extern", ppc_extern
, 0 },
262 { "function", ppc_function
, 0 },
263 { "lglobl", ppc_lglobl
, 0 },
264 { "ref", ppc_ref
, 0 },
265 { "rename", ppc_rename
, 0 },
266 { "section", ppc_named_section
, 0 },
267 { "stabx", ppc_stabx
, 0 },
268 { "text", ppc_section
, 't' },
269 { "toc", ppc_toc
, 0 },
270 { "long", ppc_xcoff_cons
, 2 },
271 { "llong", ppc_xcoff_cons
, 3 },
272 { "word", ppc_xcoff_cons
, 1 },
273 { "short", ppc_xcoff_cons
, 1 },
274 { "vbyte", ppc_vbyte
, 0 },
278 { "llong", ppc_elf_cons
, 8 },
279 { "quad", ppc_elf_cons
, 8 },
280 { "long", ppc_elf_cons
, 4 },
281 { "word", ppc_elf_cons
, 2 },
282 { "short", ppc_elf_cons
, 2 },
283 { "rdata", ppc_elf_rdata
, 0 },
284 { "rodata", ppc_elf_rdata
, 0 },
285 { "lcomm", ppc_elf_lcomm
, 0 },
289 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
290 { "previous", ppc_previous
, 0 },
291 { "pdata", ppc_pdata
, 0 },
292 { "ydata", ppc_ydata
, 0 },
293 { "reldata", ppc_reldata
, 0 },
294 { "rdata", ppc_rdata
, 0 },
295 { "ualong", ppc_ualong
, 0 },
296 { "znop", ppc_znop
, 0 },
297 { "comm", ppc_pe_comm
, 0 },
298 { "lcomm", ppc_pe_comm
, 1 },
299 { "section", ppc_pe_section
, 0 },
300 { "function", ppc_pe_function
,0 },
301 { "tocd", ppc_pe_tocd
, 0 },
304 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
306 { "machine", ppc_machine
, 0 },
313 /* Predefined register names if -mregnames (or default for Windows NT).
314 In general, there are lots of them, in an attempt to be compatible
315 with a number of other Windows NT assemblers. */
317 /* Structure to hold information about predefined registers. */
324 /* List of registers that are pre-defined:
326 Each general register has predefined names of the form:
327 1. r<reg_num> which has the value <reg_num>.
328 2. r.<reg_num> which has the value <reg_num>.
330 Each floating point register has predefined names of the form:
331 1. f<reg_num> which has the value <reg_num>.
332 2. f.<reg_num> which has the value <reg_num>.
334 Each vector unit register has predefined names of the form:
335 1. v<reg_num> which has the value <reg_num>.
336 2. v.<reg_num> which has the value <reg_num>.
338 Each condition register has predefined names of the form:
339 1. cr<reg_num> which has the value <reg_num>.
340 2. cr.<reg_num> which has the value <reg_num>.
342 There are individual registers as well:
343 sp or r.sp has the value 1
344 rtoc or r.toc has the value 2
345 fpscr has the value 0
351 dsisr has the value 18
353 sdr1 has the value 25
354 srr0 has the value 26
355 srr1 has the value 27
357 The table is sorted. Suitable for searching by a binary search. */
359 static const struct pd_reg pre_defined_registers
[] =
361 { "cr.0", 0 }, /* Condition Registers */
381 { "dar", 19 }, /* Data Access Register */
382 { "dec", 22 }, /* Decrementer */
383 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
385 { "f.0", 0 }, /* Floating point registers */
412 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
478 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
519 /* Quantization registers used with pair single instructions. */
537 { "lr", 8 }, /* Link Register */
541 { "r.0", 0 }, /* General Purpose Registers */
574 { "r.sp", 1 }, /* Stack Pointer */
576 { "r.toc", 2 }, /* Pointer to the table of contents */
578 { "r0", 0 }, /* More general purpose registers */
611 { "rtoc", 2 }, /* Table of contents */
613 { "sdr1", 25 }, /* Storage Description Register 1 */
617 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
618 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
620 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
686 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
820 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
822 /* Given NAME, find the register number associated with that name, return
823 the integer value associated with the given name or -1 on failure. */
826 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
828 int middle
, low
, high
;
836 middle
= (low
+ high
) / 2;
837 cmp
= strcasecmp (name
, regs
[middle
].name
);
843 return regs
[middle
].value
;
851 * Summary of register_name.
853 * in: Input_line_pointer points to 1st char of operand.
855 * out: A expressionS.
856 * The operand may have been a register: in this case, X_op == O_register,
857 * X_add_number is set to the register number, and truth is returned.
858 * Input_line_pointer->(next non-blank) char after operand, or is in its
863 register_name (expressionS
*expressionP
)
870 /* Find the spelling of the operand. */
871 start
= name
= input_line_pointer
;
872 if (name
[0] == '%' && ISALPHA (name
[1]))
873 name
= ++input_line_pointer
;
875 else if (!reg_names_p
|| !ISALPHA (name
[0]))
878 c
= get_symbol_end ();
879 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
881 /* Put back the delimiting char. */
882 *input_line_pointer
= c
;
884 /* Look to see if it's in the register table. */
887 expressionP
->X_op
= O_register
;
888 expressionP
->X_add_number
= reg_number
;
890 /* Make the rest nice. */
891 expressionP
->X_add_symbol
= NULL
;
892 expressionP
->X_op_symbol
= NULL
;
896 /* Reset the line as if we had not done anything. */
897 input_line_pointer
= start
;
901 /* This function is called for each symbol seen in an expression. It
902 handles the special parsing which PowerPC assemblers are supposed
903 to use for condition codes. */
905 /* Whether to do the special parsing. */
906 static bfd_boolean cr_operand
;
908 /* Names to recognize in a condition code. This table is sorted. */
909 static const struct pd_reg cr_names
[] =
926 /* Parsing function. This returns non-zero if it recognized an
930 ppc_parse_name (const char *name
, expressionS
*exp
)
939 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
944 exp
->X_op
= O_constant
;
945 exp
->X_add_number
= val
;
950 /* Local variables. */
952 /* Whether to target xcoff64/elf64. */
953 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
955 /* Opcode hash table. */
956 static struct hash_control
*ppc_hash
;
958 /* Macro hash table. */
959 static struct hash_control
*ppc_macro_hash
;
962 /* What type of shared library support to use. */
963 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
965 /* Flags to set in the elf header. */
966 static flagword ppc_flags
= 0;
968 /* Whether this is Solaris or not. */
969 #ifdef TARGET_SOLARIS_COMMENT
970 #define SOLARIS_P TRUE
972 #define SOLARIS_P FALSE
975 static bfd_boolean msolaris
= SOLARIS_P
;
980 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
981 using a bunch of different sections. These assembler sections,
982 however, are all encompassed within the .text or .data sections of
983 the final output file. We handle this by using different
984 subsegments within these main segments. */
986 /* Next subsegment to allocate within the .text segment. */
987 static subsegT ppc_text_subsegment
= 2;
989 /* Linked list of csects in the text section. */
990 static symbolS
*ppc_text_csects
;
992 /* Next subsegment to allocate within the .data segment. */
993 static subsegT ppc_data_subsegment
= 2;
995 /* Linked list of csects in the data section. */
996 static symbolS
*ppc_data_csects
;
998 /* The current csect. */
999 static symbolS
*ppc_current_csect
;
1001 /* The RS/6000 assembler uses a TOC which holds addresses of functions
1002 and variables. Symbols are put in the TOC with the .tc pseudo-op.
1003 A special relocation is used when accessing TOC entries. We handle
1004 the TOC as a subsegment within the .data segment. We set it up if
1005 we see a .toc pseudo-op, and save the csect symbol here. */
1006 static symbolS
*ppc_toc_csect
;
1008 /* The first frag in the TOC subsegment. */
1009 static fragS
*ppc_toc_frag
;
1011 /* The first frag in the first subsegment after the TOC in the .data
1012 segment. NULL if there are no subsegments after the TOC. */
1013 static fragS
*ppc_after_toc_frag
;
1015 /* The current static block. */
1016 static symbolS
*ppc_current_block
;
1018 /* The COFF debugging section; set by md_begin. This is not the
1019 .debug section, but is instead the secret BFD section which will
1020 cause BFD to set the section number of a symbol to N_DEBUG. */
1021 static asection
*ppc_coff_debug_section
;
1023 /* Structure to set the length field of the dwarf sections. */
1024 struct dw_subsection
{
1025 /* Subsections are simply linked. */
1026 struct dw_subsection
*link
;
1028 /* The subsection number. */
1031 /* Expression to compute the length of the section. */
1032 expressionS end_exp
;
1035 static struct dw_section
{
1036 /* Corresponding section. */
1039 /* Simply linked list of subsections with a label. */
1040 struct dw_subsection
*list_subseg
;
1042 /* The anonymous subsection. */
1043 struct dw_subsection
*anon_subseg
;
1044 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1045 #endif /* OBJ_XCOFF */
1049 /* Various sections that we need for PE coff support. */
1050 static segT ydata_section
;
1051 static segT pdata_section
;
1052 static segT reldata_section
;
1053 static segT rdata_section
;
1054 static segT tocdata_section
;
1056 /* The current section and the previous section. See ppc_previous. */
1057 static segT ppc_previous_section
;
1058 static segT ppc_current_section
;
1063 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1064 #define PPC_APUINFO_ISEL 0x40
1065 #define PPC_APUINFO_PMR 0x41
1066 #define PPC_APUINFO_RFMCI 0x42
1067 #define PPC_APUINFO_CACHELCK 0x43
1068 #define PPC_APUINFO_SPE 0x100
1069 #define PPC_APUINFO_EFS 0x101
1070 #define PPC_APUINFO_BRLOCK 0x102
1071 #define PPC_APUINFO_VLE 0x104
1074 * We keep a list of APUinfo
1076 unsigned long *ppc_apuinfo_list
;
1077 unsigned int ppc_apuinfo_num
;
1078 unsigned int ppc_apuinfo_num_alloc
;
1079 #endif /* OBJ_ELF */
1082 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1084 const char *const md_shortopts
= "um:";
1086 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1087 const struct option md_longopts
[] = {
1088 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1089 {NULL
, no_argument
, NULL
, 0}
1091 const size_t md_longopts_size
= sizeof (md_longopts
);
1094 md_parse_option (int c
, char *arg
)
1101 /* -u means that any undefined symbols should be treated as
1102 external, which is the default for gas anyhow. */
1107 /* Solaris as takes -le (presumably for little endian). For completeness
1108 sake, recognize -be also. */
1109 if (strcmp (arg
, "e") == 0)
1111 target_big_endian
= 0;
1112 set_target_endian
= 1;
1113 if (ppc_cpu
& PPC_OPCODE_VLE
)
1114 as_bad (_("the use of -mvle requires big endian."));
1122 if (strcmp (arg
, "e") == 0)
1124 target_big_endian
= 1;
1125 set_target_endian
= 1;
1133 /* Recognize -K PIC. */
1134 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1137 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1145 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1147 if (strcmp (arg
, "64") == 0)
1151 if (ppc_cpu
& PPC_OPCODE_VLE
)
1152 as_bad (_("the use of -mvle requires -a32."));
1154 as_fatal (_("%s unsupported"), "-a64");
1157 else if (strcmp (arg
, "32") == 0)
1164 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1168 if (strcmp (arg
, "vle") == 0)
1170 if (set_target_endian
&& target_big_endian
== 0)
1171 as_bad (_("the use of -mvle requires big endian."));
1173 as_bad (_("the use of -mvle requires -a32."));
1177 else if (strcmp (arg
, "regnames") == 0)
1180 else if (strcmp (arg
, "no-regnames") == 0)
1181 reg_names_p
= FALSE
;
1184 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1185 that require relocation. */
1186 else if (strcmp (arg
, "relocatable") == 0)
1188 shlib
= SHLIB_MRELOCATABLE
;
1189 ppc_flags
|= EF_PPC_RELOCATABLE
;
1192 else if (strcmp (arg
, "relocatable-lib") == 0)
1194 shlib
= SHLIB_MRELOCATABLE
;
1195 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1198 /* -memb, set embedded bit. */
1199 else if (strcmp (arg
, "emb") == 0)
1200 ppc_flags
|= EF_PPC_EMB
;
1202 /* -mlittle/-mbig set the endianness. */
1203 else if (strcmp (arg
, "little") == 0
1204 || strcmp (arg
, "little-endian") == 0)
1206 target_big_endian
= 0;
1207 set_target_endian
= 1;
1208 if (ppc_cpu
& PPC_OPCODE_VLE
)
1209 as_bad (_("the use of -mvle requires big endian."));
1212 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1214 target_big_endian
= 1;
1215 set_target_endian
= 1;
1218 else if (strcmp (arg
, "solaris") == 0)
1221 ppc_comment_chars
= ppc_solaris_comment_chars
;
1224 else if (strcmp (arg
, "no-solaris") == 0)
1227 ppc_comment_chars
= ppc_eabi_comment_chars
;
1232 as_bad (_("invalid switch -m%s"), arg
);
1238 /* -V: SVR4 argument to print version ID. */
1240 print_version_id ();
1243 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1244 should be emitted or not. FIXME: Not implemented. */
1248 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1249 rather than .stabs.excl, which is ignored by the linker.
1250 FIXME: Not implemented. */
1261 nop_limit
= strtoul (optarg
, &end
, 0);
1263 as_bad (_("--nops needs a numeric argument"));
1275 md_show_usage (FILE *stream
)
1277 fprintf (stream
, _("\
1279 -a32 generate ELF32/XCOFF32\n\
1280 -a64 generate ELF64/XCOFF64\n\
1282 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1283 -mpwr generate code for POWER (RIOS1)\n\
1284 -m601 generate code for PowerPC 601\n\
1285 -mppc, -mppc32, -m603, -m604\n\
1286 generate code for PowerPC 603/604\n\
1287 -m403 generate code for PowerPC 403\n\
1288 -m405 generate code for PowerPC 405\n\
1289 -m440 generate code for PowerPC 440\n\
1290 -m464 generate code for PowerPC 464\n\
1291 -m476 generate code for PowerPC 476\n\
1292 -m7400, -m7410, -m7450, -m7455\n\
1293 generate code for PowerPC 7400/7410/7450/7455\n\
1294 -m750cl generate code for PowerPC 750cl\n"));
1295 fprintf (stream
, _("\
1296 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1297 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1298 -mbooke generate code for 32-bit PowerPC BookE\n\
1299 -ma2 generate code for A2 architecture\n\
1300 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1301 -mpower5, -mpwr5, -mpwr5x\n\
1302 generate code for Power5 architecture\n\
1303 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1304 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1305 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1306 -mcell generate code for Cell Broadband Engine architecture\n\
1307 -mcom generate code Power/PowerPC common instructions\n\
1308 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1309 fprintf (stream
, _("\
1310 -maltivec generate code for AltiVec\n\
1311 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1312 -mhtm generate code for Hardware Transactional Memory\n\
1313 -me300 generate code for PowerPC e300 family\n\
1314 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1315 -me500mc, generate code for Freescale e500mc core complex\n\
1316 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1317 -me5500, generate code for Freescale e5500 core complex\n\
1318 -me6500, generate code for Freescale e6500 core complex\n\
1319 -mspe generate code for Motorola SPE instructions\n\
1320 -mvle generate code for Freescale VLE instructions\n\
1321 -mtitan generate code for AppliedMicro Titan core complex\n\
1322 -mregnames Allow symbolic names for registers\n\
1323 -mno-regnames Do not allow symbolic names for registers\n"));
1325 fprintf (stream
, _("\
1326 -mrelocatable support for GCC's -mrelocatble option\n\
1327 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1328 -memb set PPC_EMB bit in ELF flags\n\
1329 -mlittle, -mlittle-endian, -le\n\
1330 generate code for a little endian machine\n\
1331 -mbig, -mbig-endian, -be\n\
1332 generate code for a big endian machine\n\
1333 -msolaris generate code for Solaris\n\
1334 -mno-solaris do not generate code for Solaris\n\
1335 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1336 -V print assembler version number\n\
1337 -Qy, -Qn ignored\n"));
1339 fprintf (stream
, _("\
1340 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1343 /* Set ppc_cpu if it is not already set. */
1348 const char *default_os
= TARGET_OS
;
1349 const char *default_cpu
= TARGET_CPU
;
1351 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1354 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1355 else if (strncmp (default_os
, "aix", 3) == 0
1356 && default_os
[3] >= '4' && default_os
[3] <= '9')
1357 ppc_cpu
|= PPC_OPCODE_COMMON
;
1358 else if (strncmp (default_os
, "aix3", 4) == 0)
1359 ppc_cpu
|= PPC_OPCODE_POWER
;
1360 else if (strcmp (default_cpu
, "rs6000") == 0)
1361 ppc_cpu
|= PPC_OPCODE_POWER
;
1362 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1363 ppc_cpu
|= PPC_OPCODE_PPC
;
1365 as_fatal (_("unknown default cpu = %s, os = %s"),
1366 default_cpu
, default_os
);
1370 /* Figure out the BFD architecture to use. This function and ppc_mach
1371 are called well before md_begin, when the output file is opened. */
1373 enum bfd_architecture
1376 const char *default_cpu
= TARGET_CPU
;
1379 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1380 return bfd_arch_powerpc
;
1381 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1382 return bfd_arch_powerpc
;
1383 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1384 return bfd_arch_rs6000
;
1385 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1387 if (strcmp (default_cpu
, "rs6000") == 0)
1388 return bfd_arch_rs6000
;
1389 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1390 return bfd_arch_powerpc
;
1393 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1394 return bfd_arch_unknown
;
1401 return bfd_mach_ppc64
;
1402 else if (ppc_arch () == bfd_arch_rs6000
)
1403 return bfd_mach_rs6k
;
1404 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1405 return bfd_mach_ppc_titan
;
1406 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1407 return bfd_mach_ppc_vle
;
1409 return bfd_mach_ppc
;
1413 ppc_target_format (void)
1417 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1419 return "xcoff-powermac";
1422 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1424 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1430 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1431 # elif defined (TE_VXWORKS)
1432 return "elf32-powerpc-vxworks";
1434 return (target_big_endian
1435 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1436 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1441 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1442 Return TRUE if there's a problem, otherwise FALSE. */
1445 insn_validate (const struct powerpc_opcode
*op
)
1447 const unsigned char *o
;
1448 unsigned long omask
= op
->mask
;
1450 /* The mask had better not trim off opcode bits. */
1451 if ((op
->opcode
& omask
) != op
->opcode
)
1453 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1457 /* The operands must not overlap the opcode or each other. */
1458 for (o
= op
->operands
; *o
; ++o
)
1460 if (*o
>= num_powerpc_operands
)
1462 as_bad (_("operand index error for %s"), op
->name
);
1467 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1468 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1472 if (operand
->shift
>= 0)
1473 mask
= operand
->bitm
<< operand
->shift
;
1475 mask
= operand
->bitm
>> -operand
->shift
;
1478 as_bad (_("operand %d overlap in %s"),
1479 (int) (o
- op
->operands
), op
->name
);
1489 /* Insert opcodes and macros into hash tables. Called at startup and
1490 for .machine pseudo. */
1493 ppc_setup_opcodes (void)
1495 const struct powerpc_opcode
*op
;
1496 const struct powerpc_opcode
*op_end
;
1497 const struct powerpc_macro
*macro
;
1498 const struct powerpc_macro
*macro_end
;
1499 bfd_boolean bad_insn
= FALSE
;
1501 if (ppc_hash
!= NULL
)
1502 hash_die (ppc_hash
);
1503 if (ppc_macro_hash
!= NULL
)
1504 hash_die (ppc_macro_hash
);
1506 /* Insert the opcodes into a hash table. */
1507 ppc_hash
= hash_new ();
1509 if (ENABLE_CHECKING
)
1513 /* An index into powerpc_operands is stored in struct fix
1514 fx_pcrel_adjust which is 8 bits wide. */
1515 gas_assert (num_powerpc_operands
< 256);
1517 /* Check operand masks. Code here and in the disassembler assumes
1518 all the 1's in the mask are contiguous. */
1519 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1521 unsigned long mask
= powerpc_operands
[i
].bitm
;
1522 unsigned long right_bit
;
1525 right_bit
= mask
& -mask
;
1527 right_bit
= mask
& -mask
;
1528 if (mask
!= right_bit
)
1530 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1533 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1534 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1535 sizeof (powerpc_operands
[0])) == 0)
1537 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1544 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1545 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1547 if (ENABLE_CHECKING
)
1549 if (op
!= powerpc_opcodes
)
1551 int old_opcode
= PPC_OP (op
[-1].opcode
);
1552 int new_opcode
= PPC_OP (op
[0].opcode
);
1554 #ifdef PRINT_OPCODE_TABLE
1555 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1556 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1557 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1558 (unsigned long long) op
->flags
);
1561 /* The major opcodes had better be sorted. Code in the
1562 disassembler assumes the insns are sorted according to
1564 if (new_opcode
< old_opcode
)
1566 as_bad (_("major opcode is not sorted for %s"),
1571 bad_insn
|= insn_validate (op
);
1574 if ((ppc_cpu
& op
->flags
) != 0
1575 && !(ppc_cpu
& op
->deprecated
))
1579 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1582 as_bad (_("duplicate instruction %s"),
1589 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1590 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1591 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1593 op_end
= vle_opcodes
+ vle_num_opcodes
;
1594 for (op
= vle_opcodes
; op
< op_end
; op
++)
1596 if (ENABLE_CHECKING
)
1598 if (op
!= vle_opcodes
)
1600 unsigned old_seg
, new_seg
;
1602 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1603 old_seg
= VLE_OP_TO_SEG (old_seg
);
1604 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1605 new_seg
= VLE_OP_TO_SEG (new_seg
);
1607 #ifdef PRINT_OPCODE_TABLE
1608 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1609 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1610 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1611 (unsigned long long) op
->flags
);
1613 /* The major opcodes had better be sorted. Code in the
1614 disassembler assumes the insns are sorted according to
1616 if (new_seg
< old_seg
)
1618 as_bad (_("major opcode is not sorted for %s"),
1624 bad_insn
|= insn_validate (op
);
1627 if ((ppc_cpu
& op
->flags
) != 0
1628 && !(ppc_cpu
& op
->deprecated
))
1632 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1635 as_bad (_("duplicate instruction %s"),
1642 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1643 for (op
= vle_opcodes
; op
< op_end
; op
++)
1644 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1646 /* Insert the macros into a hash table. */
1647 ppc_macro_hash
= hash_new ();
1649 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1650 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1652 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1656 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1657 if (retval
!= (const char *) NULL
)
1659 as_bad (_("duplicate macro %s"), macro
->name
);
1669 /* This function is called when the assembler starts up. It is called
1670 after the options have been parsed and the output file has been
1678 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1679 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1682 /* Set the ELF flags if desired. */
1683 if (ppc_flags
&& !msolaris
)
1684 bfd_set_private_flags (stdoutput
, ppc_flags
);
1687 ppc_setup_opcodes ();
1689 /* Tell the main code what the endianness is if it is not overridden
1691 if (!set_target_endian
)
1693 set_target_endian
= 1;
1694 target_big_endian
= PPC_BIG_ENDIAN
;
1698 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1700 /* Create dummy symbols to serve as initial csects. This forces the
1701 text csects to precede the data csects. These symbols will not
1703 ppc_text_csects
= symbol_make ("dummy\001");
1704 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1705 ppc_data_csects
= symbol_make ("dummy\001");
1706 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1711 ppc_current_section
= text_section
;
1712 ppc_previous_section
= 0;
1721 if (ppc_apuinfo_list
== NULL
)
1724 /* Ok, so write the section info out. We have this layout:
1728 0 8 length of "APUinfo\0"
1729 4 (n*4) number of APU's (4 bytes each)
1732 20 APU#1 first APU's info
1733 24 APU#2 second APU's info
1738 asection
*seg
= now_seg
;
1739 subsegT subseg
= now_subseg
;
1740 asection
*apuinfo_secp
= (asection
*) NULL
;
1743 /* Create the .PPC.EMB.apuinfo section. */
1744 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1745 bfd_set_section_flags (stdoutput
,
1747 SEC_HAS_CONTENTS
| SEC_READONLY
);
1750 md_number_to_chars (p
, (valueT
) 8, 4);
1753 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1756 md_number_to_chars (p
, (valueT
) 2, 4);
1759 strcpy (p
, "APUinfo");
1761 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1764 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1767 frag_align (2, 0, 0);
1769 /* We probably can't restore the current segment, for there likely
1772 subseg_set (seg
, subseg
);
1777 /* Insert an operand value into an instruction. */
1779 static unsigned long
1780 ppc_insert_operand (unsigned long insn
,
1781 const struct powerpc_operand
*operand
,
1787 long min
, max
, right
;
1789 max
= operand
->bitm
;
1793 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1795 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1796 max
= (max
>> 1) & -right
;
1797 min
= ~max
& -right
;
1800 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1803 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1812 /* Some people write constants with the sign extension done by
1813 hand but only up to 32 bits. This shouldn't really be valid,
1814 but, to permit this code to assemble on a 64-bit host, we
1815 sign extend the 32-bit value to 64 bits if so doing makes the
1818 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1819 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1820 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1821 val
= val
- 0x80000000 - 0x80000000;
1823 /* Similarly, people write expressions like ~(1<<15), and expect
1824 this to be OK for a 32-bit unsigned value. */
1826 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1827 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1828 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1829 val
= val
+ 0x80000000 + 0x80000000;
1833 || (val
& (right
- 1)) != 0)
1834 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1837 if (operand
->insert
)
1842 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1843 if (errmsg
!= (const char *) NULL
)
1844 as_bad_where (file
, line
, "%s", errmsg
);
1846 else if (operand
->shift
>= 0)
1847 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1849 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1856 /* Parse @got, etc. and return the desired relocation. */
1857 static bfd_reloc_code_real_type
1858 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1862 unsigned int length
: 8;
1863 unsigned int valid32
: 1;
1864 unsigned int valid64
: 1;
1873 const struct map_bfd
*ptr
;
1875 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1876 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1877 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1879 static const struct map_bfd mapping
[] = {
1880 MAP ("l", BFD_RELOC_LO16
),
1881 MAP ("h", BFD_RELOC_HI16
),
1882 MAP ("ha", BFD_RELOC_HI16_S
),
1883 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1884 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1885 MAP ("got", BFD_RELOC_16_GOTOFF
),
1886 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1887 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1888 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1889 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1890 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1891 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1892 MAP ("copy", BFD_RELOC_PPC_COPY
),
1893 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1894 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1895 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1896 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1897 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1898 MAP ("tls", BFD_RELOC_PPC_TLS
),
1899 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1900 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1901 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1902 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1903 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1904 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1905 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1906 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1907 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1908 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1909 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1910 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1911 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1912 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1913 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1914 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1915 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1916 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1917 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1918 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1919 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1920 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1921 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1922 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1923 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1924 MAP32 ("fixup", BFD_RELOC_CTOR
),
1925 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1926 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1927 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1928 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1929 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1930 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1931 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1932 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1933 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1934 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1935 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1936 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1937 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1938 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1939 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1940 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1941 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1942 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1943 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1944 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1945 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1946 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1947 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1948 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1949 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1950 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1951 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1952 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1953 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1954 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1955 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1956 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1957 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1958 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1959 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1960 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1961 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1962 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1963 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1964 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1965 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1966 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1967 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1968 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1969 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1973 return BFD_RELOC_UNUSED
;
1975 for (ch
= *str
, str2
= ident
;
1976 (str2
< ident
+ sizeof (ident
) - 1
1977 && (ISALNUM (ch
) || ch
== '@'));
1980 *str2
++ = TOLOWER (ch
);
1987 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1988 if (ch
== ptr
->string
[0]
1989 && len
== ptr
->length
1990 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1991 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1993 int reloc
= ptr
->reloc
;
1995 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1999 case BFD_RELOC_16_GOTOFF
:
2000 case BFD_RELOC_LO16_GOTOFF
:
2001 case BFD_RELOC_HI16_GOTOFF
:
2002 case BFD_RELOC_HI16_S_GOTOFF
:
2003 as_warn (_("identifier+constant@got means "
2004 "identifier@got+constant"));
2007 case BFD_RELOC_PPC_GOT_TLSGD16
:
2008 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2009 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2010 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2011 case BFD_RELOC_PPC_GOT_TLSLD16
:
2012 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2013 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2014 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2015 case BFD_RELOC_PPC_GOT_DTPREL16
:
2016 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2017 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2018 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2019 case BFD_RELOC_PPC_GOT_TPREL16
:
2020 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2021 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2022 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2023 as_bad (_("symbol+offset not supported for got tls"));
2028 /* Now check for identifier@suffix+constant. */
2029 if (*str
== '-' || *str
== '+')
2031 char *orig_line
= input_line_pointer
;
2032 expressionS new_exp
;
2034 input_line_pointer
= str
;
2035 expression (&new_exp
);
2036 if (new_exp
.X_op
== O_constant
)
2038 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2039 str
= input_line_pointer
;
2042 if (&input_line_pointer
!= str_p
)
2043 input_line_pointer
= orig_line
;
2047 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2048 && exp_p
->X_op
== O_symbol
2049 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2051 /* Change the symbol so that the dummy .TOC. symbol can be
2052 omitted from the object file. */
2053 exp_p
->X_add_symbol
= &abs_symbol
;
2056 return (bfd_reloc_code_real_type
) reloc
;
2059 return BFD_RELOC_UNUSED
;
2062 /* Like normal .long/.short/.word, except support @got, etc.
2063 Clobbers input_line_pointer, checks end-of-line. */
2065 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2068 bfd_reloc_code_real_type reloc
;
2070 if (is_it_end_of_statement ())
2072 demand_empty_rest_of_line ();
2079 if (exp
.X_op
== O_symbol
2080 && *input_line_pointer
== '@'
2081 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2082 &exp
)) != BFD_RELOC_UNUSED
)
2084 reloc_howto_type
*reloc_howto
;
2087 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2088 size
= bfd_get_reloc_size (reloc_howto
);
2092 as_bad (_("%s relocations do not fit in %d bytes\n"),
2093 reloc_howto
->name
, nbytes
);
2100 p
= frag_more (nbytes
);
2101 memset (p
, 0, nbytes
);
2103 if (target_big_endian
)
2104 offset
= nbytes
- size
;
2105 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2110 emit_expr (&exp
, (unsigned int) nbytes
);
2112 while (*input_line_pointer
++ == ',');
2114 /* Put terminator back into stream. */
2115 input_line_pointer
--;
2116 demand_empty_rest_of_line ();
2119 /* Solaris pseduo op to change to the .rodata section. */
2121 ppc_elf_rdata (int xxx
)
2123 char *save_line
= input_line_pointer
;
2124 static char section
[] = ".rodata\n";
2126 /* Just pretend this is .section .rodata */
2127 input_line_pointer
= section
;
2128 obj_elf_section (xxx
);
2130 input_line_pointer
= save_line
;
2133 /* Pseudo op to make file scope bss items. */
2135 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2148 name
= input_line_pointer
;
2149 c
= get_symbol_end ();
2151 /* just after name is now '\0'. */
2152 p
= input_line_pointer
;
2155 if (*input_line_pointer
!= ',')
2157 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2158 ignore_rest_of_line ();
2162 input_line_pointer
++; /* skip ',' */
2163 if ((size
= get_absolute_expression ()) < 0)
2165 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2166 ignore_rest_of_line ();
2170 /* The third argument to .lcomm is the alignment. */
2171 if (*input_line_pointer
!= ',')
2175 ++input_line_pointer
;
2176 align
= get_absolute_expression ();
2179 as_warn (_("ignoring bad alignment"));
2185 symbolP
= symbol_find_or_make (name
);
2188 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2190 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2191 S_GET_NAME (symbolP
));
2192 ignore_rest_of_line ();
2196 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2198 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2199 S_GET_NAME (symbolP
),
2200 (long) S_GET_VALUE (symbolP
),
2203 ignore_rest_of_line ();
2209 old_subsec
= now_subseg
;
2212 /* Convert to a power of 2 alignment. */
2213 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2216 as_bad (_("common alignment not a power of 2"));
2217 ignore_rest_of_line ();
2224 record_alignment (bss_section
, align2
);
2225 subseg_set (bss_section
, 0);
2227 frag_align (align2
, 0, 0);
2228 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2229 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2230 symbol_set_frag (symbolP
, frag_now
);
2231 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2234 S_SET_SIZE (symbolP
, size
);
2235 S_SET_SEGMENT (symbolP
, bss_section
);
2236 subseg_set (old_sec
, old_subsec
);
2237 demand_empty_rest_of_line ();
2240 /* Validate any relocations emitted for -mrelocatable, possibly adding
2241 fixups for word relocations in writable segments, so we can adjust
2244 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2246 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2255 case SHLIB_MRELOCATABLE
:
2256 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2257 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2258 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2259 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2260 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2261 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2262 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2263 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2264 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2265 && (seg
->flags
& SEC_LOAD
) != 0
2266 && strcmp (segment_name (seg
), ".got2") != 0
2267 && strcmp (segment_name (seg
), ".dtors") != 0
2268 && strcmp (segment_name (seg
), ".ctors") != 0
2269 && strcmp (segment_name (seg
), ".fixup") != 0
2270 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2271 && strcmp (segment_name (seg
), ".eh_frame") != 0
2272 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2274 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2275 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2277 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2278 _("relocation cannot be done when using -mrelocatable"));
2285 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2286 function descriptor sym if the corresponding code sym is used. */
2289 ppc_frob_file_before_adjust (void)
2297 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2304 name
= S_GET_NAME (symp
);
2308 if (! S_IS_WEAK (symp
)
2309 || S_IS_DEFINED (symp
))
2312 len
= strlen (name
) + 1;
2313 dotname
= xmalloc (len
+ 1);
2315 memcpy (dotname
+ 1, name
, len
);
2316 dotsym
= symbol_find_noref (dotname
, 1);
2318 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2319 || symbol_used_in_reloc_p (dotsym
)))
2320 symbol_mark_used (symp
);
2324 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2326 && toc_reloc_types
!= has_large_toc_reloc
2327 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2328 as_warn (_("TOC section size exceeds 64k"));
2331 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2332 emitted. Other uses of .TOC. will cause the symbol to be marked
2333 with BSF_KEEP in md_apply_fix. */
2336 ppc_elf_adjust_symtab (void)
2341 symp
= symbol_find (".TOC.");
2344 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2345 if ((bsym
->flags
& BSF_KEEP
) == 0)
2346 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2352 #endif /* OBJ_ELF */
2357 * Summary of parse_toc_entry.
2359 * in: Input_line_pointer points to the '[' in one of:
2361 * [toc] [tocv] [toc32] [toc64]
2363 * Anything else is an error of one kind or another.
2366 * return value: success or failure
2367 * toc_kind: kind of toc reference
2368 * input_line_pointer:
2369 * success: first char after the ']'
2370 * failure: unchanged
2374 * [toc] - rv == success, toc_kind = default_toc
2375 * [tocv] - rv == success, toc_kind = data_in_toc
2376 * [toc32] - rv == success, toc_kind = must_be_32
2377 * [toc64] - rv == success, toc_kind = must_be_64
2381 enum toc_size_qualifier
2383 default_toc
, /* The toc cell constructed should be the system default size */
2384 data_in_toc
, /* This is a direct reference to a toc cell */
2385 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2386 must_be_64
/* The toc cell constructed must be 64 bits wide */
2390 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2395 enum toc_size_qualifier t
;
2397 /* Save the input_line_pointer. */
2398 start
= input_line_pointer
;
2400 /* Skip over the '[' , and whitespace. */
2401 ++input_line_pointer
;
2404 /* Find the spelling of the operand. */
2405 toc_spec
= input_line_pointer
;
2406 c
= get_symbol_end ();
2408 if (strcmp (toc_spec
, "toc") == 0)
2412 else if (strcmp (toc_spec
, "tocv") == 0)
2416 else if (strcmp (toc_spec
, "toc32") == 0)
2420 else if (strcmp (toc_spec
, "toc64") == 0)
2426 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2427 *input_line_pointer
= c
;
2428 input_line_pointer
= start
;
2432 /* Now find the ']'. */
2433 *input_line_pointer
= c
;
2435 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2436 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2440 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2441 input_line_pointer
= start
;
2450 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2451 /* See whether a symbol is in the TOC section. */
2454 ppc_is_toc_sym (symbolS
*sym
)
2457 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
2460 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2462 return strcmp (sname
, ".toc") == 0;
2464 return strcmp (sname
, ".got") == 0;
2467 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2471 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2473 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2477 /* Check we don't already exist. */
2478 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2479 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2482 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2484 if (ppc_apuinfo_num_alloc
== 0)
2486 ppc_apuinfo_num_alloc
= 4;
2487 ppc_apuinfo_list
= (unsigned long *)
2488 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2492 ppc_apuinfo_num_alloc
+= 4;
2493 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2494 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2497 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2503 /* We need to keep a list of fixups. We can't simply generate them as
2504 we go, because that would require us to first create the frag, and
2505 that would screw up references to ``.''. */
2511 bfd_reloc_code_real_type reloc
;
2514 #define MAX_INSN_FIXUPS (5)
2517 #define E_OR2I_INSN 0x7000C000
2518 #define E_AND2I_DOT_INSN 0x7000C800
2519 #define E_OR2IS_INSN 0x7000D000
2520 #define E_LIS_INSN 0x7000E000
2521 #define E_AND2IS_DOT_INSN 0x7000E800
2524 #define E_ADD2I_DOT_INSN 0x70008800
2525 #define E_ADD2IS_INSN 0x70009000
2526 #define E_CMP16I_INSN 0x70009800
2527 #define E_MULL2I_INSN 0x7000A000
2528 #define E_CMPL16I_INSN 0x7000A800
2529 #define E_CMPH16I_INSN 0x7000B000
2530 #define E_CMPHL16I_INSN 0x7000B800
2532 /* This routine is called for each instruction to be assembled. */
2535 md_assemble (char *str
)
2538 const struct powerpc_opcode
*opcode
;
2540 const unsigned char *opindex_ptr
;
2544 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2549 unsigned int insn_length
;
2551 /* Get the opcode. */
2552 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2557 /* Look up the opcode in the hash table. */
2558 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2559 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2561 const struct powerpc_macro
*macro
;
2563 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2564 if (macro
== (const struct powerpc_macro
*) NULL
)
2565 as_bad (_("unrecognized opcode: `%s'"), str
);
2567 ppc_macro (s
, macro
);
2572 insn
= opcode
->opcode
;
2575 while (ISSPACE (*str
))
2578 /* PowerPC operands are just expressions. The only real issue is
2579 that a few operand types are optional. All cases which might use
2580 an optional operand separate the operands only with commas (in some
2581 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2582 have optional operands). Most instructions with optional operands
2583 have only one. Those that have more than one optional operand can
2584 take either all their operands or none. So, before we start seriously
2585 parsing the operands, we check to see if we have optional operands,
2586 and if we do, we count the number of commas to see which operands
2587 have been omitted. */
2589 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2591 const struct powerpc_operand
*operand
;
2593 operand
= &powerpc_operands
[*opindex_ptr
];
2594 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2596 unsigned int opcount
;
2597 unsigned int num_operands_expected
;
2599 /* There is an optional operand. Count the number of
2600 commas in the input line. */
2607 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2614 /* Compute the number of expected operands.
2615 Do not count fake operands. */
2616 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2617 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2618 ++ num_operands_expected
;
2620 /* If there are fewer operands in the line then are called
2621 for by the instruction, we want to skip the optional
2623 if (opcount
< num_operands_expected
)
2630 /* Gather the operands. */
2634 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2636 const struct powerpc_operand
*operand
;
2642 if (next_opindex
== 0)
2643 operand
= &powerpc_operands
[*opindex_ptr
];
2646 operand
= &powerpc_operands
[next_opindex
];
2651 /* If this is a fake operand, then we do not expect anything
2653 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2655 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2656 if (errmsg
!= (const char *) NULL
)
2657 as_bad ("%s", errmsg
);
2661 /* If this is an optional operand, and we are skipping it, just
2663 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2666 if (operand
->insert
)
2668 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2669 if (errmsg
!= (const char *) NULL
)
2670 as_bad ("%s", errmsg
);
2672 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2673 next_opindex
= *opindex_ptr
+ 1;
2677 /* Gather the operand. */
2678 hold
= input_line_pointer
;
2679 input_line_pointer
= str
;
2682 if (*input_line_pointer
== '[')
2684 /* We are expecting something like the second argument here:
2686 * lwz r4,[toc].GS.0.static_int(rtoc)
2687 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2688 * The argument following the `]' must be a symbol name, and the
2689 * register must be the toc register: 'rtoc' or '2'
2691 * The effect is to 0 as the displacement field
2692 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2693 * the appropriate variation) reloc against it based on the symbol.
2694 * The linker will build the toc, and insert the resolved toc offset.
2697 * o The size of the toc entry is currently assumed to be
2698 * 32 bits. This should not be assumed to be a hard coded
2700 * o In an effort to cope with a change from 32 to 64 bits,
2701 * there are also toc entries that are specified to be
2702 * either 32 or 64 bits:
2703 * lwz r4,[toc32].GS.0.static_int(rtoc)
2704 * lwz r4,[toc64].GS.0.static_int(rtoc)
2705 * These demand toc entries of the specified size, and the
2706 * instruction probably requires it.
2710 enum toc_size_qualifier toc_kind
;
2711 bfd_reloc_code_real_type toc_reloc
;
2713 /* Go parse off the [tocXX] part. */
2714 valid_toc
= parse_toc_entry (&toc_kind
);
2718 ignore_rest_of_line ();
2722 /* Now get the symbol following the ']'. */
2728 /* In this case, we may not have seen the symbol yet,
2729 since it is allowed to appear on a .extern or .globl
2730 or just be a label in the .data section. */
2731 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2734 /* 1. The symbol must be defined and either in the toc
2735 section, or a global.
2736 2. The reloc generated must have the TOCDEFN flag set
2737 in upper bit mess of the reloc type.
2738 FIXME: It's a little confusing what the tocv
2739 qualifier can be used for. At the very least, I've
2740 seen three uses, only one of which I'm sure I can
2742 if (ex
.X_op
== O_symbol
)
2744 gas_assert (ex
.X_add_symbol
!= NULL
);
2745 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2748 as_bad (_("[tocv] symbol is not a toc symbol"));
2752 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2755 /* FIXME: these next two specifically specify 32/64 bit
2756 toc entries. We don't support them today. Is this
2757 the right way to say that? */
2758 toc_reloc
= BFD_RELOC_UNUSED
;
2759 as_bad (_("unimplemented toc32 expression modifier"));
2762 /* FIXME: see above. */
2763 toc_reloc
= BFD_RELOC_UNUSED
;
2764 as_bad (_("unimplemented toc64 expression modifier"));
2768 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2774 /* We need to generate a fixup for this expression. */
2775 if (fc
>= MAX_INSN_FIXUPS
)
2776 as_fatal (_("too many fixups"));
2778 fixups
[fc
].reloc
= toc_reloc
;
2779 fixups
[fc
].exp
= ex
;
2780 fixups
[fc
].opindex
= *opindex_ptr
;
2783 /* Ok. We've set up the fixup for the instruction. Now make it
2784 look like the constant 0 was found here. */
2786 ex
.X_op
= O_constant
;
2787 ex
.X_add_number
= 0;
2788 ex
.X_add_symbol
= NULL
;
2789 ex
.X_op_symbol
= NULL
;
2796 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2797 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2798 || !register_name (&ex
))
2800 char save_lex
= lex_type
['%'];
2802 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2803 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2806 lex_type
['%'] |= LEX_BEGIN_NAME
;
2810 lex_type
['%'] = save_lex
;
2814 str
= input_line_pointer
;
2815 input_line_pointer
= hold
;
2817 if (ex
.X_op
== O_illegal
)
2818 as_bad (_("illegal operand"));
2819 else if (ex
.X_op
== O_absent
)
2820 as_bad (_("missing operand"));
2821 else if (ex
.X_op
== O_register
)
2823 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2824 ppc_cpu
, (char *) NULL
, 0);
2826 else if (ex
.X_op
== O_constant
)
2829 /* Allow @HA, @L, @H on constants. */
2830 bfd_reloc_code_real_type reloc
;
2831 char *orig_str
= str
;
2833 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2840 case BFD_RELOC_LO16
:
2841 /* X_unsigned is the default, so if the user has done
2842 something which cleared it, we always produce a
2844 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2845 ex
.X_add_number
&= 0xffff;
2847 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2850 case BFD_RELOC_HI16
:
2851 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2852 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2854 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2857 case BFD_RELOC_HI16_S
:
2858 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2859 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2861 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2864 case BFD_RELOC_PPC64_HIGHER
:
2865 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2866 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2868 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2871 case BFD_RELOC_PPC64_HIGHER_S
:
2872 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2873 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2875 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2878 case BFD_RELOC_PPC64_HIGHEST
:
2879 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2880 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2882 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2885 case BFD_RELOC_PPC64_HIGHEST_S
:
2886 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2887 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2889 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2892 #endif /* OBJ_ELF */
2893 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2894 ppc_cpu
, (char *) NULL
, 0);
2898 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
2900 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2902 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2903 if (sym_name
[0] == '.')
2906 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2908 expressionS tls_exp
;
2910 hold
= input_line_pointer
;
2911 input_line_pointer
= str
+ 1;
2912 expression (&tls_exp
);
2913 if (tls_exp
.X_op
== O_symbol
)
2915 reloc
= BFD_RELOC_UNUSED
;
2916 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2918 reloc
= BFD_RELOC_PPC_TLSGD
;
2919 input_line_pointer
+= 7;
2921 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2923 reloc
= BFD_RELOC_PPC_TLSLD
;
2924 input_line_pointer
+= 7;
2926 if (reloc
!= BFD_RELOC_UNUSED
)
2929 str
= input_line_pointer
;
2931 if (fc
>= MAX_INSN_FIXUPS
)
2932 as_fatal (_("too many fixups"));
2933 fixups
[fc
].exp
= tls_exp
;
2934 fixups
[fc
].opindex
= *opindex_ptr
;
2935 fixups
[fc
].reloc
= reloc
;
2939 input_line_pointer
= hold
;
2943 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2945 /* Some TLS tweaks. */
2951 case BFD_RELOC_PPC_TLS
:
2952 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2953 as_bad (_("@tls may not be used with \"%s\" operands"),
2955 else if (operand
->shift
!= 11)
2956 as_bad (_("@tls may only be used in last operand"));
2958 insn
= ppc_insert_operand (insn
, operand
,
2960 ppc_cpu
, (char *) NULL
, 0);
2963 /* We'll only use the 32 (or 64) bit form of these relocations
2964 in constants. Instructions get the 16 bit form. */
2965 case BFD_RELOC_PPC_DTPREL
:
2966 reloc
= BFD_RELOC_PPC_DTPREL16
;
2968 case BFD_RELOC_PPC_TPREL
:
2969 reloc
= BFD_RELOC_PPC_TPREL16
;
2973 /* If VLE-mode convert LO/HI/HA relocations. */
2974 if (opcode
->flags
& PPC_OPCODE_VLE
)
2976 int tmp_insn
= insn
& opcode
->mask
;
2978 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
2979 || tmp_insn
== E_AND2I_DOT_INSN
2980 || tmp_insn
== E_OR2IS_INSN
2981 || tmp_insn
== E_LIS_INSN
2982 || tmp_insn
== E_AND2IS_DOT_INSN
);
2985 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
2986 || tmp_insn
== E_ADD2IS_INSN
2987 || tmp_insn
== E_CMP16I_INSN
2988 || tmp_insn
== E_MULL2I_INSN
2989 || tmp_insn
== E_CMPL16I_INSN
2990 || tmp_insn
== E_CMPH16I_INSN
2991 || tmp_insn
== E_CMPHL16I_INSN
);
2998 case BFD_RELOC_PPC_EMB_SDA21
:
2999 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3002 case BFD_RELOC_LO16
:
3004 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3005 else if (use_a_reloc
)
3006 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3009 case BFD_RELOC_HI16
:
3011 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3012 else if (use_a_reloc
)
3013 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3016 case BFD_RELOC_HI16_S
:
3018 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3019 else if (use_a_reloc
)
3020 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3023 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3025 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3028 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3030 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3033 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3035 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3040 /* For the absolute forms of branches, convert the PC
3041 relative form back into the absolute. */
3042 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3046 case BFD_RELOC_PPC_B26
:
3047 reloc
= BFD_RELOC_PPC_BA26
;
3049 case BFD_RELOC_PPC_B16
:
3050 reloc
= BFD_RELOC_PPC_BA16
;
3052 case BFD_RELOC_PPC_B16_BRTAKEN
:
3053 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3055 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3056 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3065 case BFD_RELOC_PPC_TOC16
:
3066 toc_reloc_types
|= has_small_toc_reloc
;
3068 case BFD_RELOC_PPC64_TOC16_LO
:
3069 case BFD_RELOC_PPC64_TOC16_HI
:
3070 case BFD_RELOC_PPC64_TOC16_HA
:
3071 toc_reloc_types
|= has_large_toc_reloc
;
3077 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3082 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3084 case BFD_RELOC_LO16
:
3085 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3087 case BFD_RELOC_16_GOTOFF
:
3088 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3090 case BFD_RELOC_LO16_GOTOFF
:
3091 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3093 case BFD_RELOC_LO16_PLTOFF
:
3094 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3096 case BFD_RELOC_16_BASEREL
:
3097 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3099 case BFD_RELOC_LO16_BASEREL
:
3100 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3102 case BFD_RELOC_PPC_TOC16
:
3103 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3105 case BFD_RELOC_PPC64_TOC16_LO
:
3106 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3108 case BFD_RELOC_PPC64_PLTGOT16
:
3109 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3111 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3112 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3114 case BFD_RELOC_PPC_DTPREL16
:
3115 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3117 case BFD_RELOC_PPC_DTPREL16_LO
:
3118 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3120 case BFD_RELOC_PPC_TPREL16
:
3121 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3123 case BFD_RELOC_PPC_TPREL16_LO
:
3124 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3126 case BFD_RELOC_PPC_GOT_DTPREL16
:
3127 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3128 case BFD_RELOC_PPC_GOT_TPREL16
:
3129 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3132 as_bad (_("unsupported relocation for DS offset field"));
3137 #endif /* OBJ_ELF */
3139 if (reloc
!= BFD_RELOC_UNUSED
)
3141 /* Determine a BFD reloc value based on the operand information.
3142 We are only prepared to turn a few of the operands into
3144 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3145 && operand
->bitm
== 0x3fffffc
3146 && operand
->shift
== 0)
3147 reloc
= BFD_RELOC_PPC_B26
;
3148 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3149 && operand
->bitm
== 0xfffc
3150 && operand
->shift
== 0)
3151 reloc
= BFD_RELOC_PPC_B16
;
3152 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3153 && operand
->bitm
== 0x1fe
3154 && operand
->shift
== -1)
3155 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3156 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3157 && operand
->bitm
== 0xfffe
3158 && operand
->shift
== 0)
3159 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3160 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3161 && operand
->bitm
== 0x1fffffe
3162 && operand
->shift
== 0)
3163 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3164 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3165 && operand
->bitm
== 0x3fffffc
3166 && operand
->shift
== 0)
3167 reloc
= BFD_RELOC_PPC_BA26
;
3168 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3169 && operand
->bitm
== 0xfffc
3170 && operand
->shift
== 0)
3171 reloc
= BFD_RELOC_PPC_BA16
;
3172 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3173 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3174 && (operand
->bitm
& 0xfff0) == 0xfff0
3175 && operand
->shift
== 0)
3177 if (ppc_is_toc_sym (ex
.X_add_symbol
))
3179 reloc
= BFD_RELOC_PPC_TOC16
;
3182 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3183 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3188 reloc
= BFD_RELOC_16
;
3191 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3192 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3196 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3198 /* We need to generate a fixup for this expression. */
3199 if (fc
>= MAX_INSN_FIXUPS
)
3200 as_fatal (_("too many fixups"));
3201 fixups
[fc
].exp
= ex
;
3202 fixups
[fc
].opindex
= *opindex_ptr
;
3203 fixups
[fc
].reloc
= reloc
;
3211 /* If expecting more operands, then we want to see "),". */
3212 if (*str
== endc
&& opindex_ptr
[1] != 0)
3216 while (ISSPACE (*str
));
3220 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3228 /* The call to expression should have advanced str past any
3231 && (endc
!= ',' || *str
!= '\0'))
3234 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3236 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3244 while (ISSPACE (*str
))
3248 as_bad (_("junk at end of line: `%s'"), str
);
3251 /* Do we need/want an APUinfo section? */
3252 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3255 /* These are all version "1". */
3256 if (opcode
->flags
& PPC_OPCODE_SPE
)
3257 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3258 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3259 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3260 if (opcode
->flags
& PPC_OPCODE_EFS
)
3261 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3262 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3263 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3264 if (opcode
->flags
& PPC_OPCODE_PMR
)
3265 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3266 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3267 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3268 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3269 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3270 if (opcode
->flags
& PPC_OPCODE_VLE
)
3271 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3275 /* Write out the instruction. */
3276 /* Differentiate between two and four byte insns. */
3277 if (ppc_mach () == bfd_mach_ppc_vle
)
3279 if (PPC_OP_SE_VLE (insn
))
3283 addr_mod
= frag_now_fix () & 1;
3288 addr_mod
= frag_now_fix () & 3;
3290 /* All instructions can start on a 2 byte boundary for VLE. */
3291 f
= frag_more (insn_length
);
3292 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3294 if (ppc_mach() == bfd_mach_ppc_vle
)
3295 as_bad (_("instruction address is not a multiple of 2"));
3297 as_bad (_("instruction address is not a multiple of 4"));
3299 frag_now
->insn_addr
= addr_mod
;
3300 frag_now
->has_code
= 1;
3301 md_number_to_chars (f
, insn
, insn_length
);
3304 dwarf2_emit_insn (insn_length
);
3307 /* Create any fixups. */
3308 for (i
= 0; i
< fc
; i
++)
3311 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3313 reloc_howto_type
*reloc_howto
;
3317 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3321 size
= bfd_get_reloc_size (reloc_howto
);
3322 offset
= target_big_endian
? (insn_length
- size
) : 0;
3324 if (size
< 1 || size
> 4)
3327 fixP
= fix_new_exp (frag_now
,
3328 f
- frag_now
->fr_literal
+ offset
,
3331 reloc_howto
->pc_relative
,
3336 const struct powerpc_operand
*operand
;
3338 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3339 fixP
= fix_new_exp (frag_now
,
3340 f
- frag_now
->fr_literal
,
3343 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3346 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3350 /* Handle a macro. Gather all the operands, transform them as
3351 described by the macro, and call md_assemble recursively. All the
3352 operands are separated by commas; we don't accept parentheses
3353 around operands here. */
3356 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3367 /* Gather the users operands into the operands array. */
3372 if (count
>= sizeof operands
/ sizeof operands
[0])
3374 operands
[count
++] = s
;
3375 s
= strchr (s
, ',');
3376 if (s
== (char *) NULL
)
3381 if (count
!= macro
->operands
)
3383 as_bad (_("wrong number of operands"));
3387 /* Work out how large the string must be (the size is unbounded
3388 because it includes user input). */
3390 format
= macro
->format
;
3391 while (*format
!= '\0')
3400 arg
= strtol (format
+ 1, &send
, 10);
3401 know (send
!= format
&& arg
< count
);
3402 len
+= strlen (operands
[arg
]);
3407 /* Put the string together. */
3408 complete
= s
= (char *) alloca (len
+ 1);
3409 format
= macro
->format
;
3410 while (*format
!= '\0')
3416 arg
= strtol (format
+ 1, &send
, 10);
3417 strcpy (s
, operands
[arg
]);
3424 /* Assemble the constructed instruction. */
3425 md_assemble (complete
);
3429 /* For ELF, add support for SHT_ORDERED. */
3432 ppc_section_type (char *str
, size_t len
)
3434 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3441 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3443 if (type
== SHT_ORDERED
)
3444 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3448 #endif /* OBJ_ELF */
3451 /* Pseudo-op handling. */
3453 /* The .byte pseudo-op. This is similar to the normal .byte
3454 pseudo-op, but it can also take a single ASCII string. */
3457 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3459 if (*input_line_pointer
!= '\"')
3465 /* Gather characters. A real double quote is doubled. Unusual
3466 characters are not permitted. */
3467 ++input_line_pointer
;
3472 c
= *input_line_pointer
++;
3476 if (*input_line_pointer
!= '\"')
3478 ++input_line_pointer
;
3481 FRAG_APPEND_1_CHAR (c
);
3484 demand_empty_rest_of_line ();
3489 /* XCOFF specific pseudo-op handling. */
3491 /* This is set if we are creating a .stabx symbol, since we don't want
3492 to handle symbol suffixes for such symbols. */
3493 static bfd_boolean ppc_stab_symbol
;
3495 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3496 symbols in the .bss segment as though they were local common
3497 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3498 aligns .comm and .lcomm to 4 bytes. */
3501 ppc_comm (int lcomm
)
3503 asection
*current_seg
= now_seg
;
3504 subsegT current_subseg
= now_subseg
;
3510 symbolS
*lcomm_sym
= NULL
;
3514 name
= input_line_pointer
;
3515 endc
= get_symbol_end ();
3516 end_name
= input_line_pointer
;
3519 if (*input_line_pointer
!= ',')
3521 as_bad (_("missing size"));
3522 ignore_rest_of_line ();
3525 ++input_line_pointer
;
3527 size
= get_absolute_expression ();
3530 as_bad (_("negative size"));
3531 ignore_rest_of_line ();
3537 /* The third argument to .comm is the alignment. */
3538 if (*input_line_pointer
!= ',')
3542 ++input_line_pointer
;
3543 align
= get_absolute_expression ();
3546 as_warn (_("ignoring bad alignment"));
3561 /* The third argument to .lcomm appears to be the real local
3562 common symbol to create. References to the symbol named in
3563 the first argument are turned into references to the third
3565 if (*input_line_pointer
!= ',')
3567 as_bad (_("missing real symbol name"));
3568 ignore_rest_of_line ();
3571 ++input_line_pointer
;
3573 lcomm_name
= input_line_pointer
;
3574 lcomm_endc
= get_symbol_end ();
3576 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3578 *input_line_pointer
= lcomm_endc
;
3582 sym
= symbol_find_or_make (name
);
3585 if (S_IS_DEFINED (sym
)
3586 || S_GET_VALUE (sym
) != 0)
3588 as_bad (_("attempt to redefine symbol"));
3589 ignore_rest_of_line ();
3593 record_alignment (bss_section
, align
);
3596 || ! S_IS_DEFINED (lcomm_sym
))
3605 S_SET_EXTERNAL (sym
);
3609 symbol_get_tc (lcomm_sym
)->output
= 1;
3610 def_sym
= lcomm_sym
;
3614 subseg_set (bss_section
, 1);
3615 frag_align (align
, 0, 0);
3617 symbol_set_frag (def_sym
, frag_now
);
3618 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3619 def_size
, (char *) NULL
);
3621 S_SET_SEGMENT (def_sym
, bss_section
);
3622 symbol_get_tc (def_sym
)->align
= align
;
3626 /* Align the size of lcomm_sym. */
3627 symbol_get_frag (lcomm_sym
)->fr_offset
=
3628 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3629 &~ ((1 << align
) - 1));
3630 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3631 symbol_get_tc (lcomm_sym
)->align
= align
;
3636 /* Make sym an offset from lcomm_sym. */
3637 S_SET_SEGMENT (sym
, bss_section
);
3638 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3639 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3640 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3643 subseg_set (current_seg
, current_subseg
);
3645 demand_empty_rest_of_line ();
3648 /* The .csect pseudo-op. This switches us into a different
3649 subsegment. The first argument is a symbol whose value is the
3650 start of the .csect. In COFF, csect symbols get special aux
3651 entries defined by the x_csect field of union internal_auxent. The
3652 optional second argument is the alignment (the default is 2). */
3655 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3662 name
= input_line_pointer
;
3663 endc
= get_symbol_end ();
3665 sym
= symbol_find_or_make (name
);
3667 *input_line_pointer
= endc
;
3669 if (S_GET_NAME (sym
)[0] == '\0')
3671 /* An unnamed csect is assumed to be [PR]. */
3672 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3676 if (*input_line_pointer
== ',')
3678 ++input_line_pointer
;
3679 align
= get_absolute_expression ();
3682 ppc_change_csect (sym
, align
);
3684 demand_empty_rest_of_line ();
3687 /* Change to a different csect. */
3690 ppc_change_csect (symbolS
*sym
, offsetT align
)
3692 if (S_IS_DEFINED (sym
))
3693 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3703 /* This is a new csect. We need to look at the symbol class to
3704 figure out whether it should go in the text section or the
3708 switch (symbol_get_tc (sym
)->symbol_class
)
3718 S_SET_SEGMENT (sym
, text_section
);
3719 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3720 ++ppc_text_subsegment
;
3721 list_ptr
= &ppc_text_csects
;
3731 if (ppc_toc_csect
!= NULL
3732 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3733 == ppc_data_subsegment
))
3735 S_SET_SEGMENT (sym
, data_section
);
3736 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3737 ++ppc_data_subsegment
;
3738 list_ptr
= &ppc_data_csects
;
3744 /* We set the obstack chunk size to a small value before
3745 changing subsegments, so that we don't use a lot of memory
3746 space for what may be a small section. */
3747 hold_chunksize
= chunksize
;
3750 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3751 symbol_get_tc (sym
)->subseg
);
3753 chunksize
= hold_chunksize
;
3756 ppc_after_toc_frag
= frag_now
;
3758 record_alignment (sec
, align
);
3760 frag_align_code (align
, 0);
3762 frag_align (align
, 0, 0);
3764 symbol_set_frag (sym
, frag_now
);
3765 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3767 symbol_get_tc (sym
)->align
= align
;
3768 symbol_get_tc (sym
)->output
= 1;
3769 symbol_get_tc (sym
)->within
= sym
;
3771 for (list
= *list_ptr
;
3772 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3773 list
= symbol_get_tc (list
)->next
)
3775 symbol_get_tc (list
)->next
= sym
;
3777 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3778 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3782 ppc_current_csect
= sym
;
3786 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3790 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3792 sec
= subseg_new (dw
->name
, subseg
);
3793 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3794 if (oldflags
== SEC_NO_FLAGS
)
3796 /* Just created section. */
3797 gas_assert (dw_sections
[idx
].sect
== NULL
);
3799 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3800 bfd_set_section_alignment (stdoutput
, sec
, 0);
3801 dw_sections
[idx
].sect
= sec
;
3804 /* Not anymore in a csect. */
3805 ppc_current_csect
= NULL
;
3808 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3809 .dwsect flag [, opt-label ]
3813 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3817 const struct xcoff_dwsect_name
*dw
;
3818 struct dw_subsection
*subseg
;
3819 struct dw_section
*dws
;
3823 flag
= get_absolute_expression ();
3825 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3826 if (xcoff_dwsect_names
[i
].flag
== flag
)
3828 dw
= &xcoff_dwsect_names
[i
];
3832 /* Parse opt-label. */
3833 if (*input_line_pointer
== ',')
3838 ++input_line_pointer
;
3840 label
= input_line_pointer
;
3841 c
= get_symbol_end ();
3842 opt_label
= symbol_find_or_make (label
);
3843 *input_line_pointer
= c
;
3848 demand_empty_rest_of_line ();
3850 /* Return now in case of unknown subsection. */
3853 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3858 /* Find the subsection. */
3859 dws
= &dw_sections
[i
];
3861 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3863 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3864 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3866 as_bad (_("label %s was not defined in this dwarf section"),
3867 S_GET_NAME (opt_label
));
3868 subseg
= dws
->anon_subseg
;
3872 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3877 /* Switch to the subsection. */
3878 ppc_change_debug_section (i
, subseg
->subseg
);
3882 /* Create a new dw subsection. */
3883 subseg
= (struct dw_subsection
*)
3884 xmalloc (sizeof (struct dw_subsection
));
3886 if (opt_label
== NULL
)
3888 /* The anonymous one. */
3890 subseg
->link
= NULL
;
3891 dws
->anon_subseg
= subseg
;
3896 if (dws
->list_subseg
!= NULL
)
3897 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3901 subseg
->link
= dws
->list_subseg
;
3902 dws
->list_subseg
= subseg
;
3903 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3906 ppc_change_debug_section (i
, subseg
->subseg
);
3910 /* Add the length field. */
3911 expressionS
*exp
= &subseg
->end_exp
;
3914 if (opt_label
!= NULL
)
3915 symbol_set_value_now (opt_label
);
3917 /* Add the length field. Note that according to the AIX assembler
3918 manual, the size of the length field is 4 for powerpc32 but
3919 12 for powerpc64. */
3922 /* Write the 64bit marker. */
3923 md_number_to_chars (frag_more (4), -1, 4);
3926 exp
->X_op
= O_subtract
;
3927 exp
->X_op_symbol
= symbol_temp_new_now ();
3928 exp
->X_add_symbol
= symbol_temp_make ();
3930 sz
= ppc_obj64
? 8 : 4;
3931 exp
->X_add_number
= -sz
;
3932 emit_expr (exp
, sz
);
3937 /* This function handles the .text and .data pseudo-ops. These
3938 pseudo-ops aren't really used by XCOFF; we implement them for the
3939 convenience of people who aren't used to XCOFF. */
3942 ppc_section (int type
)
3949 else if (type
== 'd')
3954 sym
= symbol_find_or_make (name
);
3956 ppc_change_csect (sym
, 2);
3958 demand_empty_rest_of_line ();
3961 /* This function handles the .section pseudo-op. This is mostly to
3962 give an error, since XCOFF only supports .text, .data and .bss, but
3963 we do permit the user to name the text or data section. */
3966 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3969 const char *real_name
;
3973 user_name
= input_line_pointer
;
3974 c
= get_symbol_end ();
3976 if (strcmp (user_name
, ".text") == 0)
3977 real_name
= ".text[PR]";
3978 else if (strcmp (user_name
, ".data") == 0)
3979 real_name
= ".data[RW]";
3982 as_bad (_("the XCOFF file format does not support arbitrary sections"));
3983 *input_line_pointer
= c
;
3984 ignore_rest_of_line ();
3988 *input_line_pointer
= c
;
3990 sym
= symbol_find_or_make (real_name
);
3992 ppc_change_csect (sym
, 2);
3994 demand_empty_rest_of_line ();
3997 /* The .extern pseudo-op. We create an undefined symbol. */
4000 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4005 name
= input_line_pointer
;
4006 endc
= get_symbol_end ();
4008 (void) symbol_find_or_make (name
);
4010 *input_line_pointer
= endc
;
4012 demand_empty_rest_of_line ();
4015 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4018 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4024 name
= input_line_pointer
;
4025 endc
= get_symbol_end ();
4027 sym
= symbol_find_or_make (name
);
4029 *input_line_pointer
= endc
;
4031 symbol_get_tc (sym
)->output
= 1;
4033 demand_empty_rest_of_line ();
4036 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4037 relocations at the beginning of the current csect.
4039 (In principle, there's no reason why the relocations _have_ to be at
4040 the beginning. Anywhere in the csect would do. However, inserting
4041 at the beginning is what the native assmebler does, and it helps to
4042 deal with cases where the .ref statements follow the section contents.)
4044 ??? .refs don't work for empty .csects. However, the native assembler
4045 doesn't report an error in this case, and neither yet do we. */
4048 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4053 if (ppc_current_csect
== NULL
)
4055 as_bad (_(".ref outside .csect"));
4056 ignore_rest_of_line ();
4062 name
= input_line_pointer
;
4063 c
= get_symbol_end ();
4065 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4066 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4068 *input_line_pointer
= c
;
4070 c
= *input_line_pointer
;
4073 input_line_pointer
++;
4075 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4077 as_bad (_("missing symbol name"));
4078 ignore_rest_of_line ();
4085 demand_empty_rest_of_line ();
4088 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4089 although I don't know why it bothers. */
4092 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4099 name
= input_line_pointer
;
4100 endc
= get_symbol_end ();
4102 sym
= symbol_find_or_make (name
);
4104 *input_line_pointer
= endc
;
4106 if (*input_line_pointer
!= ',')
4108 as_bad (_("missing rename string"));
4109 ignore_rest_of_line ();
4112 ++input_line_pointer
;
4114 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4116 demand_empty_rest_of_line ();
4119 /* The .stabx pseudo-op. This is similar to a normal .stabs
4120 pseudo-op, but slightly different. A sample is
4121 .stabx "main:F-1",.main,142,0
4122 The first argument is the symbol name to create. The second is the
4123 value, and the third is the storage class. The fourth seems to be
4124 always zero, and I am assuming it is the type. */
4127 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4134 name
= demand_copy_C_string (&len
);
4136 if (*input_line_pointer
!= ',')
4138 as_bad (_("missing value"));
4141 ++input_line_pointer
;
4143 ppc_stab_symbol
= TRUE
;
4144 sym
= symbol_make (name
);
4145 ppc_stab_symbol
= FALSE
;
4147 symbol_get_tc (sym
)->real_name
= name
;
4149 (void) expression (&exp
);
4156 as_bad (_("illegal .stabx expression; zero assumed"));
4157 exp
.X_add_number
= 0;
4160 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4161 symbol_set_frag (sym
, &zero_address_frag
);
4165 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4166 symbol_set_value_expression (sym
, &exp
);
4170 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4171 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4176 /* The value is some complex expression. This will probably
4177 fail at some later point, but this is probably the right
4178 thing to do here. */
4179 symbol_set_value_expression (sym
, &exp
);
4183 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4184 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4186 if (*input_line_pointer
!= ',')
4188 as_bad (_("missing class"));
4191 ++input_line_pointer
;
4193 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4195 if (*input_line_pointer
!= ',')
4197 as_bad (_("missing type"));
4200 ++input_line_pointer
;
4202 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4204 symbol_get_tc (sym
)->output
= 1;
4206 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4211 .stabx "z",arrays_,133,0
4214 .comm arrays_,13768,3
4216 resolve_symbol_value will copy the exp's "within" into sym's when the
4217 offset is 0. Since this seems to be corner case problem,
4218 only do the correction for storage class C_STSYM. A better solution
4219 would be to have the tc field updated in ppc_symbol_new_hook. */
4221 if (exp
.X_op
== O_symbol
)
4223 if (ppc_current_block
== NULL
)
4224 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4226 symbol_get_tc (sym
)->within
= ppc_current_block
;
4227 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4231 if (exp
.X_op
!= O_symbol
4232 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4233 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4234 ppc_frob_label (sym
);
4237 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4238 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4239 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4240 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4243 demand_empty_rest_of_line ();
4246 /* The .function pseudo-op. This takes several arguments. The first
4247 argument seems to be the external name of the symbol. The second
4248 argument seems to be the label for the start of the function. gcc
4249 uses the same name for both. I have no idea what the third and
4250 fourth arguments are meant to be. The optional fifth argument is
4251 an expression for the size of the function. In COFF this symbol
4252 gets an aux entry like that used for a csect. */
4255 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4263 name
= input_line_pointer
;
4264 endc
= get_symbol_end ();
4266 /* Ignore any [PR] suffix. */
4267 name
= ppc_canonicalize_symbol_name (name
);
4268 s
= strchr (name
, '[');
4269 if (s
!= (char *) NULL
4270 && strcmp (s
+ 1, "PR]") == 0)
4273 ext_sym
= symbol_find_or_make (name
);
4275 *input_line_pointer
= endc
;
4277 if (*input_line_pointer
!= ',')
4279 as_bad (_("missing symbol name"));
4280 ignore_rest_of_line ();
4283 ++input_line_pointer
;
4285 name
= input_line_pointer
;
4286 endc
= get_symbol_end ();
4288 lab_sym
= symbol_find_or_make (name
);
4290 *input_line_pointer
= endc
;
4292 if (ext_sym
!= lab_sym
)
4296 exp
.X_op
= O_symbol
;
4297 exp
.X_add_symbol
= lab_sym
;
4298 exp
.X_op_symbol
= NULL
;
4299 exp
.X_add_number
= 0;
4301 symbol_set_value_expression (ext_sym
, &exp
);
4304 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4305 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4306 symbol_get_tc (ext_sym
)->output
= 1;
4308 if (*input_line_pointer
== ',')
4312 /* Ignore the third argument. */
4313 ++input_line_pointer
;
4315 if (*input_line_pointer
== ',')
4317 /* Ignore the fourth argument. */
4318 ++input_line_pointer
;
4320 if (*input_line_pointer
== ',')
4322 /* The fifth argument is the function size. */
4323 ++input_line_pointer
;
4324 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4325 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4326 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4331 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4332 SF_SET_FUNCTION (ext_sym
);
4333 SF_SET_PROCESS (ext_sym
);
4334 coff_add_linesym (ext_sym
);
4336 demand_empty_rest_of_line ();
4339 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4340 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4341 with the correct line number */
4343 static symbolS
*saved_bi_sym
= 0;
4346 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4350 sym
= symbol_make (".bf");
4351 S_SET_SEGMENT (sym
, text_section
);
4352 symbol_set_frag (sym
, frag_now
);
4353 S_SET_VALUE (sym
, frag_now_fix ());
4354 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4356 coff_line_base
= get_absolute_expression ();
4358 S_SET_NUMBER_AUXILIARY (sym
, 1);
4359 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4361 /* Line number for bi. */
4364 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4369 symbol_get_tc (sym
)->output
= 1;
4371 ppc_frob_label (sym
);
4373 demand_empty_rest_of_line ();
4376 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4377 ".ef", except that the line number is absolute, not relative to the
4378 most recent ".bf" symbol. */
4381 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4385 sym
= symbol_make (".ef");
4386 S_SET_SEGMENT (sym
, text_section
);
4387 symbol_set_frag (sym
, frag_now
);
4388 S_SET_VALUE (sym
, frag_now_fix ());
4389 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4390 S_SET_NUMBER_AUXILIARY (sym
, 1);
4391 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4392 symbol_get_tc (sym
)->output
= 1;
4394 ppc_frob_label (sym
);
4396 demand_empty_rest_of_line ();
4399 /* The .bi and .ei pseudo-ops. These take a string argument and
4400 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4401 the symbol list. The value of .bi will be know when the next .bf
4407 static symbolS
*last_biei
;
4414 name
= demand_copy_C_string (&len
);
4416 /* The value of these symbols is actually file offset. Here we set
4417 the value to the index into the line number entries. In
4418 ppc_frob_symbols we set the fix_line field, which will cause BFD
4419 to do the right thing. */
4421 sym
= symbol_make (name
);
4422 /* obj-coff.c currently only handles line numbers correctly in the
4424 S_SET_SEGMENT (sym
, text_section
);
4425 S_SET_VALUE (sym
, coff_n_line_nos
);
4426 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4428 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4429 symbol_get_tc (sym
)->output
= 1;
4437 for (look
= last_biei
? last_biei
: symbol_rootP
;
4438 (look
!= (symbolS
*) NULL
4439 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4440 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4441 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4442 look
= symbol_next (look
))
4444 if (look
!= (symbolS
*) NULL
)
4446 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4447 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4451 demand_empty_rest_of_line ();
4454 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4455 There is one argument, which is a csect symbol. The value of the
4456 .bs symbol is the index of this csect symbol. */
4459 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4466 if (ppc_current_block
!= NULL
)
4467 as_bad (_("nested .bs blocks"));
4469 name
= input_line_pointer
;
4470 endc
= get_symbol_end ();
4472 csect
= symbol_find_or_make (name
);
4474 *input_line_pointer
= endc
;
4476 sym
= symbol_make (".bs");
4477 S_SET_SEGMENT (sym
, now_seg
);
4478 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4479 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4480 symbol_get_tc (sym
)->output
= 1;
4482 symbol_get_tc (sym
)->within
= csect
;
4484 ppc_frob_label (sym
);
4486 ppc_current_block
= sym
;
4488 demand_empty_rest_of_line ();
4491 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4494 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4498 if (ppc_current_block
== NULL
)
4499 as_bad (_(".es without preceding .bs"));
4501 sym
= symbol_make (".es");
4502 S_SET_SEGMENT (sym
, now_seg
);
4503 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4504 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4505 symbol_get_tc (sym
)->output
= 1;
4507 ppc_frob_label (sym
);
4509 ppc_current_block
= NULL
;
4511 demand_empty_rest_of_line ();
4514 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4518 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4522 sym
= symbol_make (".bb");
4523 S_SET_SEGMENT (sym
, text_section
);
4524 symbol_set_frag (sym
, frag_now
);
4525 S_SET_VALUE (sym
, frag_now_fix ());
4526 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4528 S_SET_NUMBER_AUXILIARY (sym
, 1);
4529 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4531 symbol_get_tc (sym
)->output
= 1;
4533 SF_SET_PROCESS (sym
);
4535 ppc_frob_label (sym
);
4537 demand_empty_rest_of_line ();
4540 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4544 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4548 sym
= symbol_make (".eb");
4549 S_SET_SEGMENT (sym
, text_section
);
4550 symbol_set_frag (sym
, frag_now
);
4551 S_SET_VALUE (sym
, frag_now_fix ());
4552 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4553 S_SET_NUMBER_AUXILIARY (sym
, 1);
4554 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4555 symbol_get_tc (sym
)->output
= 1;
4557 SF_SET_PROCESS (sym
);
4559 ppc_frob_label (sym
);
4561 demand_empty_rest_of_line ();
4564 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4568 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4574 name
= demand_copy_C_string (&len
);
4575 sym
= symbol_make (name
);
4576 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4577 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4578 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4579 S_SET_VALUE (sym
, 0);
4580 symbol_get_tc (sym
)->output
= 1;
4582 ppc_frob_label (sym
);
4584 demand_empty_rest_of_line ();
4587 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4590 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4594 sym
= symbol_make (".ec");
4595 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4596 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4597 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4598 S_SET_VALUE (sym
, 0);
4599 symbol_get_tc (sym
)->output
= 1;
4601 ppc_frob_label (sym
);
4603 demand_empty_rest_of_line ();
4606 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4609 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4611 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4612 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4619 subseg
= ppc_data_subsegment
;
4620 ++ppc_data_subsegment
;
4622 subseg_new (segment_name (data_section
), subseg
);
4623 ppc_toc_frag
= frag_now
;
4625 sym
= symbol_find_or_make ("TOC[TC0]");
4626 symbol_set_frag (sym
, frag_now
);
4627 S_SET_SEGMENT (sym
, data_section
);
4628 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4629 symbol_get_tc (sym
)->subseg
= subseg
;
4630 symbol_get_tc (sym
)->output
= 1;
4631 symbol_get_tc (sym
)->within
= sym
;
4633 ppc_toc_csect
= sym
;
4635 for (list
= ppc_data_csects
;
4636 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4637 list
= symbol_get_tc (list
)->next
)
4639 symbol_get_tc (list
)->next
= sym
;
4641 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4642 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4646 ppc_current_csect
= ppc_toc_csect
;
4648 demand_empty_rest_of_line ();
4651 /* The AIX assembler automatically aligns the operands of a .long or
4652 .short pseudo-op, and we want to be compatible. */
4655 ppc_xcoff_cons (int log_size
)
4657 frag_align (log_size
, 0, 0);
4658 record_alignment (now_seg
, log_size
);
4659 cons (1 << log_size
);
4663 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4668 (void) expression (&exp
);
4670 if (exp
.X_op
!= O_constant
)
4672 as_bad (_("non-constant byte count"));
4676 byte_count
= exp
.X_add_number
;
4678 if (*input_line_pointer
!= ',')
4680 as_bad (_("missing value"));
4684 ++input_line_pointer
;
4689 ppc_xcoff_end (void)
4693 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4695 struct dw_section
*dws
= &dw_sections
[i
];
4696 struct dw_subsection
*dwss
;
4698 if (dws
->anon_subseg
)
4700 dwss
= dws
->anon_subseg
;
4701 dwss
->link
= dws
->list_subseg
;
4704 dwss
= dws
->list_subseg
;
4706 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4707 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4709 subseg_set (dws
->sect
, dwss
->subseg
);
4710 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4715 #endif /* OBJ_XCOFF */
4716 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4718 /* The .tc pseudo-op. This is used when generating either XCOFF or
4719 ELF. This takes two or more arguments.
4721 When generating XCOFF output, the first argument is the name to
4722 give to this location in the toc; this will be a symbol with class
4723 TC. The rest of the arguments are N-byte values to actually put at
4724 this location in the TOC; often there is just one more argument, a
4725 relocatable symbol reference. The size of the value to store
4726 depends on target word size. A 32-bit target uses 4-byte values, a
4727 64-bit target uses 8-byte values.
4729 When not generating XCOFF output, the arguments are the same, but
4730 the first argument is simply ignored. */
4733 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4737 /* Define the TOC symbol name. */
4743 if (ppc_toc_csect
== (symbolS
*) NULL
4744 || ppc_toc_csect
!= ppc_current_csect
)
4746 as_bad (_(".tc not in .toc section"));
4747 ignore_rest_of_line ();
4751 name
= input_line_pointer
;
4752 endc
= get_symbol_end ();
4754 sym
= symbol_find_or_make (name
);
4756 *input_line_pointer
= endc
;
4758 if (S_IS_DEFINED (sym
))
4762 label
= symbol_get_tc (ppc_current_csect
)->within
;
4763 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4765 as_bad (_(".tc with no label"));
4766 ignore_rest_of_line ();
4770 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4771 symbol_set_frag (label
, symbol_get_frag (sym
));
4772 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4774 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4775 ++input_line_pointer
;
4780 S_SET_SEGMENT (sym
, now_seg
);
4781 symbol_set_frag (sym
, frag_now
);
4782 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4783 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4784 symbol_get_tc (sym
)->output
= 1;
4786 ppc_frob_label (sym
);
4789 #endif /* OBJ_XCOFF */
4793 /* Skip the TOC symbol name. */
4794 while (is_part_of_name (*input_line_pointer
)
4795 || *input_line_pointer
== ' '
4796 || *input_line_pointer
== '['
4797 || *input_line_pointer
== ']'
4798 || *input_line_pointer
== '{'
4799 || *input_line_pointer
== '}')
4800 ++input_line_pointer
;
4802 /* Align to a four/eight byte boundary. */
4803 align
= ppc_obj64
? 3 : 2;
4804 frag_align (align
, 0, 0);
4805 record_alignment (now_seg
, align
);
4806 #endif /* OBJ_ELF */
4808 if (*input_line_pointer
!= ',')
4809 demand_empty_rest_of_line ();
4812 ++input_line_pointer
;
4813 cons (ppc_obj64
? 8 : 4);
4817 /* Pseudo-op .machine. */
4820 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4823 #define MAX_HISTORY 100
4824 static ppc_cpu_t
*cpu_history
;
4825 static int curr_hist
;
4829 if (*input_line_pointer
== '"')
4832 cpu_string
= demand_copy_C_string (&len
);
4837 cpu_string
= input_line_pointer
;
4838 c
= get_symbol_end ();
4839 cpu_string
= xstrdup (cpu_string
);
4840 *input_line_pointer
= c
;
4843 if (cpu_string
!= NULL
)
4845 ppc_cpu_t old_cpu
= ppc_cpu
;
4849 for (p
= cpu_string
; *p
!= 0; p
++)
4852 if (strcmp (cpu_string
, "push") == 0)
4854 if (cpu_history
== NULL
)
4855 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4857 if (curr_hist
>= MAX_HISTORY
)
4858 as_bad (_(".machine stack overflow"));
4860 cpu_history
[curr_hist
++] = ppc_cpu
;
4862 else if (strcmp (cpu_string
, "pop") == 0)
4865 as_bad (_(".machine stack underflow"));
4867 ppc_cpu
= cpu_history
[--curr_hist
];
4869 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4872 as_bad (_("invalid machine `%s'"), cpu_string
);
4874 if (ppc_cpu
!= old_cpu
)
4875 ppc_setup_opcodes ();
4878 demand_empty_rest_of_line ();
4880 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4884 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4886 /* Set the current section. */
4888 ppc_set_current_section (segT
new)
4890 ppc_previous_section
= ppc_current_section
;
4891 ppc_current_section
= new;
4894 /* pseudo-op: .previous
4895 behaviour: toggles the current section with the previous section.
4897 warnings: "No previous section" */
4900 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4902 if (ppc_previous_section
== NULL
)
4904 as_warn (_("no previous section to return to, ignored."));
4908 subseg_set (ppc_previous_section
, 0);
4910 ppc_set_current_section (ppc_previous_section
);
4913 /* pseudo-op: .pdata
4914 behaviour: predefined read only data section
4918 initial: .section .pdata "adr3"
4919 a - don't know -- maybe a misprint
4920 d - initialized data
4922 3 - double word aligned (that would be 4 byte boundary)
4925 Tag index tables (also known as the function table) for exception
4926 handling, debugging, etc. */
4929 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4931 if (pdata_section
== 0)
4933 pdata_section
= subseg_new (".pdata", 0);
4935 bfd_set_section_flags (stdoutput
, pdata_section
,
4936 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4937 | SEC_READONLY
| SEC_DATA
));
4939 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4943 pdata_section
= subseg_new (".pdata", 0);
4945 ppc_set_current_section (pdata_section
);
4948 /* pseudo-op: .ydata
4949 behaviour: predefined read only data section
4953 initial: .section .ydata "drw3"
4954 a - don't know -- maybe a misprint
4955 d - initialized data
4957 3 - double word aligned (that would be 4 byte boundary)
4959 Tag tables (also known as the scope table) for exception handling,
4963 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4965 if (ydata_section
== 0)
4967 ydata_section
= subseg_new (".ydata", 0);
4968 bfd_set_section_flags (stdoutput
, ydata_section
,
4969 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4970 | SEC_READONLY
| SEC_DATA
));
4972 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4976 ydata_section
= subseg_new (".ydata", 0);
4978 ppc_set_current_section (ydata_section
);
4981 /* pseudo-op: .reldata
4982 behaviour: predefined read write data section
4983 double word aligned (4-byte)
4984 FIXME: relocation is applied to it
4985 FIXME: what's the difference between this and .data?
4988 initial: .section .reldata "drw3"
4989 d - initialized data
4992 3 - double word aligned (that would be 8 byte boundary)
4995 Like .data, but intended to hold data subject to relocation, such as
4996 function descriptors, etc. */
4999 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5001 if (reldata_section
== 0)
5003 reldata_section
= subseg_new (".reldata", 0);
5005 bfd_set_section_flags (stdoutput
, reldata_section
,
5006 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5009 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5013 reldata_section
= subseg_new (".reldata", 0);
5015 ppc_set_current_section (reldata_section
);
5018 /* pseudo-op: .rdata
5019 behaviour: predefined read only data section
5023 initial: .section .rdata "dr3"
5024 d - initialized data
5026 3 - double word aligned (that would be 4 byte boundary) */
5029 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5031 if (rdata_section
== 0)
5033 rdata_section
= subseg_new (".rdata", 0);
5034 bfd_set_section_flags (stdoutput
, rdata_section
,
5035 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5036 | SEC_READONLY
| SEC_DATA
));
5038 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5042 rdata_section
= subseg_new (".rdata", 0);
5044 ppc_set_current_section (rdata_section
);
5047 /* pseudo-op: .ualong
5048 behaviour: much like .int, with the exception that no alignment is
5050 FIXME: test the alignment statement
5055 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5061 /* pseudo-op: .znop <symbol name>
5062 behaviour: Issue a nop instruction
5063 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5064 the supplied symbol name.
5066 warnings: Missing symbol name */
5069 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5072 const struct powerpc_opcode
*opcode
;
5079 /* Strip out the symbol name. */
5080 symbol_name
= input_line_pointer
;
5081 c
= get_symbol_end ();
5083 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5084 strcpy (name
, symbol_name
);
5086 sym
= symbol_find_or_make (name
);
5088 *input_line_pointer
= c
;
5092 /* Look up the opcode in the hash table. */
5093 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5095 /* Stick in the nop. */
5096 insn
= opcode
->opcode
;
5098 /* Write out the instruction. */
5100 md_number_to_chars (f
, insn
, 4);
5102 f
- frag_now
->fr_literal
,
5107 BFD_RELOC_16_GOT_PCREL
);
5117 ppc_pe_comm (int lcomm
)
5126 name
= input_line_pointer
;
5127 c
= get_symbol_end ();
5129 /* just after name is now '\0'. */
5130 p
= input_line_pointer
;
5133 if (*input_line_pointer
!= ',')
5135 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5136 ignore_rest_of_line ();
5140 input_line_pointer
++; /* skip ',' */
5141 if ((temp
= get_absolute_expression ()) < 0)
5143 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5144 ignore_rest_of_line ();
5150 /* The third argument to .comm is the alignment. */
5151 if (*input_line_pointer
!= ',')
5155 ++input_line_pointer
;
5156 align
= get_absolute_expression ();
5159 as_warn (_("ignoring bad alignment"));
5166 symbolP
= symbol_find_or_make (name
);
5169 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5171 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5172 S_GET_NAME (symbolP
));
5173 ignore_rest_of_line ();
5177 if (S_GET_VALUE (symbolP
))
5179 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5180 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5181 S_GET_NAME (symbolP
),
5182 (long) S_GET_VALUE (symbolP
),
5187 S_SET_VALUE (symbolP
, (valueT
) temp
);
5188 S_SET_EXTERNAL (symbolP
);
5189 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5192 demand_empty_rest_of_line ();
5196 * implement the .section pseudo op:
5197 * .section name {, "flags"}
5199 * | +--- optional flags: 'b' for bss
5201 * +-- section name 'l' for lib
5205 * 'd' (apparently m88k for data)
5207 * But if the argument is not a quoted string, treat it as a
5208 * subsegment number.
5210 * FIXME: this is a copy of the section processing from obj-coff.c, with
5211 * additions/changes for the moto-pas assembler support. There are three
5214 * FIXME: I just noticed this. This doesn't work at all really. It it
5215 * setting bits that bfd probably neither understands or uses. The
5216 * correct approach (?) will have to incorporate extra fields attached
5217 * to the section to hold the system specific stuff. (krk)
5220 * 'a' - unknown - referred to in documentation, but no definition supplied
5221 * 'c' - section has code
5222 * 'd' - section has initialized data
5223 * 'u' - section has uninitialized data
5224 * 'i' - section contains directives (info)
5225 * 'n' - section can be discarded
5226 * 'R' - remove section at link time
5228 * Section Protection:
5229 * 'r' - section is readable
5230 * 'w' - section is writeable
5231 * 'x' - section is executable
5232 * 's' - section is sharable
5234 * Section Alignment:
5235 * '0' - align to byte boundary
5236 * '1' - align to halfword undary
5237 * '2' - align to word boundary
5238 * '3' - align to doubleword boundary
5239 * '4' - align to quadword boundary
5240 * '5' - align to 32 byte boundary
5241 * '6' - align to 64 byte boundary
5246 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5248 /* Strip out the section name. */
5257 section_name
= input_line_pointer
;
5258 c
= get_symbol_end ();
5260 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5261 strcpy (name
, section_name
);
5263 *input_line_pointer
= c
;
5268 flags
= SEC_NO_FLAGS
;
5270 if (strcmp (name
, ".idata$2") == 0)
5274 else if (strcmp (name
, ".idata$3") == 0)
5278 else if (strcmp (name
, ".idata$4") == 0)
5282 else if (strcmp (name
, ".idata$5") == 0)
5286 else if (strcmp (name
, ".idata$6") == 0)
5291 /* Default alignment to 16 byte boundary. */
5294 if (*input_line_pointer
== ',')
5296 ++input_line_pointer
;
5298 if (*input_line_pointer
!= '"')
5299 exp
= get_absolute_expression ();
5302 ++input_line_pointer
;
5303 while (*input_line_pointer
!= '"'
5304 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5306 switch (*input_line_pointer
)
5308 /* Section Contents */
5309 case 'a': /* unknown */
5310 as_bad (_("unsupported section attribute -- 'a'"));
5312 case 'c': /* code section */
5315 case 'd': /* section has initialized data */
5318 case 'u': /* section has uninitialized data */
5319 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5323 case 'i': /* section contains directives (info) */
5324 /* FIXME: This is IMAGE_SCN_LNK_INFO
5326 flags
|= SEC_HAS_CONTENTS
;
5328 case 'n': /* section can be discarded */
5331 case 'R': /* Remove section at link time */
5332 flags
|= SEC_NEVER_LOAD
;
5334 #if IFLICT_BRAIN_DAMAGE
5335 /* Section Protection */
5336 case 'r': /* section is readable */
5337 flags
|= IMAGE_SCN_MEM_READ
;
5339 case 'w': /* section is writeable */
5340 flags
|= IMAGE_SCN_MEM_WRITE
;
5342 case 'x': /* section is executable */
5343 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5345 case 's': /* section is sharable */
5346 flags
|= IMAGE_SCN_MEM_SHARED
;
5349 /* Section Alignment */
5350 case '0': /* align to byte boundary */
5351 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5354 case '1': /* align to halfword boundary */
5355 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5358 case '2': /* align to word boundary */
5359 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5362 case '3': /* align to doubleword boundary */
5363 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5366 case '4': /* align to quadword boundary */
5367 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5370 case '5': /* align to 32 byte boundary */
5371 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5374 case '6': /* align to 64 byte boundary */
5375 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5380 as_bad (_("unknown section attribute '%c'"),
5381 *input_line_pointer
);
5384 ++input_line_pointer
;
5386 if (*input_line_pointer
== '"')
5387 ++input_line_pointer
;
5391 sec
= subseg_new (name
, (subsegT
) exp
);
5393 ppc_set_current_section (sec
);
5395 if (flags
!= SEC_NO_FLAGS
)
5397 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5398 as_bad (_("error setting flags for \"%s\": %s"),
5399 bfd_section_name (stdoutput
, sec
),
5400 bfd_errmsg (bfd_get_error ()));
5403 bfd_set_section_alignment (stdoutput
, sec
, align
);
5407 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5413 name
= input_line_pointer
;
5414 endc
= get_symbol_end ();
5416 ext_sym
= symbol_find_or_make (name
);
5418 *input_line_pointer
= endc
;
5420 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5421 SF_SET_FUNCTION (ext_sym
);
5422 SF_SET_PROCESS (ext_sym
);
5423 coff_add_linesym (ext_sym
);
5425 demand_empty_rest_of_line ();
5429 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5431 if (tocdata_section
== 0)
5433 tocdata_section
= subseg_new (".tocd", 0);
5434 /* FIXME: section flags won't work. */
5435 bfd_set_section_flags (stdoutput
, tocdata_section
,
5436 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5437 | SEC_READONLY
| SEC_DATA
));
5439 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5443 rdata_section
= subseg_new (".tocd", 0);
5446 ppc_set_current_section (tocdata_section
);
5448 demand_empty_rest_of_line ();
5451 /* Don't adjust TOC relocs to use the section symbol. */
5454 ppc_pe_fix_adjustable (fixS
*fix
)
5456 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5463 /* XCOFF specific symbol and file handling. */
5465 /* Canonicalize the symbol name. We use the to force the suffix, if
5466 any, to use square brackets, and to be in upper case. */
5469 ppc_canonicalize_symbol_name (char *name
)
5473 if (ppc_stab_symbol
)
5476 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5490 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5493 if (*s
== '\0' || s
[1] != '\0')
5494 as_bad (_("bad symbol suffix"));
5502 /* Set the class of a symbol based on the suffix, if any. This is
5503 called whenever a new symbol is created. */
5506 ppc_symbol_new_hook (symbolS
*sym
)
5508 struct ppc_tc_sy
*tc
;
5511 tc
= symbol_get_tc (sym
);
5514 tc
->symbol_class
= -1;
5515 tc
->real_name
= NULL
;
5522 if (ppc_stab_symbol
)
5525 s
= strchr (S_GET_NAME (sym
), '[');
5526 if (s
== (const char *) NULL
)
5528 /* There is no suffix. */
5537 if (strcmp (s
, "BS]") == 0)
5538 tc
->symbol_class
= XMC_BS
;
5541 if (strcmp (s
, "DB]") == 0)
5542 tc
->symbol_class
= XMC_DB
;
5543 else if (strcmp (s
, "DS]") == 0)
5544 tc
->symbol_class
= XMC_DS
;
5547 if (strcmp (s
, "GL]") == 0)
5548 tc
->symbol_class
= XMC_GL
;
5551 if (strcmp (s
, "PR]") == 0)
5552 tc
->symbol_class
= XMC_PR
;
5555 if (strcmp (s
, "RO]") == 0)
5556 tc
->symbol_class
= XMC_RO
;
5557 else if (strcmp (s
, "RW]") == 0)
5558 tc
->symbol_class
= XMC_RW
;
5561 if (strcmp (s
, "SV]") == 0)
5562 tc
->symbol_class
= XMC_SV
;
5565 if (strcmp (s
, "TC]") == 0)
5566 tc
->symbol_class
= XMC_TC
;
5567 else if (strcmp (s
, "TI]") == 0)
5568 tc
->symbol_class
= XMC_TI
;
5569 else if (strcmp (s
, "TB]") == 0)
5570 tc
->symbol_class
= XMC_TB
;
5571 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5572 tc
->symbol_class
= XMC_TC0
;
5575 if (strcmp (s
, "UA]") == 0)
5576 tc
->symbol_class
= XMC_UA
;
5577 else if (strcmp (s
, "UC]") == 0)
5578 tc
->symbol_class
= XMC_UC
;
5581 if (strcmp (s
, "XO]") == 0)
5582 tc
->symbol_class
= XMC_XO
;
5586 if (tc
->symbol_class
== -1)
5587 as_bad (_("unrecognized symbol suffix"));
5590 /* Set the class of a label based on where it is defined. This
5591 handles symbols without suffixes. Also, move the symbol so that it
5592 follows the csect symbol. */
5595 ppc_frob_label (symbolS
*sym
)
5597 if (ppc_current_csect
!= (symbolS
*) NULL
)
5599 if (symbol_get_tc (sym
)->symbol_class
== -1)
5600 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5602 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5603 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5604 &symbol_rootP
, &symbol_lastP
);
5605 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5606 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5610 dwarf2_emit_label (sym
);
5614 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5615 seen. It tells ppc_adjust_symtab whether it needs to look through
5618 static bfd_boolean ppc_saw_abs
;
5620 /* Change the name of a symbol just before writing it out. Set the
5621 real name if the .rename pseudo-op was used. Otherwise, remove any
5622 class suffix. Return 1 if the symbol should not be included in the
5626 ppc_frob_symbol (symbolS
*sym
)
5628 static symbolS
*ppc_last_function
;
5629 static symbolS
*set_end
;
5631 /* Discard symbols that should not be included in the output symbol
5633 if (! symbol_used_in_reloc_p (sym
)
5634 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5635 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5636 && ! symbol_get_tc (sym
)->output
5637 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5640 /* This one will disappear anyway. Don't make a csect sym for it. */
5641 if (sym
== abs_section_sym
)
5644 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5645 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5651 name
= S_GET_NAME (sym
);
5652 s
= strchr (name
, '[');
5653 if (s
!= (char *) NULL
)
5659 snew
= xmalloc (len
+ 1);
5660 memcpy (snew
, name
, len
);
5663 S_SET_NAME (sym
, snew
);
5667 if (set_end
!= (symbolS
*) NULL
)
5669 SA_SET_SYM_ENDNDX (set_end
, sym
);
5673 if (SF_GET_FUNCTION (sym
))
5675 if (ppc_last_function
!= (symbolS
*) NULL
)
5676 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5677 ppc_last_function
= sym
;
5678 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5680 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5681 SA_SET_SYM_FSIZE (sym
,
5682 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5685 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5686 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5688 if (ppc_last_function
== (symbolS
*) NULL
)
5689 as_bad (_(".ef with no preceding .function"));
5692 set_end
= ppc_last_function
;
5693 ppc_last_function
= NULL
;
5695 /* We don't have a C_EFCN symbol, but we need to force the
5696 COFF backend to believe that it has seen one. */
5697 coff_last_function
= NULL
;
5701 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5702 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5703 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5704 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5705 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5706 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5707 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5708 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5709 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5710 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5711 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5713 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5714 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5715 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5718 union internal_auxent
*a
;
5720 /* Create a csect aux. */
5721 i
= S_GET_NUMBER_AUXILIARY (sym
);
5722 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5723 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5724 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5726 /* This is the TOC table. */
5727 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5728 a
->x_csect
.x_scnlen
.l
= 0;
5729 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5731 else if (symbol_get_tc (sym
)->subseg
!= 0)
5733 /* This is a csect symbol. x_scnlen is the size of the
5735 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5736 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5737 S_GET_SEGMENT (sym
))
5738 - S_GET_VALUE (sym
));
5741 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5742 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5743 - S_GET_VALUE (sym
));
5745 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5747 else if (S_GET_SEGMENT (sym
) == bss_section
)
5749 /* This is a common symbol. */
5750 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5751 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5752 if (S_IS_EXTERNAL (sym
))
5753 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5755 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5757 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5759 /* This is an absolute symbol. The csect will be created by
5760 ppc_adjust_symtab. */
5762 a
->x_csect
.x_smtyp
= XTY_LD
;
5763 if (symbol_get_tc (sym
)->symbol_class
== -1)
5764 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5766 else if (! S_IS_DEFINED (sym
))
5768 /* This is an external symbol. */
5769 a
->x_csect
.x_scnlen
.l
= 0;
5770 a
->x_csect
.x_smtyp
= XTY_ER
;
5772 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5776 /* This is a TOC definition. x_scnlen is the size of the
5778 next
= symbol_next (sym
);
5779 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5780 next
= symbol_next (next
);
5781 if (next
== (symbolS
*) NULL
5782 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5784 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5785 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5787 - S_GET_VALUE (sym
));
5789 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5790 - S_GET_VALUE (sym
));
5794 resolve_symbol_value (next
);
5795 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5796 - S_GET_VALUE (sym
));
5798 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5804 /* This is a normal symbol definition. x_scnlen is the
5805 symbol index of the containing csect. */
5806 if (S_GET_SEGMENT (sym
) == text_section
)
5807 csect
= ppc_text_csects
;
5808 else if (S_GET_SEGMENT (sym
) == data_section
)
5809 csect
= ppc_data_csects
;
5813 /* Skip the initial dummy symbol. */
5814 csect
= symbol_get_tc (csect
)->next
;
5816 if (csect
== (symbolS
*) NULL
)
5818 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5819 a
->x_csect
.x_scnlen
.l
= 0;
5823 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5825 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5826 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5827 > S_GET_VALUE (sym
))
5829 csect
= symbol_get_tc (csect
)->next
;
5832 a
->x_csect
.x_scnlen
.p
=
5833 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5834 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5837 a
->x_csect
.x_smtyp
= XTY_LD
;
5840 a
->x_csect
.x_parmhash
= 0;
5841 a
->x_csect
.x_snhash
= 0;
5842 if (symbol_get_tc (sym
)->symbol_class
== -1)
5843 a
->x_csect
.x_smclas
= XMC_PR
;
5845 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5846 a
->x_csect
.x_stab
= 0;
5847 a
->x_csect
.x_snstab
= 0;
5849 /* Don't let the COFF backend resort these symbols. */
5850 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5852 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5854 /* We want the value to be the symbol index of the referenced
5855 csect symbol. BFD will do that for us if we set the right
5857 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5858 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5860 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5861 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5863 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5868 block
= symbol_get_tc (sym
)->within
;
5871 /* The value is the offset from the enclosing csect. */
5874 csect
= symbol_get_tc (block
)->within
;
5875 resolve_symbol_value (csect
);
5876 base
= S_GET_VALUE (csect
);
5881 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5883 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5884 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5886 /* We want the value to be a file offset into the line numbers.
5887 BFD will do that for us if we set the right flags. We have
5888 already set the value correctly. */
5889 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5895 /* Adjust the symbol table. This creates csect symbols for all
5896 absolute symbols. */
5899 ppc_adjust_symtab (void)
5906 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5910 union internal_auxent
*a
;
5912 if (S_GET_SEGMENT (sym
) != absolute_section
)
5915 csect
= symbol_create (".abs[XO]", absolute_section
,
5916 S_GET_VALUE (sym
), &zero_address_frag
);
5917 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5918 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5919 i
= S_GET_NUMBER_AUXILIARY (csect
);
5920 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5921 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5922 a
->x_csect
.x_scnlen
.l
= 0;
5923 a
->x_csect
.x_smtyp
= XTY_SD
;
5924 a
->x_csect
.x_parmhash
= 0;
5925 a
->x_csect
.x_snhash
= 0;
5926 a
->x_csect
.x_smclas
= XMC_XO
;
5927 a
->x_csect
.x_stab
= 0;
5928 a
->x_csect
.x_snstab
= 0;
5930 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5932 i
= S_GET_NUMBER_AUXILIARY (sym
);
5933 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5934 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5935 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5938 ppc_saw_abs
= FALSE
;
5941 /* Set the VMA for a section. This is called on all the sections in
5945 ppc_frob_section (asection
*sec
)
5947 static bfd_vma vma
= 0;
5949 /* Dwarf sections start at 0. */
5950 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5953 vma
= md_section_align (sec
, vma
);
5954 bfd_set_section_vma (stdoutput
, sec
, vma
);
5955 vma
+= bfd_section_size (stdoutput
, sec
);
5958 #endif /* OBJ_XCOFF */
5961 md_atof (int type
, char *litp
, int *sizep
)
5963 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5966 /* Write a value out to the object file, using the appropriate
5970 md_number_to_chars (char *buf
, valueT val
, int n
)
5972 if (target_big_endian
)
5973 number_to_chars_bigendian (buf
, val
, n
);
5975 number_to_chars_littleendian (buf
, val
, n
);
5978 /* Align a section (I don't know why this is machine dependent). */
5981 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5986 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5988 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5992 /* We don't have any form of relaxing. */
5995 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5996 asection
*seg ATTRIBUTE_UNUSED
)
6002 /* Convert a machine dependent frag. We never generate these. */
6005 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6006 asection
*sec ATTRIBUTE_UNUSED
,
6007 fragS
*fragp ATTRIBUTE_UNUSED
)
6012 /* We have no need to default values of symbols. */
6015 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6020 /* Functions concerning relocs. */
6022 /* The location from which a PC relative jump should be calculated,
6023 given a PC relative reloc. */
6026 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6028 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6033 /* This is called to see whether a fixup should be adjusted to use a
6034 section symbol. We take the opportunity to change a fixup against
6035 a symbol in the TOC subsegment into a reloc against the
6036 corresponding .tc symbol. */
6039 ppc_fix_adjustable (fixS
*fix
)
6041 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6042 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6043 TC_SYMFIELD_TYPE
*tc
;
6045 if (symseg
== absolute_section
)
6048 /* Always adjust symbols in debugging sections. */
6049 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6052 if (ppc_toc_csect
!= (symbolS
*) NULL
6053 && fix
->fx_addsy
!= ppc_toc_csect
6054 && symseg
== data_section
6055 && val
>= ppc_toc_frag
->fr_address
6056 && (ppc_after_toc_frag
== (fragS
*) NULL
6057 || val
< ppc_after_toc_frag
->fr_address
))
6061 for (sy
= symbol_next (ppc_toc_csect
);
6062 sy
!= (symbolS
*) NULL
;
6063 sy
= symbol_next (sy
))
6065 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6067 if (sy_tc
->symbol_class
== XMC_TC0
)
6069 if (sy_tc
->symbol_class
!= XMC_TC
)
6071 if (val
== resolve_symbol_value (sy
))
6074 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6079 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6080 _("symbol in .toc does not match any .tc"));
6083 /* Possibly adjust the reloc to be against the csect. */
6084 tc
= symbol_get_tc (fix
->fx_addsy
);
6086 && tc
->symbol_class
!= XMC_TC0
6087 && tc
->symbol_class
!= XMC_TC
6088 && symseg
!= bss_section
6089 /* Don't adjust if this is a reloc in the toc section. */
6090 && (symseg
!= data_section
6091 || ppc_toc_csect
== NULL
6092 || val
< ppc_toc_frag
->fr_address
6093 || (ppc_after_toc_frag
!= NULL
6094 && val
>= ppc_after_toc_frag
->fr_address
)))
6096 symbolS
*csect
= tc
->within
;
6098 /* If the symbol was not declared by a label (eg: a section symbol),
6099 use the section instead of the csect. This doesn't happen in
6100 normal AIX assembly code. */
6102 csect
= seg_info (symseg
)->sym
;
6104 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6105 fix
->fx_addsy
= csect
;
6110 /* Adjust a reloc against a .lcomm symbol to be against the base
6112 if (symseg
== bss_section
6113 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6115 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6117 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6124 /* A reloc from one csect to another must be kept. The assembler
6125 will, of course, keep relocs between sections, and it will keep
6126 absolute relocs, but we need to force it to keep PC relative relocs
6127 between two csects in the same section. */
6130 ppc_force_relocation (fixS
*fix
)
6132 /* At this point fix->fx_addsy should already have been converted to
6133 a csect symbol. If the csect does not include the fragment, then
6134 we need to force the relocation. */
6136 && fix
->fx_addsy
!= NULL
6137 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6138 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6139 > fix
->fx_frag
->fr_address
)
6140 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6141 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6142 <= fix
->fx_frag
->fr_address
))))
6145 return generic_force_reloc (fix
);
6149 ppc_new_dot_label (symbolS
*sym
)
6151 /* Anchor this label to the current csect for relocations. */
6152 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6155 #endif /* OBJ_XCOFF */
6158 /* If this function returns non-zero, it guarantees that a relocation
6159 will be emitted for a fixup. */
6162 ppc_force_relocation (fixS
*fix
)
6164 /* Branch prediction relocations must force a relocation, as must
6165 the vtable description relocs. */
6166 switch (fix
->fx_r_type
)
6168 case BFD_RELOC_PPC_B16_BRTAKEN
:
6169 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6170 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6171 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6172 case BFD_RELOC_24_PLT_PCREL
:
6173 case BFD_RELOC_PPC64_TOC
:
6179 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6180 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6183 return generic_force_reloc (fix
);
6187 ppc_fix_adjustable (fixS
*fix
)
6189 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6190 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6191 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6192 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6193 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6194 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6195 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6196 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6197 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6198 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6199 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6204 ppc_frag_check (struct frag
*fragP
)
6206 if (!fragP
->has_code
)
6209 if (ppc_mach() == bfd_mach_ppc_vle
)
6211 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6212 as_bad (_("instruction address is not a multiple of 2"));
6216 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6217 as_bad (_("instruction address is not a multiple of 4"));
6221 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6222 rs_align_code frag. */
6225 ppc_handle_align (struct frag
*fragP
)
6227 valueT count
= (fragP
->fr_next
->fr_address
6228 - (fragP
->fr_address
+ fragP
->fr_fix
));
6230 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6232 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6235 md_number_to_chars (dest
, 0x4400, 2);
6237 else if (count
!= 0 && (count
& 3) == 0)
6239 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6243 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6247 /* Make a branch, then follow with nops. Insert another
6248 frag to handle the nops. */
6249 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6254 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6255 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6256 fragP
->fr_next
= rest
;
6258 rest
->fr_address
+= rest
->fr_fix
+ 4;
6260 /* If we leave the next frag as rs_align_code we'll come here
6261 again, resulting in a bunch of branches rather than a
6262 branch followed by nops. */
6263 rest
->fr_type
= rs_align
;
6264 dest
= rest
->fr_literal
;
6267 md_number_to_chars (dest
, 0x60000000, 4);
6269 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6270 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6271 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6273 /* For power6, power7 and power8, we want the last nop to be a group
6274 terminating one. Do this by inserting an rs_fill frag immediately
6275 after this one, with its address set to the last nop location.
6276 This will automatically reduce the number of nops in the current
6280 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6282 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6283 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6284 group_nop
->fr_fix
= 0;
6285 group_nop
->fr_offset
= 1;
6286 group_nop
->fr_type
= rs_fill
;
6287 fragP
->fr_next
= group_nop
;
6288 dest
= group_nop
->fr_literal
;
6291 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6292 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6294 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6295 /* e500mc group terminating nop: "ori 0,0,0". */
6296 md_number_to_chars (dest
, 0x60000000, 4);
6298 /* power7/power8 group terminating nop: "ori 2,2,0". */
6299 md_number_to_chars (dest
, 0x60420000, 4);
6302 /* power6 group terminating nop: "ori 1,1,0". */
6303 md_number_to_chars (dest
, 0x60210000, 4);
6308 /* Apply a fixup to the object code. This is called for all the
6309 fixups we generated by the calls to fix_new_exp, above. */
6312 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6314 valueT value
= * valP
;
6317 if (fixP
->fx_addsy
!= NULL
)
6319 /* Hack around bfd_install_relocation brain damage. */
6321 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6326 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6327 the symbol values. If we are doing this relocation the code in
6328 write.c is going to call bfd_install_relocation, which is also
6329 going to use the symbol value. That means that if the reloc is
6330 fully resolved we want to use *valP since bfd_install_relocation is
6332 However, if the reloc is not fully resolved we do not want to
6333 use *valP, and must use fx_offset instead. If the relocation
6334 is PC-relative, we then need to re-apply md_pcrel_from_section
6335 to this new relocation value. */
6336 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6341 value
= fixP
->fx_offset
;
6343 value
-= md_pcrel_from_section (fixP
, seg
);
6347 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6349 /* We can't actually support subtracting a symbol. */
6350 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6353 if (fixP
->fx_pcrel_adjust
!= 0)
6355 /* Handle relocs in an insn. */
6357 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6358 const struct powerpc_operand
*operand
= &powerpc_operands
[opindex
];
6364 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6365 does not generate a reloc. It uses the offset of `sym' within its
6366 csect. Other usages, such as `.long sym', generate relocs. This
6367 is the documented behaviour of non-TOC symbols. */
6368 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6369 && (operand
->bitm
& 0xfff0) == 0xfff0
6370 && operand
->shift
== 0
6371 && (operand
->insert
== NULL
|| ppc_obj64
)
6372 && fixP
->fx_addsy
!= NULL
6373 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6374 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6375 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6376 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6378 value
= fixP
->fx_offset
;
6383 switch (fixP
->fx_r_type
)
6386 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6391 case BFD_RELOC_LO16
:
6393 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6395 case BFD_RELOC_LO16_PCREL
:
6396 fieldval
= SEX16 (value
);
6399 case BFD_RELOC_HI16
:
6401 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6403 case BFD_RELOC_HI16_PCREL
:
6404 fieldval
= SEX16 (PPC_HI (value
));
6407 case BFD_RELOC_HI16_S
:
6409 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6411 case BFD_RELOC_HI16_S_PCREL
:
6412 fieldval
= SEX16 (PPC_HA (value
));
6416 case BFD_RELOC_PPC64_HIGHER
:
6419 fieldval
= SEX16 (PPC_HIGHER (value
));
6422 case BFD_RELOC_PPC64_HIGHER_S
:
6425 fieldval
= SEX16 (PPC_HIGHERA (value
));
6428 case BFD_RELOC_PPC64_HIGHEST
:
6431 fieldval
= SEX16 (PPC_HIGHEST (value
));
6434 case BFD_RELOC_PPC64_HIGHEST_S
:
6437 fieldval
= SEX16 (PPC_HIGHESTA (value
));
6440 /* The following relocs can't be calculated by the assembler.
6441 Leave the field zero. */
6442 case BFD_RELOC_PPC_TPREL16
:
6443 case BFD_RELOC_PPC_TPREL16_LO
:
6444 case BFD_RELOC_PPC_TPREL16_HI
:
6445 case BFD_RELOC_PPC_TPREL16_HA
:
6446 case BFD_RELOC_PPC_DTPREL16
:
6447 case BFD_RELOC_PPC_DTPREL16_LO
:
6448 case BFD_RELOC_PPC_DTPREL16_HI
:
6449 case BFD_RELOC_PPC_DTPREL16_HA
:
6450 case BFD_RELOC_PPC_GOT_TLSGD16
:
6451 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6452 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6453 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6454 case BFD_RELOC_PPC_GOT_TLSLD16
:
6455 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6456 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6457 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6458 case BFD_RELOC_PPC_GOT_TPREL16
:
6459 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6460 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6461 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6462 case BFD_RELOC_PPC_GOT_DTPREL16
:
6463 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6464 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6465 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6466 case BFD_RELOC_PPC64_TPREL16_DS
:
6467 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6468 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6469 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6470 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6471 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6472 case BFD_RELOC_PPC64_DTPREL16_DS
:
6473 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6474 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6475 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6476 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6477 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6478 gas_assert (fixP
->fx_addsy
!= NULL
);
6479 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6485 /* These also should leave the field zero for the same
6486 reason. Note that older versions of gas wrote values
6487 here. If we want to go back to the old behaviour, then
6488 all _LO and _LO_DS cases will need to be treated like
6489 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6490 case BFD_RELOC_16_GOTOFF
:
6491 case BFD_RELOC_LO16_GOTOFF
:
6492 case BFD_RELOC_HI16_GOTOFF
:
6493 case BFD_RELOC_HI16_S_GOTOFF
:
6494 case BFD_RELOC_LO16_PLTOFF
:
6495 case BFD_RELOC_HI16_PLTOFF
:
6496 case BFD_RELOC_HI16_S_PLTOFF
:
6497 case BFD_RELOC_GPREL16
:
6498 case BFD_RELOC_16_BASEREL
:
6499 case BFD_RELOC_LO16_BASEREL
:
6500 case BFD_RELOC_HI16_BASEREL
:
6501 case BFD_RELOC_HI16_S_BASEREL
:
6502 case BFD_RELOC_PPC_TOC16
:
6503 case BFD_RELOC_PPC64_TOC16_LO
:
6504 case BFD_RELOC_PPC64_TOC16_HI
:
6505 case BFD_RELOC_PPC64_TOC16_HA
:
6506 case BFD_RELOC_PPC64_PLTGOT16
:
6507 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6508 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6509 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6510 case BFD_RELOC_PPC64_GOT16_DS
:
6511 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6512 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6513 case BFD_RELOC_PPC64_SECTOFF_DS
:
6514 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6515 case BFD_RELOC_PPC64_TOC16_DS
:
6516 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6517 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6518 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6519 case BFD_RELOC_PPC_EMB_NADDR16
:
6520 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6521 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6522 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6523 case BFD_RELOC_PPC_EMB_SDAI16
:
6524 case BFD_RELOC_PPC_EMB_SDA2I16
:
6525 case BFD_RELOC_PPC_EMB_SDA2REL
:
6526 case BFD_RELOC_PPC_EMB_SDA21
:
6527 case BFD_RELOC_PPC_EMB_MRKREF
:
6528 case BFD_RELOC_PPC_EMB_RELSEC16
:
6529 case BFD_RELOC_PPC_EMB_RELST_LO
:
6530 case BFD_RELOC_PPC_EMB_RELST_HI
:
6531 case BFD_RELOC_PPC_EMB_RELST_HA
:
6532 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6533 case BFD_RELOC_PPC_EMB_RELSDA
:
6534 case BFD_RELOC_PPC_VLE_SDA21
:
6535 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6536 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6537 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6538 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6539 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6540 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6541 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6542 gas_assert (fixP
->fx_addsy
!= NULL
);
6545 case BFD_RELOC_PPC_TLS
:
6546 case BFD_RELOC_PPC_TLSGD
:
6547 case BFD_RELOC_PPC_TLSLD
:
6559 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6560 contents can stay at zero. */
6561 #define APPLY_RELOC fixP->fx_done
6563 #define APPLY_RELOC 1
6565 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6567 /* Fetch the instruction, insert the fully resolved operand
6568 value, and stuff the instruction back again. */
6569 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6570 if (target_big_endian
)
6572 if (fixP
->fx_size
== 4)
6573 insn
= bfd_getb32 ((unsigned char *) where
);
6575 insn
= bfd_getb16 ((unsigned char *) where
);
6579 if (fixP
->fx_size
== 4)
6580 insn
= bfd_getl32 ((unsigned char *) where
);
6582 insn
= bfd_getl16 ((unsigned char *) where
);
6584 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6585 fixP
->tc_fix_data
.ppc_cpu
,
6586 fixP
->fx_file
, fixP
->fx_line
);
6587 if (target_big_endian
)
6589 if (fixP
->fx_size
== 4)
6590 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6592 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6596 if (fixP
->fx_size
== 4)
6597 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6599 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6604 /* Nothing else to do here. */
6607 gas_assert (fixP
->fx_addsy
!= NULL
);
6608 if (fixP
->fx_r_type
== BFD_RELOC_UNUSED
)
6613 /* Use expr_symbol_where to see if this is an expression
6615 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6616 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6617 _("unresolved expression that must be resolved"));
6619 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6620 _("unsupported relocation against %s"),
6621 S_GET_NAME (fixP
->fx_addsy
));
6629 offsetT fieldval
= value
;
6631 /* Handle relocs in data. */
6632 switch (fixP
->fx_r_type
)
6634 case BFD_RELOC_CTOR
:
6641 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6644 case BFD_RELOC_32_PCREL
:
6652 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6655 case BFD_RELOC_64_PCREL
:
6661 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6664 case BFD_RELOC_16_PCREL
:
6679 /* Use expr_symbol_where to see if this is an
6680 expression symbol. */
6681 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6682 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6683 _("unresolved expression that must"
6686 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6687 _("cannot emit PC relative %s relocation"
6689 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6690 S_GET_NAME (fixP
->fx_addsy
));
6693 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6694 _("unable to resolve expression"));
6701 case BFD_RELOC_VTABLE_INHERIT
:
6703 && !S_IS_DEFINED (fixP
->fx_addsy
)
6704 && !S_IS_WEAK (fixP
->fx_addsy
))
6705 S_SET_WEAK (fixP
->fx_addsy
);
6708 case BFD_RELOC_VTABLE_ENTRY
:
6713 /* These can appear with @l etc. in data. */
6714 case BFD_RELOC_LO16
:
6716 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6717 case BFD_RELOC_LO16_PCREL
:
6721 case BFD_RELOC_HI16
:
6723 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6724 case BFD_RELOC_HI16_PCREL
:
6726 fieldval
= PPC_HI (value
);
6729 case BFD_RELOC_HI16_S
:
6731 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6732 case BFD_RELOC_HI16_S_PCREL
:
6734 fieldval
= PPC_HA (value
);
6737 case BFD_RELOC_PPC64_HIGHER
:
6741 fieldval
= PPC_HIGHER (value
);
6744 case BFD_RELOC_PPC64_HIGHER_S
:
6748 fieldval
= PPC_HIGHERA (value
);
6751 case BFD_RELOC_PPC64_HIGHEST
:
6755 fieldval
= PPC_HIGHEST (value
);
6758 case BFD_RELOC_PPC64_HIGHEST_S
:
6762 fieldval
= PPC_HIGHESTA (value
);
6765 case BFD_RELOC_PPC_DTPMOD
:
6766 case BFD_RELOC_PPC_TPREL
:
6767 case BFD_RELOC_PPC_DTPREL
:
6768 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6771 /* Just punt all of these to the linker. */
6772 case BFD_RELOC_PPC_B16_BRTAKEN
:
6773 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6774 case BFD_RELOC_16_GOTOFF
:
6775 case BFD_RELOC_LO16_GOTOFF
:
6776 case BFD_RELOC_HI16_GOTOFF
:
6777 case BFD_RELOC_HI16_S_GOTOFF
:
6778 case BFD_RELOC_LO16_PLTOFF
:
6779 case BFD_RELOC_HI16_PLTOFF
:
6780 case BFD_RELOC_HI16_S_PLTOFF
:
6781 case BFD_RELOC_PPC_COPY
:
6782 case BFD_RELOC_PPC_GLOB_DAT
:
6783 case BFD_RELOC_16_BASEREL
:
6784 case BFD_RELOC_LO16_BASEREL
:
6785 case BFD_RELOC_HI16_BASEREL
:
6786 case BFD_RELOC_HI16_S_BASEREL
:
6787 case BFD_RELOC_PPC_TLS
:
6788 case BFD_RELOC_PPC_DTPREL16_LO
:
6789 case BFD_RELOC_PPC_DTPREL16_HI
:
6790 case BFD_RELOC_PPC_DTPREL16_HA
:
6791 case BFD_RELOC_PPC_TPREL16_LO
:
6792 case BFD_RELOC_PPC_TPREL16_HI
:
6793 case BFD_RELOC_PPC_TPREL16_HA
:
6794 case BFD_RELOC_PPC_GOT_TLSGD16
:
6795 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6796 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6797 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6798 case BFD_RELOC_PPC_GOT_TLSLD16
:
6799 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6800 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6801 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6802 case BFD_RELOC_PPC_GOT_DTPREL16
:
6803 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6804 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6805 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6806 case BFD_RELOC_PPC_GOT_TPREL16
:
6807 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6808 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6809 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6810 case BFD_RELOC_24_PLT_PCREL
:
6811 case BFD_RELOC_PPC_LOCAL24PC
:
6812 case BFD_RELOC_32_PLT_PCREL
:
6813 case BFD_RELOC_GPREL16
:
6814 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6815 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6816 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6817 case BFD_RELOC_PPC_EMB_NADDR32
:
6818 case BFD_RELOC_PPC_EMB_NADDR16
:
6819 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6820 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6821 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6822 case BFD_RELOC_PPC_EMB_SDAI16
:
6823 case BFD_RELOC_PPC_EMB_SDA2REL
:
6824 case BFD_RELOC_PPC_EMB_SDA2I16
:
6825 case BFD_RELOC_PPC_EMB_SDA21
:
6826 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6827 case BFD_RELOC_PPC_EMB_MRKREF
:
6828 case BFD_RELOC_PPC_EMB_RELSEC16
:
6829 case BFD_RELOC_PPC_EMB_RELST_LO
:
6830 case BFD_RELOC_PPC_EMB_RELST_HI
:
6831 case BFD_RELOC_PPC_EMB_RELST_HA
:
6832 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6833 case BFD_RELOC_PPC_EMB_RELSDA
:
6834 case BFD_RELOC_PPC64_TOC
:
6835 case BFD_RELOC_PPC_TOC16
:
6836 case BFD_RELOC_PPC64_TOC16_LO
:
6837 case BFD_RELOC_PPC64_TOC16_HI
:
6838 case BFD_RELOC_PPC64_TOC16_HA
:
6839 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6840 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6841 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6842 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6843 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6844 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6845 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6846 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6852 case BFD_RELOC_NONE
:
6858 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6863 if (size
&& APPLY_RELOC
)
6864 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6869 ppc_elf_validate_fix (fixP
, seg
);
6870 fixP
->fx_addnumber
= value
;
6872 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6873 from the section contents. If we are going to be emitting a reloc
6874 then the section contents are immaterial, so don't warn if they
6875 happen to overflow. Leave such warnings to ld. */
6878 fixP
->fx_no_overflow
= 1;
6880 /* Arrange to emit .TOC. as a normal symbol if used in anything
6881 but .TOC.@tocbase. */
6883 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
6884 && fixP
->fx_addsy
!= NULL
6885 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
6886 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
6889 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6890 fixP
->fx_addnumber
= 0;
6894 fixP
->fx_addnumber
= 0;
6896 /* We want to use the offset within the toc, not the actual VMA
6898 fixP
->fx_addnumber
=
6899 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6900 - S_GET_VALUE (ppc_toc_csect
);
6906 /* Generate a reloc for a fixup. */
6909 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6913 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6915 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6916 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6917 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6918 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6919 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6921 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6922 _("reloc %d not supported by object file format"),
6923 (int) fixp
->fx_r_type
);
6926 reloc
->addend
= fixp
->fx_addnumber
;
6932 ppc_cfi_frame_initial_instructions (void)
6934 cfi_add_CFA_def_cfa (1, 0);
6938 tc_ppc_regname_to_dw2regnum (char *regname
)
6940 unsigned int regnum
= -1;
6944 static struct { char *name
; int dw2regnum
; } regnames
[] =
6946 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6947 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6948 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6949 { "spe_acc", 111 }, { "spefscr", 112 }
6952 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6953 if (strcmp (regnames
[i
].name
, regname
) == 0)
6954 return regnames
[i
].dw2regnum
;
6956 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6958 p
= regname
+ 1 + (regname
[1] == '.');
6959 regnum
= strtoul (p
, &q
, 10);
6960 if (p
== q
|| *q
|| regnum
>= 32)
6962 if (regname
[0] == 'f')
6964 else if (regname
[0] == 'v')
6967 else if (regname
[0] == 'c' && regname
[1] == 'r')
6969 p
= regname
+ 2 + (regname
[2] == '.');
6970 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6972 regnum
= p
[0] - '0' + 68;