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 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
68 #define PPC_HI(v) (((v) >> 16) & 0xffff)
70 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
71 the indicated value, compensating for #lo() being treated as a
73 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
75 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
76 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
78 /* #highera(value) denotes bits 32 through 47 of the indicated value,
79 compensating for #lo() being treated as a signed number. */
80 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
82 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
83 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
85 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
86 compensating for #lo being treated as a signed number. */
87 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
89 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
91 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
93 static void ppc_macro (char *, const struct powerpc_macro *);
94 static void ppc_byte (int);
96 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
97 static void ppc_tc (int);
98 static void ppc_machine (int);
102 static void ppc_comm (int);
103 static void ppc_bb (int);
104 static void ppc_bc (int);
105 static void ppc_bf (int);
106 static void ppc_biei (int);
107 static void ppc_bs (int);
108 static void ppc_eb (int);
109 static void ppc_ec (int);
110 static void ppc_ef (int);
111 static void ppc_es (int);
112 static void ppc_csect (int);
113 static void ppc_dwsect (int);
114 static void ppc_change_csect (symbolS *, offsetT);
115 static void ppc_function (int);
116 static void ppc_extern (int);
117 static void ppc_lglobl (int);
118 static void ppc_ref (int);
119 static void ppc_section (int);
120 static void ppc_named_section (int);
121 static void ppc_stabx (int);
122 static void ppc_rename (int);
123 static void ppc_toc (int);
124 static void ppc_xcoff_cons (int);
125 static void ppc_vbyte (int);
129 static void ppc_elf_cons (int);
130 static void ppc_elf_rdata (int);
131 static void ppc_elf_lcomm (int);
135 static void ppc_previous (int);
136 static void ppc_pdata (int);
137 static void ppc_ydata (int);
138 static void ppc_reldata (int);
139 static void ppc_rdata (int);
140 static void ppc_ualong (int);
141 static void ppc_znop (int);
142 static void ppc_pe_comm (int);
143 static void ppc_pe_section (int);
144 static void ppc_pe_function (int);
145 static void ppc_pe_tocd (int);
148 /* Generic assembler global variables which must be defined by all
152 /* This string holds the chars that always start a comment. If the
153 pre-processor is disabled, these aren't very useful. The macro
154 tc_comment_chars points to this. We use this, rather than the
155 usual comment_chars, so that we can switch for Solaris conventions. */
156 static const char ppc_solaris_comment_chars[] = "#!";
157 static const char ppc_eabi_comment_chars[] = "#";
159 #ifdef TARGET_SOLARIS_COMMENT
160 const char *ppc_comment_chars = ppc_solaris_comment_chars;
162 const char *ppc_comment_chars = ppc_eabi_comment_chars;
165 const char comment_chars[] = "#";
168 /* Characters which start a comment at the beginning of a line. */
169 const char line_comment_chars[] = "#";
171 /* Characters which may be used to separate multiple commands on a
173 const char line_separator_chars[] = ";";
175 /* Characters which are used to indicate an exponent in a floating
177 const char EXP_CHARS[] = "eE";
179 /* Characters which mean that a number is a floating point constant,
181 const char FLT_CHARS[] = "dD";
183 /* Anything that can start an operand needs to be mentioned here,
184 to stop the input scrubber eating whitespace. */
185 const char ppc_symbol_chars[] = "%[";
187 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
188 int ppc_cie_data_alignment;
190 /* The dwarf2 minimum instruction length. */
191 int ppc_dwarf2_line_min_insn_length;
193 /* More than this number of nops in an alignment op gets a branch
195 unsigned long nop_limit = 4;
197 /* The type of processor we are assembling for. This is one or more
198 of the PPC_OPCODE flags defined in opcode/ppc.h. */
199 ppc_cpu_t ppc_cpu = 0;
200 ppc_cpu_t sticky = 0;
202 /* Flags set on encountering toc relocs. */
204 has_large_toc_reloc = 1,
205 has_small_toc_reloc = 2
208 /* The target specific pseudo-ops which we support. */
210 const pseudo_typeS md_pseudo_table[] =
212 /* Pseudo-ops which must be overridden. */
213 { "byte", ppc_byte, 0 },
216 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
217 legitimately belong in the obj-*.c file. However, XCOFF is based
218 on COFF, and is only implemented for the RS/6000. We just use
219 obj-coff.c, and add what we need here. */
220 { "comm", ppc_comm, 0 },
221 { "lcomm", ppc_comm, 1 },
225 { "bi", ppc_biei, 0 },
227 { "csect", ppc_csect, 0 },
228 { "dwsect", ppc_dwsect, 0 },
229 { "data", ppc_section, 'd' },
233 { "ei", ppc_biei, 1 },
235 { "extern", ppc_extern, 0 },
236 { "function", ppc_function, 0 },
237 { "lglobl", ppc_lglobl, 0 },
238 { "ref", ppc_ref, 0 },
239 { "rename", ppc_rename, 0 },
240 { "section", ppc_named_section, 0 },
241 { "stabx", ppc_stabx, 0 },
242 { "text", ppc_section, 't' },
243 { "toc", ppc_toc, 0 },
244 { "long", ppc_xcoff_cons, 2 },
245 { "llong", ppc_xcoff_cons, 3 },
246 { "word", ppc_xcoff_cons, 1 },
247 { "short", ppc_xcoff_cons, 1 },
248 { "vbyte", ppc_vbyte, 0 },
252 { "llong", ppc_elf_cons, 8 },
253 { "quad", ppc_elf_cons, 8 },
254 { "long", ppc_elf_cons, 4 },
255 { "word", ppc_elf_cons, 2 },
256 { "short", ppc_elf_cons, 2 },
257 { "rdata", ppc_elf_rdata, 0 },
258 { "rodata", ppc_elf_rdata, 0 },
259 { "lcomm", ppc_elf_lcomm, 0 },
263 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
264 { "previous", ppc_previous, 0 },
265 { "pdata", ppc_pdata, 0 },
266 { "ydata", ppc_ydata, 0 },
267 { "reldata", ppc_reldata, 0 },
268 { "rdata", ppc_rdata, 0 },
269 { "ualong", ppc_ualong, 0 },
270 { "znop", ppc_znop, 0 },
271 { "comm", ppc_pe_comm, 0 },
272 { "lcomm", ppc_pe_comm, 1 },
273 { "section", ppc_pe_section, 0 },
274 { "function", ppc_pe_function,0 },
275 { "tocd", ppc_pe_tocd, 0 },
278 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
280 { "machine", ppc_machine, 0 },
287 /* Predefined register names if -mregnames (or default for Windows NT).
288 In general, there are lots of them, in an attempt to be compatible
289 with a number of other Windows NT assemblers. */
291 /* Structure to hold information about predefined registers. */
298 /* List of registers that are pre-defined:
300 Each general register has predefined names of the form:
301 1. r<reg_num> which has the value <reg_num>.
302 2. r.<reg_num> which has the value <reg_num>.
304 Each floating point register has predefined names of the form:
305 1. f<reg_num> which has the value <reg_num>.
306 2. f.<reg_num> which has the value <reg_num>.
308 Each vector unit register has predefined names of the form:
309 1. v<reg_num> which has the value <reg_num>.
310 2. v.<reg_num> which has the value <reg_num>.
312 Each condition register has predefined names of the form:
313 1. cr<reg_num> which has the value <reg_num>.
314 2. cr.<reg_num> which has the value <reg_num>.
316 There are individual registers as well:
317 sp or r.sp has the value 1
318 rtoc or r.toc has the value 2
319 fpscr has the value 0
325 dsisr has the value 18
327 sdr1 has the value 25
328 srr0 has the value 26
329 srr1 has the value 27
331 The table is sorted. Suitable for searching by a binary search. */
333 static const struct pd_reg pre_defined_registers[] =
335 { "cr.0", 0 }, /* Condition Registers */
355 { "dar", 19 }, /* Data Access Register */
356 { "dec", 22 }, /* Decrementer */
357 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
359 { "f.0", 0 }, /* Floating point registers */
386 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
452 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
493 /* Quantization registers used with pair single instructions. */
511 { "lr", 8 }, /* Link Register */
515 { "r.0", 0 }, /* General Purpose Registers */
548 { "r.sp", 1 }, /* Stack Pointer */
550 { "r.toc", 2 }, /* Pointer to the table of contents */
552 { "r0", 0 }, /* More general purpose registers */
585 { "rtoc", 2 }, /* Table of contents */
587 { "sdr1", 25 }, /* Storage Description Register 1 */
591 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
592 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
594 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
660 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
794 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
796 /* Given NAME, find the register number associated with that name, return
797 the integer value associated with the given name or -1 on failure. */
800 reg_name_search (const struct pd_reg *regs, int regcount, const char *name)
802 int middle, low, high;
810 middle = (low + high) / 2;
811 cmp = strcasecmp (name, regs[middle].name);
817 return regs[middle].value;
825 * Summary of register_name.
827 * in: Input_line_pointer points to 1st char of operand.
829 * out: A expressionS.
830 * The operand may have been a register: in this case, X_op == O_register,
831 * X_add_number is set to the register number, and truth is returned.
832 * Input_line_pointer->(next non-blank) char after operand, or is in its
837 register_name (expressionS *expressionP)
844 /* Find the spelling of the operand. */
845 start = name = input_line_pointer;
846 if (name[0] == '%' && ISALPHA (name[1]))
847 name = ++input_line_pointer;
849 else if (!reg_names_p || !ISALPHA (name[0]))
852 c = get_symbol_end ();
853 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
855 /* Put back the delimiting char. */
856 *input_line_pointer = c;
858 /* Look to see if it's in the register table. */
861 expressionP->X_op = O_register;
862 expressionP->X_add_number = reg_number;
864 /* Make the rest nice. */
865 expressionP->X_add_symbol = NULL;
866 expressionP->X_op_symbol = NULL;
870 /* Reset the line as if we had not done anything. */
871 input_line_pointer = start;
875 /* This function is called for each symbol seen in an expression. It
876 handles the special parsing which PowerPC assemblers are supposed
877 to use for condition codes. */
879 /* Whether to do the special parsing. */
880 static bfd_boolean cr_operand;
882 /* Names to recognize in a condition code. This table is sorted. */
883 static const struct pd_reg cr_names[] =
900 /* Parsing function. This returns non-zero if it recognized an
904 ppc_parse_name (const char *name, expressionS *exp)
913 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
918 exp->X_op = O_constant;
919 exp->X_add_number = val;
924 /* Local variables. */
926 /* Whether to target xcoff64/elf64. */
927 static unsigned int ppc_obj64 = BFD_DEFAULT_TARGET_SIZE == 64;
929 /* Opcode hash table. */
930 static struct hash_control *ppc_hash;
932 /* Macro hash table. */
933 static struct hash_control *ppc_macro_hash;
936 /* What type of shared library support to use. */
937 static enum { SHLIB_NONE, SHLIB_PIC, SHLIB_MRELOCATABLE } shlib = SHLIB_NONE;
939 /* Flags to set in the elf header. */
940 static flagword ppc_flags = 0;
942 /* Whether this is Solaris or not. */
943 #ifdef TARGET_SOLARIS_COMMENT
944 #define SOLARIS_P TRUE
946 #define SOLARIS_P FALSE
949 static bfd_boolean msolaris = SOLARIS_P;
954 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
955 using a bunch of different sections. These assembler sections,
956 however, are all encompassed within the .text or .data sections of
957 the final output file. We handle this by using different
958 subsegments within these main segments. */
960 /* Next subsegment to allocate within the .text segment. */
961 static subsegT ppc_text_subsegment = 2;
963 /* Linked list of csects in the text section. */
964 static symbolS *ppc_text_csects;
966 /* Next subsegment to allocate within the .data segment. */
967 static subsegT ppc_data_subsegment = 2;
969 /* Linked list of csects in the data section. */
970 static symbolS *ppc_data_csects;
972 /* The current csect. */
973 static symbolS *ppc_current_csect;
975 /* The RS/6000 assembler uses a TOC which holds addresses of functions
976 and variables. Symbols are put in the TOC with the .tc pseudo-op.
977 A special relocation is used when accessing TOC entries. We handle
978 the TOC as a subsegment within the .data segment. We set it up if
979 we see a .toc pseudo-op, and save the csect symbol here. */
980 static symbolS *ppc_toc_csect;
982 /* The first frag in the TOC subsegment. */
983 static fragS *ppc_toc_frag;
985 /* The first frag in the first subsegment after the TOC in the .data
986 segment. NULL if there are no subsegments after the TOC. */
987 static fragS *ppc_after_toc_frag;
989 /* The current static block. */
990 static symbolS *ppc_current_block;
992 /* The COFF debugging section; set by md_begin. This is not the
993 .debug section, but is instead the secret BFD section which will
994 cause BFD to set the section number of a symbol to N_DEBUG. */
995 static asection *ppc_coff_debug_section;
997 /* Structure to set the length field of the dwarf sections. */
998 struct dw_subsection {
999 /* Subsections are simply linked. */
1000 struct dw_subsection *link;
1002 /* The subsection number. */
1005 /* Expression to compute the length of the section. */
1006 expressionS end_exp;
1009 static struct dw_section {
1010 /* Corresponding section. */
1013 /* Simply linked list of subsections with a label. */
1014 struct dw_subsection *list_subseg;
1016 /* The anonymous subsection. */
1017 struct dw_subsection *anon_subseg;
1018 } dw_sections[XCOFF_DWSECT_NBR_NAMES];
1019 #endif /* OBJ_XCOFF */
1023 /* Various sections that we need for PE coff support. */
1024 static segT ydata_section;
1025 static segT pdata_section;
1026 static segT reldata_section;
1027 static segT rdata_section;
1028 static segT tocdata_section;
1030 /* The current section and the previous section. See ppc_previous. */
1031 static segT ppc_previous_section;
1032 static segT ppc_current_section;
1037 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1038 #define PPC_APUINFO_ISEL 0x40
1039 #define PPC_APUINFO_PMR 0x41
1040 #define PPC_APUINFO_RFMCI 0x42
1041 #define PPC_APUINFO_CACHELCK 0x43
1042 #define PPC_APUINFO_SPE 0x100
1043 #define PPC_APUINFO_EFS 0x101
1044 #define PPC_APUINFO_BRLOCK 0x102
1045 #define PPC_APUINFO_VLE 0x104
1048 * We keep a list of APUinfo
1050 unsigned long *ppc_apuinfo_list;
1051 unsigned int ppc_apuinfo_num;
1052 unsigned int ppc_apuinfo_num_alloc;
1053 #endif /* OBJ_ELF */
1056 const char *const md_shortopts = "b:l:usm:K:VQ:";
1058 const char *const md_shortopts = "um:";
1060 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1061 const struct option md_longopts[] = {
1062 {"nops", required_argument, NULL, OPTION_NOPS},
1063 {NULL, no_argument, NULL, 0}
1065 const size_t md_longopts_size = sizeof (md_longopts);
1068 md_parse_option (int c, char *arg)
1075 /* -u means that any undefined symbols should be treated as
1076 external, which is the default for gas anyhow. */
1081 /* Solaris as takes -le (presumably for little endian). For completeness
1082 sake, recognize -be also. */
1083 if (strcmp (arg, "e") == 0)
1085 target_big_endian = 0;
1086 set_target_endian = 1;
1087 if (ppc_cpu & PPC_OPCODE_VLE)
1088 as_bad (_("the use of -mvle requires big endian."));
1096 if (strcmp (arg, "e") == 0)
1098 target_big_endian = 1;
1099 set_target_endian = 1;
1107 /* Recognize -K PIC. */
1108 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
1111 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1119 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1121 if (strcmp (arg, "64") == 0)
1125 if (ppc_cpu & PPC_OPCODE_VLE)
1126 as_bad (_("the use of -mvle requires -a32."));
1128 as_fatal (_("%s unsupported"), "-a64");
1131 else if (strcmp (arg, "32") == 0)
1138 new_cpu = ppc_parse_cpu (ppc_cpu, &sticky, arg);
1142 if (strcmp (arg, "vle") == 0)
1144 if (set_target_endian && target_big_endian == 0)
1145 as_bad (_("the use of -mvle requires big endian."));
1147 as_bad (_("the use of -mvle requires -a32."));
1151 else if (strcmp (arg, "regnames") == 0)
1154 else if (strcmp (arg, "no-regnames") == 0)
1155 reg_names_p = FALSE;
1158 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1159 that require relocation. */
1160 else if (strcmp (arg, "relocatable") == 0)
1162 shlib = SHLIB_MRELOCATABLE;
1163 ppc_flags |= EF_PPC_RELOCATABLE;
1166 else if (strcmp (arg, "relocatable-lib") == 0)
1168 shlib = SHLIB_MRELOCATABLE;
1169 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1172 /* -memb, set embedded bit. */
1173 else if (strcmp (arg, "emb") == 0)
1174 ppc_flags |= EF_PPC_EMB;
1176 /* -mlittle/-mbig set the endianness. */
1177 else if (strcmp (arg, "little") == 0
1178 || strcmp (arg, "little-endian") == 0)
1180 target_big_endian = 0;
1181 set_target_endian = 1;
1182 if (ppc_cpu & PPC_OPCODE_VLE)
1183 as_bad (_("the use of -mvle requires big endian."));
1186 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
1188 target_big_endian = 1;
1189 set_target_endian = 1;
1192 else if (strcmp (arg, "solaris") == 0)
1195 ppc_comment_chars = ppc_solaris_comment_chars;
1198 else if (strcmp (arg, "no-solaris") == 0)
1201 ppc_comment_chars = ppc_eabi_comment_chars;
1206 as_bad (_("invalid switch -m%s"), arg);
1212 /* -V: SVR4 argument to print version ID. */
1214 print_version_id ();
1217 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1218 should be emitted or not. FIXME: Not implemented. */
1222 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1223 rather than .stabs.excl, which is ignored by the linker.
1224 FIXME: Not implemented. */
1235 nop_limit = strtoul (optarg, &end, 0);
1237 as_bad (_("--nops needs a numeric argument"));
1249 md_show_usage (FILE *stream)
1251 fprintf (stream, _("\
1253 -a32 generate ELF32/XCOFF32\n\
1254 -a64 generate ELF64/XCOFF64\n\
1256 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1257 -mpwr generate code for POWER (RIOS1)\n\
1258 -m601 generate code for PowerPC 601\n\
1259 -mppc, -mppc32, -m603, -m604\n\
1260 generate code for PowerPC 603/604\n\
1261 -m403 generate code for PowerPC 403\n\
1262 -m405 generate code for PowerPC 405\n\
1263 -m440 generate code for PowerPC 440\n\
1264 -m464 generate code for PowerPC 464\n\
1265 -m476 generate code for PowerPC 476\n\
1266 -m7400, -m7410, -m7450, -m7455\n\
1267 generate code for PowerPC 7400/7410/7450/7455\n\
1268 -m750cl generate code for PowerPC 750cl\n"));
1269 fprintf (stream, _("\
1270 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1271 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1272 -mbooke generate code for 32-bit PowerPC BookE\n\
1273 -ma2 generate code for A2 architecture\n\
1274 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1275 -mpower5, -mpwr5, -mpwr5x\n\
1276 generate code for Power5 architecture\n\
1277 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1278 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1279 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1280 -mcell generate code for Cell Broadband Engine architecture\n\
1281 -mcom generate code Power/PowerPC common instructions\n\
1282 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1283 fprintf (stream, _("\
1284 -maltivec generate code for AltiVec\n\
1285 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1286 -mhtm generate code for Hardware Transactional Memory\n\
1287 -me300 generate code for PowerPC e300 family\n\
1288 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1289 -me500mc, generate code for Freescale e500mc core complex\n\
1290 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1291 -me5500, generate code for Freescale e5500 core complex\n\
1292 -me6500, generate code for Freescale e6500 core complex\n\
1293 -mspe generate code for Motorola SPE instructions\n\
1294 -mvle generate code for Freescale VLE instructions\n\
1295 -mtitan generate code for AppliedMicro Titan core complex\n\
1296 -mregnames Allow symbolic names for registers\n\
1297 -mno-regnames Do not allow symbolic names for registers\n"));
1299 fprintf (stream, _("\
1300 -mrelocatable support for GCC's -mrelocatble option\n\
1301 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1302 -memb set PPC_EMB bit in ELF flags\n\
1303 -mlittle, -mlittle-endian, -le\n\
1304 generate code for a little endian machine\n\
1305 -mbig, -mbig-endian, -be\n\
1306 generate code for a big endian machine\n\
1307 -msolaris generate code for Solaris\n\
1308 -mno-solaris do not generate code for Solaris\n\
1309 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1310 -V print assembler version number\n\
1311 -Qy, -Qn ignored\n"));
1313 fprintf (stream, _("\
1314 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1317 /* Set ppc_cpu if it is not already set. */
1322 const char *default_os = TARGET_OS;
1323 const char *default_cpu = TARGET_CPU;
1325 if ((ppc_cpu & ~(ppc_cpu_t) PPC_OPCODE_ANY) == 0)
1328 ppc_cpu |= PPC_OPCODE_PPC | PPC_OPCODE_64;
1329 else if (strncmp (default_os, "aix", 3) == 0
1330 && default_os[3] >= '4' && default_os[3] <= '9')
1331 ppc_cpu |= PPC_OPCODE_COMMON;
1332 else if (strncmp (default_os, "aix3", 4) == 0)
1333 ppc_cpu |= PPC_OPCODE_POWER;
1334 else if (strcmp (default_cpu, "rs6000") == 0)
1335 ppc_cpu |= PPC_OPCODE_POWER;
1336 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1337 ppc_cpu |= PPC_OPCODE_PPC;
1339 as_fatal (_("unknown default cpu = %s, os = %s"),
1340 default_cpu, default_os);
1344 /* Figure out the BFD architecture to use. This function and ppc_mach
1345 are called well before md_begin, when the output file is opened. */
1347 enum bfd_architecture
1350 const char *default_cpu = TARGET_CPU;
1353 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
1354 return bfd_arch_powerpc;
1355 if ((ppc_cpu & PPC_OPCODE_VLE) != 0)
1356 return bfd_arch_powerpc;
1357 if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
1358 return bfd_arch_rs6000;
1359 if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
1361 if (strcmp (default_cpu, "rs6000") == 0)
1362 return bfd_arch_rs6000;
1363 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1364 return bfd_arch_powerpc;
1367 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1368 return bfd_arch_unknown;
1375 return bfd_mach_ppc64;
1376 else if (ppc_arch () == bfd_arch_rs6000)
1377 return bfd_mach_rs6k;
1378 else if (ppc_cpu & PPC_OPCODE_TITAN)
1379 return bfd_mach_ppc_titan;
1380 else if (ppc_cpu & PPC_OPCODE_VLE)
1381 return bfd_mach_ppc_vle;
1383 return bfd_mach_ppc;
1387 ppc_target_format (void)
1391 return target_big_endian ? "pe-powerpc" : "pe-powerpcle";
1393 return "xcoff-powermac";
1396 return (ppc_obj64 ? "aix5coff64-rs6000" : "aixcoff-rs6000");
1398 return (ppc_obj64 ? "aixcoff64-rs6000" : "aixcoff-rs6000");
1404 return (ppc_obj64 ? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1405 # elif defined (TE_VXWORKS)
1406 return "elf32-powerpc-vxworks";
1408 return (target_big_endian
1409 ? (ppc_obj64 ? "elf64-powerpc" : "elf32-powerpc")
1410 : (ppc_obj64 ? "elf64-powerpcle" : "elf32-powerpcle"));
1415 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1416 Return TRUE if there's a problem, otherwise FALSE. */
1419 insn_validate (const struct powerpc_opcode *op)
1421 const unsigned char *o;
1422 unsigned long omask = op->mask;
1424 /* The mask had better not trim off opcode bits. */
1425 if ((op->opcode & omask) != op->opcode)
1427 as_bad (_("mask trims opcode bits for %s"), op->name);
1431 /* The operands must not overlap the opcode or each other. */
1432 for (o = op->operands; *o; ++o)
1434 if (*o >= num_powerpc_operands)
1436 as_bad (_("operand index error for %s"), op->name);
1441 const struct powerpc_operand *operand = &powerpc_operands[*o];
1442 if (operand->shift != PPC_OPSHIFT_INV)
1446 if (operand->shift >= 0)
1447 mask = operand->bitm << operand->shift;
1449 mask = operand->bitm >> -operand->shift;
1452 as_bad (_("operand %d overlap in %s"),
1453 (int) (o - op->operands), op->name);
1463 /* Insert opcodes and macros into hash tables. Called at startup and
1464 for .machine pseudo. */
1467 ppc_setup_opcodes (void)
1469 const struct powerpc_opcode *op;
1470 const struct powerpc_opcode *op_end;
1471 const struct powerpc_macro *macro;
1472 const struct powerpc_macro *macro_end;
1473 bfd_boolean bad_insn = FALSE;
1475 if (ppc_hash != NULL)
1476 hash_die (ppc_hash);
1477 if (ppc_macro_hash != NULL)
1478 hash_die (ppc_macro_hash);
1480 /* Insert the opcodes into a hash table. */
1481 ppc_hash = hash_new ();
1483 if (ENABLE_CHECKING)
1487 /* An index into powerpc_operands is stored in struct fix
1488 fx_pcrel_adjust which is 8 bits wide. */
1489 gas_assert (num_powerpc_operands < 256);
1491 /* Check operand masks. Code here and in the disassembler assumes
1492 all the 1's in the mask are contiguous. */
1493 for (i = 0; i < num_powerpc_operands; ++i)
1495 unsigned long mask = powerpc_operands[i].bitm;
1496 unsigned long right_bit;
1499 right_bit = mask & -mask;
1501 right_bit = mask & -mask;
1502 if (mask != right_bit)
1504 as_bad (_("powerpc_operands[%d].bitm invalid"), i);
1507 for (j = i + 1; j < num_powerpc_operands; ++j)
1508 if (memcmp (&powerpc_operands[i], &powerpc_operands[j],
1509 sizeof (powerpc_operands[0])) == 0)
1511 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1518 op_end = powerpc_opcodes + powerpc_num_opcodes;
1519 for (op = powerpc_opcodes; op < op_end; op++)
1521 if (ENABLE_CHECKING)
1523 if (op != powerpc_opcodes)
1525 int old_opcode = PPC_OP (op[-1].opcode);
1526 int new_opcode = PPC_OP (op[0].opcode);
1528 #ifdef PRINT_OPCODE_TABLE
1529 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1530 op->name, op - powerpc_opcodes, (unsigned int) new_opcode,
1531 (unsigned int) op->opcode, (unsigned int) op->mask,
1532 (unsigned long long) op->flags);
1535 /* The major opcodes had better be sorted. Code in the
1536 disassembler assumes the insns are sorted according to
1538 if (new_opcode < old_opcode)
1540 as_bad (_("major opcode is not sorted for %s"),
1545 bad_insn |= insn_validate (op);
1548 if ((ppc_cpu & op->flags) != 0
1549 && !(ppc_cpu & op->deprecated))
1553 retval = hash_insert (ppc_hash, op->name, (void *) op);
1556 as_bad (_("duplicate instruction %s"),
1563 if ((ppc_cpu & PPC_OPCODE_ANY) != 0)
1564 for (op = powerpc_opcodes; op < op_end; op++)
1565 hash_insert (ppc_hash, op->name, (void *) op);
1567 op_end = vle_opcodes + vle_num_opcodes;
1568 for (op = vle_opcodes; op < op_end; op++)
1570 if (ENABLE_CHECKING)
1572 if (op != vle_opcodes)
1574 unsigned old_seg, new_seg;
1576 old_seg = VLE_OP (op[-1].opcode, op[-1].mask);
1577 old_seg = VLE_OP_TO_SEG (old_seg);
1578 new_seg = VLE_OP (op[0].opcode, op[0].mask);
1579 new_seg = VLE_OP_TO_SEG (new_seg);
1581 #ifdef PRINT_OPCODE_TABLE
1582 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1583 op->name, op - powerpc_opcodes, (unsigned int) new_opcode,
1584 (unsigned int) op->opcode, (unsigned int) op->mask,
1585 (unsigned long long) op->flags);
1587 /* The major opcodes had better be sorted. Code in the
1588 disassembler assumes the insns are sorted according to
1590 if (new_seg < old_seg)
1592 as_bad (_("major opcode is not sorted for %s"),
1598 bad_insn |= insn_validate (op);
1601 if ((ppc_cpu & op->flags) != 0
1602 && !(ppc_cpu & op->deprecated))
1606 retval = hash_insert (ppc_hash, op->name, (void *) op);
1609 as_bad (_("duplicate instruction %s"),
1616 if ((ppc_cpu & PPC_OPCODE_VLE) != 0)
1617 for (op = vle_opcodes; op < op_end; op++)
1618 hash_insert (ppc_hash, op->name, (void *) op);
1620 /* Insert the macros into a hash table. */
1621 ppc_macro_hash = hash_new ();
1623 macro_end = powerpc_macros + powerpc_num_macros;
1624 for (macro = powerpc_macros; macro < macro_end; macro++)
1626 if ((macro->flags & ppc_cpu) != 0 || (ppc_cpu & PPC_OPCODE_ANY) != 0)
1630 retval = hash_insert (ppc_macro_hash, macro->name, (void *) macro);
1631 if (retval != (const char *) NULL)
1633 as_bad (_("duplicate macro %s"), macro->name);
1643 /* This function is called when the assembler starts up. It is called
1644 after the options have been parsed and the output file has been
1652 ppc_cie_data_alignment = ppc_obj64 ? -8 : -4;
1653 ppc_dwarf2_line_min_insn_length = (ppc_cpu & PPC_OPCODE_VLE) ? 2 : 4;
1656 /* Set the ELF flags if desired. */
1657 if (ppc_flags && !msolaris)
1658 bfd_set_private_flags (stdoutput, ppc_flags);
1661 ppc_setup_opcodes ();
1663 /* Tell the main code what the endianness is if it is not overridden
1665 if (!set_target_endian)
1667 set_target_endian = 1;
1668 target_big_endian = PPC_BIG_ENDIAN;
1672 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1674 /* Create dummy symbols to serve as initial csects. This forces the
1675 text csects to precede the data csects. These symbols will not
1677 ppc_text_csects = symbol_make ("dummy\001");
1678 symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
1679 ppc_data_csects = symbol_make ("dummy\001");
1680 symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
1685 ppc_current_section = text_section;
1686 ppc_previous_section = 0;
1695 if (ppc_apuinfo_list == NULL)
1698 /* Ok, so write the section info out. We have this layout:
1702 0 8 length of "APUinfo\0"
1703 4 (n*4) number of APU's (4 bytes each)
1706 20 APU#1 first APU's info
1707 24 APU#2 second APU's info
1712 asection *seg = now_seg;
1713 subsegT subseg = now_subseg;
1714 asection *apuinfo_secp = (asection *) NULL;
1717 /* Create the .PPC.EMB.apuinfo section. */
1718 apuinfo_secp = subseg_new (".PPC.EMB.apuinfo", 0);
1719 bfd_set_section_flags (stdoutput,
1721 SEC_HAS_CONTENTS | SEC_READONLY);
1724 md_number_to_chars (p, (valueT) 8, 4);
1727 md_number_to_chars (p, (valueT) ppc_apuinfo_num * 4, 4);
1730 md_number_to_chars (p, (valueT) 2, 4);
1733 strcpy (p, "APUinfo");
1735 for (i = 0; i < ppc_apuinfo_num; i++)
1738 md_number_to_chars (p, (valueT) ppc_apuinfo_list[i], 4);
1741 frag_align (2, 0, 0);
1743 /* We probably can't restore the current segment, for there likely
1746 subseg_set (seg, subseg);
1751 /* Insert an operand value into an instruction. */
1753 static unsigned long
1754 ppc_insert_operand (unsigned long insn,
1755 const struct powerpc_operand *operand,
1761 long min, max, right;
1763 max = operand->bitm;
1767 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1769 if ((operand->flags & PPC_OPERAND_SIGNOPT) == 0)
1770 max = (max >> 1) & -right;
1771 min = ~max & -right;
1774 if ((operand->flags & PPC_OPERAND_PLUS1) != 0)
1777 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1786 /* Some people write constants with the sign extension done by
1787 hand but only up to 32 bits. This shouldn't really be valid,
1788 but, to permit this code to assemble on a 64-bit host, we
1789 sign extend the 32-bit value to 64 bits if so doing makes the
1792 && (offsetT) (val - 0x80000000 - 0x80000000) >= min
1793 && (offsetT) (val - 0x80000000 - 0x80000000) <= max
1794 && ((val - 0x80000000 - 0x80000000) & (right - 1)) == 0)
1795 val = val - 0x80000000 - 0x80000000;
1797 /* Similarly, people write expressions like ~(1<<15), and expect
1798 this to be OK for a 32-bit unsigned value. */
1800 && (offsetT) (val + 0x80000000 + 0x80000000) >= min
1801 && (offsetT) (val + 0x80000000 + 0x80000000) <= max
1802 && ((val + 0x80000000 + 0x80000000) & (right - 1)) == 0)
1803 val = val + 0x80000000 + 0x80000000;
1807 || (val & (right - 1)) != 0)
1808 as_bad_value_out_of_range (_("operand"), val, min, max, file, line);
1811 if (operand->insert)
1816 insn = (*operand->insert) (insn, (long) val, cpu, &errmsg);
1817 if (errmsg != (const char *) NULL)
1818 as_bad_where (file, line, "%s", errmsg);
1820 else if (operand->shift >= 0)
1821 insn |= ((long) val & operand->bitm) << operand->shift;
1823 insn |= ((long) val & operand->bitm) >> -operand->shift;
1830 /* Parse @got, etc. and return the desired relocation. */
1831 static bfd_reloc_code_real_type
1832 ppc_elf_suffix (char **str_p, expressionS *exp_p)
1836 unsigned int length : 8;
1837 unsigned int valid32 : 1;
1838 unsigned int valid64 : 1;
1847 const struct map_bfd *ptr;
1849 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1850 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1851 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1853 static const struct map_bfd mapping[] = {
1854 MAP ("l", BFD_RELOC_LO16),
1855 MAP ("h", BFD_RELOC_HI16),
1856 MAP ("ha", BFD_RELOC_HI16_S),
1857 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1858 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1859 MAP ("got", BFD_RELOC_16_GOTOFF),
1860 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1861 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1862 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1863 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1864 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1865 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1866 MAP ("copy", BFD_RELOC_PPC_COPY),
1867 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1868 MAP ("sectoff", BFD_RELOC_16_BASEREL),
1869 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1870 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1871 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1872 MAP ("tls", BFD_RELOC_PPC_TLS),
1873 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD),
1874 MAP ("dtprel", BFD_RELOC_PPC_DTPREL),
1875 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO),
1876 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI),
1877 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA),
1878 MAP ("tprel", BFD_RELOC_PPC_TPREL),
1879 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO),
1880 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI),
1881 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA),
1882 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16),
1883 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO),
1884 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI),
1885 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA),
1886 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16),
1887 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO),
1888 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI),
1889 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA),
1890 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16),
1891 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO),
1892 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI),
1893 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA),
1894 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16),
1895 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO),
1896 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI),
1897 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA),
1898 MAP32 ("fixup", BFD_RELOC_CTOR),
1899 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL),
1900 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1901 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1902 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC),
1903 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL),
1904 MAP32 ("sdarel", BFD_RELOC_GPREL16),
1905 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A),
1906 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A),
1907 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A),
1908 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1909 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1910 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1911 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1912 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1913 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1914 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1915 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1916 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1917 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO),
1918 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1919 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1920 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1921 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1922 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1923 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1924 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1925 MAP32 ("xgot", BFD_RELOC_PPC_TOC16),
1926 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER),
1927 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S),
1928 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST),
1929 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S),
1930 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC),
1931 MAP64 ("toc", BFD_RELOC_PPC_TOC16),
1932 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO),
1933 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI),
1934 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA),
1935 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER),
1936 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA),
1937 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST),
1938 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA),
1939 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER),
1940 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA),
1941 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST),
1942 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA),
1943 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED }
1947 return BFD_RELOC_UNUSED;
1949 for (ch = *str, str2 = ident;
1950 (str2 < ident + sizeof (ident) - 1
1951 && (ISALNUM (ch) || ch == '@'));
1954 *str2++ = TOLOWER (ch);
1961 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1962 if (ch == ptr->string[0]
1963 && len == ptr->length
1964 && memcmp (ident, ptr->string, ptr->length) == 0
1965 && (ppc_obj64 ? ptr->valid64 : ptr->valid32))
1967 int reloc = ptr->reloc;
1969 if (!ppc_obj64 && exp_p->X_add_number != 0)
1973 case BFD_RELOC_16_GOTOFF:
1974 case BFD_RELOC_LO16_GOTOFF:
1975 case BFD_RELOC_HI16_GOTOFF:
1976 case BFD_RELOC_HI16_S_GOTOFF:
1977 as_warn (_("identifier+constant@got means "
1978 "identifier@got+constant"));
1981 case BFD_RELOC_PPC_GOT_TLSGD16:
1982 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
1983 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
1984 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
1985 case BFD_RELOC_PPC_GOT_TLSLD16:
1986 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
1987 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
1988 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
1989 case BFD_RELOC_PPC_GOT_DTPREL16:
1990 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
1991 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
1992 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
1993 case BFD_RELOC_PPC_GOT_TPREL16:
1994 case BFD_RELOC_PPC_GOT_TPREL16_LO:
1995 case BFD_RELOC_PPC_GOT_TPREL16_HI:
1996 case BFD_RELOC_PPC_GOT_TPREL16_HA:
1997 as_bad (_("symbol+offset not supported for got tls"));
2002 /* Now check for identifier@suffix+constant. */
2003 if (*str == '-' || *str == '+')
2005 char *orig_line = input_line_pointer;
2006 expressionS new_exp;
2008 input_line_pointer = str;
2009 expression (&new_exp);
2010 if (new_exp.X_op == O_constant)
2012 exp_p->X_add_number += new_exp.X_add_number;
2013 str = input_line_pointer;
2016 if (&input_line_pointer != str_p)
2017 input_line_pointer = orig_line;
2021 if (reloc == (int) BFD_RELOC_PPC64_TOC
2022 && exp_p->X_op == O_symbol
2023 && strcmp (S_GET_NAME (exp_p->X_add_symbol), ".TOC.") == 0)
2025 /* Change the symbol so that the dummy .TOC. symbol can be
2026 omitted from the object file. */
2027 exp_p->X_add_symbol = &abs_symbol;
2030 return (bfd_reloc_code_real_type) reloc;
2033 return BFD_RELOC_UNUSED;
2036 /* Like normal .long/.short/.word, except support @got, etc.
2037 Clobbers input_line_pointer, checks end-of-line. */
2039 ppc_elf_cons (int nbytes /* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2042 bfd_reloc_code_real_type reloc;
2044 if (is_it_end_of_statement ())
2046 demand_empty_rest_of_line ();
2053 if (exp.X_op == O_symbol
2054 && *input_line_pointer == '@'
2055 && (reloc = ppc_elf_suffix (&input_line_pointer,
2056 &exp)) != BFD_RELOC_UNUSED)
2058 reloc_howto_type *reloc_howto;
2061 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
2062 size = bfd_get_reloc_size (reloc_howto);
2066 as_bad (_("%s relocations do not fit in %d bytes\n"),
2067 reloc_howto->name, nbytes);
2074 p = frag_more (nbytes);
2075 memset (p, 0, nbytes);
2077 if (target_big_endian)
2078 offset = nbytes - size;
2079 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
2084 emit_expr (&exp, (unsigned int) nbytes);
2086 while (*input_line_pointer++ == ',');
2088 /* Put terminator back into stream. */
2089 input_line_pointer--;
2090 demand_empty_rest_of_line ();
2093 /* Solaris pseduo op to change to the .rodata section. */
2095 ppc_elf_rdata (int xxx)
2097 char *save_line = input_line_pointer;
2098 static char section[] = ".rodata\n";
2100 /* Just pretend this is .section .rodata */
2101 input_line_pointer = section;
2102 obj_elf_section (xxx);
2104 input_line_pointer = save_line;
2107 /* Pseudo op to make file scope bss items. */
2109 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED)
2122 name = input_line_pointer;
2123 c = get_symbol_end ();
2125 /* just after name is now '\0'. */
2126 p = input_line_pointer;
2129 if (*input_line_pointer != ',')
2131 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2132 ignore_rest_of_line ();
2136 input_line_pointer++; /* skip ',' */
2137 if ((size = get_absolute_expression ()) < 0)
2139 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
2140 ignore_rest_of_line ();
2144 /* The third argument to .lcomm is the alignment. */
2145 if (*input_line_pointer != ',')
2149 ++input_line_pointer;
2150 align = get_absolute_expression ();
2153 as_warn (_("ignoring bad alignment"));
2159 symbolP = symbol_find_or_make (name);
2162 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
2164 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2165 S_GET_NAME (symbolP));
2166 ignore_rest_of_line ();
2170 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
2172 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2173 S_GET_NAME (symbolP),
2174 (long) S_GET_VALUE (symbolP),
2177 ignore_rest_of_line ();
2183 old_subsec = now_subseg;
2186 /* Convert to a power of 2 alignment. */
2187 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
2190 as_bad (_("common alignment not a power of 2"));
2191 ignore_rest_of_line ();
2198 record_alignment (bss_section, align2);
2199 subseg_set (bss_section, 0);
2201 frag_align (align2, 0, 0);
2202 if (S_GET_SEGMENT (symbolP) == bss_section)
2203 symbol_get_frag (symbolP)->fr_symbol = 0;
2204 symbol_set_frag (symbolP, frag_now);
2205 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
2208 S_SET_SIZE (symbolP, size);
2209 S_SET_SEGMENT (symbolP, bss_section);
2210 subseg_set (old_sec, old_subsec);
2211 demand_empty_rest_of_line ();
2214 /* Validate any relocations emitted for -mrelocatable, possibly adding
2215 fixups for word relocations in writable segments, so we can adjust
2218 ppc_elf_validate_fix (fixS *fixp, segT seg)
2220 if (fixp->fx_done || fixp->fx_pcrel)
2229 case SHLIB_MRELOCATABLE:
2230 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
2231 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
2232 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
2233 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
2234 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
2235 && fixp->fx_r_type != BFD_RELOC_16_BASEREL
2236 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
2237 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
2238 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
2239 && (seg->flags & SEC_LOAD) != 0
2240 && strcmp (segment_name (seg), ".got2") != 0
2241 && strcmp (segment_name (seg), ".dtors") != 0
2242 && strcmp (segment_name (seg), ".ctors") != 0
2243 && strcmp (segment_name (seg), ".fixup") != 0
2244 && strcmp (segment_name (seg), ".gcc_except_table") != 0
2245 && strcmp (segment_name (seg), ".eh_frame") != 0
2246 && strcmp (segment_name (seg), ".ex_shared") != 0)
2248 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
2249 || fixp->fx_r_type != BFD_RELOC_CTOR)
2251 as_bad_where (fixp->fx_file, fixp->fx_line,
2252 _("relocation cannot be done when using -mrelocatable"));
2259 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2260 function descriptor sym if the corresponding code sym is used. */
2263 ppc_frob_file_before_adjust (void)
2271 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2278 name = S_GET_NAME (symp);
2282 if (! S_IS_WEAK (symp)
2283 || S_IS_DEFINED (symp))
2286 len = strlen (name) + 1;
2287 dotname = xmalloc (len + 1);
2289 memcpy (dotname + 1, name, len);
2290 dotsym = symbol_find_noref (dotname, 1);
2292 if (dotsym != NULL && (symbol_used_p (dotsym)
2293 || symbol_used_in_reloc_p (dotsym)))
2294 symbol_mark_used (symp);
2298 toc = bfd_get_section_by_name (stdoutput, ".toc");
2300 && toc_reloc_types != has_large_toc_reloc
2301 && bfd_section_size (stdoutput, toc) > 0x10000)
2302 as_warn (_("TOC section size exceeds 64k"));
2305 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2306 emitted. Other uses of .TOC. will cause the symbol to be marked
2307 with BSF_KEEP in md_apply_fix. */
2310 ppc_elf_adjust_symtab (void)
2315 symp = symbol_find (".TOC.");
2318 asymbol *bsym = symbol_get_bfdsym (symp);
2319 if ((bsym->flags & BSF_KEEP) == 0)
2320 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2326 #endif /* OBJ_ELF */
2331 * Summary of parse_toc_entry.
2333 * in: Input_line_pointer points to the '[' in one of:
2335 * [toc] [tocv] [toc32] [toc64]
2337 * Anything else is an error of one kind or another.
2340 * return value: success or failure
2341 * toc_kind: kind of toc reference
2342 * input_line_pointer:
2343 * success: first char after the ']'
2344 * failure: unchanged
2348 * [toc] - rv == success, toc_kind = default_toc
2349 * [tocv] - rv == success, toc_kind = data_in_toc
2350 * [toc32] - rv == success, toc_kind = must_be_32
2351 * [toc64] - rv == success, toc_kind = must_be_64
2355 enum toc_size_qualifier
2357 default_toc, /* The toc cell constructed should be the system default size */
2358 data_in_toc, /* This is a direct reference to a toc cell */
2359 must_be_32, /* The toc cell constructed must be 32 bits wide */
2360 must_be_64 /* The toc cell constructed must be 64 bits wide */
2364 parse_toc_entry (enum toc_size_qualifier *toc_kind)
2369 enum toc_size_qualifier t;
2371 /* Save the input_line_pointer. */
2372 start = input_line_pointer;
2374 /* Skip over the '[' , and whitespace. */
2375 ++input_line_pointer;
2378 /* Find the spelling of the operand. */
2379 toc_spec = input_line_pointer;
2380 c = get_symbol_end ();
2382 if (strcmp (toc_spec, "toc") == 0)
2386 else if (strcmp (toc_spec, "tocv") == 0)
2390 else if (strcmp (toc_spec, "toc32") == 0)
2394 else if (strcmp (toc_spec, "toc64") == 0)
2400 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
2401 *input_line_pointer = c;
2402 input_line_pointer = start;
2406 /* Now find the ']'. */
2407 *input_line_pointer = c;
2409 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2410 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
2414 as_bad (_("syntax error: expected `]', found `%c'"), c);
2415 input_line_pointer = start;
2424 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2425 /* See whether a symbol is in the TOC section. */
2428 ppc_is_toc_sym (symbolS *sym)
2431 return (symbol_get_tc (sym)->symbol_class == XMC_TC
2432 || symbol_get_tc (sym)->symbol_class == XMC_TC0);
2435 const char *sname = segment_name (S_GET_SEGMENT (sym));
2437 return strcmp (sname, ".toc") == 0;
2439 return strcmp (sname, ".got") == 0;
2442 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2446 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2448 ppc_apuinfo_section_add (unsigned int apu, unsigned int version)
2452 /* Check we don't already exist. */
2453 for (i = 0; i < ppc_apuinfo_num; i++)
2454 if (ppc_apuinfo_list[i] == APUID (apu, version))
2457 if (ppc_apuinfo_num == ppc_apuinfo_num_alloc)
2459 if (ppc_apuinfo_num_alloc == 0)
2461 ppc_apuinfo_num_alloc = 4;
2462 ppc_apuinfo_list = (unsigned long *)
2463 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2467 ppc_apuinfo_num_alloc += 4;
2468 ppc_apuinfo_list = (unsigned long *) xrealloc (ppc_apuinfo_list,
2469 sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2472 ppc_apuinfo_list[ppc_apuinfo_num++] = APUID (apu, version);
2478 /* We need to keep a list of fixups. We can't simply generate them as
2479 we go, because that would require us to first create the frag, and
2480 that would screw up references to ``.''. */
2486 bfd_reloc_code_real_type reloc;
2489 #define MAX_INSN_FIXUPS (5)
2492 #define E_OR2I_INSN 0x7000C000
2493 #define E_AND2I_DOT_INSN 0x7000C800
2494 #define E_OR2IS_INSN 0x7000D000
2495 #define E_LIS_INSN 0x7000E000
2496 #define E_AND2IS_DOT_INSN 0x7000E800
2499 #define E_ADD2I_DOT_INSN 0x70008800
2500 #define E_ADD2IS_INSN 0x70009000
2501 #define E_CMP16I_INSN 0x70009800
2502 #define E_MULL2I_INSN 0x7000A000
2503 #define E_CMPL16I_INSN 0x7000A800
2504 #define E_CMPH16I_INSN 0x7000B000
2505 #define E_CMPHL16I_INSN 0x7000B800
2507 /* This routine is called for each instruction to be assembled. */
2510 md_assemble (char *str)
2513 const struct powerpc_opcode *opcode;
2515 const unsigned char *opindex_ptr;
2519 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
2524 unsigned int insn_length;
2526 /* Get the opcode. */
2527 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
2532 /* Look up the opcode in the hash table. */
2533 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
2534 if (opcode == (const struct powerpc_opcode *) NULL)
2536 const struct powerpc_macro *macro;
2538 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
2539 if (macro == (const struct powerpc_macro *) NULL)
2540 as_bad (_("unrecognized opcode: `%s'"), str);
2542 ppc_macro (s, macro);
2547 insn = opcode->opcode;
2550 while (ISSPACE (*str))
2553 /* PowerPC operands are just expressions. The only real issue is
2554 that a few operand types are optional. All cases which might use
2555 an optional operand separate the operands only with commas (in some
2556 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2557 have optional operands). Most instructions with optional operands
2558 have only one. Those that have more than one optional operand can
2559 take either all their operands or none. So, before we start seriously
2560 parsing the operands, we check to see if we have optional operands,
2561 and if we do, we count the number of commas to see which operands
2562 have been omitted. */
2564 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2566 const struct powerpc_operand *operand;
2568 operand = &powerpc_operands[*opindex_ptr];
2569 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
2571 unsigned int opcount;
2572 unsigned int num_operands_expected;
2574 /* There is an optional operand. Count the number of
2575 commas in the input line. */
2582 while ((s = strchr (s, ',')) != (char *) NULL)
2589 /* Compute the number of expected operands.
2590 Do not count fake operands. */
2591 for (num_operands_expected = 0, i = 0; opcode->operands[i]; i ++)
2592 if ((powerpc_operands [opcode->operands[i]].flags & PPC_OPERAND_FAKE) == 0)
2593 ++ num_operands_expected;
2595 /* If there are fewer operands in the line then are called
2596 for by the instruction, we want to skip the optional
2598 if (opcount < num_operands_expected)
2605 /* Gather the operands. */
2609 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2611 const struct powerpc_operand *operand;
2617 if (next_opindex == 0)
2618 operand = &powerpc_operands[*opindex_ptr];
2621 operand = &powerpc_operands[next_opindex];
2626 /* If this is a fake operand, then we do not expect anything
2628 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
2630 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2631 if (errmsg != (const char *) NULL)
2632 as_bad ("%s", errmsg);
2636 /* If this is an optional operand, and we are skipping it, just
2638 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
2641 if (operand->insert)
2643 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2644 if (errmsg != (const char *) NULL)
2645 as_bad ("%s", errmsg);
2647 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
2648 next_opindex = *opindex_ptr + 1;
2652 /* Gather the operand. */
2653 hold = input_line_pointer;
2654 input_line_pointer = str;
2657 if (*input_line_pointer == '[')
2659 /* We are expecting something like the second argument here:
2661 * lwz r4,[toc].GS.0.static_int(rtoc)
2662 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2663 * The argument following the `]' must be a symbol name, and the
2664 * register must be the toc register: 'rtoc' or '2'
2666 * The effect is to 0 as the displacement field
2667 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2668 * the appropriate variation) reloc against it based on the symbol.
2669 * The linker will build the toc, and insert the resolved toc offset.
2672 * o The size of the toc entry is currently assumed to be
2673 * 32 bits. This should not be assumed to be a hard coded
2675 * o In an effort to cope with a change from 32 to 64 bits,
2676 * there are also toc entries that are specified to be
2677 * either 32 or 64 bits:
2678 * lwz r4,[toc32].GS.0.static_int(rtoc)
2679 * lwz r4,[toc64].GS.0.static_int(rtoc)
2680 * These demand toc entries of the specified size, and the
2681 * instruction probably requires it.
2685 enum toc_size_qualifier toc_kind;
2686 bfd_reloc_code_real_type toc_reloc;
2688 /* Go parse off the [tocXX] part. */
2689 valid_toc = parse_toc_entry (&toc_kind);
2693 ignore_rest_of_line ();
2697 /* Now get the symbol following the ']'. */
2703 /* In this case, we may not have seen the symbol yet,
2704 since it is allowed to appear on a .extern or .globl
2705 or just be a label in the .data section. */
2706 toc_reloc = BFD_RELOC_PPC_TOC16;
2709 /* 1. The symbol must be defined and either in the toc
2710 section, or a global.
2711 2. The reloc generated must have the TOCDEFN flag set
2712 in upper bit mess of the reloc type.
2713 FIXME: It's a little confusing what the tocv
2714 qualifier can be used for. At the very least, I've
2715 seen three uses, only one of which I'm sure I can
2717 if (ex.X_op == O_symbol)
2719 gas_assert (ex.X_add_symbol != NULL);
2720 if (symbol_get_bfdsym (ex.X_add_symbol)->section
2723 as_bad (_("[tocv] symbol is not a toc symbol"));
2727 toc_reloc = BFD_RELOC_PPC_TOC16;
2730 /* FIXME: these next two specifically specify 32/64 bit
2731 toc entries. We don't support them today. Is this
2732 the right way to say that? */
2733 toc_reloc = BFD_RELOC_UNUSED;
2734 as_bad (_("unimplemented toc32 expression modifier"));
2737 /* FIXME: see above. */
2738 toc_reloc = BFD_RELOC_UNUSED;
2739 as_bad (_("unimplemented toc64 expression modifier"));
2743 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2749 /* We need to generate a fixup for this expression. */
2750 if (fc >= MAX_INSN_FIXUPS)
2751 as_fatal (_("too many fixups"));
2753 fixups[fc].reloc = toc_reloc;
2754 fixups[fc].exp = ex;
2755 fixups[fc].opindex = *opindex_ptr;
2758 /* Ok. We've set up the fixup for the instruction. Now make it
2759 look like the constant 0 was found here. */
2761 ex.X_op = O_constant;
2762 ex.X_add_number = 0;
2763 ex.X_add_symbol = NULL;
2764 ex.X_op_symbol = NULL;
2771 && (((operand->flags & PPC_OPERAND_CR_BIT) != 0)
2772 || ((operand->flags & PPC_OPERAND_CR_REG) != 0)))
2773 || !register_name (&ex))
2775 char save_lex = lex_type['%'];
2777 if (((operand->flags & PPC_OPERAND_CR_REG) != 0)
2778 || (operand->flags & PPC_OPERAND_CR_BIT) != 0)
2781 lex_type['%'] |= LEX_BEGIN_NAME;
2785 lex_type['%'] = save_lex;
2789 str = input_line_pointer;
2790 input_line_pointer = hold;
2792 if (ex.X_op == O_illegal)
2793 as_bad (_("illegal operand"));
2794 else if (ex.X_op == O_absent)
2795 as_bad (_("missing operand"));
2796 else if (ex.X_op == O_register)
2798 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2799 ppc_cpu, (char *) NULL, 0);
2801 else if (ex.X_op == O_constant)
2804 /* Allow @HA, @L, @H on constants. */
2805 bfd_reloc_code_real_type reloc;
2806 char *orig_str = str;
2808 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2815 case BFD_RELOC_LO16:
2816 /* X_unsigned is the default, so if the user has done
2817 something which cleared it, we always produce a
2819 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2820 ex.X_add_number &= 0xffff;
2822 ex.X_add_number = SEX16 (ex.X_add_number);
2825 case BFD_RELOC_HI16:
2826 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2827 ex.X_add_number = PPC_HI (ex.X_add_number);
2829 ex.X_add_number = SEX16 (PPC_HI (ex.X_add_number));
2832 case BFD_RELOC_HI16_S:
2833 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2834 ex.X_add_number = PPC_HA (ex.X_add_number);
2836 ex.X_add_number = SEX16 (PPC_HA (ex.X_add_number));
2839 case BFD_RELOC_PPC64_HIGHER:
2840 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2841 ex.X_add_number = PPC_HIGHER (ex.X_add_number);
2843 ex.X_add_number = SEX16 (PPC_HIGHER (ex.X_add_number));
2846 case BFD_RELOC_PPC64_HIGHER_S:
2847 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2848 ex.X_add_number = PPC_HIGHERA (ex.X_add_number);
2850 ex.X_add_number = SEX16 (PPC_HIGHERA (ex.X_add_number));
2853 case BFD_RELOC_PPC64_HIGHEST:
2854 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2855 ex.X_add_number = PPC_HIGHEST (ex.X_add_number);
2857 ex.X_add_number = SEX16 (PPC_HIGHEST (ex.X_add_number));
2860 case BFD_RELOC_PPC64_HIGHEST_S:
2861 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2862 ex.X_add_number = PPC_HIGHESTA (ex.X_add_number);
2864 ex.X_add_number = SEX16 (PPC_HIGHESTA (ex.X_add_number));
2867 #endif /* OBJ_ELF */
2868 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2869 ppc_cpu, (char *) NULL, 0);
2873 bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
2875 if (ex.X_op == O_symbol && str[0] == '(')
2877 const char *sym_name = S_GET_NAME (ex.X_add_symbol);
2878 if (sym_name[0] == '.')
2881 if (strcasecmp (sym_name, "__tls_get_addr") == 0)
2883 expressionS tls_exp;
2885 hold = input_line_pointer;
2886 input_line_pointer = str + 1;
2887 expression (&tls_exp);
2888 if (tls_exp.X_op == O_symbol)
2890 reloc = BFD_RELOC_UNUSED;
2891 if (strncasecmp (input_line_pointer, "@tlsgd)", 7) == 0)
2893 reloc = BFD_RELOC_PPC_TLSGD;
2894 input_line_pointer += 7;
2896 else if (strncasecmp (input_line_pointer, "@tlsld)", 7) == 0)
2898 reloc = BFD_RELOC_PPC_TLSLD;
2899 input_line_pointer += 7;
2901 if (reloc != BFD_RELOC_UNUSED)
2904 str = input_line_pointer;
2906 if (fc >= MAX_INSN_FIXUPS)
2907 as_fatal (_("too many fixups"));
2908 fixups[fc].exp = tls_exp;
2909 fixups[fc].opindex = *opindex_ptr;
2910 fixups[fc].reloc = reloc;
2914 input_line_pointer = hold;
2918 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2920 /* Some TLS tweaks. */
2926 case BFD_RELOC_PPC_TLS:
2927 if (!_bfd_elf_ppc_at_tls_transform (opcode->opcode, 0))
2928 as_bad (_("@tls may not be used with \"%s\" operands"),
2930 else if (operand->shift != 11)
2931 as_bad (_("@tls may only be used in last operand"));
2933 insn = ppc_insert_operand (insn, operand,
2935 ppc_cpu, (char *) NULL, 0);
2938 /* We'll only use the 32 (or 64) bit form of these relocations
2939 in constants. Instructions get the 16 bit form. */
2940 case BFD_RELOC_PPC_DTPREL:
2941 reloc = BFD_RELOC_PPC_DTPREL16;
2943 case BFD_RELOC_PPC_TPREL:
2944 reloc = BFD_RELOC_PPC_TPREL16;
2948 /* If VLE-mode convert LO/HI/HA relocations. */
2949 if (opcode->flags & PPC_OPCODE_VLE)
2951 int tmp_insn = insn & opcode->mask;
2953 int use_d_reloc = (tmp_insn == E_OR2I_INSN
2954 || tmp_insn == E_AND2I_DOT_INSN
2955 || tmp_insn == E_OR2IS_INSN
2956 || tmp_insn == E_LIS_INSN
2957 || tmp_insn == E_AND2IS_DOT_INSN);
2960 int use_a_reloc = (tmp_insn == E_ADD2I_DOT_INSN
2961 || tmp_insn == E_ADD2IS_INSN
2962 || tmp_insn == E_CMP16I_INSN
2963 || tmp_insn == E_MULL2I_INSN
2964 || tmp_insn == E_CMPL16I_INSN
2965 || tmp_insn == E_CMPH16I_INSN
2966 || tmp_insn == E_CMPHL16I_INSN);
2973 case BFD_RELOC_PPC_EMB_SDA21:
2974 reloc = BFD_RELOC_PPC_VLE_SDA21;
2977 case BFD_RELOC_LO16:
2979 reloc = BFD_RELOC_PPC_VLE_LO16D;
2980 else if (use_a_reloc)
2981 reloc = BFD_RELOC_PPC_VLE_LO16A;
2984 case BFD_RELOC_HI16:
2986 reloc = BFD_RELOC_PPC_VLE_HI16D;
2987 else if (use_a_reloc)
2988 reloc = BFD_RELOC_PPC_VLE_HI16A;
2991 case BFD_RELOC_HI16_S:
2993 reloc = BFD_RELOC_PPC_VLE_HA16D;
2994 else if (use_a_reloc)
2995 reloc = BFD_RELOC_PPC_VLE_HA16A;
2998 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
3000 reloc = BFD_RELOC_PPC_VLE_SDAREL_LO16D;
3003 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
3005 reloc = BFD_RELOC_PPC_VLE_SDAREL_HI16D;
3008 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
3010 reloc = BFD_RELOC_PPC_VLE_SDAREL_HA16D;
3015 /* For the absolute forms of branches, convert the PC
3016 relative form back into the absolute. */
3017 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
3021 case BFD_RELOC_PPC_B26:
3022 reloc = BFD_RELOC_PPC_BA26;
3024 case BFD_RELOC_PPC_B16:
3025 reloc = BFD_RELOC_PPC_BA16;
3027 case BFD_RELOC_PPC_B16_BRTAKEN:
3028 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
3030 case BFD_RELOC_PPC_B16_BRNTAKEN:
3031 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
3040 case BFD_RELOC_PPC_TOC16:
3041 toc_reloc_types |= has_small_toc_reloc;
3043 case BFD_RELOC_PPC64_TOC16_LO:
3044 case BFD_RELOC_PPC64_TOC16_HI:
3045 case BFD_RELOC_PPC64_TOC16_HA:
3046 toc_reloc_types |= has_large_toc_reloc;
3052 if ((operand->flags & (PPC_OPERAND_DS | PPC_OPERAND_DQ)) != 0)
3057 reloc = BFD_RELOC_PPC64_ADDR16_DS;
3059 case BFD_RELOC_LO16:
3060 reloc = BFD_RELOC_PPC64_ADDR16_LO_DS;
3062 case BFD_RELOC_16_GOTOFF:
3063 reloc = BFD_RELOC_PPC64_GOT16_DS;
3065 case BFD_RELOC_LO16_GOTOFF:
3066 reloc = BFD_RELOC_PPC64_GOT16_LO_DS;
3068 case BFD_RELOC_LO16_PLTOFF:
3069 reloc = BFD_RELOC_PPC64_PLT16_LO_DS;
3071 case BFD_RELOC_16_BASEREL:
3072 reloc = BFD_RELOC_PPC64_SECTOFF_DS;
3074 case BFD_RELOC_LO16_BASEREL:
3075 reloc = BFD_RELOC_PPC64_SECTOFF_LO_DS;
3077 case BFD_RELOC_PPC_TOC16:
3078 reloc = BFD_RELOC_PPC64_TOC16_DS;
3080 case BFD_RELOC_PPC64_TOC16_LO:
3081 reloc = BFD_RELOC_PPC64_TOC16_LO_DS;
3083 case BFD_RELOC_PPC64_PLTGOT16:
3084 reloc = BFD_RELOC_PPC64_PLTGOT16_DS;
3086 case BFD_RELOC_PPC64_PLTGOT16_LO:
3087 reloc = BFD_RELOC_PPC64_PLTGOT16_LO_DS;
3089 case BFD_RELOC_PPC_DTPREL16:
3090 reloc = BFD_RELOC_PPC64_DTPREL16_DS;
3092 case BFD_RELOC_PPC_DTPREL16_LO:
3093 reloc = BFD_RELOC_PPC64_DTPREL16_LO_DS;
3095 case BFD_RELOC_PPC_TPREL16:
3096 reloc = BFD_RELOC_PPC64_TPREL16_DS;
3098 case BFD_RELOC_PPC_TPREL16_LO:
3099 reloc = BFD_RELOC_PPC64_TPREL16_LO_DS;
3101 case BFD_RELOC_PPC_GOT_DTPREL16:
3102 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
3103 case BFD_RELOC_PPC_GOT_TPREL16:
3104 case BFD_RELOC_PPC_GOT_TPREL16_LO:
3107 as_bad (_("unsupported relocation for DS offset field"));
3112 #endif /* OBJ_ELF */
3114 if (reloc != BFD_RELOC_UNUSED)
3116 /* Determine a BFD reloc value based on the operand information.
3117 We are only prepared to turn a few of the operands into
3119 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3120 && operand->bitm == 0x3fffffc
3121 && operand->shift == 0)
3122 reloc = BFD_RELOC_PPC_B26;
3123 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3124 && operand->bitm == 0xfffc
3125 && operand->shift == 0)
3126 reloc = BFD_RELOC_PPC_B16;
3127 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3128 && operand->bitm == 0x1fe
3129 && operand->shift == -1)
3130 reloc = BFD_RELOC_PPC_VLE_REL8;
3131 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3132 && operand->bitm == 0xfffe
3133 && operand->shift == 0)
3134 reloc = BFD_RELOC_PPC_VLE_REL15;
3135 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3136 && operand->bitm == 0x1fffffe
3137 && operand->shift == 0)
3138 reloc = BFD_RELOC_PPC_VLE_REL24;
3139 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
3140 && operand->bitm == 0x3fffffc
3141 && operand->shift == 0)
3142 reloc = BFD_RELOC_PPC_BA26;
3143 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
3144 && operand->bitm == 0xfffc
3145 && operand->shift == 0)
3146 reloc = BFD_RELOC_PPC_BA16;
3147 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3148 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
3149 && (operand->bitm & 0xfff0) == 0xfff0
3150 && operand->shift == 0)
3152 if (ppc_is_toc_sym (ex.X_add_symbol))
3154 reloc = BFD_RELOC_PPC_TOC16;
3157 && (operand->flags & PPC_OPERAND_DS) != 0)
3158 reloc = BFD_RELOC_PPC64_TOC16_DS;
3163 reloc = BFD_RELOC_16;
3166 && (operand->flags & PPC_OPERAND_DS) != 0)
3167 reloc = BFD_RELOC_PPC64_ADDR16_DS;
3171 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3173 /* We need to generate a fixup for this expression. */
3174 if (fc >= MAX_INSN_FIXUPS)
3175 as_fatal (_("too many fixups"));
3176 fixups[fc].exp = ex;
3177 fixups[fc].opindex = *opindex_ptr;
3178 fixups[fc].reloc = reloc;
3186 /* If expecting more operands, then we want to see "),". */
3187 if (*str == endc && opindex_ptr[1] != 0)
3191 while (ISSPACE (*str));
3195 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
3203 /* The call to expression should have advanced str past any
3206 && (endc != ',' || *str != '\0'))
3209 as_bad (_("syntax error; end of line, expected `%c'"), endc);
3211 as_bad (_("syntax error; found `%c', expected `%c'"), *str, endc);
3219 while (ISSPACE (*str))
3223 as_bad (_("junk at end of line: `%s'"), str);
3226 /* Do we need/want an APUinfo section? */
3227 if ((ppc_cpu & (PPC_OPCODE_E500 | PPC_OPCODE_E500MC | PPC_OPCODE_VLE)) != 0
3230 /* These are all version "1". */
3231 if (opcode->flags & PPC_OPCODE_SPE)
3232 ppc_apuinfo_section_add (PPC_APUINFO_SPE, 1);
3233 if (opcode->flags & PPC_OPCODE_ISEL)
3234 ppc_apuinfo_section_add (PPC_APUINFO_ISEL, 1);
3235 if (opcode->flags & PPC_OPCODE_EFS)
3236 ppc_apuinfo_section_add (PPC_APUINFO_EFS, 1);
3237 if (opcode->flags & PPC_OPCODE_BRLOCK)
3238 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK, 1);
3239 if (opcode->flags & PPC_OPCODE_PMR)
3240 ppc_apuinfo_section_add (PPC_APUINFO_PMR, 1);
3241 if (opcode->flags & PPC_OPCODE_CACHELCK)
3242 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK, 1);
3243 if (opcode->flags & PPC_OPCODE_RFMCI)
3244 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI, 1);
3245 if (opcode->flags & PPC_OPCODE_VLE)
3246 ppc_apuinfo_section_add (PPC_APUINFO_VLE, 1);
3250 /* Write out the instruction. */
3251 /* Differentiate between two and four byte insns. */
3252 if (ppc_mach () == bfd_mach_ppc_vle)
3254 if (PPC_OP_SE_VLE (insn))
3258 addr_mod = frag_now_fix () & 1;
3263 addr_mod = frag_now_fix () & 3;
3265 /* All instructions can start on a 2 byte boundary for VLE. */
3266 f = frag_more (insn_length);
3267 if (frag_now->has_code && frag_now->insn_addr != addr_mod)
3269 if (ppc_mach() == bfd_mach_ppc_vle)
3270 as_bad (_("instruction address is not a multiple of 2"));
3272 as_bad (_("instruction address is not a multiple of 4"));
3274 frag_now->insn_addr = addr_mod;
3275 frag_now->has_code = 1;
3276 md_number_to_chars (f, insn, insn_length);
3279 dwarf2_emit_insn (insn_length);
3282 /* Create any fixups. */
3283 for (i = 0; i < fc; i++)
3286 if (fixups[i].reloc != BFD_RELOC_UNUSED)
3288 reloc_howto_type *reloc_howto;
3292 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
3296 size = bfd_get_reloc_size (reloc_howto);
3297 offset = target_big_endian ? (insn_length - size) : 0;
3299 if (size < 1 || size > 4)
3302 fixP = fix_new_exp (frag_now,
3303 f - frag_now->fr_literal + offset,
3306 reloc_howto->pc_relative,
3311 const struct powerpc_operand *operand;
3313 operand = &powerpc_operands[fixups[i].opindex];
3314 fixP = fix_new_exp (frag_now,
3315 f - frag_now->fr_literal,
3318 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
3321 fixP->fx_pcrel_adjust = fixups[i].opindex;
3325 /* Handle a macro. Gather all the operands, transform them as
3326 described by the macro, and call md_assemble recursively. All the
3327 operands are separated by commas; we don't accept parentheses
3328 around operands here. */
3331 ppc_macro (char *str, const struct powerpc_macro *macro)
3342 /* Gather the users operands into the operands array. */
3347 if (count >= sizeof operands / sizeof operands[0])
3349 operands[count++] = s;
3350 s = strchr (s, ',');
3351 if (s == (char *) NULL)
3356 if (count != macro->operands)
3358 as_bad (_("wrong number of operands"));
3362 /* Work out how large the string must be (the size is unbounded
3363 because it includes user input). */
3365 format = macro->format;
3366 while (*format != '\0')
3375 arg = strtol (format + 1, &send, 10);
3376 know (send != format && arg < count);
3377 len += strlen (operands[arg]);
3382 /* Put the string together. */
3383 complete = s = (char *) alloca (len + 1);
3384 format = macro->format;
3385 while (*format != '\0')
3391 arg = strtol (format + 1, &send, 10);
3392 strcpy (s, operands[arg]);
3399 /* Assemble the constructed instruction. */
3400 md_assemble (complete);
3404 /* For ELF, add support for SHT_ORDERED. */
3407 ppc_section_type (char *str, size_t len)
3409 if (len == 7 && strncmp (str, "ordered", 7) == 0)
3416 ppc_section_flags (flagword flags, bfd_vma attr ATTRIBUTE_UNUSED, int type)
3418 if (type == SHT_ORDERED)
3419 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
3423 #endif /* OBJ_ELF */
3426 /* Pseudo-op handling. */
3428 /* The .byte pseudo-op. This is similar to the normal .byte
3429 pseudo-op, but it can also take a single ASCII string. */
3432 ppc_byte (int ignore ATTRIBUTE_UNUSED)
3434 if (*input_line_pointer != '\"')
3440 /* Gather characters. A real double quote is doubled. Unusual
3441 characters are not permitted. */
3442 ++input_line_pointer;
3447 c = *input_line_pointer++;
3451 if (*input_line_pointer != '\"')
3453 ++input_line_pointer;
3456 FRAG_APPEND_1_CHAR (c);
3459 demand_empty_rest_of_line ();
3464 /* XCOFF specific pseudo-op handling. */
3466 /* This is set if we are creating a .stabx symbol, since we don't want
3467 to handle symbol suffixes for such symbols. */
3468 static bfd_boolean ppc_stab_symbol;
3470 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3471 symbols in the .bss segment as though they were local common
3472 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3473 aligns .comm and .lcomm to 4 bytes. */
3476 ppc_comm (int lcomm)
3478 asection *current_seg = now_seg;
3479 subsegT current_subseg = now_subseg;
3485 symbolS *lcomm_sym = NULL;
3489 name = input_line_pointer;
3490 endc = get_symbol_end ();
3491 end_name = input_line_pointer;
3494 if (*input_line_pointer != ',')
3496 as_bad (_("missing size"));
3497 ignore_rest_of_line ();
3500 ++input_line_pointer;
3502 size = get_absolute_expression ();
3505 as_bad (_("negative size"));
3506 ignore_rest_of_line ();
3512 /* The third argument to .comm is the alignment. */
3513 if (*input_line_pointer != ',')
3517 ++input_line_pointer;
3518 align = get_absolute_expression ();
3521 as_warn (_("ignoring bad alignment"));
3536 /* The third argument to .lcomm appears to be the real local
3537 common symbol to create. References to the symbol named in
3538 the first argument are turned into references to the third
3540 if (*input_line_pointer != ',')
3542 as_bad (_("missing real symbol name"));
3543 ignore_rest_of_line ();
3546 ++input_line_pointer;
3548 lcomm_name = input_line_pointer;
3549 lcomm_endc = get_symbol_end ();
3551 lcomm_sym = symbol_find_or_make (lcomm_name);
3553 *input_line_pointer = lcomm_endc;
3557 sym = symbol_find_or_make (name);
3560 if (S_IS_DEFINED (sym)
3561 || S_GET_VALUE (sym) != 0)
3563 as_bad (_("attempt to redefine symbol"));
3564 ignore_rest_of_line ();
3568 record_alignment (bss_section, align);
3571 || ! S_IS_DEFINED (lcomm_sym))
3580 S_SET_EXTERNAL (sym);
3584 symbol_get_tc (lcomm_sym)->output = 1;
3585 def_sym = lcomm_sym;
3589 subseg_set (bss_section, 1);
3590 frag_align (align, 0, 0);
3592 symbol_set_frag (def_sym, frag_now);
3593 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
3594 def_size, (char *) NULL);
3596 S_SET_SEGMENT (def_sym, bss_section);
3597 symbol_get_tc (def_sym)->align = align;
3601 /* Align the size of lcomm_sym. */
3602 symbol_get_frag (lcomm_sym)->fr_offset =
3603 ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
3604 &~ ((1 << align) - 1));
3605 if (align > symbol_get_tc (lcomm_sym)->align)
3606 symbol_get_tc (lcomm_sym)->align = align;
3611 /* Make sym an offset from lcomm_sym. */
3612 S_SET_SEGMENT (sym, bss_section);
3613 symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
3614 S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
3615 symbol_get_frag (lcomm_sym)->fr_offset += size;
3618 subseg_set (current_seg, current_subseg);
3620 demand_empty_rest_of_line ();
3623 /* The .csect pseudo-op. This switches us into a different
3624 subsegment. The first argument is a symbol whose value is the
3625 start of the .csect. In COFF, csect symbols get special aux
3626 entries defined by the x_csect field of union internal_auxent. The
3627 optional second argument is the alignment (the default is 2). */
3630 ppc_csect (int ignore ATTRIBUTE_UNUSED)
3637 name = input_line_pointer;
3638 endc = get_symbol_end ();
3640 sym = symbol_find_or_make (name);
3642 *input_line_pointer = endc;
3644 if (S_GET_NAME (sym)[0] == '\0')
3646 /* An unnamed csect is assumed to be [PR]. */
3647 symbol_get_tc (sym)->symbol_class = XMC_PR;
3651 if (*input_line_pointer == ',')
3653 ++input_line_pointer;
3654 align = get_absolute_expression ();
3657 ppc_change_csect (sym, align);
3659 demand_empty_rest_of_line ();
3662 /* Change to a different csect. */
3665 ppc_change_csect (symbolS *sym, offsetT align)
3667 if (S_IS_DEFINED (sym))
3668 subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
3678 /* This is a new csect. We need to look at the symbol class to
3679 figure out whether it should go in the text section or the
3683 switch (symbol_get_tc (sym)->symbol_class)
3693 S_SET_SEGMENT (sym, text_section);
3694 symbol_get_tc (sym)->subseg = ppc_text_subsegment;
3695 ++ppc_text_subsegment;
3696 list_ptr = &ppc_text_csects;
3706 if (ppc_toc_csect != NULL
3707 && (symbol_get_tc (ppc_toc_csect)->subseg + 1
3708 == ppc_data_subsegment))
3710 S_SET_SEGMENT (sym, data_section);
3711 symbol_get_tc (sym)->subseg = ppc_data_subsegment;
3712 ++ppc_data_subsegment;
3713 list_ptr = &ppc_data_csects;
3719 /* We set the obstack chunk size to a small value before
3720 changing subsegments, so that we don't use a lot of memory
3721 space for what may be a small section. */
3722 hold_chunksize = chunksize;
3725 sec = subseg_new (segment_name (S_GET_SEGMENT (sym)),
3726 symbol_get_tc (sym)->subseg);
3728 chunksize = hold_chunksize;
3731 ppc_after_toc_frag = frag_now;
3733 record_alignment (sec, align);
3735 frag_align_code (align, 0);
3737 frag_align (align, 0, 0);
3739 symbol_set_frag (sym, frag_now);
3740 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3742 symbol_get_tc (sym)->align = align;
3743 symbol_get_tc (sym)->output = 1;
3744 symbol_get_tc (sym)->within = sym;
3746 for (list = *list_ptr;
3747 symbol_get_tc (list)->next != (symbolS *) NULL;
3748 list = symbol_get_tc (list)->next)
3750 symbol_get_tc (list)->next = sym;
3752 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3753 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3757 ppc_current_csect = sym;
3761 ppc_change_debug_section (unsigned int idx, subsegT subseg)
3765 const struct xcoff_dwsect_name *dw = &xcoff_dwsect_names[idx];
3767 sec = subseg_new (dw->name, subseg);
3768 oldflags = bfd_get_section_flags (stdoutput, sec);
3769 if (oldflags == SEC_NO_FLAGS)
3771 /* Just created section. */
3772 gas_assert (dw_sections[idx].sect == NULL);
3774 bfd_set_section_flags (stdoutput, sec, SEC_DEBUGGING);
3775 bfd_set_section_alignment (stdoutput, sec, 0);
3776 dw_sections[idx].sect = sec;
3779 /* Not anymore in a csect. */
3780 ppc_current_csect = NULL;
3783 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3784 .dwsect flag [, opt-label ]
3788 ppc_dwsect (int ignore ATTRIBUTE_UNUSED)
3792 const struct xcoff_dwsect_name *dw;
3793 struct dw_subsection *subseg;
3794 struct dw_section *dws;
3798 flag = get_absolute_expression ();
3800 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
3801 if (xcoff_dwsect_names[i].flag == flag)
3803 dw = &xcoff_dwsect_names[i];
3807 /* Parse opt-label. */
3808 if (*input_line_pointer == ',')
3813 ++input_line_pointer;
3815 label = input_line_pointer;
3816 c = get_symbol_end ();
3817 opt_label = symbol_find_or_make (label);
3818 *input_line_pointer = c;
3823 demand_empty_rest_of_line ();
3825 /* Return now in case of unknown subsection. */
3828 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3833 /* Find the subsection. */
3834 dws = &dw_sections[i];
3836 if (opt_label != NULL && S_IS_DEFINED (opt_label))
3838 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3839 if (dws->sect == NULL || S_GET_SEGMENT (opt_label) != dws->sect)
3841 as_bad (_("label %s was not defined in this dwarf section"),
3842 S_GET_NAME (opt_label));
3843 subseg = dws->anon_subseg;
3847 subseg = symbol_get_tc (opt_label)->u.dw;
3852 /* Switch to the subsection. */
3853 ppc_change_debug_section (i, subseg->subseg);
3857 /* Create a new dw subsection. */
3858 subseg = (struct dw_subsection *)
3859 xmalloc (sizeof (struct dw_subsection));
3861 if (opt_label == NULL)
3863 /* The anonymous one. */
3865 subseg->link = NULL;
3866 dws->anon_subseg = subseg;
3871 if (dws->list_subseg != NULL)
3872 subseg->subseg = dws->list_subseg->subseg + 1;
3876 subseg->link = dws->list_subseg;
3877 dws->list_subseg = subseg;
3878 symbol_get_tc (opt_label)->u.dw = subseg;
3881 ppc_change_debug_section (i, subseg->subseg);
3885 /* Add the length field. */
3886 expressionS *exp = &subseg->end_exp;
3889 if (opt_label != NULL)
3890 symbol_set_value_now (opt_label);
3892 /* Add the length field. Note that according to the AIX assembler
3893 manual, the size of the length field is 4 for powerpc32 but
3894 12 for powerpc64. */
3897 /* Write the 64bit marker. */
3898 md_number_to_chars (frag_more (4), -1, 4);
3901 exp->X_op = O_subtract;
3902 exp->X_op_symbol = symbol_temp_new_now ();
3903 exp->X_add_symbol = symbol_temp_make ();
3905 sz = ppc_obj64 ? 8 : 4;
3906 exp->X_add_number = -sz;
3907 emit_expr (exp, sz);
3912 /* This function handles the .text and .data pseudo-ops. These
3913 pseudo-ops aren't really used by XCOFF; we implement them for the
3914 convenience of people who aren't used to XCOFF. */
3917 ppc_section (int type)
3924 else if (type == 'd')
3929 sym = symbol_find_or_make (name);
3931 ppc_change_csect (sym, 2);
3933 demand_empty_rest_of_line ();
3936 /* This function handles the .section pseudo-op. This is mostly to
3937 give an error, since XCOFF only supports .text, .data and .bss, but
3938 we do permit the user to name the text or data section. */
3941 ppc_named_section (int ignore ATTRIBUTE_UNUSED)
3944 const char *real_name;
3948 user_name = input_line_pointer;
3949 c = get_symbol_end ();
3951 if (strcmp (user_name, ".text") == 0)
3952 real_name = ".text[PR]";
3953 else if (strcmp (user_name, ".data") == 0)
3954 real_name = ".data[RW]";
3957 as_bad (_("the XCOFF file format does not support arbitrary sections"));
3958 *input_line_pointer = c;
3959 ignore_rest_of_line ();
3963 *input_line_pointer = c;
3965 sym = symbol_find_or_make (real_name);
3967 ppc_change_csect (sym, 2);
3969 demand_empty_rest_of_line ();
3972 /* The .extern pseudo-op. We create an undefined symbol. */
3975 ppc_extern (int ignore ATTRIBUTE_UNUSED)
3980 name = input_line_pointer;
3981 endc = get_symbol_end ();
3983 (void) symbol_find_or_make (name);
3985 *input_line_pointer = endc;
3987 demand_empty_rest_of_line ();
3990 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3993 ppc_lglobl (int ignore ATTRIBUTE_UNUSED)
3999 name = input_line_pointer;
4000 endc = get_symbol_end ();
4002 sym = symbol_find_or_make (name);
4004 *input_line_pointer = endc;
4006 symbol_get_tc (sym)->output = 1;
4008 demand_empty_rest_of_line ();
4011 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4012 relocations at the beginning of the current csect.
4014 (In principle, there's no reason why the relocations _have_ to be at
4015 the beginning. Anywhere in the csect would do. However, inserting
4016 at the beginning is what the native assmebler does, and it helps to
4017 deal with cases where the .ref statements follow the section contents.)
4019 ??? .refs don't work for empty .csects. However, the native assembler
4020 doesn't report an error in this case, and neither yet do we. */
4023 ppc_ref (int ignore ATTRIBUTE_UNUSED)
4028 if (ppc_current_csect == NULL)
4030 as_bad (_(".ref outside .csect"));
4031 ignore_rest_of_line ();
4037 name = input_line_pointer;
4038 c = get_symbol_end ();
4040 fix_at_start (symbol_get_frag (ppc_current_csect), 0,
4041 symbol_find_or_make (name), 0, FALSE, BFD_RELOC_NONE);
4043 *input_line_pointer = c;
4045 c = *input_line_pointer;
4048 input_line_pointer++;
4050 if (is_end_of_line[(unsigned char) *input_line_pointer])
4052 as_bad (_("missing symbol name"));
4053 ignore_rest_of_line ();
4060 demand_empty_rest_of_line ();
4063 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4064 although I don't know why it bothers. */
4067 ppc_rename (int ignore ATTRIBUTE_UNUSED)
4074 name = input_line_pointer;
4075 endc = get_symbol_end ();
4077 sym = symbol_find_or_make (name);
4079 *input_line_pointer = endc;
4081 if (*input_line_pointer != ',')
4083 as_bad (_("missing rename string"));
4084 ignore_rest_of_line ();
4087 ++input_line_pointer;
4089 symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
4091 demand_empty_rest_of_line ();
4094 /* The .stabx pseudo-op. This is similar to a normal .stabs
4095 pseudo-op, but slightly different. A sample is
4096 .stabx "main:F-1",.main,142,0
4097 The first argument is the symbol name to create. The second is the
4098 value, and the third is the storage class. The fourth seems to be
4099 always zero, and I am assuming it is the type. */
4102 ppc_stabx (int ignore ATTRIBUTE_UNUSED)
4109 name = demand_copy_C_string (&len);
4111 if (*input_line_pointer != ',')
4113 as_bad (_("missing value"));
4116 ++input_line_pointer;
4118 ppc_stab_symbol = TRUE;
4119 sym = symbol_make (name);
4120 ppc_stab_symbol = FALSE;
4122 symbol_get_tc (sym)->real_name = name;
4124 (void) expression (&exp);
4131 as_bad (_("illegal .stabx expression; zero assumed"));
4132 exp.X_add_number = 0;
4135 S_SET_VALUE (sym, (valueT) exp.X_add_number);
4136 symbol_set_frag (sym, &zero_address_frag);
4140 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
4141 symbol_set_value_expression (sym, &exp);
4145 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
4146 symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
4151 /* The value is some complex expression. This will probably
4152 fail at some later point, but this is probably the right
4153 thing to do here. */
4154 symbol_set_value_expression (sym, &exp);
4158 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4159 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4161 if (*input_line_pointer != ',')
4163 as_bad (_("missing class"));
4166 ++input_line_pointer;
4168 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
4170 if (*input_line_pointer != ',')
4172 as_bad (_("missing type"));
4175 ++input_line_pointer;
4177 S_SET_DATA_TYPE (sym, get_absolute_expression ());
4179 symbol_get_tc (sym)->output = 1;
4181 if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4186 .stabx "z",arrays_,133,0
4189 .comm arrays_,13768,3
4191 resolve_symbol_value will copy the exp's "within" into sym's when the
4192 offset is 0. Since this seems to be corner case problem,
4193 only do the correction for storage class C_STSYM. A better solution
4194 would be to have the tc field updated in ppc_symbol_new_hook. */
4196 if (exp.X_op == O_symbol)
4198 if (ppc_current_block == NULL)
4199 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4201 symbol_get_tc (sym)->within = ppc_current_block;
4202 symbol_get_tc (exp.X_add_symbol)->within = ppc_current_block;
4206 if (exp.X_op != O_symbol
4207 || ! S_IS_EXTERNAL (exp.X_add_symbol)
4208 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
4209 ppc_frob_label (sym);
4212 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4213 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
4214 if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
4215 symbol_get_tc (ppc_current_csect)->within = sym;
4218 demand_empty_rest_of_line ();
4221 /* The .function pseudo-op. This takes several arguments. The first
4222 argument seems to be the external name of the symbol. The second
4223 argument seems to be the label for the start of the function. gcc
4224 uses the same name for both. I have no idea what the third and
4225 fourth arguments are meant to be. The optional fifth argument is
4226 an expression for the size of the function. In COFF this symbol
4227 gets an aux entry like that used for a csect. */
4230 ppc_function (int ignore ATTRIBUTE_UNUSED)
4238 name = input_line_pointer;
4239 endc = get_symbol_end ();
4241 /* Ignore any [PR] suffix. */
4242 name = ppc_canonicalize_symbol_name (name);
4243 s = strchr (name, '[');
4244 if (s != (char *) NULL
4245 && strcmp (s + 1, "PR]") == 0)
4248 ext_sym = symbol_find_or_make (name);
4250 *input_line_pointer = endc;
4252 if (*input_line_pointer != ',')
4254 as_bad (_("missing symbol name"));
4255 ignore_rest_of_line ();
4258 ++input_line_pointer;
4260 name = input_line_pointer;
4261 endc = get_symbol_end ();
4263 lab_sym = symbol_find_or_make (name);
4265 *input_line_pointer = endc;
4267 if (ext_sym != lab_sym)
4271 exp.X_op = O_symbol;
4272 exp.X_add_symbol = lab_sym;
4273 exp.X_op_symbol = NULL;
4274 exp.X_add_number = 0;
4276 symbol_set_value_expression (ext_sym, &exp);
4279 if (symbol_get_tc (ext_sym)->symbol_class == -1)
4280 symbol_get_tc (ext_sym)->symbol_class = XMC_PR;
4281 symbol_get_tc (ext_sym)->output = 1;
4283 if (*input_line_pointer == ',')
4287 /* Ignore the third argument. */
4288 ++input_line_pointer;
4290 if (*input_line_pointer == ',')
4292 /* Ignore the fourth argument. */
4293 ++input_line_pointer;
4295 if (*input_line_pointer == ',')
4297 /* The fifth argument is the function size. */
4298 ++input_line_pointer;
4299 symbol_get_tc (ext_sym)->u.size = symbol_new
4300 ("L0\001", absolute_section,(valueT) 0, &zero_address_frag);
4301 pseudo_set (symbol_get_tc (ext_sym)->u.size);
4306 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
4307 SF_SET_FUNCTION (ext_sym);
4308 SF_SET_PROCESS (ext_sym);
4309 coff_add_linesym (ext_sym);
4311 demand_empty_rest_of_line ();
4314 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4315 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4316 with the correct line number */
4318 static symbolS *saved_bi_sym = 0;
4321 ppc_bf (int ignore ATTRIBUTE_UNUSED)
4325 sym = symbol_make (".bf");
4326 S_SET_SEGMENT (sym, text_section);
4327 symbol_set_frag (sym, frag_now);
4328 S_SET_VALUE (sym, frag_now_fix ());
4329 S_SET_STORAGE_CLASS (sym, C_FCN);
4331 coff_line_base = get_absolute_expression ();
4333 S_SET_NUMBER_AUXILIARY (sym, 1);
4334 SA_SET_SYM_LNNO (sym, coff_line_base);
4336 /* Line number for bi. */
4339 S_SET_VALUE (saved_bi_sym, coff_n_line_nos);
4344 symbol_get_tc (sym)->output = 1;
4346 ppc_frob_label (sym);
4348 demand_empty_rest_of_line ();
4351 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4352 ".ef", except that the line number is absolute, not relative to the
4353 most recent ".bf" symbol. */
4356 ppc_ef (int ignore ATTRIBUTE_UNUSED)
4360 sym = symbol_make (".ef");
4361 S_SET_SEGMENT (sym, text_section);
4362 symbol_set_frag (sym, frag_now);
4363 S_SET_VALUE (sym, frag_now_fix ());
4364 S_SET_STORAGE_CLASS (sym, C_FCN);
4365 S_SET_NUMBER_AUXILIARY (sym, 1);
4366 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4367 symbol_get_tc (sym)->output = 1;
4369 ppc_frob_label (sym);
4371 demand_empty_rest_of_line ();
4374 /* The .bi and .ei pseudo-ops. These take a string argument and
4375 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4376 the symbol list. The value of .bi will be know when the next .bf
4382 static symbolS *last_biei;
4389 name = demand_copy_C_string (&len);
4391 /* The value of these symbols is actually file offset. Here we set
4392 the value to the index into the line number entries. In
4393 ppc_frob_symbols we set the fix_line field, which will cause BFD
4394 to do the right thing. */
4396 sym = symbol_make (name);
4397 /* obj-coff.c currently only handles line numbers correctly in the
4399 S_SET_SEGMENT (sym, text_section);
4400 S_SET_VALUE (sym, coff_n_line_nos);
4401 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4403 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
4404 symbol_get_tc (sym)->output = 1;
4412 for (look = last_biei ? last_biei : symbol_rootP;
4413 (look != (symbolS *) NULL
4414 && (S_GET_STORAGE_CLASS (look) == C_FILE
4415 || S_GET_STORAGE_CLASS (look) == C_BINCL
4416 || S_GET_STORAGE_CLASS (look) == C_EINCL));
4417 look = symbol_next (look))
4419 if (look != (symbolS *) NULL)
4421 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4422 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
4426 demand_empty_rest_of_line ();
4429 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4430 There is one argument, which is a csect symbol. The value of the
4431 .bs symbol is the index of this csect symbol. */
4434 ppc_bs (int ignore ATTRIBUTE_UNUSED)
4441 if (ppc_current_block != NULL)
4442 as_bad (_("nested .bs blocks"));
4444 name = input_line_pointer;
4445 endc = get_symbol_end ();
4447 csect = symbol_find_or_make (name);
4449 *input_line_pointer = endc;
4451 sym = symbol_make (".bs");
4452 S_SET_SEGMENT (sym, now_seg);
4453 S_SET_STORAGE_CLASS (sym, C_BSTAT);
4454 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4455 symbol_get_tc (sym)->output = 1;
4457 symbol_get_tc (sym)->within = csect;
4459 ppc_frob_label (sym);
4461 ppc_current_block = sym;
4463 demand_empty_rest_of_line ();
4466 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4469 ppc_es (int ignore ATTRIBUTE_UNUSED)
4473 if (ppc_current_block == NULL)
4474 as_bad (_(".es without preceding .bs"));
4476 sym = symbol_make (".es");
4477 S_SET_SEGMENT (sym, now_seg);
4478 S_SET_STORAGE_CLASS (sym, C_ESTAT);
4479 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4480 symbol_get_tc (sym)->output = 1;
4482 ppc_frob_label (sym);
4484 ppc_current_block = NULL;
4486 demand_empty_rest_of_line ();
4489 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4493 ppc_bb (int ignore ATTRIBUTE_UNUSED)
4497 sym = symbol_make (".bb");
4498 S_SET_SEGMENT (sym, text_section);
4499 symbol_set_frag (sym, frag_now);
4500 S_SET_VALUE (sym, frag_now_fix ());
4501 S_SET_STORAGE_CLASS (sym, C_BLOCK);
4503 S_SET_NUMBER_AUXILIARY (sym, 1);
4504 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4506 symbol_get_tc (sym)->output = 1;
4508 SF_SET_PROCESS (sym);
4510 ppc_frob_label (sym);
4512 demand_empty_rest_of_line ();
4515 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4519 ppc_eb (int ignore ATTRIBUTE_UNUSED)
4523 sym = symbol_make (".eb");
4524 S_SET_SEGMENT (sym, text_section);
4525 symbol_set_frag (sym, frag_now);
4526 S_SET_VALUE (sym, frag_now_fix ());
4527 S_SET_STORAGE_CLASS (sym, C_BLOCK);
4528 S_SET_NUMBER_AUXILIARY (sym, 1);
4529 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4530 symbol_get_tc (sym)->output = 1;
4532 SF_SET_PROCESS (sym);
4534 ppc_frob_label (sym);
4536 demand_empty_rest_of_line ();
4539 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4543 ppc_bc (int ignore ATTRIBUTE_UNUSED)
4549 name = demand_copy_C_string (&len);
4550 sym = symbol_make (name);
4551 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4552 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4553 S_SET_STORAGE_CLASS (sym, C_BCOMM);
4554 S_SET_VALUE (sym, 0);
4555 symbol_get_tc (sym)->output = 1;
4557 ppc_frob_label (sym);
4559 demand_empty_rest_of_line ();
4562 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4565 ppc_ec (int ignore ATTRIBUTE_UNUSED)
4569 sym = symbol_make (".ec");
4570 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4571 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4572 S_SET_STORAGE_CLASS (sym, C_ECOMM);
4573 S_SET_VALUE (sym, 0);
4574 symbol_get_tc (sym)->output = 1;
4576 ppc_frob_label (sym);
4578 demand_empty_rest_of_line ();
4581 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4584 ppc_toc (int ignore ATTRIBUTE_UNUSED)
4586 if (ppc_toc_csect != (symbolS *) NULL)
4587 subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
4594 subseg = ppc_data_subsegment;
4595 ++ppc_data_subsegment;
4597 subseg_new (segment_name (data_section), subseg);
4598 ppc_toc_frag = frag_now;
4600 sym = symbol_find_or_make ("TOC[TC0]");
4601 symbol_set_frag (sym, frag_now);
4602 S_SET_SEGMENT (sym, data_section);
4603 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4604 symbol_get_tc (sym)->subseg = subseg;
4605 symbol_get_tc (sym)->output = 1;
4606 symbol_get_tc (sym)->within = sym;
4608 ppc_toc_csect = sym;
4610 for (list = ppc_data_csects;
4611 symbol_get_tc (list)->next != (symbolS *) NULL;
4612 list = symbol_get_tc (list)->next)
4614 symbol_get_tc (list)->next = sym;
4616 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4617 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
4621 ppc_current_csect = ppc_toc_csect;
4623 demand_empty_rest_of_line ();
4626 /* The AIX assembler automatically aligns the operands of a .long or
4627 .short pseudo-op, and we want to be compatible. */
4630 ppc_xcoff_cons (int log_size)
4632 frag_align (log_size, 0, 0);
4633 record_alignment (now_seg, log_size);
4634 cons (1 << log_size);
4638 ppc_vbyte (int dummy ATTRIBUTE_UNUSED)
4643 (void) expression (&exp);
4645 if (exp.X_op != O_constant)
4647 as_bad (_("non-constant byte count"));
4651 byte_count = exp.X_add_number;
4653 if (*input_line_pointer != ',')
4655 as_bad (_("missing value"));
4659 ++input_line_pointer;
4664 ppc_xcoff_end (void)
4668 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
4670 struct dw_section *dws = &dw_sections[i];
4671 struct dw_subsection *dwss;
4673 if (dws->anon_subseg)
4675 dwss = dws->anon_subseg;
4676 dwss->link = dws->list_subseg;
4679 dwss = dws->list_subseg;
4681 for (; dwss != NULL; dwss = dwss->link)
4682 if (dwss->end_exp.X_add_symbol != NULL)
4684 subseg_set (dws->sect, dwss->subseg);
4685 symbol_set_value_now (dwss->end_exp.X_add_symbol);
4690 #endif /* OBJ_XCOFF */
4691 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4693 /* The .tc pseudo-op. This is used when generating either XCOFF or
4694 ELF. This takes two or more arguments.
4696 When generating XCOFF output, the first argument is the name to
4697 give to this location in the toc; this will be a symbol with class
4698 TC. The rest of the arguments are N-byte values to actually put at
4699 this location in the TOC; often there is just one more argument, a
4700 relocatable symbol reference. The size of the value to store
4701 depends on target word size. A 32-bit target uses 4-byte values, a
4702 64-bit target uses 8-byte values.
4704 When not generating XCOFF output, the arguments are the same, but
4705 the first argument is simply ignored. */
4708 ppc_tc (int ignore ATTRIBUTE_UNUSED)
4712 /* Define the TOC symbol name. */
4718 if (ppc_toc_csect == (symbolS *) NULL
4719 || ppc_toc_csect != ppc_current_csect)
4721 as_bad (_(".tc not in .toc section"));
4722 ignore_rest_of_line ();
4726 name = input_line_pointer;
4727 endc = get_symbol_end ();
4729 sym = symbol_find_or_make (name);
4731 *input_line_pointer = endc;
4733 if (S_IS_DEFINED (sym))
4737 label = symbol_get_tc (ppc_current_csect)->within;
4738 if (symbol_get_tc (label)->symbol_class != XMC_TC0)
4740 as_bad (_(".tc with no label"));
4741 ignore_rest_of_line ();
4745 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
4746 symbol_set_frag (label, symbol_get_frag (sym));
4747 S_SET_VALUE (label, S_GET_VALUE (sym));
4749 while (! is_end_of_line[(unsigned char) *input_line_pointer])
4750 ++input_line_pointer;
4755 S_SET_SEGMENT (sym, now_seg);
4756 symbol_set_frag (sym, frag_now);
4757 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4758 symbol_get_tc (sym)->symbol_class = XMC_TC;
4759 symbol_get_tc (sym)->output = 1;
4761 ppc_frob_label (sym);
4764 #endif /* OBJ_XCOFF */
4768 /* Skip the TOC symbol name. */
4769 while (is_part_of_name (*input_line_pointer)
4770 || *input_line_pointer == ' '
4771 || *input_line_pointer == '['
4772 || *input_line_pointer == ']'
4773 || *input_line_pointer == '{'
4774 || *input_line_pointer == '}')
4775 ++input_line_pointer;
4777 /* Align to a four/eight byte boundary. */
4778 align = ppc_obj64 ? 3 : 2;
4779 frag_align (align, 0, 0);
4780 record_alignment (now_seg, align);
4781 #endif /* OBJ_ELF */
4783 if (*input_line_pointer != ',')
4784 demand_empty_rest_of_line ();
4787 ++input_line_pointer;
4788 cons (ppc_obj64 ? 8 : 4);
4792 /* Pseudo-op .machine. */
4795 ppc_machine (int ignore ATTRIBUTE_UNUSED)
4798 #define MAX_HISTORY 100
4799 static ppc_cpu_t *cpu_history;
4800 static int curr_hist;
4804 if (*input_line_pointer == '"')
4807 cpu_string = demand_copy_C_string (&len);
4812 cpu_string = input_line_pointer;
4813 c = get_symbol_end ();
4814 cpu_string = xstrdup (cpu_string);
4815 *input_line_pointer = c;
4818 if (cpu_string != NULL)
4820 ppc_cpu_t old_cpu = ppc_cpu;
4824 for (p = cpu_string; *p != 0; p++)
4827 if (strcmp (cpu_string, "push") == 0)
4829 if (cpu_history == NULL)
4830 cpu_history = xmalloc (MAX_HISTORY * sizeof (*cpu_history));
4832 if (curr_hist >= MAX_HISTORY)
4833 as_bad (_(".machine stack overflow"));
4835 cpu_history[curr_hist++] = ppc_cpu;
4837 else if (strcmp (cpu_string, "pop") == 0)
4840 as_bad (_(".machine stack underflow"));
4842 ppc_cpu = cpu_history[--curr_hist];
4844 else if ((new_cpu = ppc_parse_cpu (ppc_cpu, &sticky, cpu_string)) != 0)
4847 as_bad (_("invalid machine `%s'"), cpu_string);
4849 if (ppc_cpu != old_cpu)
4850 ppc_setup_opcodes ();
4853 demand_empty_rest_of_line ();
4855 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4859 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4861 /* Set the current section. */
4863 ppc_set_current_section (segT new)
4865 ppc_previous_section = ppc_current_section;
4866 ppc_current_section = new;
4869 /* pseudo-op: .previous
4870 behaviour: toggles the current section with the previous section.
4872 warnings: "No previous section" */
4875 ppc_previous (int ignore ATTRIBUTE_UNUSED)
4877 if (ppc_previous_section == NULL)
4879 as_warn (_("no previous section to return to, ignored."));
4883 subseg_set (ppc_previous_section, 0);
4885 ppc_set_current_section (ppc_previous_section);
4888 /* pseudo-op: .pdata
4889 behaviour: predefined read only data section
4893 initial: .section .pdata "adr3"
4894 a - don't know -- maybe a misprint
4895 d - initialized data
4897 3 - double word aligned (that would be 4 byte boundary)
4900 Tag index tables (also known as the function table) for exception
4901 handling, debugging, etc. */
4904 ppc_pdata (int ignore ATTRIBUTE_UNUSED)
4906 if (pdata_section == 0)
4908 pdata_section = subseg_new (".pdata", 0);
4910 bfd_set_section_flags (stdoutput, pdata_section,
4911 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4912 | SEC_READONLY | SEC_DATA ));
4914 bfd_set_section_alignment (stdoutput, pdata_section, 2);
4918 pdata_section = subseg_new (".pdata", 0);
4920 ppc_set_current_section (pdata_section);
4923 /* pseudo-op: .ydata
4924 behaviour: predefined read only data section
4928 initial: .section .ydata "drw3"
4929 a - don't know -- maybe a misprint
4930 d - initialized data
4932 3 - double word aligned (that would be 4 byte boundary)
4934 Tag tables (also known as the scope table) for exception handling,
4938 ppc_ydata (int ignore ATTRIBUTE_UNUSED)
4940 if (ydata_section == 0)
4942 ydata_section = subseg_new (".ydata", 0);
4943 bfd_set_section_flags (stdoutput, ydata_section,
4944 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4945 | SEC_READONLY | SEC_DATA ));
4947 bfd_set_section_alignment (stdoutput, ydata_section, 3);
4951 ydata_section = subseg_new (".ydata", 0);
4953 ppc_set_current_section (ydata_section);
4956 /* pseudo-op: .reldata
4957 behaviour: predefined read write data section
4958 double word aligned (4-byte)
4959 FIXME: relocation is applied to it
4960 FIXME: what's the difference between this and .data?
4963 initial: .section .reldata "drw3"
4964 d - initialized data
4967 3 - double word aligned (that would be 8 byte boundary)
4970 Like .data, but intended to hold data subject to relocation, such as
4971 function descriptors, etc. */
4974 ppc_reldata (int ignore ATTRIBUTE_UNUSED)
4976 if (reldata_section == 0)
4978 reldata_section = subseg_new (".reldata", 0);
4980 bfd_set_section_flags (stdoutput, reldata_section,
4981 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4984 bfd_set_section_alignment (stdoutput, reldata_section, 2);
4988 reldata_section = subseg_new (".reldata", 0);
4990 ppc_set_current_section (reldata_section);
4993 /* pseudo-op: .rdata
4994 behaviour: predefined read only data section
4998 initial: .section .rdata "dr3"
4999 d - initialized data
5001 3 - double word aligned (that would be 4 byte boundary) */
5004 ppc_rdata (int ignore ATTRIBUTE_UNUSED)
5006 if (rdata_section == 0)
5008 rdata_section = subseg_new (".rdata", 0);
5009 bfd_set_section_flags (stdoutput, rdata_section,
5010 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5011 | SEC_READONLY | SEC_DATA ));
5013 bfd_set_section_alignment (stdoutput, rdata_section, 2);
5017 rdata_section = subseg_new (".rdata", 0);
5019 ppc_set_current_section (rdata_section);
5022 /* pseudo-op: .ualong
5023 behaviour: much like .int, with the exception that no alignment is
5025 FIXME: test the alignment statement
5030 ppc_ualong (int ignore ATTRIBUTE_UNUSED)
5036 /* pseudo-op: .znop <symbol name>
5037 behaviour: Issue a nop instruction
5038 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5039 the supplied symbol name.
5041 warnings: Missing symbol name */
5044 ppc_znop (int ignore ATTRIBUTE_UNUSED)
5047 const struct powerpc_opcode *opcode;
5054 /* Strip out the symbol name. */
5055 symbol_name = input_line_pointer;
5056 c = get_symbol_end ();
5058 name = xmalloc (input_line_pointer - symbol_name + 1);
5059 strcpy (name, symbol_name);
5061 sym = symbol_find_or_make (name);
5063 *input_line_pointer = c;
5067 /* Look up the opcode in the hash table. */
5068 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
5070 /* Stick in the nop. */
5071 insn = opcode->opcode;
5073 /* Write out the instruction. */
5075 md_number_to_chars (f, insn, 4);
5077 f - frag_now->fr_literal,
5082 BFD_RELOC_16_GOT_PCREL);
5092 ppc_pe_comm (int lcomm)
5101 name = input_line_pointer;
5102 c = get_symbol_end ();
5104 /* just after name is now '\0'. */
5105 p = input_line_pointer;
5108 if (*input_line_pointer != ',')
5110 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5111 ignore_rest_of_line ();
5115 input_line_pointer++; /* skip ',' */
5116 if ((temp = get_absolute_expression ()) < 0)
5118 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
5119 ignore_rest_of_line ();
5125 /* The third argument to .comm is the alignment. */
5126 if (*input_line_pointer != ',')
5130 ++input_line_pointer;
5131 align = get_absolute_expression ();
5134 as_warn (_("ignoring bad alignment"));
5141 symbolP = symbol_find_or_make (name);
5144 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
5146 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5147 S_GET_NAME (symbolP));
5148 ignore_rest_of_line ();
5152 if (S_GET_VALUE (symbolP))
5154 if (S_GET_VALUE (symbolP) != (valueT) temp)
5155 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5156 S_GET_NAME (symbolP),
5157 (long) S_GET_VALUE (symbolP),
5162 S_SET_VALUE (symbolP, (valueT) temp);
5163 S_SET_EXTERNAL (symbolP);
5164 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
5167 demand_empty_rest_of_line ();
5171 * implement the .section pseudo op:
5172 * .section name {, "flags"}
5174 * | +--- optional flags: 'b' for bss
5176 * +-- section name 'l' for lib
5180 * 'd' (apparently m88k for data)
5182 * But if the argument is not a quoted string, treat it as a
5183 * subsegment number.
5185 * FIXME: this is a copy of the section processing from obj-coff.c, with
5186 * additions/changes for the moto-pas assembler support. There are three
5189 * FIXME: I just noticed this. This doesn't work at all really. It it
5190 * setting bits that bfd probably neither understands or uses. The
5191 * correct approach (?) will have to incorporate extra fields attached
5192 * to the section to hold the system specific stuff. (krk)
5195 * 'a' - unknown - referred to in documentation, but no definition supplied
5196 * 'c' - section has code
5197 * 'd' - section has initialized data
5198 * 'u' - section has uninitialized data
5199 * 'i' - section contains directives (info)
5200 * 'n' - section can be discarded
5201 * 'R' - remove section at link time
5203 * Section Protection:
5204 * 'r' - section is readable
5205 * 'w' - section is writeable
5206 * 'x' - section is executable
5207 * 's' - section is sharable
5209 * Section Alignment:
5210 * '0' - align to byte boundary
5211 * '1' - align to halfword undary
5212 * '2' - align to word boundary
5213 * '3' - align to doubleword boundary
5214 * '4' - align to quadword boundary
5215 * '5' - align to 32 byte boundary
5216 * '6' - align to 64 byte boundary
5221 ppc_pe_section (int ignore ATTRIBUTE_UNUSED)
5223 /* Strip out the section name. */
5232 section_name = input_line_pointer;
5233 c = get_symbol_end ();
5235 name = xmalloc (input_line_pointer - section_name + 1);
5236 strcpy (name, section_name);
5238 *input_line_pointer = c;
5243 flags = SEC_NO_FLAGS;
5245 if (strcmp (name, ".idata$2") == 0)
5249 else if (strcmp (name, ".idata$3") == 0)
5253 else if (strcmp (name, ".idata$4") == 0)
5257 else if (strcmp (name, ".idata$5") == 0)
5261 else if (strcmp (name, ".idata$6") == 0)
5266 /* Default alignment to 16 byte boundary. */
5269 if (*input_line_pointer == ',')
5271 ++input_line_pointer;
5273 if (*input_line_pointer != '"')
5274 exp = get_absolute_expression ();
5277 ++input_line_pointer;
5278 while (*input_line_pointer != '"'
5279 && ! is_end_of_line[(unsigned char) *input_line_pointer])
5281 switch (*input_line_pointer)
5283 /* Section Contents */
5284 case 'a': /* unknown */
5285 as_bad (_("unsupported section attribute -- 'a'"));
5287 case 'c': /* code section */
5290 case 'd': /* section has initialized data */
5293 case 'u': /* section has uninitialized data */
5294 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5298 case 'i': /* section contains directives (info) */
5299 /* FIXME: This is IMAGE_SCN_LNK_INFO
5301 flags |= SEC_HAS_CONTENTS;
5303 case 'n': /* section can be discarded */
5306 case 'R': /* Remove section at link time */
5307 flags |= SEC_NEVER_LOAD;
5309 #if IFLICT_BRAIN_DAMAGE
5310 /* Section Protection */
5311 case 'r': /* section is readable */
5312 flags |= IMAGE_SCN_MEM_READ;
5314 case 'w': /* section is writeable */
5315 flags |= IMAGE_SCN_MEM_WRITE;
5317 case 'x': /* section is executable */
5318 flags |= IMAGE_SCN_MEM_EXECUTE;
5320 case 's': /* section is sharable */
5321 flags |= IMAGE_SCN_MEM_SHARED;
5324 /* Section Alignment */
5325 case '0': /* align to byte boundary */
5326 flags |= IMAGE_SCN_ALIGN_1BYTES;
5329 case '1': /* align to halfword boundary */
5330 flags |= IMAGE_SCN_ALIGN_2BYTES;
5333 case '2': /* align to word boundary */
5334 flags |= IMAGE_SCN_ALIGN_4BYTES;
5337 case '3': /* align to doubleword boundary */
5338 flags |= IMAGE_SCN_ALIGN_8BYTES;
5341 case '4': /* align to quadword boundary */
5342 flags |= IMAGE_SCN_ALIGN_16BYTES;
5345 case '5': /* align to 32 byte boundary */
5346 flags |= IMAGE_SCN_ALIGN_32BYTES;
5349 case '6': /* align to 64 byte boundary */
5350 flags |= IMAGE_SCN_ALIGN_64BYTES;
5355 as_bad (_("unknown section attribute '%c'"),
5356 *input_line_pointer);
5359 ++input_line_pointer;
5361 if (*input_line_pointer == '"')
5362 ++input_line_pointer;
5366 sec = subseg_new (name, (subsegT) exp);
5368 ppc_set_current_section (sec);
5370 if (flags != SEC_NO_FLAGS)
5372 if (! bfd_set_section_flags (stdoutput, sec, flags))
5373 as_bad (_("error setting flags for \"%s\": %s"),
5374 bfd_section_name (stdoutput, sec),
5375 bfd_errmsg (bfd_get_error ()));
5378 bfd_set_section_alignment (stdoutput, sec, align);
5382 ppc_pe_function (int ignore ATTRIBUTE_UNUSED)
5388 name = input_line_pointer;
5389 endc = get_symbol_end ();
5391 ext_sym = symbol_find_or_make (name);
5393 *input_line_pointer = endc;
5395 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
5396 SF_SET_FUNCTION (ext_sym);
5397 SF_SET_PROCESS (ext_sym);
5398 coff_add_linesym (ext_sym);
5400 demand_empty_rest_of_line ();
5404 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED)
5406 if (tocdata_section == 0)
5408 tocdata_section = subseg_new (".tocd", 0);
5409 /* FIXME: section flags won't work. */
5410 bfd_set_section_flags (stdoutput, tocdata_section,
5411 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5412 | SEC_READONLY | SEC_DATA));
5414 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
5418 rdata_section = subseg_new (".tocd", 0);
5421 ppc_set_current_section (tocdata_section);
5423 demand_empty_rest_of_line ();
5426 /* Don't adjust TOC relocs to use the section symbol. */
5429 ppc_pe_fix_adjustable (fixS *fix)
5431 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
5438 /* XCOFF specific symbol and file handling. */
5440 /* Canonicalize the symbol name. We use the to force the suffix, if
5441 any, to use square brackets, and to be in upper case. */
5444 ppc_canonicalize_symbol_name (char *name)
5448 if (ppc_stab_symbol)
5451 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
5465 for (s++; *s != '\0' && *s != brac; s++)
5468 if (*s == '\0' || s[1] != '\0')
5469 as_bad (_("bad symbol suffix"));
5477 /* Set the class of a symbol based on the suffix, if any. This is
5478 called whenever a new symbol is created. */
5481 ppc_symbol_new_hook (symbolS *sym)
5483 struct ppc_tc_sy *tc;
5486 tc = symbol_get_tc (sym);
5489 tc->symbol_class = -1;
5490 tc->real_name = NULL;
5497 if (ppc_stab_symbol)
5500 s = strchr (S_GET_NAME (sym), '[');
5501 if (s == (const char *) NULL)
5503 /* There is no suffix. */
5512 if (strcmp (s, "BS]") == 0)
5513 tc->symbol_class = XMC_BS;
5516 if (strcmp (s, "DB]") == 0)
5517 tc->symbol_class = XMC_DB;
5518 else if (strcmp (s, "DS]") == 0)
5519 tc->symbol_class = XMC_DS;
5522 if (strcmp (s, "GL]") == 0)
5523 tc->symbol_class = XMC_GL;
5526 if (strcmp (s, "PR]") == 0)
5527 tc->symbol_class = XMC_PR;
5530 if (strcmp (s, "RO]") == 0)
5531 tc->symbol_class = XMC_RO;
5532 else if (strcmp (s, "RW]") == 0)
5533 tc->symbol_class = XMC_RW;
5536 if (strcmp (s, "SV]") == 0)
5537 tc->symbol_class = XMC_SV;
5540 if (strcmp (s, "TC]") == 0)
5541 tc->symbol_class = XMC_TC;
5542 else if (strcmp (s, "TI]") == 0)
5543 tc->symbol_class = XMC_TI;
5544 else if (strcmp (s, "TB]") == 0)
5545 tc->symbol_class = XMC_TB;
5546 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
5547 tc->symbol_class = XMC_TC0;
5550 if (strcmp (s, "UA]") == 0)
5551 tc->symbol_class = XMC_UA;
5552 else if (strcmp (s, "UC]") == 0)
5553 tc->symbol_class = XMC_UC;
5556 if (strcmp (s, "XO]") == 0)
5557 tc->symbol_class = XMC_XO;
5561 if (tc->symbol_class == -1)
5562 as_bad (_("unrecognized symbol suffix"));
5565 /* Set the class of a label based on where it is defined. This
5566 handles symbols without suffixes. Also, move the symbol so that it
5567 follows the csect symbol. */
5570 ppc_frob_label (symbolS *sym)
5572 if (ppc_current_csect != (symbolS *) NULL)
5574 if (symbol_get_tc (sym)->symbol_class == -1)
5575 symbol_get_tc (sym)->symbol_class = symbol_get_tc (ppc_current_csect)->symbol_class;
5577 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
5578 symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
5579 &symbol_rootP, &symbol_lastP);
5580 symbol_get_tc (ppc_current_csect)->within = sym;
5581 symbol_get_tc (sym)->within = ppc_current_csect;
5585 dwarf2_emit_label (sym);
5589 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5590 seen. It tells ppc_adjust_symtab whether it needs to look through
5593 static bfd_boolean ppc_saw_abs;
5595 /* Change the name of a symbol just before writing it out. Set the
5596 real name if the .rename pseudo-op was used. Otherwise, remove any
5597 class suffix. Return 1 if the symbol should not be included in the
5601 ppc_frob_symbol (symbolS *sym)
5603 static symbolS *ppc_last_function;
5604 static symbolS *set_end;
5606 /* Discard symbols that should not be included in the output symbol
5608 if (! symbol_used_in_reloc_p (sym)
5609 && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
5610 || (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
5611 && ! symbol_get_tc (sym)->output
5612 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
5615 /* This one will disappear anyway. Don't make a csect sym for it. */
5616 if (sym == abs_section_sym)
5619 if (symbol_get_tc (sym)->real_name != (char *) NULL)
5620 S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
5626 name = S_GET_NAME (sym);
5627 s = strchr (name, '[');
5628 if (s != (char *) NULL)
5634 snew = xmalloc (len + 1);
5635 memcpy (snew, name, len);
5638 S_SET_NAME (sym, snew);
5642 if (set_end != (symbolS *) NULL)
5644 SA_SET_SYM_ENDNDX (set_end, sym);
5648 if (SF_GET_FUNCTION (sym))
5650 if (ppc_last_function != (symbolS *) NULL)
5651 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5652 ppc_last_function = sym;
5653 if (symbol_get_tc (sym)->u.size != (symbolS *) NULL)
5655 resolve_symbol_value (symbol_get_tc (sym)->u.size);
5656 SA_SET_SYM_FSIZE (sym,
5657 (long) S_GET_VALUE (symbol_get_tc (sym)->u.size));
5660 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
5661 && strcmp (S_GET_NAME (sym), ".ef") == 0)
5663 if (ppc_last_function == (symbolS *) NULL)
5664 as_bad (_(".ef with no preceding .function"));
5667 set_end = ppc_last_function;
5668 ppc_last_function = NULL;
5670 /* We don't have a C_EFCN symbol, but we need to force the
5671 COFF backend to believe that it has seen one. */
5672 coff_last_function = NULL;
5676 if (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
5677 && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
5678 && S_GET_STORAGE_CLASS (sym) != C_FILE
5679 && S_GET_STORAGE_CLASS (sym) != C_FCN
5680 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
5681 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
5682 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
5683 && S_GET_STORAGE_CLASS (sym) != C_BINCL
5684 && S_GET_STORAGE_CLASS (sym) != C_EINCL
5685 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
5686 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
5688 if (S_GET_STORAGE_CLASS (sym) == C_EXT
5689 || S_GET_STORAGE_CLASS (sym) == C_AIX_WEAKEXT
5690 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
5693 union internal_auxent *a;
5695 /* Create a csect aux. */
5696 i = S_GET_NUMBER_AUXILIARY (sym);
5697 S_SET_NUMBER_AUXILIARY (sym, i + 1);
5698 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
5699 if (symbol_get_tc (sym)->symbol_class == XMC_TC0)
5701 /* This is the TOC table. */
5702 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
5703 a->x_csect.x_scnlen.l = 0;
5704 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5706 else if (symbol_get_tc (sym)->subseg != 0)
5708 /* This is a csect symbol. x_scnlen is the size of the
5710 if (symbol_get_tc (sym)->next == (symbolS *) NULL)
5711 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5712 S_GET_SEGMENT (sym))
5713 - S_GET_VALUE (sym));
5716 resolve_symbol_value (symbol_get_tc (sym)->next);
5717 a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
5718 - S_GET_VALUE (sym));
5720 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
5722 else if (S_GET_SEGMENT (sym) == bss_section)
5724 /* This is a common symbol. */
5725 a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
5726 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
5727 if (S_IS_EXTERNAL (sym))
5728 symbol_get_tc (sym)->symbol_class = XMC_RW;
5730 symbol_get_tc (sym)->symbol_class = XMC_BS;
5732 else if (S_GET_SEGMENT (sym) == absolute_section)
5734 /* This is an absolute symbol. The csect will be created by
5735 ppc_adjust_symtab. */
5737 a->x_csect.x_smtyp = XTY_LD;
5738 if (symbol_get_tc (sym)->symbol_class == -1)
5739 symbol_get_tc (sym)->symbol_class = XMC_XO;
5741 else if (! S_IS_DEFINED (sym))
5743 /* This is an external symbol. */
5744 a->x_csect.x_scnlen.l = 0;
5745 a->x_csect.x_smtyp = XTY_ER;
5747 else if (symbol_get_tc (sym)->symbol_class == XMC_TC)
5751 /* This is a TOC definition. x_scnlen is the size of the
5753 next = symbol_next (sym);
5754 while (symbol_get_tc (next)->symbol_class == XMC_TC0)
5755 next = symbol_next (next);
5756 if (next == (symbolS *) NULL
5757 || symbol_get_tc (next)->symbol_class != XMC_TC)
5759 if (ppc_after_toc_frag == (fragS *) NULL)
5760 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5762 - S_GET_VALUE (sym));
5764 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
5765 - S_GET_VALUE (sym));
5769 resolve_symbol_value (next);
5770 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
5771 - S_GET_VALUE (sym));
5773 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5779 /* This is a normal symbol definition. x_scnlen is the
5780 symbol index of the containing csect. */
5781 if (S_GET_SEGMENT (sym) == text_section)
5782 csect = ppc_text_csects;
5783 else if (S_GET_SEGMENT (sym) == data_section)
5784 csect = ppc_data_csects;
5788 /* Skip the initial dummy symbol. */
5789 csect = symbol_get_tc (csect)->next;
5791 if (csect == (symbolS *) NULL)
5793 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
5794 a->x_csect.x_scnlen.l = 0;
5798 while (symbol_get_tc (csect)->next != (symbolS *) NULL)
5800 resolve_symbol_value (symbol_get_tc (csect)->next);
5801 if (S_GET_VALUE (symbol_get_tc (csect)->next)
5802 > S_GET_VALUE (sym))
5804 csect = symbol_get_tc (csect)->next;
5807 a->x_csect.x_scnlen.p =
5808 coffsymbol (symbol_get_bfdsym (csect))->native;
5809 coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
5812 a->x_csect.x_smtyp = XTY_LD;
5815 a->x_csect.x_parmhash = 0;
5816 a->x_csect.x_snhash = 0;
5817 if (symbol_get_tc (sym)->symbol_class == -1)
5818 a->x_csect.x_smclas = XMC_PR;
5820 a->x_csect.x_smclas = symbol_get_tc (sym)->symbol_class;
5821 a->x_csect.x_stab = 0;
5822 a->x_csect.x_snstab = 0;
5824 /* Don't let the COFF backend resort these symbols. */
5825 symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
5827 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
5829 /* We want the value to be the symbol index of the referenced
5830 csect symbol. BFD will do that for us if we set the right
5832 asymbol *bsym = symbol_get_bfdsym (symbol_get_tc (sym)->within);
5833 combined_entry_type *c = coffsymbol (bsym)->native;
5835 S_SET_VALUE (sym, (valueT) (size_t) c);
5836 coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
5838 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
5843 block = symbol_get_tc (sym)->within;
5846 /* The value is the offset from the enclosing csect. */
5849 csect = symbol_get_tc (block)->within;
5850 resolve_symbol_value (csect);
5851 base = S_GET_VALUE (csect);
5856 S_SET_VALUE (sym, S_GET_VALUE (sym) - base);
5858 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
5859 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
5861 /* We want the value to be a file offset into the line numbers.
5862 BFD will do that for us if we set the right flags. We have
5863 already set the value correctly. */
5864 coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
5870 /* Adjust the symbol table. This creates csect symbols for all
5871 absolute symbols. */
5874 ppc_adjust_symtab (void)
5881 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
5885 union internal_auxent *a;
5887 if (S_GET_SEGMENT (sym) != absolute_section)
5890 csect = symbol_create (".abs[XO]", absolute_section,
5891 S_GET_VALUE (sym), &zero_address_frag);
5892 symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
5893 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
5894 i = S_GET_NUMBER_AUXILIARY (csect);
5895 S_SET_NUMBER_AUXILIARY (csect, i + 1);
5896 a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
5897 a->x_csect.x_scnlen.l = 0;
5898 a->x_csect.x_smtyp = XTY_SD;
5899 a->x_csect.x_parmhash = 0;
5900 a->x_csect.x_snhash = 0;
5901 a->x_csect.x_smclas = XMC_XO;
5902 a->x_csect.x_stab = 0;
5903 a->x_csect.x_snstab = 0;
5905 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
5907 i = S_GET_NUMBER_AUXILIARY (sym);
5908 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
5909 a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
5910 coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
5913 ppc_saw_abs = FALSE;
5916 /* Set the VMA for a section. This is called on all the sections in
5920 ppc_frob_section (asection *sec)
5922 static bfd_vma vma = 0;
5924 /* Dwarf sections start at 0. */
5925 if (bfd_get_section_flags (NULL, sec) & SEC_DEBUGGING)
5928 vma = md_section_align (sec, vma);
5929 bfd_set_section_vma (stdoutput, sec, vma);
5930 vma += bfd_section_size (stdoutput, sec);
5933 #endif /* OBJ_XCOFF */
5936 md_atof (int type, char *litp, int *sizep)
5938 return ieee_md_atof (type, litp, sizep, target_big_endian);
5941 /* Write a value out to the object file, using the appropriate
5945 md_number_to_chars (char *buf, valueT val, int n)
5947 if (target_big_endian)
5948 number_to_chars_bigendian (buf, val, n);
5950 number_to_chars_littleendian (buf, val, n);
5953 /* Align a section (I don't know why this is machine dependent). */
5956 md_section_align (asection *seg ATTRIBUTE_UNUSED, valueT addr)
5961 int align = bfd_get_section_alignment (stdoutput, seg);
5963 return ((addr + (1 << align) - 1) & (-1 << align));
5967 /* We don't have any form of relaxing. */
5970 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
5971 asection *seg ATTRIBUTE_UNUSED)
5977 /* Convert a machine dependent frag. We never generate these. */
5980 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
5981 asection *sec ATTRIBUTE_UNUSED,
5982 fragS *fragp ATTRIBUTE_UNUSED)
5987 /* We have no need to default values of symbols. */
5990 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5995 /* Functions concerning relocs. */
5997 /* The location from which a PC relative jump should be calculated,
5998 given a PC relative reloc. */
6001 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
6003 return fixp->fx_frag->fr_address + fixp->fx_where;
6008 /* This is called to see whether a fixup should be adjusted to use a
6009 section symbol. We take the opportunity to change a fixup against
6010 a symbol in the TOC subsegment into a reloc against the
6011 corresponding .tc symbol. */
6014 ppc_fix_adjustable (fixS *fix)
6016 valueT val = resolve_symbol_value (fix->fx_addsy);
6017 segT symseg = S_GET_SEGMENT (fix->fx_addsy);
6018 TC_SYMFIELD_TYPE *tc;
6020 if (symseg == absolute_section)
6023 /* Always adjust symbols in debugging sections. */
6024 if (bfd_get_section_flags (stdoutput, symseg) & SEC_DEBUGGING)
6027 if (ppc_toc_csect != (symbolS *) NULL
6028 && fix->fx_addsy != ppc_toc_csect
6029 && symseg == data_section
6030 && val >= ppc_toc_frag->fr_address
6031 && (ppc_after_toc_frag == (fragS *) NULL
6032 || val < ppc_after_toc_frag->fr_address))
6036 for (sy = symbol_next (ppc_toc_csect);
6037 sy != (symbolS *) NULL;
6038 sy = symbol_next (sy))
6040 TC_SYMFIELD_TYPE *sy_tc = symbol_get_tc (sy);
6042 if (sy_tc->symbol_class == XMC_TC0)
6044 if (sy_tc->symbol_class != XMC_TC)
6046 if (val == resolve_symbol_value (sy))
6049 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
6054 as_bad_where (fix->fx_file, fix->fx_line,
6055 _("symbol in .toc does not match any .tc"));
6058 /* Possibly adjust the reloc to be against the csect. */
6059 tc = symbol_get_tc (fix->fx_addsy);
6061 && tc->symbol_class != XMC_TC0
6062 && tc->symbol_class != XMC_TC
6063 && symseg != bss_section
6064 /* Don't adjust if this is a reloc in the toc section. */
6065 && (symseg != data_section
6066 || ppc_toc_csect == NULL
6067 || val < ppc_toc_frag->fr_address
6068 || (ppc_after_toc_frag != NULL
6069 && val >= ppc_after_toc_frag->fr_address)))
6071 symbolS *csect = tc->within;
6073 /* If the symbol was not declared by a label (eg: a section symbol),
6074 use the section instead of the csect. This doesn't happen in
6075 normal AIX assembly code. */
6077 csect = seg_info (symseg)->sym;
6079 fix->fx_offset += val - symbol_get_frag (csect)->fr_address;
6080 fix->fx_addsy = csect;
6085 /* Adjust a reloc against a .lcomm symbol to be against the base
6087 if (symseg == bss_section
6088 && ! S_IS_EXTERNAL (fix->fx_addsy))
6090 symbolS *sy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
6092 fix->fx_offset += val - resolve_symbol_value (sy);
6099 /* A reloc from one csect to another must be kept. The assembler
6100 will, of course, keep relocs between sections, and it will keep
6101 absolute relocs, but we need to force it to keep PC relative relocs
6102 between two csects in the same section. */
6105 ppc_force_relocation (fixS *fix)
6107 /* At this point fix->fx_addsy should already have been converted to
6108 a csect symbol. If the csect does not include the fragment, then
6109 we need to force the relocation. */
6111 && fix->fx_addsy != NULL
6112 && symbol_get_tc (fix->fx_addsy)->subseg != 0
6113 && ((symbol_get_frag (fix->fx_addsy)->fr_address
6114 > fix->fx_frag->fr_address)
6115 || (symbol_get_tc (fix->fx_addsy)->next != NULL
6116 && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
6117 <= fix->fx_frag->fr_address))))
6120 return generic_force_reloc (fix);
6124 ppc_new_dot_label (symbolS *sym)
6126 /* Anchor this label to the current csect for relocations. */
6127 symbol_get_tc (sym)->within = ppc_current_csect;
6130 #endif /* OBJ_XCOFF */
6133 /* If this function returns non-zero, it guarantees that a relocation
6134 will be emitted for a fixup. */
6137 ppc_force_relocation (fixS *fix)
6139 /* Branch prediction relocations must force a relocation, as must
6140 the vtable description relocs. */
6141 switch (fix->fx_r_type)
6143 case BFD_RELOC_PPC_B16_BRTAKEN:
6144 case BFD_RELOC_PPC_B16_BRNTAKEN:
6145 case BFD_RELOC_PPC_BA16_BRTAKEN:
6146 case BFD_RELOC_PPC_BA16_BRNTAKEN:
6147 case BFD_RELOC_24_PLT_PCREL:
6148 case BFD_RELOC_PPC64_TOC:
6154 if (fix->fx_r_type >= BFD_RELOC_PPC_TLS
6155 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA)
6158 return generic_force_reloc (fix);
6162 ppc_fix_adjustable (fixS *fix)
6164 return (fix->fx_r_type != BFD_RELOC_16_GOTOFF
6165 && fix->fx_r_type != BFD_RELOC_LO16_GOTOFF
6166 && fix->fx_r_type != BFD_RELOC_HI16_GOTOFF
6167 && fix->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
6168 && fix->fx_r_type != BFD_RELOC_PPC64_GOT16_DS
6169 && fix->fx_r_type != BFD_RELOC_PPC64_GOT16_LO_DS
6170 && fix->fx_r_type != BFD_RELOC_GPREL16
6171 && fix->fx_r_type != BFD_RELOC_VTABLE_INHERIT
6172 && fix->fx_r_type != BFD_RELOC_VTABLE_ENTRY
6173 && !(fix->fx_r_type >= BFD_RELOC_PPC_TLS
6174 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA));
6179 ppc_frag_check (struct frag *fragP)
6181 if (!fragP->has_code)
6184 if (ppc_mach() == bfd_mach_ppc_vle)
6186 if (((fragP->fr_address + fragP->insn_addr) & 1) != 0)
6187 as_bad (_("instruction address is not a multiple of 2"));
6191 if (((fragP->fr_address + fragP->insn_addr) & 3) != 0)
6192 as_bad (_("instruction address is not a multiple of 4"));
6196 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6197 rs_align_code frag. */
6200 ppc_handle_align (struct frag *fragP)
6202 valueT count = (fragP->fr_next->fr_address
6203 - (fragP->fr_address + fragP->fr_fix));
6205 if (ppc_mach() == bfd_mach_ppc_vle && count != 0 && (count & 1) == 0)
6207 char *dest = fragP->fr_literal + fragP->fr_fix;
6210 md_number_to_chars (dest, 0x4400, 2);
6212 else if (count != 0 && (count & 3) == 0)
6214 char *dest = fragP->fr_literal + fragP->fr_fix;
6218 if (count > 4 * nop_limit && count < 0x2000000)
6222 /* Make a branch, then follow with nops. Insert another
6223 frag to handle the nops. */
6224 md_number_to_chars (dest, 0x48000000 + count, 4);
6229 rest = xmalloc (SIZEOF_STRUCT_FRAG + 4);
6230 memcpy (rest, fragP, SIZEOF_STRUCT_FRAG);
6231 fragP->fr_next = rest;
6233 rest->fr_address += rest->fr_fix + 4;
6235 /* If we leave the next frag as rs_align_code we'll come here
6236 again, resulting in a bunch of branches rather than a
6237 branch followed by nops. */
6238 rest->fr_type = rs_align;
6239 dest = rest->fr_literal;
6242 md_number_to_chars (dest, 0x60000000, 4);
6244 if ((ppc_cpu & PPC_OPCODE_POWER6) != 0
6245 || (ppc_cpu & PPC_OPCODE_POWER7) != 0
6246 || (ppc_cpu & PPC_OPCODE_POWER8) != 0)
6248 /* For power6, power7 and power8, we want the last nop to be a group
6249 terminating one. Do this by inserting an rs_fill frag immediately
6250 after this one, with its address set to the last nop location.
6251 This will automatically reduce the number of nops in the current
6255 struct frag *group_nop = xmalloc (SIZEOF_STRUCT_FRAG + 4);
6257 memcpy (group_nop, fragP, SIZEOF_STRUCT_FRAG);
6258 group_nop->fr_address = group_nop->fr_next->fr_address - 4;
6259 group_nop->fr_fix = 0;
6260 group_nop->fr_offset = 1;
6261 group_nop->fr_type = rs_fill;
6262 fragP->fr_next = group_nop;
6263 dest = group_nop->fr_literal;
6266 if ((ppc_cpu & PPC_OPCODE_POWER7) != 0
6267 || (ppc_cpu & PPC_OPCODE_POWER8) != 0)
6269 if (ppc_cpu & PPC_OPCODE_E500MC)
6270 /* e500mc group terminating nop: "ori 0,0,0". */
6271 md_number_to_chars (dest, 0x60000000, 4);
6273 /* power7/power8 group terminating nop: "ori 2,2,0". */
6274 md_number_to_chars (dest, 0x60420000, 4);
6277 /* power6 group terminating nop: "ori 1,1,0". */
6278 md_number_to_chars (dest, 0x60210000, 4);
6283 /* Apply a fixup to the object code. This is called for all the
6284 fixups we generated by the calls to fix_new_exp, above. */
6287 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
6289 valueT value = * valP;
6292 if (fixP->fx_addsy != NULL)
6294 /* Hack around bfd_install_relocation brain damage. */
6296 value += fixP->fx_frag->fr_address + fixP->fx_where;
6301 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6302 the symbol values. If we are doing this relocation the code in
6303 write.c is going to call bfd_install_relocation, which is also
6304 going to use the symbol value. That means that if the reloc is
6305 fully resolved we want to use *valP since bfd_install_relocation is
6307 However, if the reloc is not fully resolved we do not want to
6308 use *valP, and must use fx_offset instead. If the relocation
6309 is PC-relative, we then need to re-apply md_pcrel_from_section
6310 to this new relocation value. */
6311 if (fixP->fx_addsy == (symbolS *) NULL)
6316 value = fixP->fx_offset;
6318 value -= md_pcrel_from_section (fixP, seg);
6322 if (fixP->fx_subsy != (symbolS *) NULL)
6324 /* We can't actually support subtracting a symbol. */
6325 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
6328 if (fixP->fx_pcrel_adjust != 0)
6330 /* Handle relocs in an insn. */
6332 int opindex = fixP->fx_pcrel_adjust & 0xff;
6333 const struct powerpc_operand *operand = &powerpc_operands[opindex];
6339 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6340 does not generate a reloc. It uses the offset of `sym' within its
6341 csect. Other usages, such as `.long sym', generate relocs. This
6342 is the documented behaviour of non-TOC symbols. */
6343 if ((operand->flags & PPC_OPERAND_PARENS) != 0
6344 && (operand->bitm & 0xfff0) == 0xfff0
6345 && operand->shift == 0
6346 && (operand->insert == NULL || ppc_obj64)
6347 && fixP->fx_addsy != NULL
6348 && symbol_get_tc (fixP->fx_addsy)->subseg != 0
6349 && symbol_get_tc (fixP->fx_addsy)->symbol_class != XMC_TC
6350 && symbol_get_tc (fixP->fx_addsy)->symbol_class != XMC_TC0
6351 && S_GET_SEGMENT (fixP->fx_addsy) != bss_section)
6353 value = fixP->fx_offset;
6358 switch (fixP->fx_r_type)
6361 case BFD_RELOC_PPC64_ADDR16_LO_DS:
6366 case BFD_RELOC_LO16:
6368 fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
6370 case BFD_RELOC_LO16_PCREL:
6371 case BFD_RELOC_PPC_VLE_LO16A:
6372 case BFD_RELOC_PPC_VLE_LO16D:
6373 fieldval = value & 0xffff;
6375 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
6376 fieldval = (fieldval ^ 0x8000) - 0x8000;
6377 fixP->fx_no_overflow = 1;
6380 case BFD_RELOC_HI16:
6382 fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
6384 case BFD_RELOC_HI16_PCREL:
6385 case BFD_RELOC_PPC_VLE_HI16A:
6386 case BFD_RELOC_PPC_VLE_HI16D:
6387 fieldval = PPC_HI (value);
6388 goto sign_extend_16;
6390 case BFD_RELOC_HI16_S:
6392 fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
6394 case BFD_RELOC_HI16_S_PCREL:
6395 case BFD_RELOC_PPC_VLE_HA16A:
6396 case BFD_RELOC_PPC_VLE_HA16D:
6397 fieldval = PPC_HA (value);
6398 goto sign_extend_16;
6401 case BFD_RELOC_PPC64_HIGHER:
6404 fieldval = PPC_HIGHER (value);
6405 goto sign_extend_16;
6407 case BFD_RELOC_PPC64_HIGHER_S:
6410 fieldval = PPC_HIGHERA (value);
6411 goto sign_extend_16;
6413 case BFD_RELOC_PPC64_HIGHEST:
6416 fieldval = PPC_HIGHEST (value);
6417 goto sign_extend_16;
6419 case BFD_RELOC_PPC64_HIGHEST_S:
6422 fieldval = PPC_HIGHESTA (value);
6423 goto sign_extend_16;
6425 /* The following relocs can't be calculated by the assembler.
6426 Leave the field zero. */
6427 case BFD_RELOC_PPC_TPREL16:
6428 case BFD_RELOC_PPC_TPREL16_LO:
6429 case BFD_RELOC_PPC_TPREL16_HI:
6430 case BFD_RELOC_PPC_TPREL16_HA:
6431 case BFD_RELOC_PPC_DTPREL16:
6432 case BFD_RELOC_PPC_DTPREL16_LO:
6433 case BFD_RELOC_PPC_DTPREL16_HI:
6434 case BFD_RELOC_PPC_DTPREL16_HA:
6435 case BFD_RELOC_PPC_GOT_TLSGD16:
6436 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
6437 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
6438 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
6439 case BFD_RELOC_PPC_GOT_TLSLD16:
6440 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
6441 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
6442 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
6443 case BFD_RELOC_PPC_GOT_TPREL16:
6444 case BFD_RELOC_PPC_GOT_TPREL16_LO:
6445 case BFD_RELOC_PPC_GOT_TPREL16_HI:
6446 case BFD_RELOC_PPC_GOT_TPREL16_HA:
6447 case BFD_RELOC_PPC_GOT_DTPREL16:
6448 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
6449 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
6450 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
6451 case BFD_RELOC_PPC64_TPREL16_DS:
6452 case BFD_RELOC_PPC64_TPREL16_LO_DS:
6453 case BFD_RELOC_PPC64_TPREL16_HIGHER:
6454 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
6455 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
6456 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
6457 case BFD_RELOC_PPC64_DTPREL16_DS:
6458 case BFD_RELOC_PPC64_DTPREL16_LO_DS:
6459 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
6460 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6461 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6462 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6463 gas_assert (fixP->fx_addsy != NULL);
6464 S_SET_THREAD_LOCAL (fixP->fx_addsy);
6470 /* These also should leave the field zero for the same
6471 reason. Note that older versions of gas wrote values
6472 here. If we want to go back to the old behaviour, then
6473 all _LO and _LO_DS cases will need to be treated like
6474 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6475 case BFD_RELOC_16_GOTOFF:
6476 case BFD_RELOC_LO16_GOTOFF:
6477 case BFD_RELOC_HI16_GOTOFF:
6478 case BFD_RELOC_HI16_S_GOTOFF:
6479 case BFD_RELOC_LO16_PLTOFF:
6480 case BFD_RELOC_HI16_PLTOFF:
6481 case BFD_RELOC_HI16_S_PLTOFF:
6482 case BFD_RELOC_GPREL16:
6483 case BFD_RELOC_16_BASEREL:
6484 case BFD_RELOC_LO16_BASEREL:
6485 case BFD_RELOC_HI16_BASEREL:
6486 case BFD_RELOC_HI16_S_BASEREL:
6487 case BFD_RELOC_PPC_TOC16:
6488 case BFD_RELOC_PPC64_TOC16_LO:
6489 case BFD_RELOC_PPC64_TOC16_HI:
6490 case BFD_RELOC_PPC64_TOC16_HA:
6491 case BFD_RELOC_PPC64_PLTGOT16:
6492 case BFD_RELOC_PPC64_PLTGOT16_LO:
6493 case BFD_RELOC_PPC64_PLTGOT16_HI:
6494 case BFD_RELOC_PPC64_PLTGOT16_HA:
6495 case BFD_RELOC_PPC64_GOT16_DS:
6496 case BFD_RELOC_PPC64_GOT16_LO_DS:
6497 case BFD_RELOC_PPC64_PLT16_LO_DS:
6498 case BFD_RELOC_PPC64_SECTOFF_DS:
6499 case BFD_RELOC_PPC64_SECTOFF_LO_DS:
6500 case BFD_RELOC_PPC64_TOC16_DS:
6501 case BFD_RELOC_PPC64_TOC16_LO_DS:
6502 case BFD_RELOC_PPC64_PLTGOT16_DS:
6503 case BFD_RELOC_PPC64_PLTGOT16_LO_DS:
6504 case BFD_RELOC_PPC_EMB_NADDR16:
6505 case BFD_RELOC_PPC_EMB_NADDR16_LO:
6506 case BFD_RELOC_PPC_EMB_NADDR16_HI:
6507 case BFD_RELOC_PPC_EMB_NADDR16_HA:
6508 case BFD_RELOC_PPC_EMB_SDAI16:
6509 case BFD_RELOC_PPC_EMB_SDA2I16:
6510 case BFD_RELOC_PPC_EMB_SDA2REL:
6511 case BFD_RELOC_PPC_EMB_SDA21:
6512 case BFD_RELOC_PPC_EMB_MRKREF:
6513 case BFD_RELOC_PPC_EMB_RELSEC16:
6514 case BFD_RELOC_PPC_EMB_RELST_LO:
6515 case BFD_RELOC_PPC_EMB_RELST_HI:
6516 case BFD_RELOC_PPC_EMB_RELST_HA:
6517 case BFD_RELOC_PPC_EMB_BIT_FLD:
6518 case BFD_RELOC_PPC_EMB_RELSDA:
6519 case BFD_RELOC_PPC_VLE_SDA21:
6520 case BFD_RELOC_PPC_VLE_SDA21_LO:
6521 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
6522 case BFD_RELOC_PPC_VLE_SDAREL_LO16D:
6523 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
6524 case BFD_RELOC_PPC_VLE_SDAREL_HI16D:
6525 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
6526 case BFD_RELOC_PPC_VLE_SDAREL_HA16D:
6527 gas_assert (fixP->fx_addsy != NULL);
6530 case BFD_RELOC_PPC_TLS:
6531 case BFD_RELOC_PPC_TLSGD:
6532 case BFD_RELOC_PPC_TLSLD:
6544 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6545 contents can stay at zero. */
6546 #define APPLY_RELOC fixP->fx_done
6548 #define APPLY_RELOC 1
6550 if ((fieldval != 0 && APPLY_RELOC) || operand->insert != NULL)
6552 /* Fetch the instruction, insert the fully resolved operand
6553 value, and stuff the instruction back again. */
6554 where = fixP->fx_frag->fr_literal + fixP->fx_where;
6555 if (target_big_endian)
6557 if (fixP->fx_size == 4)
6558 insn = bfd_getb32 ((unsigned char *) where);
6560 insn = bfd_getb16 ((unsigned char *) where);
6564 if (fixP->fx_size == 4)
6565 insn = bfd_getl32 ((unsigned char *) where);
6567 insn = bfd_getl16 ((unsigned char *) where);
6569 insn = ppc_insert_operand (insn, operand, fieldval,
6570 fixP->tc_fix_data.ppc_cpu,
6571 fixP->fx_file, fixP->fx_line);
6572 if (target_big_endian)
6574 if (fixP->fx_size == 4)
6575 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
6577 bfd_putb16 ((bfd_vma) insn, (unsigned char *) where);
6581 if (fixP->fx_size == 4)
6582 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
6584 bfd_putl16 ((bfd_vma) insn, (unsigned char *) where);
6589 /* Nothing else to do here. */
6592 gas_assert (fixP->fx_addsy != NULL);
6593 if (fixP->fx_r_type == BFD_RELOC_UNUSED)
6598 /* Use expr_symbol_where to see if this is an expression
6600 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
6601 as_bad_where (fixP->fx_file, fixP->fx_line,
6602 _("unresolved expression that must be resolved"));
6604 as_bad_where (fixP->fx_file, fixP->fx_line,
6605 _("unsupported relocation against %s"),
6606 S_GET_NAME (fixP->fx_addsy));
6614 offsetT fieldval = value;
6616 /* Handle relocs in data. */
6617 switch (fixP->fx_r_type)
6619 case BFD_RELOC_CTOR:
6626 fixP->fx_r_type = BFD_RELOC_32_PCREL;
6629 case BFD_RELOC_32_PCREL:
6637 fixP->fx_r_type = BFD_RELOC_64_PCREL;
6640 case BFD_RELOC_64_PCREL:
6646 fixP->fx_r_type = BFD_RELOC_16_PCREL;
6649 case BFD_RELOC_16_PCREL:
6664 /* Use expr_symbol_where to see if this is an
6665 expression symbol. */
6666 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
6667 as_bad_where (fixP->fx_file, fixP->fx_line,
6668 _("unresolved expression that must"
6671 as_bad_where (fixP->fx_file, fixP->fx_line,
6672 _("cannot emit PC relative %s relocation"
6674 bfd_get_reloc_code_name (fixP->fx_r_type),
6675 S_GET_NAME (fixP->fx_addsy));
6678 as_bad_where (fixP->fx_file, fixP->fx_line,
6679 _("unable to resolve expression"));
6686 case BFD_RELOC_VTABLE_INHERIT:
6688 && !S_IS_DEFINED (fixP->fx_addsy)
6689 && !S_IS_WEAK (fixP->fx_addsy))
6690 S_SET_WEAK (fixP->fx_addsy);
6693 case BFD_RELOC_VTABLE_ENTRY:
6698 /* These can appear with @l etc. in data. */
6699 case BFD_RELOC_LO16:
6701 fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
6702 case BFD_RELOC_LO16_PCREL:
6706 case BFD_RELOC_HI16:
6708 fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
6709 case BFD_RELOC_HI16_PCREL:
6711 fieldval = PPC_HI (value);
6714 case BFD_RELOC_HI16_S:
6716 fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
6717 case BFD_RELOC_HI16_S_PCREL:
6719 fieldval = PPC_HA (value);
6722 case BFD_RELOC_PPC64_HIGHER:
6726 fieldval = PPC_HIGHER (value);
6729 case BFD_RELOC_PPC64_HIGHER_S:
6733 fieldval = PPC_HIGHERA (value);
6736 case BFD_RELOC_PPC64_HIGHEST:
6740 fieldval = PPC_HIGHEST (value);
6743 case BFD_RELOC_PPC64_HIGHEST_S:
6747 fieldval = PPC_HIGHESTA (value);
6750 case BFD_RELOC_PPC_DTPMOD:
6751 case BFD_RELOC_PPC_TPREL:
6752 case BFD_RELOC_PPC_DTPREL:
6753 S_SET_THREAD_LOCAL (fixP->fx_addsy);
6756 /* Just punt all of these to the linker. */
6757 case BFD_RELOC_PPC_B16_BRTAKEN:
6758 case BFD_RELOC_PPC_B16_BRNTAKEN:
6759 case BFD_RELOC_16_GOTOFF:
6760 case BFD_RELOC_LO16_GOTOFF:
6761 case BFD_RELOC_HI16_GOTOFF:
6762 case BFD_RELOC_HI16_S_GOTOFF:
6763 case BFD_RELOC_LO16_PLTOFF:
6764 case BFD_RELOC_HI16_PLTOFF:
6765 case BFD_RELOC_HI16_S_PLTOFF:
6766 case BFD_RELOC_PPC_COPY:
6767 case BFD_RELOC_PPC_GLOB_DAT:
6768 case BFD_RELOC_16_BASEREL:
6769 case BFD_RELOC_LO16_BASEREL:
6770 case BFD_RELOC_HI16_BASEREL:
6771 case BFD_RELOC_HI16_S_BASEREL:
6772 case BFD_RELOC_PPC_TLS:
6773 case BFD_RELOC_PPC_DTPREL16_LO:
6774 case BFD_RELOC_PPC_DTPREL16_HI:
6775 case BFD_RELOC_PPC_DTPREL16_HA:
6776 case BFD_RELOC_PPC_TPREL16_LO:
6777 case BFD_RELOC_PPC_TPREL16_HI:
6778 case BFD_RELOC_PPC_TPREL16_HA:
6779 case BFD_RELOC_PPC_GOT_TLSGD16:
6780 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
6781 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
6782 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
6783 case BFD_RELOC_PPC_GOT_TLSLD16:
6784 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
6785 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
6786 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
6787 case BFD_RELOC_PPC_GOT_DTPREL16:
6788 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
6789 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
6790 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
6791 case BFD_RELOC_PPC_GOT_TPREL16:
6792 case BFD_RELOC_PPC_GOT_TPREL16_LO:
6793 case BFD_RELOC_PPC_GOT_TPREL16_HI:
6794 case BFD_RELOC_PPC_GOT_TPREL16_HA:
6795 case BFD_RELOC_24_PLT_PCREL:
6796 case BFD_RELOC_PPC_LOCAL24PC:
6797 case BFD_RELOC_32_PLT_PCREL:
6798 case BFD_RELOC_GPREL16:
6799 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
6800 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
6801 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
6802 case BFD_RELOC_PPC_EMB_NADDR32:
6803 case BFD_RELOC_PPC_EMB_NADDR16:
6804 case BFD_RELOC_PPC_EMB_NADDR16_LO:
6805 case BFD_RELOC_PPC_EMB_NADDR16_HI:
6806 case BFD_RELOC_PPC_EMB_NADDR16_HA:
6807 case BFD_RELOC_PPC_EMB_SDAI16:
6808 case BFD_RELOC_PPC_EMB_SDA2REL:
6809 case BFD_RELOC_PPC_EMB_SDA2I16:
6810 case BFD_RELOC_PPC_EMB_SDA21:
6811 case BFD_RELOC_PPC_VLE_SDA21_LO:
6812 case BFD_RELOC_PPC_EMB_MRKREF:
6813 case BFD_RELOC_PPC_EMB_RELSEC16:
6814 case BFD_RELOC_PPC_EMB_RELST_LO:
6815 case BFD_RELOC_PPC_EMB_RELST_HI:
6816 case BFD_RELOC_PPC_EMB_RELST_HA:
6817 case BFD_RELOC_PPC_EMB_BIT_FLD:
6818 case BFD_RELOC_PPC_EMB_RELSDA:
6819 case BFD_RELOC_PPC64_TOC:
6820 case BFD_RELOC_PPC_TOC16:
6821 case BFD_RELOC_PPC64_TOC16_LO:
6822 case BFD_RELOC_PPC64_TOC16_HI:
6823 case BFD_RELOC_PPC64_TOC16_HA:
6824 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
6825 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6826 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6827 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6828 case BFD_RELOC_PPC64_TPREL16_HIGHER:
6829 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
6830 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
6831 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
6837 case BFD_RELOC_NONE:
6843 _("Gas failure, reloc value %d\n"), fixP->fx_r_type);
6848 if (size && APPLY_RELOC)
6849 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
6854 ppc_elf_validate_fix (fixP, seg);
6855 fixP->fx_addnumber = value;
6857 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6858 from the section contents. If we are going to be emitting a reloc
6859 then the section contents are immaterial, so don't warn if they
6860 happen to overflow. Leave such warnings to ld. */
6863 fixP->fx_no_overflow = 1;
6865 /* Arrange to emit .TOC. as a normal symbol if used in anything
6866 but .TOC.@tocbase. */
6868 && fixP->fx_r_type != BFD_RELOC_PPC64_TOC
6869 && fixP->fx_addsy != NULL
6870 && strcmp (S_GET_NAME (fixP->fx_addsy), ".TOC.") == 0)
6871 symbol_get_bfdsym (fixP->fx_addsy)->flags |= BSF_KEEP;
6874 if (fixP->fx_r_type != BFD_RELOC_PPC_TOC16)
6875 fixP->fx_addnumber = 0;
6879 fixP->fx_addnumber = 0;
6881 /* We want to use the offset within the toc, not the actual VMA
6883 fixP->fx_addnumber =
6884 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixP->fx_addsy))
6885 - S_GET_VALUE (ppc_toc_csect);
6891 /* Generate a reloc for a fixup. */
6894 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
6898 reloc = (arelent *) xmalloc (sizeof (arelent));
6900 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6901 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6902 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6903 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6904 if (reloc->howto == (reloc_howto_type *) NULL)
6906 as_bad_where (fixp->fx_file, fixp->fx_line,
6907 _("reloc %d not supported by object file format"),
6908 (int) fixp->fx_r_type);
6911 reloc->addend = fixp->fx_addnumber;
6917 ppc_cfi_frame_initial_instructions (void)
6919 cfi_add_CFA_def_cfa (1, 0);
6923 tc_ppc_regname_to_dw2regnum (char *regname)
6925 unsigned int regnum = -1;
6929 static struct { char *name; int dw2regnum; } regnames[] =
6931 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6932 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6933 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6934 { "spe_acc", 111 }, { "spefscr", 112 }
6937 for (i = 0; i < ARRAY_SIZE (regnames); ++i)
6938 if (strcmp (regnames[i].name, regname) == 0)
6939 return regnames[i].dw2regnum;
6941 if (regname[0] == 'r' || regname[0] == 'f' || regname[0] == 'v')
6943 p = regname + 1 + (regname[1] == '.');
6944 regnum = strtoul (p, &q, 10);
6945 if (p == q || *q || regnum >= 32)
6947 if (regname[0] == 'f')
6949 else if (regname[0] == 'v')
6952 else if (regname[0] == 'c' && regname[1] == 'r')
6954 p = regname + 2 + (regname[2] == '.');
6955 if (p[0] < '0' || p[0] > '7' || p[1])
6957 regnum = p[0] - '0' + 68;