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 "elf/ppc64.h"
33 #include "dwarf2dbg.h"
41 #include "coff/xcoff.h"
45 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
47 /* Tell the main code what the endianness is. */
48 extern int target_big_endian;
50 /* Whether or not, we've set target_big_endian. */
51 static int set_target_endian = 0;
53 /* Whether to use user friendly register names. */
54 #ifndef TARGET_REG_NAMES_P
56 #define TARGET_REG_NAMES_P TRUE
58 #define TARGET_REG_NAMES_P FALSE
62 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
65 /* #lo(value) denotes the least significant 16 bits of the indicated. */
66 #define PPC_LO(v) ((v) & 0xffff)
68 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
69 #define PPC_HI(v) (((v) >> 16) & 0xffff)
71 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
72 the indicated value, compensating for #lo() being treated as a
74 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
76 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
77 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
79 /* #highera(value) denotes bits 32 through 47 of the indicated value,
80 compensating for #lo() being treated as a signed number. */
81 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
83 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
84 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
86 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
87 compensating for #lo being treated as a signed number. */
88 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
90 #define SEX16(val) (((val) ^ 0x8000) - 0x8000)
92 /* For the time being on ppc64, don't report overflow on @h and @ha
93 applied to constants. */
94 #define REPORT_OVERFLOW_HI 0
96 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
98 static void ppc_macro (char *, const struct powerpc_macro *);
99 static void ppc_byte (int);
101 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
102 static void ppc_tc (int);
103 static void ppc_machine (int);
107 static void ppc_comm (int);
108 static void ppc_bb (int);
109 static void ppc_bc (int);
110 static void ppc_bf (int);
111 static void ppc_biei (int);
112 static void ppc_bs (int);
113 static void ppc_eb (int);
114 static void ppc_ec (int);
115 static void ppc_ef (int);
116 static void ppc_es (int);
117 static void ppc_csect (int);
118 static void ppc_dwsect (int);
119 static void ppc_change_csect (symbolS *, offsetT);
120 static void ppc_function (int);
121 static void ppc_extern (int);
122 static void ppc_lglobl (int);
123 static void ppc_ref (int);
124 static void ppc_section (int);
125 static void ppc_named_section (int);
126 static void ppc_stabx (int);
127 static void ppc_rename (int);
128 static void ppc_toc (int);
129 static void ppc_xcoff_cons (int);
130 static void ppc_vbyte (int);
134 static void ppc_elf_cons (int);
135 static void ppc_elf_rdata (int);
136 static void ppc_elf_lcomm (int);
137 static void ppc_elf_localentry (int);
138 static void ppc_elf_abiversion (int);
142 static void ppc_previous (int);
143 static void ppc_pdata (int);
144 static void ppc_ydata (int);
145 static void ppc_reldata (int);
146 static void ppc_rdata (int);
147 static void ppc_ualong (int);
148 static void ppc_znop (int);
149 static void ppc_pe_comm (int);
150 static void ppc_pe_section (int);
151 static void ppc_pe_function (int);
152 static void ppc_pe_tocd (int);
155 /* Generic assembler global variables which must be defined by all
159 /* This string holds the chars that always start a comment. If the
160 pre-processor is disabled, these aren't very useful. The macro
161 tc_comment_chars points to this. We use this, rather than the
162 usual comment_chars, so that we can switch for Solaris conventions. */
163 static const char ppc_solaris_comment_chars[] = "#!";
164 static const char ppc_eabi_comment_chars[] = "#";
166 #ifdef TARGET_SOLARIS_COMMENT
167 const char *ppc_comment_chars = ppc_solaris_comment_chars;
169 const char *ppc_comment_chars = ppc_eabi_comment_chars;
172 const char comment_chars[] = "#";
175 /* Characters which start a comment at the beginning of a line. */
176 const char line_comment_chars[] = "#";
178 /* Characters which may be used to separate multiple commands on a
180 const char line_separator_chars[] = ";";
182 /* Characters which are used to indicate an exponent in a floating
184 const char EXP_CHARS[] = "eE";
186 /* Characters which mean that a number is a floating point constant,
188 const char FLT_CHARS[] = "dD";
190 /* Anything that can start an operand needs to be mentioned here,
191 to stop the input scrubber eating whitespace. */
192 const char ppc_symbol_chars[] = "%[";
194 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
195 int ppc_cie_data_alignment;
197 /* The dwarf2 minimum instruction length. */
198 int ppc_dwarf2_line_min_insn_length;
200 /* More than this number of nops in an alignment op gets a branch
202 unsigned long nop_limit = 4;
204 /* The type of processor we are assembling for. This is one or more
205 of the PPC_OPCODE flags defined in opcode/ppc.h. */
206 ppc_cpu_t ppc_cpu = 0;
207 ppc_cpu_t sticky = 0;
209 /* Value for ELF e_flags EF_PPC64_ABI. */
210 unsigned int ppc_abiversion = 0;
212 /* Flags set on encountering toc relocs. */
214 has_large_toc_reloc = 1,
215 has_small_toc_reloc = 2
218 /* The target specific pseudo-ops which we support. */
220 const pseudo_typeS md_pseudo_table[] =
222 /* Pseudo-ops which must be overridden. */
223 { "byte", ppc_byte, 0 },
226 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
227 legitimately belong in the obj-*.c file. However, XCOFF is based
228 on COFF, and is only implemented for the RS/6000. We just use
229 obj-coff.c, and add what we need here. */
230 { "comm", ppc_comm, 0 },
231 { "lcomm", ppc_comm, 1 },
235 { "bi", ppc_biei, 0 },
237 { "csect", ppc_csect, 0 },
238 { "dwsect", ppc_dwsect, 0 },
239 { "data", ppc_section, 'd' },
243 { "ei", ppc_biei, 1 },
245 { "extern", ppc_extern, 0 },
246 { "function", ppc_function, 0 },
247 { "lglobl", ppc_lglobl, 0 },
248 { "ref", ppc_ref, 0 },
249 { "rename", ppc_rename, 0 },
250 { "section", ppc_named_section, 0 },
251 { "stabx", ppc_stabx, 0 },
252 { "text", ppc_section, 't' },
253 { "toc", ppc_toc, 0 },
254 { "long", ppc_xcoff_cons, 2 },
255 { "llong", ppc_xcoff_cons, 3 },
256 { "word", ppc_xcoff_cons, 1 },
257 { "short", ppc_xcoff_cons, 1 },
258 { "vbyte", ppc_vbyte, 0 },
262 { "llong", ppc_elf_cons, 8 },
263 { "quad", ppc_elf_cons, 8 },
264 { "long", ppc_elf_cons, 4 },
265 { "word", ppc_elf_cons, 2 },
266 { "short", ppc_elf_cons, 2 },
267 { "rdata", ppc_elf_rdata, 0 },
268 { "rodata", ppc_elf_rdata, 0 },
269 { "lcomm", ppc_elf_lcomm, 0 },
270 { "localentry", ppc_elf_localentry, 0 },
271 { "abiversion", ppc_elf_abiversion, 0 },
275 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
276 { "previous", ppc_previous, 0 },
277 { "pdata", ppc_pdata, 0 },
278 { "ydata", ppc_ydata, 0 },
279 { "reldata", ppc_reldata, 0 },
280 { "rdata", ppc_rdata, 0 },
281 { "ualong", ppc_ualong, 0 },
282 { "znop", ppc_znop, 0 },
283 { "comm", ppc_pe_comm, 0 },
284 { "lcomm", ppc_pe_comm, 1 },
285 { "section", ppc_pe_section, 0 },
286 { "function", ppc_pe_function,0 },
287 { "tocd", ppc_pe_tocd, 0 },
290 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
292 { "machine", ppc_machine, 0 },
299 /* Predefined register names if -mregnames (or default for Windows NT).
300 In general, there are lots of them, in an attempt to be compatible
301 with a number of other Windows NT assemblers. */
303 /* Structure to hold information about predefined registers. */
310 /* List of registers that are pre-defined:
312 Each general register has predefined names of the form:
313 1. r<reg_num> which has the value <reg_num>.
314 2. r.<reg_num> which has the value <reg_num>.
316 Each floating point register has predefined names of the form:
317 1. f<reg_num> which has the value <reg_num>.
318 2. f.<reg_num> which has the value <reg_num>.
320 Each vector unit register has predefined names of the form:
321 1. v<reg_num> which has the value <reg_num>.
322 2. v.<reg_num> which has the value <reg_num>.
324 Each condition register has predefined names of the form:
325 1. cr<reg_num> which has the value <reg_num>.
326 2. cr.<reg_num> which has the value <reg_num>.
328 There are individual registers as well:
329 sp or r.sp has the value 1
330 rtoc or r.toc has the value 2
331 fpscr has the value 0
337 dsisr has the value 18
339 sdr1 has the value 25
340 srr0 has the value 26
341 srr1 has the value 27
343 The table is sorted. Suitable for searching by a binary search. */
345 static const struct pd_reg pre_defined_registers[] =
347 { "cr.0", 0 }, /* Condition Registers */
367 { "dar", 19 }, /* Data Access Register */
368 { "dec", 22 }, /* Decrementer */
369 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
371 { "f.0", 0 }, /* Floating point registers */
398 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
464 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
505 /* Quantization registers used with pair single instructions. */
523 { "lr", 8 }, /* Link Register */
527 { "r.0", 0 }, /* General Purpose Registers */
560 { "r.sp", 1 }, /* Stack Pointer */
562 { "r.toc", 2 }, /* Pointer to the table of contents */
564 { "r0", 0 }, /* More general purpose registers */
597 { "rtoc", 2 }, /* Table of contents */
599 { "sdr1", 25 }, /* Storage Description Register 1 */
603 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
604 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
606 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
672 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
806 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
808 /* Given NAME, find the register number associated with that name, return
809 the integer value associated with the given name or -1 on failure. */
812 reg_name_search (const struct pd_reg *regs, int regcount, const char *name)
814 int middle, low, high;
822 middle = (low + high) / 2;
823 cmp = strcasecmp (name, regs[middle].name);
829 return regs[middle].value;
837 * Summary of register_name.
839 * in: Input_line_pointer points to 1st char of operand.
841 * out: A expressionS.
842 * The operand may have been a register: in this case, X_op == O_register,
843 * X_add_number is set to the register number, and truth is returned.
844 * Input_line_pointer->(next non-blank) char after operand, or is in its
849 register_name (expressionS *expressionP)
856 /* Find the spelling of the operand. */
857 start = name = input_line_pointer;
858 if (name[0] == '%' && ISALPHA (name[1]))
859 name = ++input_line_pointer;
861 else if (!reg_names_p || !ISALPHA (name[0]))
864 c = get_symbol_end ();
865 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
867 /* Put back the delimiting char. */
868 *input_line_pointer = c;
870 /* Look to see if it's in the register table. */
873 expressionP->X_op = O_register;
874 expressionP->X_add_number = reg_number;
876 /* Make the rest nice. */
877 expressionP->X_add_symbol = NULL;
878 expressionP->X_op_symbol = NULL;
882 /* Reset the line as if we had not done anything. */
883 input_line_pointer = start;
887 /* This function is called for each symbol seen in an expression. It
888 handles the special parsing which PowerPC assemblers are supposed
889 to use for condition codes. */
891 /* Whether to do the special parsing. */
892 static bfd_boolean cr_operand;
894 /* Names to recognize in a condition code. This table is sorted. */
895 static const struct pd_reg cr_names[] =
912 /* Parsing function. This returns non-zero if it recognized an
916 ppc_parse_name (const char *name, expressionS *exp)
925 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
930 exp->X_op = O_constant;
931 exp->X_add_number = val;
936 /* Local variables. */
938 /* Whether to target xcoff64/elf64. */
939 static unsigned int ppc_obj64 = BFD_DEFAULT_TARGET_SIZE == 64;
941 /* Opcode hash table. */
942 static struct hash_control *ppc_hash;
944 /* Macro hash table. */
945 static struct hash_control *ppc_macro_hash;
948 /* What type of shared library support to use. */
949 static enum { SHLIB_NONE, SHLIB_PIC, SHLIB_MRELOCATABLE } shlib = SHLIB_NONE;
951 /* Flags to set in the elf header. */
952 static flagword ppc_flags = 0;
954 /* Whether this is Solaris or not. */
955 #ifdef TARGET_SOLARIS_COMMENT
956 #define SOLARIS_P TRUE
958 #define SOLARIS_P FALSE
961 static bfd_boolean msolaris = SOLARIS_P;
966 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
967 using a bunch of different sections. These assembler sections,
968 however, are all encompassed within the .text or .data sections of
969 the final output file. We handle this by using different
970 subsegments within these main segments. */
972 /* Next subsegment to allocate within the .text segment. */
973 static subsegT ppc_text_subsegment = 2;
975 /* Linked list of csects in the text section. */
976 static symbolS *ppc_text_csects;
978 /* Next subsegment to allocate within the .data segment. */
979 static subsegT ppc_data_subsegment = 2;
981 /* Linked list of csects in the data section. */
982 static symbolS *ppc_data_csects;
984 /* The current csect. */
985 static symbolS *ppc_current_csect;
987 /* The RS/6000 assembler uses a TOC which holds addresses of functions
988 and variables. Symbols are put in the TOC with the .tc pseudo-op.
989 A special relocation is used when accessing TOC entries. We handle
990 the TOC as a subsegment within the .data segment. We set it up if
991 we see a .toc pseudo-op, and save the csect symbol here. */
992 static symbolS *ppc_toc_csect;
994 /* The first frag in the TOC subsegment. */
995 static fragS *ppc_toc_frag;
997 /* The first frag in the first subsegment after the TOC in the .data
998 segment. NULL if there are no subsegments after the TOC. */
999 static fragS *ppc_after_toc_frag;
1001 /* The current static block. */
1002 static symbolS *ppc_current_block;
1004 /* The COFF debugging section; set by md_begin. This is not the
1005 .debug section, but is instead the secret BFD section which will
1006 cause BFD to set the section number of a symbol to N_DEBUG. */
1007 static asection *ppc_coff_debug_section;
1009 /* Structure to set the length field of the dwarf sections. */
1010 struct dw_subsection {
1011 /* Subsections are simply linked. */
1012 struct dw_subsection *link;
1014 /* The subsection number. */
1017 /* Expression to compute the length of the section. */
1018 expressionS end_exp;
1021 static struct dw_section {
1022 /* Corresponding section. */
1025 /* Simply linked list of subsections with a label. */
1026 struct dw_subsection *list_subseg;
1028 /* The anonymous subsection. */
1029 struct dw_subsection *anon_subseg;
1030 } dw_sections[XCOFF_DWSECT_NBR_NAMES];
1031 #endif /* OBJ_XCOFF */
1035 /* Various sections that we need for PE coff support. */
1036 static segT ydata_section;
1037 static segT pdata_section;
1038 static segT reldata_section;
1039 static segT rdata_section;
1040 static segT tocdata_section;
1042 /* The current section and the previous section. See ppc_previous. */
1043 static segT ppc_previous_section;
1044 static segT ppc_current_section;
1049 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1050 #define PPC_APUINFO_ISEL 0x40
1051 #define PPC_APUINFO_PMR 0x41
1052 #define PPC_APUINFO_RFMCI 0x42
1053 #define PPC_APUINFO_CACHELCK 0x43
1054 #define PPC_APUINFO_SPE 0x100
1055 #define PPC_APUINFO_EFS 0x101
1056 #define PPC_APUINFO_BRLOCK 0x102
1057 #define PPC_APUINFO_VLE 0x104
1060 * We keep a list of APUinfo
1062 unsigned long *ppc_apuinfo_list;
1063 unsigned int ppc_apuinfo_num;
1064 unsigned int ppc_apuinfo_num_alloc;
1065 #endif /* OBJ_ELF */
1068 const char *const md_shortopts = "b:l:usm:K:VQ:";
1070 const char *const md_shortopts = "um:";
1072 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1073 const struct option md_longopts[] = {
1074 {"nops", required_argument, NULL, OPTION_NOPS},
1075 {NULL, no_argument, NULL, 0}
1077 const size_t md_longopts_size = sizeof (md_longopts);
1080 md_parse_option (int c, char *arg)
1087 /* -u means that any undefined symbols should be treated as
1088 external, which is the default for gas anyhow. */
1093 /* Solaris as takes -le (presumably for little endian). For completeness
1094 sake, recognize -be also. */
1095 if (strcmp (arg, "e") == 0)
1097 target_big_endian = 0;
1098 set_target_endian = 1;
1099 if (ppc_cpu & PPC_OPCODE_VLE)
1100 as_bad (_("the use of -mvle requires big endian."));
1108 if (strcmp (arg, "e") == 0)
1110 target_big_endian = 1;
1111 set_target_endian = 1;
1119 /* Recognize -K PIC. */
1120 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
1123 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1131 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1133 if (strcmp (arg, "64") == 0)
1137 if (ppc_cpu & PPC_OPCODE_VLE)
1138 as_bad (_("the use of -mvle requires -a32."));
1140 as_fatal (_("%s unsupported"), "-a64");
1143 else if (strcmp (arg, "32") == 0)
1150 new_cpu = ppc_parse_cpu (ppc_cpu, &sticky, arg);
1154 if (strcmp (arg, "vle") == 0)
1156 if (set_target_endian && target_big_endian == 0)
1157 as_bad (_("the use of -mvle requires big endian."));
1159 as_bad (_("the use of -mvle requires -a32."));
1163 else if (strcmp (arg, "regnames") == 0)
1166 else if (strcmp (arg, "no-regnames") == 0)
1167 reg_names_p = FALSE;
1170 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1171 that require relocation. */
1172 else if (strcmp (arg, "relocatable") == 0)
1174 shlib = SHLIB_MRELOCATABLE;
1175 ppc_flags |= EF_PPC_RELOCATABLE;
1178 else if (strcmp (arg, "relocatable-lib") == 0)
1180 shlib = SHLIB_MRELOCATABLE;
1181 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1184 /* -memb, set embedded bit. */
1185 else if (strcmp (arg, "emb") == 0)
1186 ppc_flags |= EF_PPC_EMB;
1188 /* -mlittle/-mbig set the endianness. */
1189 else if (strcmp (arg, "little") == 0
1190 || strcmp (arg, "little-endian") == 0)
1192 target_big_endian = 0;
1193 set_target_endian = 1;
1194 if (ppc_cpu & PPC_OPCODE_VLE)
1195 as_bad (_("the use of -mvle requires big endian."));
1198 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
1200 target_big_endian = 1;
1201 set_target_endian = 1;
1204 else if (strcmp (arg, "solaris") == 0)
1207 ppc_comment_chars = ppc_solaris_comment_chars;
1210 else if (strcmp (arg, "no-solaris") == 0)
1213 ppc_comment_chars = ppc_eabi_comment_chars;
1218 as_bad (_("invalid switch -m%s"), arg);
1224 /* -V: SVR4 argument to print version ID. */
1226 print_version_id ();
1229 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1230 should be emitted or not. FIXME: Not implemented. */
1234 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1235 rather than .stabs.excl, which is ignored by the linker.
1236 FIXME: Not implemented. */
1247 nop_limit = strtoul (optarg, &end, 0);
1249 as_bad (_("--nops needs a numeric argument"));
1261 md_show_usage (FILE *stream)
1263 fprintf (stream, _("\
1265 -a32 generate ELF32/XCOFF32\n\
1266 -a64 generate ELF64/XCOFF64\n\
1268 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1269 -mpwr generate code for POWER (RIOS1)\n\
1270 -m601 generate code for PowerPC 601\n\
1271 -mppc, -mppc32, -m603, -m604\n\
1272 generate code for PowerPC 603/604\n\
1273 -m403 generate code for PowerPC 403\n\
1274 -m405 generate code for PowerPC 405\n\
1275 -m440 generate code for PowerPC 440\n\
1276 -m464 generate code for PowerPC 464\n\
1277 -m476 generate code for PowerPC 476\n\
1278 -m7400, -m7410, -m7450, -m7455\n\
1279 generate code for PowerPC 7400/7410/7450/7455\n\
1280 -m750cl generate code for PowerPC 750cl\n"));
1281 fprintf (stream, _("\
1282 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1283 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1284 -mbooke generate code for 32-bit PowerPC BookE\n\
1285 -ma2 generate code for A2 architecture\n\
1286 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1287 -mpower5, -mpwr5, -mpwr5x\n\
1288 generate code for Power5 architecture\n\
1289 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1290 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1291 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1292 -mcell generate code for Cell Broadband Engine architecture\n\
1293 -mcom generate code Power/PowerPC common instructions\n\
1294 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1295 fprintf (stream, _("\
1296 -maltivec generate code for AltiVec\n\
1297 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1298 -mhtm generate code for Hardware Transactional Memory\n\
1299 -me300 generate code for PowerPC e300 family\n\
1300 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1301 -me500mc, generate code for Freescale e500mc core complex\n\
1302 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1303 -me5500, generate code for Freescale e5500 core complex\n\
1304 -me6500, generate code for Freescale e6500 core complex\n\
1305 -mspe generate code for Motorola SPE instructions\n\
1306 -mvle generate code for Freescale VLE instructions\n\
1307 -mtitan generate code for AppliedMicro Titan core complex\n\
1308 -mregnames Allow symbolic names for registers\n\
1309 -mno-regnames Do not allow symbolic names for registers\n"));
1311 fprintf (stream, _("\
1312 -mrelocatable support for GCC's -mrelocatble option\n\
1313 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1314 -memb set PPC_EMB bit in ELF flags\n\
1315 -mlittle, -mlittle-endian, -le\n\
1316 generate code for a little endian machine\n\
1317 -mbig, -mbig-endian, -be\n\
1318 generate code for a big endian machine\n\
1319 -msolaris generate code for Solaris\n\
1320 -mno-solaris do not generate code for Solaris\n\
1321 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1322 -V print assembler version number\n\
1323 -Qy, -Qn ignored\n"));
1325 fprintf (stream, _("\
1326 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1329 /* Set ppc_cpu if it is not already set. */
1334 const char *default_os = TARGET_OS;
1335 const char *default_cpu = TARGET_CPU;
1337 if ((ppc_cpu & ~(ppc_cpu_t) PPC_OPCODE_ANY) == 0)
1340 ppc_cpu |= PPC_OPCODE_PPC | PPC_OPCODE_64;
1341 else if (strncmp (default_os, "aix", 3) == 0
1342 && default_os[3] >= '4' && default_os[3] <= '9')
1343 ppc_cpu |= PPC_OPCODE_COMMON;
1344 else if (strncmp (default_os, "aix3", 4) == 0)
1345 ppc_cpu |= PPC_OPCODE_POWER;
1346 else if (strcmp (default_cpu, "rs6000") == 0)
1347 ppc_cpu |= PPC_OPCODE_POWER;
1348 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1349 ppc_cpu |= PPC_OPCODE_PPC;
1351 as_fatal (_("unknown default cpu = %s, os = %s"),
1352 default_cpu, default_os);
1356 /* Figure out the BFD architecture to use. This function and ppc_mach
1357 are called well before md_begin, when the output file is opened. */
1359 enum bfd_architecture
1362 const char *default_cpu = TARGET_CPU;
1365 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
1366 return bfd_arch_powerpc;
1367 if ((ppc_cpu & PPC_OPCODE_VLE) != 0)
1368 return bfd_arch_powerpc;
1369 if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
1370 return bfd_arch_rs6000;
1371 if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
1373 if (strcmp (default_cpu, "rs6000") == 0)
1374 return bfd_arch_rs6000;
1375 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1376 return bfd_arch_powerpc;
1379 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1380 return bfd_arch_unknown;
1387 return bfd_mach_ppc64;
1388 else if (ppc_arch () == bfd_arch_rs6000)
1389 return bfd_mach_rs6k;
1390 else if (ppc_cpu & PPC_OPCODE_TITAN)
1391 return bfd_mach_ppc_titan;
1392 else if (ppc_cpu & PPC_OPCODE_VLE)
1393 return bfd_mach_ppc_vle;
1395 return bfd_mach_ppc;
1399 ppc_target_format (void)
1403 return target_big_endian ? "pe-powerpc" : "pe-powerpcle";
1405 return "xcoff-powermac";
1408 return (ppc_obj64 ? "aix5coff64-rs6000" : "aixcoff-rs6000");
1410 return (ppc_obj64 ? "aixcoff64-rs6000" : "aixcoff-rs6000");
1416 return (ppc_obj64 ? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1417 # elif defined (TE_VXWORKS)
1418 return "elf32-powerpc-vxworks";
1420 return (target_big_endian
1421 ? (ppc_obj64 ? "elf64-powerpc" : "elf32-powerpc")
1422 : (ppc_obj64 ? "elf64-powerpcle" : "elf32-powerpcle"));
1427 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1428 Return TRUE if there's a problem, otherwise FALSE. */
1431 insn_validate (const struct powerpc_opcode *op)
1433 const unsigned char *o;
1434 unsigned long omask = op->mask;
1436 /* The mask had better not trim off opcode bits. */
1437 if ((op->opcode & omask) != op->opcode)
1439 as_bad (_("mask trims opcode bits for %s"), op->name);
1443 /* The operands must not overlap the opcode or each other. */
1444 for (o = op->operands; *o; ++o)
1446 if (*o >= num_powerpc_operands)
1448 as_bad (_("operand index error for %s"), op->name);
1453 const struct powerpc_operand *operand = &powerpc_operands[*o];
1454 if (operand->shift != PPC_OPSHIFT_INV)
1458 if (operand->shift >= 0)
1459 mask = operand->bitm << operand->shift;
1461 mask = operand->bitm >> -operand->shift;
1464 as_bad (_("operand %d overlap in %s"),
1465 (int) (o - op->operands), op->name);
1475 /* Insert opcodes and macros into hash tables. Called at startup and
1476 for .machine pseudo. */
1479 ppc_setup_opcodes (void)
1481 const struct powerpc_opcode *op;
1482 const struct powerpc_opcode *op_end;
1483 const struct powerpc_macro *macro;
1484 const struct powerpc_macro *macro_end;
1485 bfd_boolean bad_insn = FALSE;
1487 if (ppc_hash != NULL)
1488 hash_die (ppc_hash);
1489 if (ppc_macro_hash != NULL)
1490 hash_die (ppc_macro_hash);
1492 /* Insert the opcodes into a hash table. */
1493 ppc_hash = hash_new ();
1495 if (ENABLE_CHECKING)
1499 /* An index into powerpc_operands is stored in struct fix
1500 fx_pcrel_adjust which is 8 bits wide. */
1501 gas_assert (num_powerpc_operands < 256);
1503 /* Check operand masks. Code here and in the disassembler assumes
1504 all the 1's in the mask are contiguous. */
1505 for (i = 0; i < num_powerpc_operands; ++i)
1507 unsigned long mask = powerpc_operands[i].bitm;
1508 unsigned long right_bit;
1511 right_bit = mask & -mask;
1513 right_bit = mask & -mask;
1514 if (mask != right_bit)
1516 as_bad (_("powerpc_operands[%d].bitm invalid"), i);
1519 for (j = i + 1; j < num_powerpc_operands; ++j)
1520 if (memcmp (&powerpc_operands[i], &powerpc_operands[j],
1521 sizeof (powerpc_operands[0])) == 0)
1523 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1530 op_end = powerpc_opcodes + powerpc_num_opcodes;
1531 for (op = powerpc_opcodes; op < op_end; op++)
1533 if (ENABLE_CHECKING)
1535 if (op != powerpc_opcodes)
1537 int old_opcode = PPC_OP (op[-1].opcode);
1538 int new_opcode = PPC_OP (op[0].opcode);
1540 #ifdef PRINT_OPCODE_TABLE
1541 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1542 op->name, (unsigned int) (op - powerpc_opcodes),
1543 (unsigned int) new_opcode, (unsigned int) op->opcode,
1544 (unsigned int) op->mask, (unsigned long long) op->flags);
1547 /* The major opcodes had better be sorted. Code in the
1548 disassembler assumes the insns are sorted according to
1550 if (new_opcode < old_opcode)
1552 as_bad (_("major opcode is not sorted for %s"),
1557 bad_insn |= insn_validate (op);
1560 if ((ppc_cpu & op->flags) != 0
1561 && !(ppc_cpu & op->deprecated))
1565 retval = hash_insert (ppc_hash, op->name, (void *) op);
1568 as_bad (_("duplicate instruction %s"),
1575 if ((ppc_cpu & PPC_OPCODE_ANY) != 0)
1576 for (op = powerpc_opcodes; op < op_end; op++)
1577 hash_insert (ppc_hash, op->name, (void *) op);
1579 op_end = vle_opcodes + vle_num_opcodes;
1580 for (op = vle_opcodes; op < op_end; op++)
1582 if (ENABLE_CHECKING)
1584 if (op != vle_opcodes)
1586 unsigned old_seg, new_seg;
1588 old_seg = VLE_OP (op[-1].opcode, op[-1].mask);
1589 old_seg = VLE_OP_TO_SEG (old_seg);
1590 new_seg = VLE_OP (op[0].opcode, op[0].mask);
1591 new_seg = VLE_OP_TO_SEG (new_seg);
1593 #ifdef PRINT_OPCODE_TABLE
1594 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1595 op->name, (unsigned int) (op - powerpc_opcodes),
1596 (unsigned int) new_seg, (unsigned int) op->opcode,
1597 (unsigned int) op->mask, (unsigned long long) op->flags);
1599 /* The major opcodes had better be sorted. Code in the
1600 disassembler assumes the insns are sorted according to
1602 if (new_seg < old_seg)
1604 as_bad (_("major opcode is not sorted for %s"),
1610 bad_insn |= insn_validate (op);
1613 if ((ppc_cpu & op->flags) != 0
1614 && !(ppc_cpu & op->deprecated))
1618 retval = hash_insert (ppc_hash, op->name, (void *) op);
1621 as_bad (_("duplicate instruction %s"),
1628 if ((ppc_cpu & PPC_OPCODE_VLE) != 0)
1629 for (op = vle_opcodes; op < op_end; op++)
1630 hash_insert (ppc_hash, op->name, (void *) op);
1632 /* Insert the macros into a hash table. */
1633 ppc_macro_hash = hash_new ();
1635 macro_end = powerpc_macros + powerpc_num_macros;
1636 for (macro = powerpc_macros; macro < macro_end; macro++)
1638 if ((macro->flags & ppc_cpu) != 0 || (ppc_cpu & PPC_OPCODE_ANY) != 0)
1642 retval = hash_insert (ppc_macro_hash, macro->name, (void *) macro);
1643 if (retval != (const char *) NULL)
1645 as_bad (_("duplicate macro %s"), macro->name);
1655 /* This function is called when the assembler starts up. It is called
1656 after the options have been parsed and the output file has been
1664 ppc_cie_data_alignment = ppc_obj64 ? -8 : -4;
1665 ppc_dwarf2_line_min_insn_length = (ppc_cpu & PPC_OPCODE_VLE) ? 2 : 4;
1668 /* Set the ELF flags if desired. */
1669 if (ppc_flags && !msolaris)
1670 bfd_set_private_flags (stdoutput, ppc_flags);
1673 ppc_setup_opcodes ();
1675 /* Tell the main code what the endianness is if it is not overridden
1677 if (!set_target_endian)
1679 set_target_endian = 1;
1680 target_big_endian = PPC_BIG_ENDIAN;
1684 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1686 /* Create dummy symbols to serve as initial csects. This forces the
1687 text csects to precede the data csects. These symbols will not
1689 ppc_text_csects = symbol_make ("dummy\001");
1690 symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
1691 ppc_data_csects = symbol_make ("dummy\001");
1692 symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
1697 ppc_current_section = text_section;
1698 ppc_previous_section = 0;
1707 if (ppc_apuinfo_list == NULL)
1710 /* Ok, so write the section info out. We have this layout:
1714 0 8 length of "APUinfo\0"
1715 4 (n*4) number of APU's (4 bytes each)
1718 20 APU#1 first APU's info
1719 24 APU#2 second APU's info
1724 asection *seg = now_seg;
1725 subsegT subseg = now_subseg;
1726 asection *apuinfo_secp = (asection *) NULL;
1729 /* Create the .PPC.EMB.apuinfo section. */
1730 apuinfo_secp = subseg_new (".PPC.EMB.apuinfo", 0);
1731 bfd_set_section_flags (stdoutput,
1733 SEC_HAS_CONTENTS | SEC_READONLY);
1736 md_number_to_chars (p, (valueT) 8, 4);
1739 md_number_to_chars (p, (valueT) ppc_apuinfo_num * 4, 4);
1742 md_number_to_chars (p, (valueT) 2, 4);
1745 strcpy (p, "APUinfo");
1747 for (i = 0; i < ppc_apuinfo_num; i++)
1750 md_number_to_chars (p, (valueT) ppc_apuinfo_list[i], 4);
1753 frag_align (2, 0, 0);
1755 /* We probably can't restore the current segment, for there likely
1758 subseg_set (seg, subseg);
1763 /* Insert an operand value into an instruction. */
1765 static unsigned long
1766 ppc_insert_operand (unsigned long insn,
1767 const struct powerpc_operand *operand,
1773 long min, max, right;
1775 max = operand->bitm;
1779 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1781 if ((operand->flags & PPC_OPERAND_SIGNOPT) == 0)
1782 max = (max >> 1) & -right;
1783 min = ~max & -right;
1786 if ((operand->flags & PPC_OPERAND_PLUS1) != 0)
1789 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1798 /* Some people write constants with the sign extension done by
1799 hand but only up to 32 bits. This shouldn't really be valid,
1800 but, to permit this code to assemble on a 64-bit host, we
1801 sign extend the 32-bit value to 64 bits if so doing makes the
1804 && (offsetT) (val - 0x80000000 - 0x80000000) >= min
1805 && (offsetT) (val - 0x80000000 - 0x80000000) <= max
1806 && ((val - 0x80000000 - 0x80000000) & (right - 1)) == 0)
1807 val = val - 0x80000000 - 0x80000000;
1809 /* Similarly, people write expressions like ~(1<<15), and expect
1810 this to be OK for a 32-bit unsigned value. */
1812 && (offsetT) (val + 0x80000000 + 0x80000000) >= min
1813 && (offsetT) (val + 0x80000000 + 0x80000000) <= max
1814 && ((val + 0x80000000 + 0x80000000) & (right - 1)) == 0)
1815 val = val + 0x80000000 + 0x80000000;
1819 || (val & (right - 1)) != 0)
1820 as_bad_value_out_of_range (_("operand"), val, min, max, file, line);
1823 if (operand->insert)
1828 insn = (*operand->insert) (insn, (long) val, cpu, &errmsg);
1829 if (errmsg != (const char *) NULL)
1830 as_bad_where (file, line, "%s", errmsg);
1832 else if (operand->shift >= 0)
1833 insn |= ((long) val & operand->bitm) << operand->shift;
1835 insn |= ((long) val & operand->bitm) >> -operand->shift;
1842 /* Parse @got, etc. and return the desired relocation. */
1843 static bfd_reloc_code_real_type
1844 ppc_elf_suffix (char **str_p, expressionS *exp_p)
1848 unsigned int length : 8;
1849 unsigned int valid32 : 1;
1850 unsigned int valid64 : 1;
1859 const struct map_bfd *ptr;
1861 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1862 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1863 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1865 static const struct map_bfd mapping[] = {
1866 MAP ("l", BFD_RELOC_LO16),
1867 MAP ("h", BFD_RELOC_HI16),
1868 MAP ("ha", BFD_RELOC_HI16_S),
1869 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1870 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1871 MAP ("got", BFD_RELOC_16_GOTOFF),
1872 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1873 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1874 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1875 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1876 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1877 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1878 MAP ("copy", BFD_RELOC_PPC_COPY),
1879 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1880 MAP ("sectoff", BFD_RELOC_16_BASEREL),
1881 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1882 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1883 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1884 MAP ("tls", BFD_RELOC_PPC_TLS),
1885 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD),
1886 MAP ("dtprel", BFD_RELOC_PPC_DTPREL),
1887 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO),
1888 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI),
1889 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA),
1890 MAP ("tprel", BFD_RELOC_PPC_TPREL),
1891 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO),
1892 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI),
1893 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA),
1894 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16),
1895 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO),
1896 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI),
1897 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA),
1898 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16),
1899 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO),
1900 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI),
1901 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA),
1902 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16),
1903 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO),
1904 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI),
1905 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA),
1906 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16),
1907 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO),
1908 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI),
1909 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA),
1910 MAP32 ("fixup", BFD_RELOC_CTOR),
1911 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL),
1912 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1913 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1914 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC),
1915 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL),
1916 MAP32 ("sdarel", BFD_RELOC_GPREL16),
1917 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A),
1918 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A),
1919 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A),
1920 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1921 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1922 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1923 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1924 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1925 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1926 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1927 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1928 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1929 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO),
1930 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1931 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1932 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1933 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1934 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1935 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1936 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1937 MAP32 ("xgot", BFD_RELOC_PPC_TOC16),
1938 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH),
1939 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA),
1940 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER),
1941 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S),
1942 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST),
1943 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S),
1944 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC),
1945 MAP64 ("toc", BFD_RELOC_PPC_TOC16),
1946 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO),
1947 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI),
1948 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA),
1949 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH),
1950 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA),
1951 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER),
1952 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA),
1953 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST),
1954 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA),
1955 MAP64 ("localentry", BFD_RELOC_PPC64_ADDR64_LOCAL),
1956 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH),
1957 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA),
1958 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER),
1959 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA),
1960 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST),
1961 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA),
1962 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED }
1966 return BFD_RELOC_UNUSED;
1968 for (ch = *str, str2 = ident;
1969 (str2 < ident + sizeof (ident) - 1
1970 && (ISALNUM (ch) || ch == '@'));
1973 *str2++ = TOLOWER (ch);
1980 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1981 if (ch == ptr->string[0]
1982 && len == ptr->length
1983 && memcmp (ident, ptr->string, ptr->length) == 0
1984 && (ppc_obj64 ? ptr->valid64 : ptr->valid32))
1986 int reloc = ptr->reloc;
1988 if (!ppc_obj64 && exp_p->X_add_number != 0)
1992 case BFD_RELOC_16_GOTOFF:
1993 case BFD_RELOC_LO16_GOTOFF:
1994 case BFD_RELOC_HI16_GOTOFF:
1995 case BFD_RELOC_HI16_S_GOTOFF:
1996 as_warn (_("identifier+constant@got means "
1997 "identifier@got+constant"));
2000 case BFD_RELOC_PPC_GOT_TLSGD16:
2001 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
2002 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
2003 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
2004 case BFD_RELOC_PPC_GOT_TLSLD16:
2005 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
2006 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
2007 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
2008 case BFD_RELOC_PPC_GOT_DTPREL16:
2009 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
2010 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
2011 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
2012 case BFD_RELOC_PPC_GOT_TPREL16:
2013 case BFD_RELOC_PPC_GOT_TPREL16_LO:
2014 case BFD_RELOC_PPC_GOT_TPREL16_HI:
2015 case BFD_RELOC_PPC_GOT_TPREL16_HA:
2016 as_bad (_("symbol+offset not supported for got tls"));
2021 /* Now check for identifier@suffix+constant. */
2022 if (*str == '-' || *str == '+')
2024 char *orig_line = input_line_pointer;
2025 expressionS new_exp;
2027 input_line_pointer = str;
2028 expression (&new_exp);
2029 if (new_exp.X_op == O_constant)
2031 exp_p->X_add_number += new_exp.X_add_number;
2032 str = input_line_pointer;
2035 if (&input_line_pointer != str_p)
2036 input_line_pointer = orig_line;
2040 if (reloc == (int) BFD_RELOC_PPC64_TOC
2041 && exp_p->X_op == O_symbol
2042 && strcmp (S_GET_NAME (exp_p->X_add_symbol), ".TOC.") == 0)
2044 /* Change the symbol so that the dummy .TOC. symbol can be
2045 omitted from the object file. */
2046 exp_p->X_add_symbol = &abs_symbol;
2049 return (bfd_reloc_code_real_type) reloc;
2052 return BFD_RELOC_UNUSED;
2055 /* Like normal .long/.short/.word, except support @got, etc.
2056 Clobbers input_line_pointer, checks end-of-line. */
2058 ppc_elf_cons (int nbytes /* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2061 bfd_reloc_code_real_type reloc;
2063 if (is_it_end_of_statement ())
2065 demand_empty_rest_of_line ();
2072 if (*input_line_pointer == '@'
2073 && (reloc = ppc_elf_suffix (&input_line_pointer,
2074 &exp)) != BFD_RELOC_UNUSED)
2076 reloc_howto_type *reloc_howto;
2079 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
2080 size = bfd_get_reloc_size (reloc_howto);
2084 as_bad (_("%s relocations do not fit in %d bytes\n"),
2085 reloc_howto->name, nbytes);
2092 p = frag_more (nbytes);
2093 memset (p, 0, nbytes);
2095 if (target_big_endian)
2096 offset = nbytes - size;
2097 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
2102 emit_expr (&exp, (unsigned int) nbytes);
2104 while (*input_line_pointer++ == ',');
2106 /* Put terminator back into stream. */
2107 input_line_pointer--;
2108 demand_empty_rest_of_line ();
2111 /* Solaris pseduo op to change to the .rodata section. */
2113 ppc_elf_rdata (int xxx)
2115 char *save_line = input_line_pointer;
2116 static char section[] = ".rodata\n";
2118 /* Just pretend this is .section .rodata */
2119 input_line_pointer = section;
2120 obj_elf_section (xxx);
2122 input_line_pointer = save_line;
2125 /* Pseudo op to make file scope bss items. */
2127 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED)
2140 name = input_line_pointer;
2141 c = get_symbol_end ();
2143 /* just after name is now '\0'. */
2144 p = input_line_pointer;
2147 if (*input_line_pointer != ',')
2149 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2150 ignore_rest_of_line ();
2154 input_line_pointer++; /* skip ',' */
2155 if ((size = get_absolute_expression ()) < 0)
2157 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
2158 ignore_rest_of_line ();
2162 /* The third argument to .lcomm is the alignment. */
2163 if (*input_line_pointer != ',')
2167 ++input_line_pointer;
2168 align = get_absolute_expression ();
2171 as_warn (_("ignoring bad alignment"));
2177 symbolP = symbol_find_or_make (name);
2180 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
2182 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2183 S_GET_NAME (symbolP));
2184 ignore_rest_of_line ();
2188 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
2190 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2191 S_GET_NAME (symbolP),
2192 (long) S_GET_VALUE (symbolP),
2195 ignore_rest_of_line ();
2201 old_subsec = now_subseg;
2204 /* Convert to a power of 2 alignment. */
2205 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
2208 as_bad (_("common alignment not a power of 2"));
2209 ignore_rest_of_line ();
2216 record_alignment (bss_section, align2);
2217 subseg_set (bss_section, 1);
2219 frag_align (align2, 0, 0);
2220 if (S_GET_SEGMENT (symbolP) == bss_section)
2221 symbol_get_frag (symbolP)->fr_symbol = 0;
2222 symbol_set_frag (symbolP, frag_now);
2223 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
2226 S_SET_SIZE (symbolP, size);
2227 S_SET_SEGMENT (symbolP, bss_section);
2228 subseg_set (old_sec, old_subsec);
2229 demand_empty_rest_of_line ();
2232 /* Pseudo op to set symbol local entry point. */
2234 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED)
2236 char *name = input_line_pointer;
2237 char c = get_symbol_end ();
2242 elf_symbol_type *elfsym;
2244 p = input_line_pointer;
2247 if (*input_line_pointer != ',')
2250 as_bad (_("expected comma after name `%s' in .localentry directive"),
2253 ignore_rest_of_line ();
2256 input_line_pointer++;
2258 if (exp.X_op == O_absent)
2260 as_bad (_("missing expression in .localentry directive"));
2261 exp.X_op = O_constant;
2262 exp.X_add_number = 0;
2265 sym = symbol_find_or_make (name);
2268 if (resolve_expression (&exp)
2269 && exp.X_op == O_constant)
2271 unsigned char encoded = PPC64_SET_LOCAL_ENTRY_OFFSET (exp.X_add_number);
2273 if (exp.X_add_number != (offsetT) PPC64_LOCAL_ENTRY_OFFSET (encoded))
2274 as_bad (_(".localentry expression for `%s' "
2275 "is not a valid power of 2"), S_GET_NAME (sym));
2278 bfdsym = symbol_get_bfdsym (sym);
2279 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
2280 gas_assert (elfsym);
2281 elfsym->internal_elf_sym.st_other &= ~STO_PPC64_LOCAL_MASK;
2282 elfsym->internal_elf_sym.st_other |= encoded;
2283 if (ppc_abiversion == 0)
2288 as_bad (_(".localentry expression for `%s' "
2289 "does not evaluate to a constant"), S_GET_NAME (sym));
2291 demand_empty_rest_of_line ();
2294 /* Pseudo op to set ABI version. */
2296 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED)
2301 if (exp.X_op == O_absent)
2303 as_bad (_("missing expression in .abiversion directive"));
2304 exp.X_op = O_constant;
2305 exp.X_add_number = 0;
2308 if (resolve_expression (&exp)
2309 && exp.X_op == O_constant)
2310 ppc_abiversion = exp.X_add_number;
2312 as_bad (_(".abiversion expression does not evaluate to a constant"));
2313 demand_empty_rest_of_line ();
2316 /* Set ABI version in output file. */
2320 if (ppc_obj64 && ppc_abiversion != 0)
2322 elf_elfheader (stdoutput)->e_flags &= ~EF_PPC64_ABI;
2323 elf_elfheader (stdoutput)->e_flags |= ppc_abiversion & EF_PPC64_ABI;
2327 /* Validate any relocations emitted for -mrelocatable, possibly adding
2328 fixups for word relocations in writable segments, so we can adjust
2331 ppc_elf_validate_fix (fixS *fixp, segT seg)
2333 if (fixp->fx_done || fixp->fx_pcrel)
2342 case SHLIB_MRELOCATABLE:
2343 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
2344 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
2345 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
2346 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
2347 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
2348 && fixp->fx_r_type != BFD_RELOC_16_BASEREL
2349 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
2350 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
2351 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
2352 && (seg->flags & SEC_LOAD) != 0
2353 && strcmp (segment_name (seg), ".got2") != 0
2354 && strcmp (segment_name (seg), ".dtors") != 0
2355 && strcmp (segment_name (seg), ".ctors") != 0
2356 && strcmp (segment_name (seg), ".fixup") != 0
2357 && strcmp (segment_name (seg), ".gcc_except_table") != 0
2358 && strcmp (segment_name (seg), ".eh_frame") != 0
2359 && strcmp (segment_name (seg), ".ex_shared") != 0)
2361 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
2362 || fixp->fx_r_type != BFD_RELOC_CTOR)
2364 as_bad_where (fixp->fx_file, fixp->fx_line,
2365 _("relocation cannot be done when using -mrelocatable"));
2372 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2373 function descriptor sym if the corresponding code sym is used. */
2376 ppc_frob_file_before_adjust (void)
2384 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2391 name = S_GET_NAME (symp);
2395 if (! S_IS_WEAK (symp)
2396 || S_IS_DEFINED (symp))
2399 len = strlen (name) + 1;
2400 dotname = xmalloc (len + 1);
2402 memcpy (dotname + 1, name, len);
2403 dotsym = symbol_find_noref (dotname, 1);
2405 if (dotsym != NULL && (symbol_used_p (dotsym)
2406 || symbol_used_in_reloc_p (dotsym)))
2407 symbol_mark_used (symp);
2411 toc = bfd_get_section_by_name (stdoutput, ".toc");
2413 && toc_reloc_types != has_large_toc_reloc
2414 && bfd_section_size (stdoutput, toc) > 0x10000)
2415 as_warn (_("TOC section size exceeds 64k"));
2418 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2419 emitted. Other uses of .TOC. will cause the symbol to be marked
2420 with BSF_KEEP in md_apply_fix. */
2423 ppc_elf_adjust_symtab (void)
2428 symp = symbol_find (".TOC.");
2431 asymbol *bsym = symbol_get_bfdsym (symp);
2432 if ((bsym->flags & BSF_KEEP) == 0)
2433 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2437 #endif /* OBJ_ELF */
2442 * Summary of parse_toc_entry.
2444 * in: Input_line_pointer points to the '[' in one of:
2446 * [toc] [tocv] [toc32] [toc64]
2448 * Anything else is an error of one kind or another.
2451 * return value: success or failure
2452 * toc_kind: kind of toc reference
2453 * input_line_pointer:
2454 * success: first char after the ']'
2455 * failure: unchanged
2459 * [toc] - rv == success, toc_kind = default_toc
2460 * [tocv] - rv == success, toc_kind = data_in_toc
2461 * [toc32] - rv == success, toc_kind = must_be_32
2462 * [toc64] - rv == success, toc_kind = must_be_64
2466 enum toc_size_qualifier
2468 default_toc, /* The toc cell constructed should be the system default size */
2469 data_in_toc, /* This is a direct reference to a toc cell */
2470 must_be_32, /* The toc cell constructed must be 32 bits wide */
2471 must_be_64 /* The toc cell constructed must be 64 bits wide */
2475 parse_toc_entry (enum toc_size_qualifier *toc_kind)
2480 enum toc_size_qualifier t;
2482 /* Save the input_line_pointer. */
2483 start = input_line_pointer;
2485 /* Skip over the '[' , and whitespace. */
2486 ++input_line_pointer;
2489 /* Find the spelling of the operand. */
2490 toc_spec = input_line_pointer;
2491 c = get_symbol_end ();
2493 if (strcmp (toc_spec, "toc") == 0)
2497 else if (strcmp (toc_spec, "tocv") == 0)
2501 else if (strcmp (toc_spec, "toc32") == 0)
2505 else if (strcmp (toc_spec, "toc64") == 0)
2511 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
2512 *input_line_pointer = c;
2513 input_line_pointer = start;
2517 /* Now find the ']'. */
2518 *input_line_pointer = c;
2520 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2521 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
2525 as_bad (_("syntax error: expected `]', found `%c'"), c);
2526 input_line_pointer = start;
2536 /* See whether a symbol is in the TOC section. */
2539 ppc_is_toc_sym (symbolS *sym)
2541 return (symbol_get_tc (sym)->symbol_class == XMC_TC
2542 || symbol_get_tc (sym)->symbol_class == XMC_TC0);
2548 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2550 ppc_apuinfo_section_add (unsigned int apu, unsigned int version)
2554 /* Check we don't already exist. */
2555 for (i = 0; i < ppc_apuinfo_num; i++)
2556 if (ppc_apuinfo_list[i] == APUID (apu, version))
2559 if (ppc_apuinfo_num == ppc_apuinfo_num_alloc)
2561 if (ppc_apuinfo_num_alloc == 0)
2563 ppc_apuinfo_num_alloc = 4;
2564 ppc_apuinfo_list = (unsigned long *)
2565 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2569 ppc_apuinfo_num_alloc += 4;
2570 ppc_apuinfo_list = (unsigned long *) xrealloc (ppc_apuinfo_list,
2571 sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2574 ppc_apuinfo_list[ppc_apuinfo_num++] = APUID (apu, version);
2580 /* We need to keep a list of fixups. We can't simply generate them as
2581 we go, because that would require us to first create the frag, and
2582 that would screw up references to ``.''. */
2588 bfd_reloc_code_real_type reloc;
2591 #define MAX_INSN_FIXUPS (5)
2594 #define E_OR2I_INSN 0x7000C000
2595 #define E_AND2I_DOT_INSN 0x7000C800
2596 #define E_OR2IS_INSN 0x7000D000
2597 #define E_LIS_INSN 0x7000E000
2598 #define E_AND2IS_DOT_INSN 0x7000E800
2601 #define E_ADD2I_DOT_INSN 0x70008800
2602 #define E_ADD2IS_INSN 0x70009000
2603 #define E_CMP16I_INSN 0x70009800
2604 #define E_MULL2I_INSN 0x7000A000
2605 #define E_CMPL16I_INSN 0x7000A800
2606 #define E_CMPH16I_INSN 0x7000B000
2607 #define E_CMPHL16I_INSN 0x7000B800
2609 /* This routine is called for each instruction to be assembled. */
2612 md_assemble (char *str)
2615 const struct powerpc_opcode *opcode;
2617 const unsigned char *opindex_ptr;
2621 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
2626 unsigned int insn_length;
2628 /* Get the opcode. */
2629 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
2634 /* Look up the opcode in the hash table. */
2635 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
2636 if (opcode == (const struct powerpc_opcode *) NULL)
2638 const struct powerpc_macro *macro;
2640 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
2641 if (macro == (const struct powerpc_macro *) NULL)
2642 as_bad (_("unrecognized opcode: `%s'"), str);
2644 ppc_macro (s, macro);
2649 insn = opcode->opcode;
2652 while (ISSPACE (*str))
2655 /* PowerPC operands are just expressions. The only real issue is
2656 that a few operand types are optional. All cases which might use
2657 an optional operand separate the operands only with commas (in some
2658 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2659 have optional operands). Most instructions with optional operands
2660 have only one. Those that have more than one optional operand can
2661 take either all their operands or none. So, before we start seriously
2662 parsing the operands, we check to see if we have optional operands,
2663 and if we do, we count the number of commas to see which operands
2664 have been omitted. */
2666 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2668 const struct powerpc_operand *operand;
2670 operand = &powerpc_operands[*opindex_ptr];
2671 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
2673 unsigned int opcount;
2674 unsigned int num_operands_expected;
2676 /* There is an optional operand. Count the number of
2677 commas in the input line. */
2684 while ((s = strchr (s, ',')) != (char *) NULL)
2691 /* Compute the number of expected operands.
2692 Do not count fake operands. */
2693 for (num_operands_expected = 0, i = 0; opcode->operands[i]; i ++)
2694 if ((powerpc_operands [opcode->operands[i]].flags & PPC_OPERAND_FAKE) == 0)
2695 ++ num_operands_expected;
2697 /* If there are fewer operands in the line then are called
2698 for by the instruction, we want to skip the optional
2700 if (opcount < num_operands_expected)
2707 /* Gather the operands. */
2711 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2713 const struct powerpc_operand *operand;
2719 if (next_opindex == 0)
2720 operand = &powerpc_operands[*opindex_ptr];
2723 operand = &powerpc_operands[next_opindex];
2728 /* If this is a fake operand, then we do not expect anything
2730 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
2732 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2733 if (errmsg != (const char *) NULL)
2734 as_bad ("%s", errmsg);
2738 /* If this is an optional operand, and we are skipping it, just
2740 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
2743 if (operand->insert)
2745 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2746 if (errmsg != (const char *) NULL)
2747 as_bad ("%s", errmsg);
2749 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
2750 next_opindex = *opindex_ptr + 1;
2754 /* Gather the operand. */
2755 hold = input_line_pointer;
2756 input_line_pointer = str;
2759 if (*input_line_pointer == '[')
2761 /* We are expecting something like the second argument here:
2763 * lwz r4,[toc].GS.0.static_int(rtoc)
2764 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2765 * The argument following the `]' must be a symbol name, and the
2766 * register must be the toc register: 'rtoc' or '2'
2768 * The effect is to 0 as the displacement field
2769 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2770 * the appropriate variation) reloc against it based on the symbol.
2771 * The linker will build the toc, and insert the resolved toc offset.
2774 * o The size of the toc entry is currently assumed to be
2775 * 32 bits. This should not be assumed to be a hard coded
2777 * o In an effort to cope with a change from 32 to 64 bits,
2778 * there are also toc entries that are specified to be
2779 * either 32 or 64 bits:
2780 * lwz r4,[toc32].GS.0.static_int(rtoc)
2781 * lwz r4,[toc64].GS.0.static_int(rtoc)
2782 * These demand toc entries of the specified size, and the
2783 * instruction probably requires it.
2787 enum toc_size_qualifier toc_kind;
2788 bfd_reloc_code_real_type toc_reloc;
2790 /* Go parse off the [tocXX] part. */
2791 valid_toc = parse_toc_entry (&toc_kind);
2795 ignore_rest_of_line ();
2799 /* Now get the symbol following the ']'. */
2805 /* In this case, we may not have seen the symbol yet,
2806 since it is allowed to appear on a .extern or .globl
2807 or just be a label in the .data section. */
2808 toc_reloc = BFD_RELOC_PPC_TOC16;
2811 /* 1. The symbol must be defined and either in the toc
2812 section, or a global.
2813 2. The reloc generated must have the TOCDEFN flag set
2814 in upper bit mess of the reloc type.
2815 FIXME: It's a little confusing what the tocv
2816 qualifier can be used for. At the very least, I've
2817 seen three uses, only one of which I'm sure I can
2819 if (ex.X_op == O_symbol)
2821 gas_assert (ex.X_add_symbol != NULL);
2822 if (symbol_get_bfdsym (ex.X_add_symbol)->section
2825 as_bad (_("[tocv] symbol is not a toc symbol"));
2829 toc_reloc = BFD_RELOC_PPC_TOC16;
2832 /* FIXME: these next two specifically specify 32/64 bit
2833 toc entries. We don't support them today. Is this
2834 the right way to say that? */
2835 toc_reloc = BFD_RELOC_UNUSED;
2836 as_bad (_("unimplemented toc32 expression modifier"));
2839 /* FIXME: see above. */
2840 toc_reloc = BFD_RELOC_UNUSED;
2841 as_bad (_("unimplemented toc64 expression modifier"));
2845 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2851 /* We need to generate a fixup for this expression. */
2852 if (fc >= MAX_INSN_FIXUPS)
2853 as_fatal (_("too many fixups"));
2855 fixups[fc].reloc = toc_reloc;
2856 fixups[fc].exp = ex;
2857 fixups[fc].opindex = *opindex_ptr;
2860 /* Ok. We've set up the fixup for the instruction. Now make it
2861 look like the constant 0 was found here. */
2863 ex.X_op = O_constant;
2864 ex.X_add_number = 0;
2865 ex.X_add_symbol = NULL;
2866 ex.X_op_symbol = NULL;
2873 && (((operand->flags & PPC_OPERAND_CR_BIT) != 0)
2874 || ((operand->flags & PPC_OPERAND_CR_REG) != 0)))
2875 || !register_name (&ex))
2877 char save_lex = lex_type['%'];
2879 if (((operand->flags & PPC_OPERAND_CR_REG) != 0)
2880 || (operand->flags & PPC_OPERAND_CR_BIT) != 0)
2883 lex_type['%'] |= LEX_BEGIN_NAME;
2887 lex_type['%'] = save_lex;
2891 str = input_line_pointer;
2892 input_line_pointer = hold;
2894 if (ex.X_op == O_illegal)
2895 as_bad (_("illegal operand"));
2896 else if (ex.X_op == O_absent)
2897 as_bad (_("missing operand"));
2898 else if (ex.X_op == O_register)
2900 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2901 ppc_cpu, (char *) NULL, 0);
2903 else if (ex.X_op == O_constant)
2906 /* Allow @HA, @L, @H on constants. */
2907 bfd_reloc_code_real_type reloc;
2908 char *orig_str = str;
2910 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2917 case BFD_RELOC_LO16:
2918 ex.X_add_number &= 0xffff;
2919 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2920 ex.X_add_number = SEX16 (ex.X_add_number);
2923 case BFD_RELOC_HI16:
2924 if (REPORT_OVERFLOW_HI && ppc_obj64)
2926 /* PowerPC64 @h is tested for overflow. */
2927 ex.X_add_number = (addressT) ex.X_add_number >> 16;
2928 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2930 addressT sign = (((addressT) -1 >> 16) + 1) >> 1;
2932 = ((addressT) ex.X_add_number ^ sign) - sign;
2938 case BFD_RELOC_PPC64_ADDR16_HIGH:
2939 ex.X_add_number = PPC_HI (ex.X_add_number);
2940 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2941 ex.X_add_number = SEX16 (ex.X_add_number);
2944 case BFD_RELOC_HI16_S:
2945 if (REPORT_OVERFLOW_HI && ppc_obj64)
2947 /* PowerPC64 @ha is tested for overflow. */
2949 = ((addressT) ex.X_add_number + 0x8000) >> 16;
2950 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2952 addressT sign = (((addressT) -1 >> 16) + 1) >> 1;
2954 = ((addressT) ex.X_add_number ^ sign) - sign;
2960 case BFD_RELOC_PPC64_ADDR16_HIGHA:
2961 ex.X_add_number = PPC_HA (ex.X_add_number);
2962 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2963 ex.X_add_number = SEX16 (ex.X_add_number);
2966 case BFD_RELOC_PPC64_HIGHER:
2967 ex.X_add_number = PPC_HIGHER (ex.X_add_number);
2968 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2969 ex.X_add_number = SEX16 (ex.X_add_number);
2972 case BFD_RELOC_PPC64_HIGHER_S:
2973 ex.X_add_number = PPC_HIGHERA (ex.X_add_number);
2974 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2975 ex.X_add_number = SEX16 (ex.X_add_number);
2978 case BFD_RELOC_PPC64_HIGHEST:
2979 ex.X_add_number = PPC_HIGHEST (ex.X_add_number);
2980 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2981 ex.X_add_number = SEX16 (ex.X_add_number);
2984 case BFD_RELOC_PPC64_HIGHEST_S:
2985 ex.X_add_number = PPC_HIGHESTA (ex.X_add_number);
2986 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
2987 ex.X_add_number = SEX16 (ex.X_add_number);
2990 #endif /* OBJ_ELF */
2991 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2992 ppc_cpu, (char *) NULL, 0);
2996 bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
2998 if (ex.X_op == O_symbol && str[0] == '(')
3000 const char *sym_name = S_GET_NAME (ex.X_add_symbol);
3001 if (sym_name[0] == '.')
3004 if (strcasecmp (sym_name, "__tls_get_addr") == 0)
3006 expressionS tls_exp;
3008 hold = input_line_pointer;
3009 input_line_pointer = str + 1;
3010 expression (&tls_exp);
3011 if (tls_exp.X_op == O_symbol)
3013 reloc = BFD_RELOC_UNUSED;
3014 if (strncasecmp (input_line_pointer, "@tlsgd)", 7) == 0)
3016 reloc = BFD_RELOC_PPC_TLSGD;
3017 input_line_pointer += 7;
3019 else if (strncasecmp (input_line_pointer, "@tlsld)", 7) == 0)
3021 reloc = BFD_RELOC_PPC_TLSLD;
3022 input_line_pointer += 7;
3024 if (reloc != BFD_RELOC_UNUSED)
3027 str = input_line_pointer;
3029 if (fc >= MAX_INSN_FIXUPS)
3030 as_fatal (_("too many fixups"));
3031 fixups[fc].exp = tls_exp;
3032 fixups[fc].opindex = *opindex_ptr;
3033 fixups[fc].reloc = reloc;
3037 input_line_pointer = hold;
3041 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
3043 /* Some TLS tweaks. */
3049 case BFD_RELOC_PPC_TLS:
3050 if (!_bfd_elf_ppc_at_tls_transform (opcode->opcode, 0))
3051 as_bad (_("@tls may not be used with \"%s\" operands"),
3053 else if (operand->shift != 11)
3054 as_bad (_("@tls may only be used in last operand"));
3056 insn = ppc_insert_operand (insn, operand,
3058 ppc_cpu, (char *) NULL, 0);
3061 /* We'll only use the 32 (or 64) bit form of these relocations
3062 in constants. Instructions get the 16 bit form. */
3063 case BFD_RELOC_PPC_DTPREL:
3064 reloc = BFD_RELOC_PPC_DTPREL16;
3066 case BFD_RELOC_PPC_TPREL:
3067 reloc = BFD_RELOC_PPC_TPREL16;
3071 /* If VLE-mode convert LO/HI/HA relocations. */
3072 if (opcode->flags & PPC_OPCODE_VLE)
3074 int tmp_insn = insn & opcode->mask;
3076 int use_d_reloc = (tmp_insn == E_OR2I_INSN
3077 || tmp_insn == E_AND2I_DOT_INSN
3078 || tmp_insn == E_OR2IS_INSN
3079 || tmp_insn == E_LIS_INSN
3080 || tmp_insn == E_AND2IS_DOT_INSN);
3083 int use_a_reloc = (tmp_insn == E_ADD2I_DOT_INSN
3084 || tmp_insn == E_ADD2IS_INSN
3085 || tmp_insn == E_CMP16I_INSN
3086 || tmp_insn == E_MULL2I_INSN
3087 || tmp_insn == E_CMPL16I_INSN
3088 || tmp_insn == E_CMPH16I_INSN
3089 || tmp_insn == E_CMPHL16I_INSN);
3096 case BFD_RELOC_PPC_EMB_SDA21:
3097 reloc = BFD_RELOC_PPC_VLE_SDA21;
3100 case BFD_RELOC_LO16:
3102 reloc = BFD_RELOC_PPC_VLE_LO16D;
3103 else if (use_a_reloc)
3104 reloc = BFD_RELOC_PPC_VLE_LO16A;
3107 case BFD_RELOC_HI16:
3109 reloc = BFD_RELOC_PPC_VLE_HI16D;
3110 else if (use_a_reloc)
3111 reloc = BFD_RELOC_PPC_VLE_HI16A;
3114 case BFD_RELOC_HI16_S:
3116 reloc = BFD_RELOC_PPC_VLE_HA16D;
3117 else if (use_a_reloc)
3118 reloc = BFD_RELOC_PPC_VLE_HA16A;
3121 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
3123 reloc = BFD_RELOC_PPC_VLE_SDAREL_LO16D;
3126 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
3128 reloc = BFD_RELOC_PPC_VLE_SDAREL_HI16D;
3131 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
3133 reloc = BFD_RELOC_PPC_VLE_SDAREL_HA16D;
3138 #endif /* OBJ_ELF */
3140 if (reloc != BFD_RELOC_UNUSED)
3142 /* Determine a BFD reloc value based on the operand information.
3143 We are only prepared to turn a few of the operands into
3145 else if ((operand->flags & (PPC_OPERAND_RELATIVE
3146 | PPC_OPERAND_ABSOLUTE)) != 0
3147 && operand->bitm == 0x3fffffc
3148 && operand->shift == 0)
3149 reloc = BFD_RELOC_PPC_B26;
3150 else if ((operand->flags & (PPC_OPERAND_RELATIVE
3151 | PPC_OPERAND_ABSOLUTE)) != 0
3152 && operand->bitm == 0xfffc
3153 && operand->shift == 0)
3154 reloc = BFD_RELOC_PPC_B16;
3155 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3156 && operand->bitm == 0x1fe
3157 && operand->shift == -1)
3158 reloc = BFD_RELOC_PPC_VLE_REL8;
3159 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3160 && operand->bitm == 0xfffe
3161 && operand->shift == 0)
3162 reloc = BFD_RELOC_PPC_VLE_REL15;
3163 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3164 && operand->bitm == 0x1fffffe
3165 && operand->shift == 0)
3166 reloc = BFD_RELOC_PPC_VLE_REL24;
3167 else if ((operand->flags & PPC_OPERAND_NEGATIVE) == 0
3168 && (operand->bitm & 0xfff0) == 0xfff0
3169 && operand->shift == 0)
3171 reloc = BFD_RELOC_16;
3173 /* Note: the symbol may be not yet defined. */
3174 if ((operand->flags & PPC_OPERAND_PARENS) != 0
3175 && ppc_is_toc_sym (ex.X_add_symbol))
3176 reloc = BFD_RELOC_PPC_TOC16;
3180 /* For the absolute forms of branches, convert the PC
3181 relative form back into the absolute. */
3182 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
3186 case BFD_RELOC_PPC_B26:
3187 reloc = BFD_RELOC_PPC_BA26;
3189 case BFD_RELOC_PPC_B16:
3190 reloc = BFD_RELOC_PPC_BA16;
3193 case BFD_RELOC_PPC_B16_BRTAKEN:
3194 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
3196 case BFD_RELOC_PPC_B16_BRNTAKEN:
3197 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
3208 case BFD_RELOC_PPC_TOC16:
3209 toc_reloc_types |= has_small_toc_reloc;
3211 case BFD_RELOC_PPC64_TOC16_LO:
3212 case BFD_RELOC_PPC64_TOC16_HI:
3213 case BFD_RELOC_PPC64_TOC16_HA:
3214 toc_reloc_types |= has_large_toc_reloc;
3221 && (operand->flags & (PPC_OPERAND_DS | PPC_OPERAND_DQ)) != 0)
3226 reloc = BFD_RELOC_PPC64_ADDR16_DS;
3228 case BFD_RELOC_LO16:
3229 reloc = BFD_RELOC_PPC64_ADDR16_LO_DS;
3231 case BFD_RELOC_16_GOTOFF:
3232 reloc = BFD_RELOC_PPC64_GOT16_DS;
3234 case BFD_RELOC_LO16_GOTOFF:
3235 reloc = BFD_RELOC_PPC64_GOT16_LO_DS;
3237 case BFD_RELOC_LO16_PLTOFF:
3238 reloc = BFD_RELOC_PPC64_PLT16_LO_DS;
3240 case BFD_RELOC_16_BASEREL:
3241 reloc = BFD_RELOC_PPC64_SECTOFF_DS;
3243 case BFD_RELOC_LO16_BASEREL:
3244 reloc = BFD_RELOC_PPC64_SECTOFF_LO_DS;
3246 case BFD_RELOC_PPC_TOC16:
3247 reloc = BFD_RELOC_PPC64_TOC16_DS;
3249 case BFD_RELOC_PPC64_TOC16_LO:
3250 reloc = BFD_RELOC_PPC64_TOC16_LO_DS;
3252 case BFD_RELOC_PPC64_PLTGOT16:
3253 reloc = BFD_RELOC_PPC64_PLTGOT16_DS;
3255 case BFD_RELOC_PPC64_PLTGOT16_LO:
3256 reloc = BFD_RELOC_PPC64_PLTGOT16_LO_DS;
3258 case BFD_RELOC_PPC_DTPREL16:
3259 reloc = BFD_RELOC_PPC64_DTPREL16_DS;
3261 case BFD_RELOC_PPC_DTPREL16_LO:
3262 reloc = BFD_RELOC_PPC64_DTPREL16_LO_DS;
3264 case BFD_RELOC_PPC_TPREL16:
3265 reloc = BFD_RELOC_PPC64_TPREL16_DS;
3267 case BFD_RELOC_PPC_TPREL16_LO:
3268 reloc = BFD_RELOC_PPC64_TPREL16_LO_DS;
3270 case BFD_RELOC_PPC_GOT_DTPREL16:
3271 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
3272 case BFD_RELOC_PPC_GOT_TPREL16:
3273 case BFD_RELOC_PPC_GOT_TPREL16_LO:
3276 as_bad (_("unsupported relocation for DS offset field"));
3282 /* We need to generate a fixup for this expression. */
3283 if (fc >= MAX_INSN_FIXUPS)
3284 as_fatal (_("too many fixups"));
3285 fixups[fc].exp = ex;
3286 fixups[fc].opindex = *opindex_ptr;
3287 fixups[fc].reloc = reloc;
3295 /* If expecting more operands, then we want to see "),". */
3296 if (*str == endc && opindex_ptr[1] != 0)
3300 while (ISSPACE (*str));
3304 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
3312 /* The call to expression should have advanced str past any
3315 && (endc != ',' || *str != '\0'))
3318 as_bad (_("syntax error; end of line, expected `%c'"), endc);
3320 as_bad (_("syntax error; found `%c', expected `%c'"), *str, endc);
3328 while (ISSPACE (*str))
3332 as_bad (_("junk at end of line: `%s'"), str);
3335 /* Do we need/want an APUinfo section? */
3336 if ((ppc_cpu & (PPC_OPCODE_E500 | PPC_OPCODE_E500MC | PPC_OPCODE_VLE)) != 0
3339 /* These are all version "1". */
3340 if (opcode->flags & PPC_OPCODE_SPE)
3341 ppc_apuinfo_section_add (PPC_APUINFO_SPE, 1);
3342 if (opcode->flags & PPC_OPCODE_ISEL)
3343 ppc_apuinfo_section_add (PPC_APUINFO_ISEL, 1);
3344 if (opcode->flags & PPC_OPCODE_EFS)
3345 ppc_apuinfo_section_add (PPC_APUINFO_EFS, 1);
3346 if (opcode->flags & PPC_OPCODE_BRLOCK)
3347 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK, 1);
3348 if (opcode->flags & PPC_OPCODE_PMR)
3349 ppc_apuinfo_section_add (PPC_APUINFO_PMR, 1);
3350 if (opcode->flags & PPC_OPCODE_CACHELCK)
3351 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK, 1);
3352 if (opcode->flags & PPC_OPCODE_RFMCI)
3353 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI, 1);
3354 if (opcode->flags & PPC_OPCODE_VLE)
3355 ppc_apuinfo_section_add (PPC_APUINFO_VLE, 1);
3359 /* Write out the instruction. */
3360 /* Differentiate between two and four byte insns. */
3361 if (ppc_mach () == bfd_mach_ppc_vle)
3363 if (PPC_OP_SE_VLE (insn))
3367 addr_mod = frag_now_fix () & 1;
3372 addr_mod = frag_now_fix () & 3;
3374 /* All instructions can start on a 2 byte boundary for VLE. */
3375 f = frag_more (insn_length);
3376 if (frag_now->has_code && frag_now->insn_addr != addr_mod)
3378 if (ppc_mach() == bfd_mach_ppc_vle)
3379 as_bad (_("instruction address is not a multiple of 2"));
3381 as_bad (_("instruction address is not a multiple of 4"));
3383 frag_now->insn_addr = addr_mod;
3384 frag_now->has_code = 1;
3385 md_number_to_chars (f, insn, insn_length);
3388 dwarf2_emit_insn (insn_length);
3391 /* Create any fixups. */
3392 for (i = 0; i < fc; i++)
3395 if (fixups[i].reloc != BFD_RELOC_UNUSED)
3397 reloc_howto_type *reloc_howto;
3401 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
3405 size = bfd_get_reloc_size (reloc_howto);
3406 offset = target_big_endian ? (insn_length - size) : 0;
3408 if (size < 1 || size > 4)
3411 fixP = fix_new_exp (frag_now,
3412 f - frag_now->fr_literal + offset,
3415 reloc_howto->pc_relative,
3420 const struct powerpc_operand *operand;
3422 operand = &powerpc_operands[fixups[i].opindex];
3423 fixP = fix_new_exp (frag_now,
3424 f - frag_now->fr_literal,
3427 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
3430 fixP->fx_pcrel_adjust = fixups[i].opindex;
3434 /* Handle a macro. Gather all the operands, transform them as
3435 described by the macro, and call md_assemble recursively. All the
3436 operands are separated by commas; we don't accept parentheses
3437 around operands here. */
3440 ppc_macro (char *str, const struct powerpc_macro *macro)
3451 /* Gather the users operands into the operands array. */
3456 if (count >= sizeof operands / sizeof operands[0])
3458 operands[count++] = s;
3459 s = strchr (s, ',');
3460 if (s == (char *) NULL)
3465 if (count != macro->operands)
3467 as_bad (_("wrong number of operands"));
3471 /* Work out how large the string must be (the size is unbounded
3472 because it includes user input). */
3474 format = macro->format;
3475 while (*format != '\0')
3484 arg = strtol (format + 1, &send, 10);
3485 know (send != format && arg < count);
3486 len += strlen (operands[arg]);
3491 /* Put the string together. */
3492 complete = s = (char *) alloca (len + 1);
3493 format = macro->format;
3494 while (*format != '\0')
3500 arg = strtol (format + 1, &send, 10);
3501 strcpy (s, operands[arg]);
3508 /* Assemble the constructed instruction. */
3509 md_assemble (complete);
3513 /* For ELF, add support for SHT_ORDERED. */
3516 ppc_section_type (char *str, size_t len)
3518 if (len == 7 && strncmp (str, "ordered", 7) == 0)
3525 ppc_section_flags (flagword flags, bfd_vma attr ATTRIBUTE_UNUSED, int type)
3527 if (type == SHT_ORDERED)
3528 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
3532 #endif /* OBJ_ELF */
3535 /* Pseudo-op handling. */
3537 /* The .byte pseudo-op. This is similar to the normal .byte
3538 pseudo-op, but it can also take a single ASCII string. */
3541 ppc_byte (int ignore ATTRIBUTE_UNUSED)
3543 if (*input_line_pointer != '\"')
3549 /* Gather characters. A real double quote is doubled. Unusual
3550 characters are not permitted. */
3551 ++input_line_pointer;
3556 c = *input_line_pointer++;
3560 if (*input_line_pointer != '\"')
3562 ++input_line_pointer;
3565 FRAG_APPEND_1_CHAR (c);
3568 demand_empty_rest_of_line ();
3573 /* XCOFF specific pseudo-op handling. */
3575 /* This is set if we are creating a .stabx symbol, since we don't want
3576 to handle symbol suffixes for such symbols. */
3577 static bfd_boolean ppc_stab_symbol;
3579 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3580 symbols in the .bss segment as though they were local common
3581 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3582 aligns .comm and .lcomm to 4 bytes. */
3585 ppc_comm (int lcomm)
3587 asection *current_seg = now_seg;
3588 subsegT current_subseg = now_subseg;
3594 symbolS *lcomm_sym = NULL;
3598 name = input_line_pointer;
3599 endc = get_symbol_end ();
3600 end_name = input_line_pointer;
3603 if (*input_line_pointer != ',')
3605 as_bad (_("missing size"));
3606 ignore_rest_of_line ();
3609 ++input_line_pointer;
3611 size = get_absolute_expression ();
3614 as_bad (_("negative size"));
3615 ignore_rest_of_line ();
3621 /* The third argument to .comm is the alignment. */
3622 if (*input_line_pointer != ',')
3626 ++input_line_pointer;
3627 align = get_absolute_expression ();
3630 as_warn (_("ignoring bad alignment"));
3640 /* The third argument to .lcomm appears to be the real local
3641 common symbol to create. References to the symbol named in
3642 the first argument are turned into references to the third
3644 if (*input_line_pointer != ',')
3646 as_bad (_("missing real symbol name"));
3647 ignore_rest_of_line ();
3650 ++input_line_pointer;
3652 lcomm_name = input_line_pointer;
3653 lcomm_endc = get_symbol_end ();
3655 lcomm_sym = symbol_find_or_make (lcomm_name);
3657 *input_line_pointer = lcomm_endc;
3659 /* The fourth argument to .lcomm is the alignment. */
3660 if (*input_line_pointer != ',')
3669 ++input_line_pointer;
3670 align = get_absolute_expression ();
3673 as_warn (_("ignoring bad alignment"));
3680 sym = symbol_find_or_make (name);
3683 if (S_IS_DEFINED (sym)
3684 || S_GET_VALUE (sym) != 0)
3686 as_bad (_("attempt to redefine symbol"));
3687 ignore_rest_of_line ();
3691 record_alignment (bss_section, align);
3694 || ! S_IS_DEFINED (lcomm_sym))
3703 S_SET_EXTERNAL (sym);
3707 symbol_get_tc (lcomm_sym)->output = 1;
3708 def_sym = lcomm_sym;
3712 subseg_set (bss_section, 1);
3713 frag_align (align, 0, 0);
3715 symbol_set_frag (def_sym, frag_now);
3716 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
3717 def_size, (char *) NULL);
3719 S_SET_SEGMENT (def_sym, bss_section);
3720 symbol_get_tc (def_sym)->align = align;
3724 /* Align the size of lcomm_sym. */
3725 symbol_get_frag (lcomm_sym)->fr_offset =
3726 ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
3727 &~ ((1 << align) - 1));
3728 if (align > symbol_get_tc (lcomm_sym)->align)
3729 symbol_get_tc (lcomm_sym)->align = align;
3734 /* Make sym an offset from lcomm_sym. */
3735 S_SET_SEGMENT (sym, bss_section);
3736 symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
3737 S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
3738 symbol_get_frag (lcomm_sym)->fr_offset += size;
3741 subseg_set (current_seg, current_subseg);
3743 demand_empty_rest_of_line ();
3746 /* The .csect pseudo-op. This switches us into a different
3747 subsegment. The first argument is a symbol whose value is the
3748 start of the .csect. In COFF, csect symbols get special aux
3749 entries defined by the x_csect field of union internal_auxent. The
3750 optional second argument is the alignment (the default is 2). */
3753 ppc_csect (int ignore ATTRIBUTE_UNUSED)
3760 name = input_line_pointer;
3761 endc = get_symbol_end ();
3763 sym = symbol_find_or_make (name);
3765 *input_line_pointer = endc;
3767 if (S_GET_NAME (sym)[0] == '\0')
3769 /* An unnamed csect is assumed to be [PR]. */
3770 symbol_get_tc (sym)->symbol_class = XMC_PR;
3774 if (*input_line_pointer == ',')
3776 ++input_line_pointer;
3777 align = get_absolute_expression ();
3780 ppc_change_csect (sym, align);
3782 demand_empty_rest_of_line ();
3785 /* Change to a different csect. */
3788 ppc_change_csect (symbolS *sym, offsetT align)
3790 if (S_IS_DEFINED (sym))
3791 subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
3801 /* This is a new csect. We need to look at the symbol class to
3802 figure out whether it should go in the text section or the
3806 switch (symbol_get_tc (sym)->symbol_class)
3816 S_SET_SEGMENT (sym, text_section);
3817 symbol_get_tc (sym)->subseg = ppc_text_subsegment;
3818 ++ppc_text_subsegment;
3819 list_ptr = &ppc_text_csects;
3829 if (ppc_toc_csect != NULL
3830 && (symbol_get_tc (ppc_toc_csect)->subseg + 1
3831 == ppc_data_subsegment))
3833 S_SET_SEGMENT (sym, data_section);
3834 symbol_get_tc (sym)->subseg = ppc_data_subsegment;
3835 ++ppc_data_subsegment;
3836 list_ptr = &ppc_data_csects;
3842 /* We set the obstack chunk size to a small value before
3843 changing subsegments, so that we don't use a lot of memory
3844 space for what may be a small section. */
3845 hold_chunksize = chunksize;
3848 sec = subseg_new (segment_name (S_GET_SEGMENT (sym)),
3849 symbol_get_tc (sym)->subseg);
3851 chunksize = hold_chunksize;
3854 ppc_after_toc_frag = frag_now;
3856 record_alignment (sec, align);
3858 frag_align_code (align, 0);
3860 frag_align (align, 0, 0);
3862 symbol_set_frag (sym, frag_now);
3863 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3865 symbol_get_tc (sym)->align = align;
3866 symbol_get_tc (sym)->output = 1;
3867 symbol_get_tc (sym)->within = sym;
3869 for (list = *list_ptr;
3870 symbol_get_tc (list)->next != (symbolS *) NULL;
3871 list = symbol_get_tc (list)->next)
3873 symbol_get_tc (list)->next = sym;
3875 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3876 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3880 ppc_current_csect = sym;
3884 ppc_change_debug_section (unsigned int idx, subsegT subseg)
3888 const struct xcoff_dwsect_name *dw = &xcoff_dwsect_names[idx];
3890 sec = subseg_new (dw->name, subseg);
3891 oldflags = bfd_get_section_flags (stdoutput, sec);
3892 if (oldflags == SEC_NO_FLAGS)
3894 /* Just created section. */
3895 gas_assert (dw_sections[idx].sect == NULL);
3897 bfd_set_section_flags (stdoutput, sec, SEC_DEBUGGING);
3898 bfd_set_section_alignment (stdoutput, sec, 0);
3899 dw_sections[idx].sect = sec;
3902 /* Not anymore in a csect. */
3903 ppc_current_csect = NULL;
3906 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3907 .dwsect flag [, opt-label ]
3911 ppc_dwsect (int ignore ATTRIBUTE_UNUSED)
3915 const struct xcoff_dwsect_name *dw;
3916 struct dw_subsection *subseg;
3917 struct dw_section *dws;
3921 flag = get_absolute_expression ();
3923 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
3924 if (xcoff_dwsect_names[i].flag == flag)
3926 dw = &xcoff_dwsect_names[i];
3930 /* Parse opt-label. */
3931 if (*input_line_pointer == ',')
3936 ++input_line_pointer;
3938 label = input_line_pointer;
3939 c = get_symbol_end ();
3940 opt_label = symbol_find_or_make (label);
3941 *input_line_pointer = c;
3946 demand_empty_rest_of_line ();
3948 /* Return now in case of unknown subsection. */
3951 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3956 /* Find the subsection. */
3957 dws = &dw_sections[i];
3959 if (opt_label != NULL && S_IS_DEFINED (opt_label))
3961 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3962 if (dws->sect == NULL || S_GET_SEGMENT (opt_label) != dws->sect)
3964 as_bad (_("label %s was not defined in this dwarf section"),
3965 S_GET_NAME (opt_label));
3966 subseg = dws->anon_subseg;
3970 subseg = symbol_get_tc (opt_label)->u.dw;
3975 /* Switch to the subsection. */
3976 ppc_change_debug_section (i, subseg->subseg);
3980 /* Create a new dw subsection. */
3981 subseg = (struct dw_subsection *)
3982 xmalloc (sizeof (struct dw_subsection));
3984 if (opt_label == NULL)
3986 /* The anonymous one. */
3988 subseg->link = NULL;
3989 dws->anon_subseg = subseg;
3994 if (dws->list_subseg != NULL)
3995 subseg->subseg = dws->list_subseg->subseg + 1;
3999 subseg->link = dws->list_subseg;
4000 dws->list_subseg = subseg;
4001 symbol_get_tc (opt_label)->u.dw = subseg;
4004 ppc_change_debug_section (i, subseg->subseg);
4008 /* Add the length field. */
4009 expressionS *exp = &subseg->end_exp;
4012 if (opt_label != NULL)
4013 symbol_set_value_now (opt_label);
4015 /* Add the length field. Note that according to the AIX assembler
4016 manual, the size of the length field is 4 for powerpc32 but
4017 12 for powerpc64. */
4020 /* Write the 64bit marker. */
4021 md_number_to_chars (frag_more (4), -1, 4);
4024 exp->X_op = O_subtract;
4025 exp->X_op_symbol = symbol_temp_new_now ();
4026 exp->X_add_symbol = symbol_temp_make ();
4028 sz = ppc_obj64 ? 8 : 4;
4029 exp->X_add_number = -sz;
4030 emit_expr (exp, sz);
4035 /* This function handles the .text and .data pseudo-ops. These
4036 pseudo-ops aren't really used by XCOFF; we implement them for the
4037 convenience of people who aren't used to XCOFF. */
4040 ppc_section (int type)
4047 else if (type == 'd')
4052 sym = symbol_find_or_make (name);
4054 ppc_change_csect (sym, 2);
4056 demand_empty_rest_of_line ();
4059 /* This function handles the .section pseudo-op. This is mostly to
4060 give an error, since XCOFF only supports .text, .data and .bss, but
4061 we do permit the user to name the text or data section. */
4064 ppc_named_section (int ignore ATTRIBUTE_UNUSED)
4067 const char *real_name;
4071 user_name = input_line_pointer;
4072 c = get_symbol_end ();
4074 if (strcmp (user_name, ".text") == 0)
4075 real_name = ".text[PR]";
4076 else if (strcmp (user_name, ".data") == 0)
4077 real_name = ".data[RW]";
4080 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4081 *input_line_pointer = c;
4082 ignore_rest_of_line ();
4086 *input_line_pointer = c;
4088 sym = symbol_find_or_make (real_name);
4090 ppc_change_csect (sym, 2);
4092 demand_empty_rest_of_line ();
4095 /* The .extern pseudo-op. We create an undefined symbol. */
4098 ppc_extern (int ignore ATTRIBUTE_UNUSED)
4103 name = input_line_pointer;
4104 endc = get_symbol_end ();
4106 (void) symbol_find_or_make (name);
4108 *input_line_pointer = endc;
4110 demand_empty_rest_of_line ();
4113 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4116 ppc_lglobl (int ignore ATTRIBUTE_UNUSED)
4122 name = input_line_pointer;
4123 endc = get_symbol_end ();
4125 sym = symbol_find_or_make (name);
4127 *input_line_pointer = endc;
4129 symbol_get_tc (sym)->output = 1;
4131 demand_empty_rest_of_line ();
4134 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4135 relocations at the beginning of the current csect.
4137 (In principle, there's no reason why the relocations _have_ to be at
4138 the beginning. Anywhere in the csect would do. However, inserting
4139 at the beginning is what the native assmebler does, and it helps to
4140 deal with cases where the .ref statements follow the section contents.)
4142 ??? .refs don't work for empty .csects. However, the native assembler
4143 doesn't report an error in this case, and neither yet do we. */
4146 ppc_ref (int ignore ATTRIBUTE_UNUSED)
4151 if (ppc_current_csect == NULL)
4153 as_bad (_(".ref outside .csect"));
4154 ignore_rest_of_line ();
4160 name = input_line_pointer;
4161 c = get_symbol_end ();
4163 fix_at_start (symbol_get_frag (ppc_current_csect), 0,
4164 symbol_find_or_make (name), 0, FALSE, BFD_RELOC_NONE);
4166 *input_line_pointer = c;
4168 c = *input_line_pointer;
4171 input_line_pointer++;
4173 if (is_end_of_line[(unsigned char) *input_line_pointer])
4175 as_bad (_("missing symbol name"));
4176 ignore_rest_of_line ();
4183 demand_empty_rest_of_line ();
4186 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4187 although I don't know why it bothers. */
4190 ppc_rename (int ignore ATTRIBUTE_UNUSED)
4197 name = input_line_pointer;
4198 endc = get_symbol_end ();
4200 sym = symbol_find_or_make (name);
4202 *input_line_pointer = endc;
4204 if (*input_line_pointer != ',')
4206 as_bad (_("missing rename string"));
4207 ignore_rest_of_line ();
4210 ++input_line_pointer;
4212 symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
4214 demand_empty_rest_of_line ();
4217 /* The .stabx pseudo-op. This is similar to a normal .stabs
4218 pseudo-op, but slightly different. A sample is
4219 .stabx "main:F-1",.main,142,0
4220 The first argument is the symbol name to create. The second is the
4221 value, and the third is the storage class. The fourth seems to be
4222 always zero, and I am assuming it is the type. */
4225 ppc_stabx (int ignore ATTRIBUTE_UNUSED)
4232 name = demand_copy_C_string (&len);
4234 if (*input_line_pointer != ',')
4236 as_bad (_("missing value"));
4239 ++input_line_pointer;
4241 ppc_stab_symbol = TRUE;
4242 sym = symbol_make (name);
4243 ppc_stab_symbol = FALSE;
4245 symbol_get_tc (sym)->real_name = name;
4247 (void) expression (&exp);
4254 as_bad (_("illegal .stabx expression; zero assumed"));
4255 exp.X_add_number = 0;
4258 S_SET_VALUE (sym, (valueT) exp.X_add_number);
4259 symbol_set_frag (sym, &zero_address_frag);
4263 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
4264 symbol_set_value_expression (sym, &exp);
4268 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
4269 symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
4274 /* The value is some complex expression. This will probably
4275 fail at some later point, but this is probably the right
4276 thing to do here. */
4277 symbol_set_value_expression (sym, &exp);
4281 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4282 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4284 if (*input_line_pointer != ',')
4286 as_bad (_("missing class"));
4289 ++input_line_pointer;
4291 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
4293 if (*input_line_pointer != ',')
4295 as_bad (_("missing type"));
4298 ++input_line_pointer;
4300 S_SET_DATA_TYPE (sym, get_absolute_expression ());
4302 symbol_get_tc (sym)->output = 1;
4304 if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4309 .stabx "z",arrays_,133,0
4312 .comm arrays_,13768,3
4314 resolve_symbol_value will copy the exp's "within" into sym's when the
4315 offset is 0. Since this seems to be corner case problem,
4316 only do the correction for storage class C_STSYM. A better solution
4317 would be to have the tc field updated in ppc_symbol_new_hook. */
4319 if (exp.X_op == O_symbol)
4321 if (ppc_current_block == NULL)
4322 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4324 symbol_get_tc (sym)->within = ppc_current_block;
4325 symbol_get_tc (exp.X_add_symbol)->within = ppc_current_block;
4329 if (exp.X_op != O_symbol
4330 || ! S_IS_EXTERNAL (exp.X_add_symbol)
4331 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
4332 ppc_frob_label (sym);
4335 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4336 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
4337 if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
4338 symbol_get_tc (ppc_current_csect)->within = sym;
4341 demand_empty_rest_of_line ();
4344 /* The .function pseudo-op. This takes several arguments. The first
4345 argument seems to be the external name of the symbol. The second
4346 argument seems to be the label for the start of the function. gcc
4347 uses the same name for both. I have no idea what the third and
4348 fourth arguments are meant to be. The optional fifth argument is
4349 an expression for the size of the function. In COFF this symbol
4350 gets an aux entry like that used for a csect. */
4353 ppc_function (int ignore ATTRIBUTE_UNUSED)
4361 name = input_line_pointer;
4362 endc = get_symbol_end ();
4364 /* Ignore any [PR] suffix. */
4365 name = ppc_canonicalize_symbol_name (name);
4366 s = strchr (name, '[');
4367 if (s != (char *) NULL
4368 && strcmp (s + 1, "PR]") == 0)
4371 ext_sym = symbol_find_or_make (name);
4373 *input_line_pointer = endc;
4375 if (*input_line_pointer != ',')
4377 as_bad (_("missing symbol name"));
4378 ignore_rest_of_line ();
4381 ++input_line_pointer;
4383 name = input_line_pointer;
4384 endc = get_symbol_end ();
4386 lab_sym = symbol_find_or_make (name);
4388 *input_line_pointer = endc;
4390 if (ext_sym != lab_sym)
4394 exp.X_op = O_symbol;
4395 exp.X_add_symbol = lab_sym;
4396 exp.X_op_symbol = NULL;
4397 exp.X_add_number = 0;
4399 symbol_set_value_expression (ext_sym, &exp);
4402 if (symbol_get_tc (ext_sym)->symbol_class == -1)
4403 symbol_get_tc (ext_sym)->symbol_class = XMC_PR;
4404 symbol_get_tc (ext_sym)->output = 1;
4406 if (*input_line_pointer == ',')
4410 /* Ignore the third argument. */
4411 ++input_line_pointer;
4413 if (*input_line_pointer == ',')
4415 /* Ignore the fourth argument. */
4416 ++input_line_pointer;
4418 if (*input_line_pointer == ',')
4420 /* The fifth argument is the function size. */
4421 ++input_line_pointer;
4422 symbol_get_tc (ext_sym)->u.size = symbol_new
4423 ("L0\001", absolute_section,(valueT) 0, &zero_address_frag);
4424 pseudo_set (symbol_get_tc (ext_sym)->u.size);
4429 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
4430 SF_SET_FUNCTION (ext_sym);
4431 SF_SET_PROCESS (ext_sym);
4432 coff_add_linesym (ext_sym);
4434 demand_empty_rest_of_line ();
4437 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4438 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4439 with the correct line number */
4441 static symbolS *saved_bi_sym = 0;
4444 ppc_bf (int ignore ATTRIBUTE_UNUSED)
4448 sym = symbol_make (".bf");
4449 S_SET_SEGMENT (sym, text_section);
4450 symbol_set_frag (sym, frag_now);
4451 S_SET_VALUE (sym, frag_now_fix ());
4452 S_SET_STORAGE_CLASS (sym, C_FCN);
4454 coff_line_base = get_absolute_expression ();
4456 S_SET_NUMBER_AUXILIARY (sym, 1);
4457 SA_SET_SYM_LNNO (sym, coff_line_base);
4459 /* Line number for bi. */
4462 S_SET_VALUE (saved_bi_sym, coff_n_line_nos);
4467 symbol_get_tc (sym)->output = 1;
4469 ppc_frob_label (sym);
4471 demand_empty_rest_of_line ();
4474 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4475 ".ef", except that the line number is absolute, not relative to the
4476 most recent ".bf" symbol. */
4479 ppc_ef (int ignore ATTRIBUTE_UNUSED)
4483 sym = symbol_make (".ef");
4484 S_SET_SEGMENT (sym, text_section);
4485 symbol_set_frag (sym, frag_now);
4486 S_SET_VALUE (sym, frag_now_fix ());
4487 S_SET_STORAGE_CLASS (sym, C_FCN);
4488 S_SET_NUMBER_AUXILIARY (sym, 1);
4489 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4490 symbol_get_tc (sym)->output = 1;
4492 ppc_frob_label (sym);
4494 demand_empty_rest_of_line ();
4497 /* The .bi and .ei pseudo-ops. These take a string argument and
4498 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4499 the symbol list. The value of .bi will be know when the next .bf
4505 static symbolS *last_biei;
4512 name = demand_copy_C_string (&len);
4514 /* The value of these symbols is actually file offset. Here we set
4515 the value to the index into the line number entries. In
4516 ppc_frob_symbols we set the fix_line field, which will cause BFD
4517 to do the right thing. */
4519 sym = symbol_make (name);
4520 /* obj-coff.c currently only handles line numbers correctly in the
4522 S_SET_SEGMENT (sym, text_section);
4523 S_SET_VALUE (sym, coff_n_line_nos);
4524 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4526 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
4527 symbol_get_tc (sym)->output = 1;
4535 for (look = last_biei ? last_biei : symbol_rootP;
4536 (look != (symbolS *) NULL
4537 && (S_GET_STORAGE_CLASS (look) == C_FILE
4538 || S_GET_STORAGE_CLASS (look) == C_BINCL
4539 || S_GET_STORAGE_CLASS (look) == C_EINCL));
4540 look = symbol_next (look))
4542 if (look != (symbolS *) NULL)
4544 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4545 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
4549 demand_empty_rest_of_line ();
4552 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4553 There is one argument, which is a csect symbol. The value of the
4554 .bs symbol is the index of this csect symbol. */
4557 ppc_bs (int ignore ATTRIBUTE_UNUSED)
4564 if (ppc_current_block != NULL)
4565 as_bad (_("nested .bs blocks"));
4567 name = input_line_pointer;
4568 endc = get_symbol_end ();
4570 csect = symbol_find_or_make (name);
4572 *input_line_pointer = endc;
4574 sym = symbol_make (".bs");
4575 S_SET_SEGMENT (sym, now_seg);
4576 S_SET_STORAGE_CLASS (sym, C_BSTAT);
4577 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4578 symbol_get_tc (sym)->output = 1;
4580 symbol_get_tc (sym)->within = csect;
4582 ppc_frob_label (sym);
4584 ppc_current_block = sym;
4586 demand_empty_rest_of_line ();
4589 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4592 ppc_es (int ignore ATTRIBUTE_UNUSED)
4596 if (ppc_current_block == NULL)
4597 as_bad (_(".es without preceding .bs"));
4599 sym = symbol_make (".es");
4600 S_SET_SEGMENT (sym, now_seg);
4601 S_SET_STORAGE_CLASS (sym, C_ESTAT);
4602 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4603 symbol_get_tc (sym)->output = 1;
4605 ppc_frob_label (sym);
4607 ppc_current_block = NULL;
4609 demand_empty_rest_of_line ();
4612 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4616 ppc_bb (int ignore ATTRIBUTE_UNUSED)
4620 sym = symbol_make (".bb");
4621 S_SET_SEGMENT (sym, text_section);
4622 symbol_set_frag (sym, frag_now);
4623 S_SET_VALUE (sym, frag_now_fix ());
4624 S_SET_STORAGE_CLASS (sym, C_BLOCK);
4626 S_SET_NUMBER_AUXILIARY (sym, 1);
4627 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4629 symbol_get_tc (sym)->output = 1;
4631 SF_SET_PROCESS (sym);
4633 ppc_frob_label (sym);
4635 demand_empty_rest_of_line ();
4638 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4642 ppc_eb (int ignore ATTRIBUTE_UNUSED)
4646 sym = symbol_make (".eb");
4647 S_SET_SEGMENT (sym, text_section);
4648 symbol_set_frag (sym, frag_now);
4649 S_SET_VALUE (sym, frag_now_fix ());
4650 S_SET_STORAGE_CLASS (sym, C_BLOCK);
4651 S_SET_NUMBER_AUXILIARY (sym, 1);
4652 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4653 symbol_get_tc (sym)->output = 1;
4655 SF_SET_PROCESS (sym);
4657 ppc_frob_label (sym);
4659 demand_empty_rest_of_line ();
4662 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4666 ppc_bc (int ignore ATTRIBUTE_UNUSED)
4672 name = demand_copy_C_string (&len);
4673 sym = symbol_make (name);
4674 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4675 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4676 S_SET_STORAGE_CLASS (sym, C_BCOMM);
4677 S_SET_VALUE (sym, 0);
4678 symbol_get_tc (sym)->output = 1;
4680 ppc_frob_label (sym);
4682 demand_empty_rest_of_line ();
4685 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4688 ppc_ec (int ignore ATTRIBUTE_UNUSED)
4692 sym = symbol_make (".ec");
4693 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4694 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4695 S_SET_STORAGE_CLASS (sym, C_ECOMM);
4696 S_SET_VALUE (sym, 0);
4697 symbol_get_tc (sym)->output = 1;
4699 ppc_frob_label (sym);
4701 demand_empty_rest_of_line ();
4704 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4707 ppc_toc (int ignore ATTRIBUTE_UNUSED)
4709 if (ppc_toc_csect != (symbolS *) NULL)
4710 subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
4717 subseg = ppc_data_subsegment;
4718 ++ppc_data_subsegment;
4720 subseg_new (segment_name (data_section), subseg);
4721 ppc_toc_frag = frag_now;
4723 sym = symbol_find_or_make ("TOC[TC0]");
4724 symbol_set_frag (sym, frag_now);
4725 S_SET_SEGMENT (sym, data_section);
4726 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4727 symbol_get_tc (sym)->subseg = subseg;
4728 symbol_get_tc (sym)->output = 1;
4729 symbol_get_tc (sym)->within = sym;
4731 ppc_toc_csect = sym;
4733 for (list = ppc_data_csects;
4734 symbol_get_tc (list)->next != (symbolS *) NULL;
4735 list = symbol_get_tc (list)->next)
4737 symbol_get_tc (list)->next = sym;
4739 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4740 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
4744 ppc_current_csect = ppc_toc_csect;
4746 demand_empty_rest_of_line ();
4749 /* The AIX assembler automatically aligns the operands of a .long or
4750 .short pseudo-op, and we want to be compatible. */
4753 ppc_xcoff_cons (int log_size)
4755 frag_align (log_size, 0, 0);
4756 record_alignment (now_seg, log_size);
4757 cons (1 << log_size);
4761 ppc_vbyte (int dummy ATTRIBUTE_UNUSED)
4766 (void) expression (&exp);
4768 if (exp.X_op != O_constant)
4770 as_bad (_("non-constant byte count"));
4774 byte_count = exp.X_add_number;
4776 if (*input_line_pointer != ',')
4778 as_bad (_("missing value"));
4782 ++input_line_pointer;
4787 ppc_xcoff_end (void)
4791 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
4793 struct dw_section *dws = &dw_sections[i];
4794 struct dw_subsection *dwss;
4796 if (dws->anon_subseg)
4798 dwss = dws->anon_subseg;
4799 dwss->link = dws->list_subseg;
4802 dwss = dws->list_subseg;
4804 for (; dwss != NULL; dwss = dwss->link)
4805 if (dwss->end_exp.X_add_symbol != NULL)
4807 subseg_set (dws->sect, dwss->subseg);
4808 symbol_set_value_now (dwss->end_exp.X_add_symbol);
4813 #endif /* OBJ_XCOFF */
4814 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4816 /* The .tc pseudo-op. This is used when generating either XCOFF or
4817 ELF. This takes two or more arguments.
4819 When generating XCOFF output, the first argument is the name to
4820 give to this location in the toc; this will be a symbol with class
4821 TC. The rest of the arguments are N-byte values to actually put at
4822 this location in the TOC; often there is just one more argument, a
4823 relocatable symbol reference. The size of the value to store
4824 depends on target word size. A 32-bit target uses 4-byte values, a
4825 64-bit target uses 8-byte values.
4827 When not generating XCOFF output, the arguments are the same, but
4828 the first argument is simply ignored. */
4831 ppc_tc (int ignore ATTRIBUTE_UNUSED)
4835 /* Define the TOC symbol name. */
4841 if (ppc_toc_csect == (symbolS *) NULL
4842 || ppc_toc_csect != ppc_current_csect)
4844 as_bad (_(".tc not in .toc section"));
4845 ignore_rest_of_line ();
4849 name = input_line_pointer;
4850 endc = get_symbol_end ();
4852 sym = symbol_find_or_make (name);
4854 *input_line_pointer = endc;
4856 if (S_IS_DEFINED (sym))
4860 label = symbol_get_tc (ppc_current_csect)->within;
4861 if (symbol_get_tc (label)->symbol_class != XMC_TC0)
4863 as_bad (_(".tc with no label"));
4864 ignore_rest_of_line ();
4868 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
4869 symbol_set_frag (label, symbol_get_frag (sym));
4870 S_SET_VALUE (label, S_GET_VALUE (sym));
4872 while (! is_end_of_line[(unsigned char) *input_line_pointer])
4873 ++input_line_pointer;
4878 S_SET_SEGMENT (sym, now_seg);
4879 symbol_set_frag (sym, frag_now);
4880 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4881 symbol_get_tc (sym)->symbol_class = XMC_TC;
4882 symbol_get_tc (sym)->output = 1;
4884 ppc_frob_label (sym);
4887 #endif /* OBJ_XCOFF */
4891 /* Skip the TOC symbol name. */
4892 while (is_part_of_name (*input_line_pointer)
4893 || *input_line_pointer == ' '
4894 || *input_line_pointer == '['
4895 || *input_line_pointer == ']'
4896 || *input_line_pointer == '{'
4897 || *input_line_pointer == '}')
4898 ++input_line_pointer;
4900 /* Align to a four/eight byte boundary. */
4901 align = ppc_obj64 ? 3 : 2;
4902 frag_align (align, 0, 0);
4903 record_alignment (now_seg, align);
4904 #endif /* OBJ_ELF */
4906 if (*input_line_pointer != ',')
4907 demand_empty_rest_of_line ();
4910 ++input_line_pointer;
4911 cons (ppc_obj64 ? 8 : 4);
4915 /* Pseudo-op .machine. */
4918 ppc_machine (int ignore ATTRIBUTE_UNUSED)
4921 #define MAX_HISTORY 100
4922 static ppc_cpu_t *cpu_history;
4923 static int curr_hist;
4927 if (*input_line_pointer == '"')
4930 cpu_string = demand_copy_C_string (&len);
4935 cpu_string = input_line_pointer;
4936 c = get_symbol_end ();
4937 cpu_string = xstrdup (cpu_string);
4938 *input_line_pointer = c;
4941 if (cpu_string != NULL)
4943 ppc_cpu_t old_cpu = ppc_cpu;
4947 for (p = cpu_string; *p != 0; p++)
4950 if (strcmp (cpu_string, "push") == 0)
4952 if (cpu_history == NULL)
4953 cpu_history = xmalloc (MAX_HISTORY * sizeof (*cpu_history));
4955 if (curr_hist >= MAX_HISTORY)
4956 as_bad (_(".machine stack overflow"));
4958 cpu_history[curr_hist++] = ppc_cpu;
4960 else if (strcmp (cpu_string, "pop") == 0)
4963 as_bad (_(".machine stack underflow"));
4965 ppc_cpu = cpu_history[--curr_hist];
4967 else if ((new_cpu = ppc_parse_cpu (ppc_cpu, &sticky, cpu_string)) != 0)
4970 as_bad (_("invalid machine `%s'"), cpu_string);
4972 if (ppc_cpu != old_cpu)
4973 ppc_setup_opcodes ();
4976 demand_empty_rest_of_line ();
4978 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4982 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4984 /* Set the current section. */
4986 ppc_set_current_section (segT new)
4988 ppc_previous_section = ppc_current_section;
4989 ppc_current_section = new;
4992 /* pseudo-op: .previous
4993 behaviour: toggles the current section with the previous section.
4995 warnings: "No previous section" */
4998 ppc_previous (int ignore ATTRIBUTE_UNUSED)
5000 if (ppc_previous_section == NULL)
5002 as_warn (_("no previous section to return to, ignored."));
5006 subseg_set (ppc_previous_section, 0);
5008 ppc_set_current_section (ppc_previous_section);
5011 /* pseudo-op: .pdata
5012 behaviour: predefined read only data section
5016 initial: .section .pdata "adr3"
5017 a - don't know -- maybe a misprint
5018 d - initialized data
5020 3 - double word aligned (that would be 4 byte boundary)
5023 Tag index tables (also known as the function table) for exception
5024 handling, debugging, etc. */
5027 ppc_pdata (int ignore ATTRIBUTE_UNUSED)
5029 if (pdata_section == 0)
5031 pdata_section = subseg_new (".pdata", 0);
5033 bfd_set_section_flags (stdoutput, pdata_section,
5034 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5035 | SEC_READONLY | SEC_DATA ));
5037 bfd_set_section_alignment (stdoutput, pdata_section, 2);
5041 pdata_section = subseg_new (".pdata", 0);
5043 ppc_set_current_section (pdata_section);
5046 /* pseudo-op: .ydata
5047 behaviour: predefined read only data section
5051 initial: .section .ydata "drw3"
5052 a - don't know -- maybe a misprint
5053 d - initialized data
5055 3 - double word aligned (that would be 4 byte boundary)
5057 Tag tables (also known as the scope table) for exception handling,
5061 ppc_ydata (int ignore ATTRIBUTE_UNUSED)
5063 if (ydata_section == 0)
5065 ydata_section = subseg_new (".ydata", 0);
5066 bfd_set_section_flags (stdoutput, ydata_section,
5067 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5068 | SEC_READONLY | SEC_DATA ));
5070 bfd_set_section_alignment (stdoutput, ydata_section, 3);
5074 ydata_section = subseg_new (".ydata", 0);
5076 ppc_set_current_section (ydata_section);
5079 /* pseudo-op: .reldata
5080 behaviour: predefined read write data section
5081 double word aligned (4-byte)
5082 FIXME: relocation is applied to it
5083 FIXME: what's the difference between this and .data?
5086 initial: .section .reldata "drw3"
5087 d - initialized data
5090 3 - double word aligned (that would be 8 byte boundary)
5093 Like .data, but intended to hold data subject to relocation, such as
5094 function descriptors, etc. */
5097 ppc_reldata (int ignore ATTRIBUTE_UNUSED)
5099 if (reldata_section == 0)
5101 reldata_section = subseg_new (".reldata", 0);
5103 bfd_set_section_flags (stdoutput, reldata_section,
5104 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5107 bfd_set_section_alignment (stdoutput, reldata_section, 2);
5111 reldata_section = subseg_new (".reldata", 0);
5113 ppc_set_current_section (reldata_section);
5116 /* pseudo-op: .rdata
5117 behaviour: predefined read only data section
5121 initial: .section .rdata "dr3"
5122 d - initialized data
5124 3 - double word aligned (that would be 4 byte boundary) */
5127 ppc_rdata (int ignore ATTRIBUTE_UNUSED)
5129 if (rdata_section == 0)
5131 rdata_section = subseg_new (".rdata", 0);
5132 bfd_set_section_flags (stdoutput, rdata_section,
5133 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5134 | SEC_READONLY | SEC_DATA ));
5136 bfd_set_section_alignment (stdoutput, rdata_section, 2);
5140 rdata_section = subseg_new (".rdata", 0);
5142 ppc_set_current_section (rdata_section);
5145 /* pseudo-op: .ualong
5146 behaviour: much like .int, with the exception that no alignment is
5148 FIXME: test the alignment statement
5153 ppc_ualong (int ignore ATTRIBUTE_UNUSED)
5159 /* pseudo-op: .znop <symbol name>
5160 behaviour: Issue a nop instruction
5161 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5162 the supplied symbol name.
5164 warnings: Missing symbol name */
5167 ppc_znop (int ignore ATTRIBUTE_UNUSED)
5170 const struct powerpc_opcode *opcode;
5177 /* Strip out the symbol name. */
5178 symbol_name = input_line_pointer;
5179 c = get_symbol_end ();
5181 name = xmalloc (input_line_pointer - symbol_name + 1);
5182 strcpy (name, symbol_name);
5184 sym = symbol_find_or_make (name);
5186 *input_line_pointer = c;
5190 /* Look up the opcode in the hash table. */
5191 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
5193 /* Stick in the nop. */
5194 insn = opcode->opcode;
5196 /* Write out the instruction. */
5198 md_number_to_chars (f, insn, 4);
5200 f - frag_now->fr_literal,
5205 BFD_RELOC_16_GOT_PCREL);
5215 ppc_pe_comm (int lcomm)
5224 name = input_line_pointer;
5225 c = get_symbol_end ();
5227 /* just after name is now '\0'. */
5228 p = input_line_pointer;
5231 if (*input_line_pointer != ',')
5233 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5234 ignore_rest_of_line ();
5238 input_line_pointer++; /* skip ',' */
5239 if ((temp = get_absolute_expression ()) < 0)
5241 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
5242 ignore_rest_of_line ();
5248 /* The third argument to .comm is the alignment. */
5249 if (*input_line_pointer != ',')
5253 ++input_line_pointer;
5254 align = get_absolute_expression ();
5257 as_warn (_("ignoring bad alignment"));
5264 symbolP = symbol_find_or_make (name);
5267 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
5269 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5270 S_GET_NAME (symbolP));
5271 ignore_rest_of_line ();
5275 if (S_GET_VALUE (symbolP))
5277 if (S_GET_VALUE (symbolP) != (valueT) temp)
5278 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5279 S_GET_NAME (symbolP),
5280 (long) S_GET_VALUE (symbolP),
5285 S_SET_VALUE (symbolP, (valueT) temp);
5286 S_SET_EXTERNAL (symbolP);
5287 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
5290 demand_empty_rest_of_line ();
5294 * implement the .section pseudo op:
5295 * .section name {, "flags"}
5297 * | +--- optional flags: 'b' for bss
5299 * +-- section name 'l' for lib
5303 * 'd' (apparently m88k for data)
5305 * But if the argument is not a quoted string, treat it as a
5306 * subsegment number.
5308 * FIXME: this is a copy of the section processing from obj-coff.c, with
5309 * additions/changes for the moto-pas assembler support. There are three
5312 * FIXME: I just noticed this. This doesn't work at all really. It it
5313 * setting bits that bfd probably neither understands or uses. The
5314 * correct approach (?) will have to incorporate extra fields attached
5315 * to the section to hold the system specific stuff. (krk)
5318 * 'a' - unknown - referred to in documentation, but no definition supplied
5319 * 'c' - section has code
5320 * 'd' - section has initialized data
5321 * 'u' - section has uninitialized data
5322 * 'i' - section contains directives (info)
5323 * 'n' - section can be discarded
5324 * 'R' - remove section at link time
5326 * Section Protection:
5327 * 'r' - section is readable
5328 * 'w' - section is writeable
5329 * 'x' - section is executable
5330 * 's' - section is sharable
5332 * Section Alignment:
5333 * '0' - align to byte boundary
5334 * '1' - align to halfword undary
5335 * '2' - align to word boundary
5336 * '3' - align to doubleword boundary
5337 * '4' - align to quadword boundary
5338 * '5' - align to 32 byte boundary
5339 * '6' - align to 64 byte boundary
5344 ppc_pe_section (int ignore ATTRIBUTE_UNUSED)
5346 /* Strip out the section name. */
5355 section_name = input_line_pointer;
5356 c = get_symbol_end ();
5358 name = xmalloc (input_line_pointer - section_name + 1);
5359 strcpy (name, section_name);
5361 *input_line_pointer = c;
5366 flags = SEC_NO_FLAGS;
5368 if (strcmp (name, ".idata$2") == 0)
5372 else if (strcmp (name, ".idata$3") == 0)
5376 else if (strcmp (name, ".idata$4") == 0)
5380 else if (strcmp (name, ".idata$5") == 0)
5384 else if (strcmp (name, ".idata$6") == 0)
5389 /* Default alignment to 16 byte boundary. */
5392 if (*input_line_pointer == ',')
5394 ++input_line_pointer;
5396 if (*input_line_pointer != '"')
5397 exp = get_absolute_expression ();
5400 ++input_line_pointer;
5401 while (*input_line_pointer != '"'
5402 && ! is_end_of_line[(unsigned char) *input_line_pointer])
5404 switch (*input_line_pointer)
5406 /* Section Contents */
5407 case 'a': /* unknown */
5408 as_bad (_("unsupported section attribute -- 'a'"));
5410 case 'c': /* code section */
5413 case 'd': /* section has initialized data */
5416 case 'u': /* section has uninitialized data */
5417 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5421 case 'i': /* section contains directives (info) */
5422 /* FIXME: This is IMAGE_SCN_LNK_INFO
5424 flags |= SEC_HAS_CONTENTS;
5426 case 'n': /* section can be discarded */
5429 case 'R': /* Remove section at link time */
5430 flags |= SEC_NEVER_LOAD;
5432 #if IFLICT_BRAIN_DAMAGE
5433 /* Section Protection */
5434 case 'r': /* section is readable */
5435 flags |= IMAGE_SCN_MEM_READ;
5437 case 'w': /* section is writeable */
5438 flags |= IMAGE_SCN_MEM_WRITE;
5440 case 'x': /* section is executable */
5441 flags |= IMAGE_SCN_MEM_EXECUTE;
5443 case 's': /* section is sharable */
5444 flags |= IMAGE_SCN_MEM_SHARED;
5447 /* Section Alignment */
5448 case '0': /* align to byte boundary */
5449 flags |= IMAGE_SCN_ALIGN_1BYTES;
5452 case '1': /* align to halfword boundary */
5453 flags |= IMAGE_SCN_ALIGN_2BYTES;
5456 case '2': /* align to word boundary */
5457 flags |= IMAGE_SCN_ALIGN_4BYTES;
5460 case '3': /* align to doubleword boundary */
5461 flags |= IMAGE_SCN_ALIGN_8BYTES;
5464 case '4': /* align to quadword boundary */
5465 flags |= IMAGE_SCN_ALIGN_16BYTES;
5468 case '5': /* align to 32 byte boundary */
5469 flags |= IMAGE_SCN_ALIGN_32BYTES;
5472 case '6': /* align to 64 byte boundary */
5473 flags |= IMAGE_SCN_ALIGN_64BYTES;
5478 as_bad (_("unknown section attribute '%c'"),
5479 *input_line_pointer);
5482 ++input_line_pointer;
5484 if (*input_line_pointer == '"')
5485 ++input_line_pointer;
5489 sec = subseg_new (name, (subsegT) exp);
5491 ppc_set_current_section (sec);
5493 if (flags != SEC_NO_FLAGS)
5495 if (! bfd_set_section_flags (stdoutput, sec, flags))
5496 as_bad (_("error setting flags for \"%s\": %s"),
5497 bfd_section_name (stdoutput, sec),
5498 bfd_errmsg (bfd_get_error ()));
5501 bfd_set_section_alignment (stdoutput, sec, align);
5505 ppc_pe_function (int ignore ATTRIBUTE_UNUSED)
5511 name = input_line_pointer;
5512 endc = get_symbol_end ();
5514 ext_sym = symbol_find_or_make (name);
5516 *input_line_pointer = endc;
5518 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
5519 SF_SET_FUNCTION (ext_sym);
5520 SF_SET_PROCESS (ext_sym);
5521 coff_add_linesym (ext_sym);
5523 demand_empty_rest_of_line ();
5527 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED)
5529 if (tocdata_section == 0)
5531 tocdata_section = subseg_new (".tocd", 0);
5532 /* FIXME: section flags won't work. */
5533 bfd_set_section_flags (stdoutput, tocdata_section,
5534 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5535 | SEC_READONLY | SEC_DATA));
5537 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
5541 rdata_section = subseg_new (".tocd", 0);
5544 ppc_set_current_section (tocdata_section);
5546 demand_empty_rest_of_line ();
5549 /* Don't adjust TOC relocs to use the section symbol. */
5552 ppc_pe_fix_adjustable (fixS *fix)
5554 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
5561 /* XCOFF specific symbol and file handling. */
5563 /* Canonicalize the symbol name. We use the to force the suffix, if
5564 any, to use square brackets, and to be in upper case. */
5567 ppc_canonicalize_symbol_name (char *name)
5571 if (ppc_stab_symbol)
5574 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
5588 for (s++; *s != '\0' && *s != brac; s++)
5591 if (*s == '\0' || s[1] != '\0')
5592 as_bad (_("bad symbol suffix"));
5600 /* Set the class of a symbol based on the suffix, if any. This is
5601 called whenever a new symbol is created. */
5604 ppc_symbol_new_hook (symbolS *sym)
5606 struct ppc_tc_sy *tc;
5609 tc = symbol_get_tc (sym);
5612 tc->symbol_class = -1;
5613 tc->real_name = NULL;
5620 if (ppc_stab_symbol)
5623 s = strchr (S_GET_NAME (sym), '[');
5624 if (s == (const char *) NULL)
5626 /* There is no suffix. */
5635 if (strcmp (s, "BS]") == 0)
5636 tc->symbol_class = XMC_BS;
5639 if (strcmp (s, "DB]") == 0)
5640 tc->symbol_class = XMC_DB;
5641 else if (strcmp (s, "DS]") == 0)
5642 tc->symbol_class = XMC_DS;
5645 if (strcmp (s, "GL]") == 0)
5646 tc->symbol_class = XMC_GL;
5649 if (strcmp (s, "PR]") == 0)
5650 tc->symbol_class = XMC_PR;
5653 if (strcmp (s, "RO]") == 0)
5654 tc->symbol_class = XMC_RO;
5655 else if (strcmp (s, "RW]") == 0)
5656 tc->symbol_class = XMC_RW;
5659 if (strcmp (s, "SV]") == 0)
5660 tc->symbol_class = XMC_SV;
5663 if (strcmp (s, "TC]") == 0)
5664 tc->symbol_class = XMC_TC;
5665 else if (strcmp (s, "TI]") == 0)
5666 tc->symbol_class = XMC_TI;
5667 else if (strcmp (s, "TB]") == 0)
5668 tc->symbol_class = XMC_TB;
5669 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
5670 tc->symbol_class = XMC_TC0;
5673 if (strcmp (s, "UA]") == 0)
5674 tc->symbol_class = XMC_UA;
5675 else if (strcmp (s, "UC]") == 0)
5676 tc->symbol_class = XMC_UC;
5679 if (strcmp (s, "XO]") == 0)
5680 tc->symbol_class = XMC_XO;
5684 if (tc->symbol_class == -1)
5685 as_bad (_("unrecognized symbol suffix"));
5688 /* Set the class of a label based on where it is defined. This
5689 handles symbols without suffixes. Also, move the symbol so that it
5690 follows the csect symbol. */
5693 ppc_frob_label (symbolS *sym)
5695 if (ppc_current_csect != (symbolS *) NULL)
5697 if (symbol_get_tc (sym)->symbol_class == -1)
5698 symbol_get_tc (sym)->symbol_class = symbol_get_tc (ppc_current_csect)->symbol_class;
5700 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
5701 symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
5702 &symbol_rootP, &symbol_lastP);
5703 symbol_get_tc (ppc_current_csect)->within = sym;
5704 symbol_get_tc (sym)->within = ppc_current_csect;
5708 dwarf2_emit_label (sym);
5712 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5713 seen. It tells ppc_adjust_symtab whether it needs to look through
5716 static bfd_boolean ppc_saw_abs;
5718 /* Change the name of a symbol just before writing it out. Set the
5719 real name if the .rename pseudo-op was used. Otherwise, remove any
5720 class suffix. Return 1 if the symbol should not be included in the
5724 ppc_frob_symbol (symbolS *sym)
5726 static symbolS *ppc_last_function;
5727 static symbolS *set_end;
5729 /* Discard symbols that should not be included in the output symbol
5731 if (! symbol_used_in_reloc_p (sym)
5732 && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
5733 || (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
5734 && ! symbol_get_tc (sym)->output
5735 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
5738 /* This one will disappear anyway. Don't make a csect sym for it. */
5739 if (sym == abs_section_sym)
5742 if (symbol_get_tc (sym)->real_name != (char *) NULL)
5743 S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
5749 name = S_GET_NAME (sym);
5750 s = strchr (name, '[');
5751 if (s != (char *) NULL)
5757 snew = xmalloc (len + 1);
5758 memcpy (snew, name, len);
5761 S_SET_NAME (sym, snew);
5765 if (set_end != (symbolS *) NULL)
5767 SA_SET_SYM_ENDNDX (set_end, sym);
5771 if (SF_GET_FUNCTION (sym))
5773 if (ppc_last_function != (symbolS *) NULL)
5774 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5775 ppc_last_function = sym;
5776 if (symbol_get_tc (sym)->u.size != (symbolS *) NULL)
5778 resolve_symbol_value (symbol_get_tc (sym)->u.size);
5779 SA_SET_SYM_FSIZE (sym,
5780 (long) S_GET_VALUE (symbol_get_tc (sym)->u.size));
5783 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
5784 && strcmp (S_GET_NAME (sym), ".ef") == 0)
5786 if (ppc_last_function == (symbolS *) NULL)
5787 as_bad (_(".ef with no preceding .function"));
5790 set_end = ppc_last_function;
5791 ppc_last_function = NULL;
5793 /* We don't have a C_EFCN symbol, but we need to force the
5794 COFF backend to believe that it has seen one. */
5795 coff_last_function = NULL;
5799 if (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
5800 && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
5801 && S_GET_STORAGE_CLASS (sym) != C_FILE
5802 && S_GET_STORAGE_CLASS (sym) != C_FCN
5803 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
5804 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
5805 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
5806 && S_GET_STORAGE_CLASS (sym) != C_BINCL
5807 && S_GET_STORAGE_CLASS (sym) != C_EINCL
5808 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
5809 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
5811 if (S_GET_STORAGE_CLASS (sym) == C_EXT
5812 || S_GET_STORAGE_CLASS (sym) == C_AIX_WEAKEXT
5813 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
5816 union internal_auxent *a;
5818 /* Create a csect aux. */
5819 i = S_GET_NUMBER_AUXILIARY (sym);
5820 S_SET_NUMBER_AUXILIARY (sym, i + 1);
5821 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
5822 if (symbol_get_tc (sym)->symbol_class == XMC_TC0)
5824 /* This is the TOC table. */
5825 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
5826 a->x_csect.x_scnlen.l = 0;
5827 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5829 else if (symbol_get_tc (sym)->subseg != 0)
5831 /* This is a csect symbol. x_scnlen is the size of the
5833 if (symbol_get_tc (sym)->next == (symbolS *) NULL)
5834 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5835 S_GET_SEGMENT (sym))
5836 - S_GET_VALUE (sym));
5839 resolve_symbol_value (symbol_get_tc (sym)->next);
5840 a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
5841 - S_GET_VALUE (sym));
5843 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
5845 else if (S_GET_SEGMENT (sym) == bss_section)
5847 /* This is a common symbol. */
5848 a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
5849 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
5850 if (S_IS_EXTERNAL (sym))
5851 symbol_get_tc (sym)->symbol_class = XMC_RW;
5853 symbol_get_tc (sym)->symbol_class = XMC_BS;
5855 else if (S_GET_SEGMENT (sym) == absolute_section)
5857 /* This is an absolute symbol. The csect will be created by
5858 ppc_adjust_symtab. */
5860 a->x_csect.x_smtyp = XTY_LD;
5861 if (symbol_get_tc (sym)->symbol_class == -1)
5862 symbol_get_tc (sym)->symbol_class = XMC_XO;
5864 else if (! S_IS_DEFINED (sym))
5866 /* This is an external symbol. */
5867 a->x_csect.x_scnlen.l = 0;
5868 a->x_csect.x_smtyp = XTY_ER;
5870 else if (symbol_get_tc (sym)->symbol_class == XMC_TC)
5874 /* This is a TOC definition. x_scnlen is the size of the
5876 next = symbol_next (sym);
5877 while (symbol_get_tc (next)->symbol_class == XMC_TC0)
5878 next = symbol_next (next);
5879 if (next == (symbolS *) NULL
5880 || symbol_get_tc (next)->symbol_class != XMC_TC)
5882 if (ppc_after_toc_frag == (fragS *) NULL)
5883 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5885 - S_GET_VALUE (sym));
5887 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
5888 - S_GET_VALUE (sym));
5892 resolve_symbol_value (next);
5893 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
5894 - S_GET_VALUE (sym));
5896 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5902 /* This is a normal symbol definition. x_scnlen is the
5903 symbol index of the containing csect. */
5904 if (S_GET_SEGMENT (sym) == text_section)
5905 csect = ppc_text_csects;
5906 else if (S_GET_SEGMENT (sym) == data_section)
5907 csect = ppc_data_csects;
5911 /* Skip the initial dummy symbol. */
5912 csect = symbol_get_tc (csect)->next;
5914 if (csect == (symbolS *) NULL)
5916 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
5917 a->x_csect.x_scnlen.l = 0;
5921 while (symbol_get_tc (csect)->next != (symbolS *) NULL)
5923 resolve_symbol_value (symbol_get_tc (csect)->next);
5924 if (S_GET_VALUE (symbol_get_tc (csect)->next)
5925 > S_GET_VALUE (sym))
5927 csect = symbol_get_tc (csect)->next;
5930 a->x_csect.x_scnlen.p =
5931 coffsymbol (symbol_get_bfdsym (csect))->native;
5932 coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
5935 a->x_csect.x_smtyp = XTY_LD;
5938 a->x_csect.x_parmhash = 0;
5939 a->x_csect.x_snhash = 0;
5940 if (symbol_get_tc (sym)->symbol_class == -1)
5941 a->x_csect.x_smclas = XMC_PR;
5943 a->x_csect.x_smclas = symbol_get_tc (sym)->symbol_class;
5944 a->x_csect.x_stab = 0;
5945 a->x_csect.x_snstab = 0;
5947 /* Don't let the COFF backend resort these symbols. */
5948 symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
5950 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
5952 /* We want the value to be the symbol index of the referenced
5953 csect symbol. BFD will do that for us if we set the right
5955 asymbol *bsym = symbol_get_bfdsym (symbol_get_tc (sym)->within);
5956 combined_entry_type *c = coffsymbol (bsym)->native;
5958 S_SET_VALUE (sym, (valueT) (size_t) c);
5959 coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
5961 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
5966 block = symbol_get_tc (sym)->within;
5969 /* The value is the offset from the enclosing csect. */
5972 csect = symbol_get_tc (block)->within;
5973 resolve_symbol_value (csect);
5974 base = S_GET_VALUE (csect);
5979 S_SET_VALUE (sym, S_GET_VALUE (sym) - base);
5981 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
5982 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
5984 /* We want the value to be a file offset into the line numbers.
5985 BFD will do that for us if we set the right flags. We have
5986 already set the value correctly. */
5987 coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
5993 /* Adjust the symbol table. This creates csect symbols for all
5994 absolute symbols. */
5997 ppc_adjust_symtab (void)
6004 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
6008 union internal_auxent *a;
6010 if (S_GET_SEGMENT (sym) != absolute_section)
6013 csect = symbol_create (".abs[XO]", absolute_section,
6014 S_GET_VALUE (sym), &zero_address_frag);
6015 symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
6016 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
6017 i = S_GET_NUMBER_AUXILIARY (csect);
6018 S_SET_NUMBER_AUXILIARY (csect, i + 1);
6019 a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
6020 a->x_csect.x_scnlen.l = 0;
6021 a->x_csect.x_smtyp = XTY_SD;
6022 a->x_csect.x_parmhash = 0;
6023 a->x_csect.x_snhash = 0;
6024 a->x_csect.x_smclas = XMC_XO;
6025 a->x_csect.x_stab = 0;
6026 a->x_csect.x_snstab = 0;
6028 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
6030 i = S_GET_NUMBER_AUXILIARY (sym);
6031 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
6032 a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
6033 coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
6036 ppc_saw_abs = FALSE;
6039 /* Set the VMA for a section. This is called on all the sections in
6043 ppc_frob_section (asection *sec)
6045 static bfd_vma vma = 0;
6047 /* Dwarf sections start at 0. */
6048 if (bfd_get_section_flags (NULL, sec) & SEC_DEBUGGING)
6051 vma = md_section_align (sec, vma);
6052 bfd_set_section_vma (stdoutput, sec, vma);
6053 vma += bfd_section_size (stdoutput, sec);
6056 #endif /* OBJ_XCOFF */
6059 md_atof (int type, char *litp, int *sizep)
6061 return ieee_md_atof (type, litp, sizep, target_big_endian);
6064 /* Write a value out to the object file, using the appropriate
6068 md_number_to_chars (char *buf, valueT val, int n)
6070 if (target_big_endian)
6071 number_to_chars_bigendian (buf, val, n);
6073 number_to_chars_littleendian (buf, val, n);
6076 /* Align a section (I don't know why this is machine dependent). */
6079 md_section_align (asection *seg ATTRIBUTE_UNUSED, valueT addr)
6084 int align = bfd_get_section_alignment (stdoutput, seg);
6086 return ((addr + (1 << align) - 1) & (-1 << align));
6090 /* We don't have any form of relaxing. */
6093 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
6094 asection *seg ATTRIBUTE_UNUSED)
6100 /* Convert a machine dependent frag. We never generate these. */
6103 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
6104 asection *sec ATTRIBUTE_UNUSED,
6105 fragS *fragp ATTRIBUTE_UNUSED)
6110 /* We have no need to default values of symbols. */
6113 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
6118 /* Functions concerning relocs. */
6120 /* The location from which a PC relative jump should be calculated,
6121 given a PC relative reloc. */
6124 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
6126 return fixp->fx_frag->fr_address + fixp->fx_where;
6131 /* This is called to see whether a fixup should be adjusted to use a
6132 section symbol. We take the opportunity to change a fixup against
6133 a symbol in the TOC subsegment into a reloc against the
6134 corresponding .tc symbol. */
6137 ppc_fix_adjustable (fixS *fix)
6139 valueT val = resolve_symbol_value (fix->fx_addsy);
6140 segT symseg = S_GET_SEGMENT (fix->fx_addsy);
6141 TC_SYMFIELD_TYPE *tc;
6143 if (symseg == absolute_section)
6146 /* Always adjust symbols in debugging sections. */
6147 if (bfd_get_section_flags (stdoutput, symseg) & SEC_DEBUGGING)
6150 if (ppc_toc_csect != (symbolS *) NULL
6151 && fix->fx_addsy != ppc_toc_csect
6152 && symseg == data_section
6153 && val >= ppc_toc_frag->fr_address
6154 && (ppc_after_toc_frag == (fragS *) NULL
6155 || val < ppc_after_toc_frag->fr_address))
6159 for (sy = symbol_next (ppc_toc_csect);
6160 sy != (symbolS *) NULL;
6161 sy = symbol_next (sy))
6163 TC_SYMFIELD_TYPE *sy_tc = symbol_get_tc (sy);
6165 if (sy_tc->symbol_class == XMC_TC0)
6167 if (sy_tc->symbol_class != XMC_TC)
6169 if (val == resolve_symbol_value (sy))
6172 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
6177 as_bad_where (fix->fx_file, fix->fx_line,
6178 _("symbol in .toc does not match any .tc"));
6181 /* Possibly adjust the reloc to be against the csect. */
6182 tc = symbol_get_tc (fix->fx_addsy);
6184 && tc->symbol_class != XMC_TC0
6185 && tc->symbol_class != XMC_TC
6186 && symseg != bss_section
6187 /* Don't adjust if this is a reloc in the toc section. */
6188 && (symseg != data_section
6189 || ppc_toc_csect == NULL
6190 || val < ppc_toc_frag->fr_address
6191 || (ppc_after_toc_frag != NULL
6192 && val >= ppc_after_toc_frag->fr_address)))
6194 symbolS *csect = tc->within;
6196 /* If the symbol was not declared by a label (eg: a section symbol),
6197 use the section instead of the csect. This doesn't happen in
6198 normal AIX assembly code. */
6200 csect = seg_info (symseg)->sym;
6202 fix->fx_offset += val - symbol_get_frag (csect)->fr_address;
6203 fix->fx_addsy = csect;
6208 /* Adjust a reloc against a .lcomm symbol to be against the base
6210 if (symseg == bss_section
6211 && ! S_IS_EXTERNAL (fix->fx_addsy))
6213 symbolS *sy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
6215 fix->fx_offset += val - resolve_symbol_value (sy);
6222 /* A reloc from one csect to another must be kept. The assembler
6223 will, of course, keep relocs between sections, and it will keep
6224 absolute relocs, but we need to force it to keep PC relative relocs
6225 between two csects in the same section. */
6228 ppc_force_relocation (fixS *fix)
6230 /* At this point fix->fx_addsy should already have been converted to
6231 a csect symbol. If the csect does not include the fragment, then
6232 we need to force the relocation. */
6234 && fix->fx_addsy != NULL
6235 && symbol_get_tc (fix->fx_addsy)->subseg != 0
6236 && ((symbol_get_frag (fix->fx_addsy)->fr_address
6237 > fix->fx_frag->fr_address)
6238 || (symbol_get_tc (fix->fx_addsy)->next != NULL
6239 && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
6240 <= fix->fx_frag->fr_address))))
6243 return generic_force_reloc (fix);
6247 ppc_new_dot_label (symbolS *sym)
6249 /* Anchor this label to the current csect for relocations. */
6250 symbol_get_tc (sym)->within = ppc_current_csect;
6253 #endif /* OBJ_XCOFF */
6256 /* If this function returns non-zero, it guarantees that a relocation
6257 will be emitted for a fixup. */
6260 ppc_force_relocation (fixS *fix)
6262 /* Branch prediction relocations must force a relocation, as must
6263 the vtable description relocs. */
6264 switch (fix->fx_r_type)
6266 case BFD_RELOC_PPC_B16_BRTAKEN:
6267 case BFD_RELOC_PPC_B16_BRNTAKEN:
6268 case BFD_RELOC_PPC_BA16_BRTAKEN:
6269 case BFD_RELOC_PPC_BA16_BRNTAKEN:
6270 case BFD_RELOC_24_PLT_PCREL:
6271 case BFD_RELOC_PPC64_TOC:
6273 case BFD_RELOC_PPC_B26:
6274 case BFD_RELOC_PPC_BA26:
6275 case BFD_RELOC_PPC_B16:
6276 case BFD_RELOC_PPC_BA16:
6277 /* All branch fixups targeting a localentry symbol must
6278 force a relocation. */
6281 asymbol *bfdsym = symbol_get_bfdsym (fix->fx_addsy);
6282 elf_symbol_type *elfsym
6283 = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
6284 gas_assert (elfsym);
6285 if ((STO_PPC64_LOCAL_MASK & elfsym->internal_elf_sym.st_other) != 0)
6293 if (fix->fx_r_type >= BFD_RELOC_PPC_TLS
6294 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA)
6297 return generic_force_reloc (fix);
6301 ppc_fix_adjustable (fixS *fix)
6303 switch (fix->fx_r_type)
6305 /* All branch fixups targeting a localentry symbol must
6306 continue using the symbol. */
6307 case BFD_RELOC_PPC_B26:
6308 case BFD_RELOC_PPC_BA26:
6309 case BFD_RELOC_PPC_B16:
6310 case BFD_RELOC_PPC_BA16:
6311 case BFD_RELOC_PPC_B16_BRTAKEN:
6312 case BFD_RELOC_PPC_B16_BRNTAKEN:
6313 case BFD_RELOC_PPC_BA16_BRTAKEN:
6314 case BFD_RELOC_PPC_BA16_BRNTAKEN:
6317 asymbol *bfdsym = symbol_get_bfdsym (fix->fx_addsy);
6318 elf_symbol_type *elfsym
6319 = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
6320 gas_assert (elfsym);
6321 if ((STO_PPC64_LOCAL_MASK & elfsym->internal_elf_sym.st_other) != 0)
6329 return (fix->fx_r_type != BFD_RELOC_16_GOTOFF
6330 && fix->fx_r_type != BFD_RELOC_LO16_GOTOFF
6331 && fix->fx_r_type != BFD_RELOC_HI16_GOTOFF
6332 && fix->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
6333 && fix->fx_r_type != BFD_RELOC_PPC64_GOT16_DS
6334 && fix->fx_r_type != BFD_RELOC_PPC64_GOT16_LO_DS
6335 && fix->fx_r_type != BFD_RELOC_GPREL16
6336 && fix->fx_r_type != BFD_RELOC_VTABLE_INHERIT
6337 && fix->fx_r_type != BFD_RELOC_VTABLE_ENTRY
6338 && !(fix->fx_r_type >= BFD_RELOC_PPC_TLS
6339 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA));
6344 ppc_frag_check (struct frag *fragP)
6346 if (!fragP->has_code)
6349 if (ppc_mach() == bfd_mach_ppc_vle)
6351 if (((fragP->fr_address + fragP->insn_addr) & 1) != 0)
6352 as_bad (_("instruction address is not a multiple of 2"));
6356 if (((fragP->fr_address + fragP->insn_addr) & 3) != 0)
6357 as_bad (_("instruction address is not a multiple of 4"));
6361 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6362 rs_align_code frag. */
6365 ppc_handle_align (struct frag *fragP)
6367 valueT count = (fragP->fr_next->fr_address
6368 - (fragP->fr_address + fragP->fr_fix));
6370 if (ppc_mach() == bfd_mach_ppc_vle && count != 0 && (count & 1) == 0)
6372 char *dest = fragP->fr_literal + fragP->fr_fix;
6375 md_number_to_chars (dest, 0x4400, 2);
6377 else if (count != 0 && (count & 3) == 0)
6379 char *dest = fragP->fr_literal + fragP->fr_fix;
6383 if (count > 4 * nop_limit && count < 0x2000000)
6387 /* Make a branch, then follow with nops. Insert another
6388 frag to handle the nops. */
6389 md_number_to_chars (dest, 0x48000000 + count, 4);
6394 rest = xmalloc (SIZEOF_STRUCT_FRAG + 4);
6395 memcpy (rest, fragP, SIZEOF_STRUCT_FRAG);
6396 fragP->fr_next = rest;
6398 rest->fr_address += rest->fr_fix + 4;
6400 /* If we leave the next frag as rs_align_code we'll come here
6401 again, resulting in a bunch of branches rather than a
6402 branch followed by nops. */
6403 rest->fr_type = rs_align;
6404 dest = rest->fr_literal;
6407 md_number_to_chars (dest, 0x60000000, 4);
6409 if ((ppc_cpu & PPC_OPCODE_POWER6) != 0
6410 || (ppc_cpu & PPC_OPCODE_POWER7) != 0
6411 || (ppc_cpu & PPC_OPCODE_POWER8) != 0)
6413 /* For power6, power7 and power8, we want the last nop to be a group
6414 terminating one. Do this by inserting an rs_fill frag immediately
6415 after this one, with its address set to the last nop location.
6416 This will automatically reduce the number of nops in the current
6420 struct frag *group_nop = xmalloc (SIZEOF_STRUCT_FRAG + 4);
6422 memcpy (group_nop, fragP, SIZEOF_STRUCT_FRAG);
6423 group_nop->fr_address = group_nop->fr_next->fr_address - 4;
6424 group_nop->fr_fix = 0;
6425 group_nop->fr_offset = 1;
6426 group_nop->fr_type = rs_fill;
6427 fragP->fr_next = group_nop;
6428 dest = group_nop->fr_literal;
6431 if ((ppc_cpu & PPC_OPCODE_POWER7) != 0
6432 || (ppc_cpu & PPC_OPCODE_POWER8) != 0)
6434 if (ppc_cpu & PPC_OPCODE_E500MC)
6435 /* e500mc group terminating nop: "ori 0,0,0". */
6436 md_number_to_chars (dest, 0x60000000, 4);
6438 /* power7/power8 group terminating nop: "ori 2,2,0". */
6439 md_number_to_chars (dest, 0x60420000, 4);
6442 /* power6 group terminating nop: "ori 1,1,0". */
6443 md_number_to_chars (dest, 0x60210000, 4);
6448 /* Apply a fixup to the object code. This is called for all the
6449 fixups we generated by the calls to fix_new_exp, above. */
6452 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
6454 valueT value = * valP;
6456 const struct powerpc_operand *operand;
6459 if (fixP->fx_addsy != NULL)
6461 /* Hack around bfd_install_relocation brain damage. */
6463 value += fixP->fx_frag->fr_address + fixP->fx_where;
6468 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6469 the symbol values. If we are doing this relocation the code in
6470 write.c is going to call bfd_install_relocation, which is also
6471 going to use the symbol value. That means that if the reloc is
6472 fully resolved we want to use *valP since bfd_install_relocation is
6474 However, if the reloc is not fully resolved we do not want to
6475 use *valP, and must use fx_offset instead. If the relocation
6476 is PC-relative, we then need to re-apply md_pcrel_from_section
6477 to this new relocation value. */
6478 if (fixP->fx_addsy == (symbolS *) NULL)
6483 value = fixP->fx_offset;
6485 value -= md_pcrel_from_section (fixP, seg);
6489 if (fixP->fx_subsy != (symbolS *) NULL)
6491 /* We can't actually support subtracting a symbol. */
6492 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
6496 if (fixP->fx_pcrel_adjust != 0)
6498 /* This is a fixup on an instruction. */
6499 int opindex = fixP->fx_pcrel_adjust & 0xff;
6501 operand = &powerpc_operands[opindex];
6503 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6504 does not generate a reloc. It uses the offset of `sym' within its
6505 csect. Other usages, such as `.long sym', generate relocs. This
6506 is the documented behaviour of non-TOC symbols. */
6507 if ((operand->flags & PPC_OPERAND_PARENS) != 0
6508 && (operand->bitm & 0xfff0) == 0xfff0
6509 && operand->shift == 0
6510 && (operand->insert == NULL || ppc_obj64)
6511 && fixP->fx_addsy != NULL
6512 && symbol_get_tc (fixP->fx_addsy)->subseg != 0
6513 && symbol_get_tc (fixP->fx_addsy)->symbol_class != XMC_TC
6514 && symbol_get_tc (fixP->fx_addsy)->symbol_class != XMC_TC0
6515 && S_GET_SEGMENT (fixP->fx_addsy) != bss_section)
6517 value = fixP->fx_offset;
6521 /* During parsing of instructions, a TOC16 reloc is generated for
6522 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6523 in the toc. But at parse time, SYM may be not yet defined, so
6524 check again here. */
6525 if (fixP->fx_r_type == BFD_RELOC_16
6526 && fixP->fx_addsy != NULL
6527 && ppc_is_toc_sym (fixP->fx_addsy))
6528 fixP->fx_r_type = BFD_RELOC_PPC_TOC16;
6532 /* Calculate value to be stored in field. */
6534 switch (fixP->fx_r_type)
6537 case BFD_RELOC_PPC64_ADDR16_LO_DS:
6538 case BFD_RELOC_PPC_VLE_LO16A:
6539 case BFD_RELOC_PPC_VLE_LO16D:
6541 case BFD_RELOC_LO16:
6542 case BFD_RELOC_LO16_PCREL:
6543 fieldval = value & 0xffff;
6545 if (operand != NULL && (operand->flags & PPC_OPERAND_SIGNED) != 0)
6546 fieldval = SEX16 (fieldval);
6547 fixP->fx_no_overflow = 1;
6550 case BFD_RELOC_HI16:
6551 case BFD_RELOC_HI16_PCREL:
6553 if (REPORT_OVERFLOW_HI && ppc_obj64)
6555 fieldval = value >> 16;
6556 if (operand != NULL && (operand->flags & PPC_OPERAND_SIGNED) != 0)
6558 valueT sign = (((valueT) -1 >> 16) + 1) >> 1;
6559 fieldval = ((valueT) fieldval ^ sign) - sign;
6565 case BFD_RELOC_PPC_VLE_HI16A:
6566 case BFD_RELOC_PPC_VLE_HI16D:
6567 case BFD_RELOC_PPC64_ADDR16_HIGH:
6569 fieldval = PPC_HI (value);
6570 goto sign_extend_16;
6572 case BFD_RELOC_HI16_S:
6573 case BFD_RELOC_HI16_S_PCREL:
6575 if (REPORT_OVERFLOW_HI && ppc_obj64)
6577 fieldval = (value + 0x8000) >> 16;
6578 if (operand != NULL && (operand->flags & PPC_OPERAND_SIGNED) != 0)
6580 valueT sign = (((valueT) -1 >> 16) + 1) >> 1;
6581 fieldval = ((valueT) fieldval ^ sign) - sign;
6587 case BFD_RELOC_PPC_VLE_HA16A:
6588 case BFD_RELOC_PPC_VLE_HA16D:
6589 case BFD_RELOC_PPC64_ADDR16_HIGHA:
6591 fieldval = PPC_HA (value);
6592 goto sign_extend_16;
6595 case BFD_RELOC_PPC64_HIGHER:
6596 fieldval = PPC_HIGHER (value);
6597 goto sign_extend_16;
6599 case BFD_RELOC_PPC64_HIGHER_S:
6600 fieldval = PPC_HIGHERA (value);
6601 goto sign_extend_16;
6603 case BFD_RELOC_PPC64_HIGHEST:
6604 fieldval = PPC_HIGHEST (value);
6605 goto sign_extend_16;
6607 case BFD_RELOC_PPC64_HIGHEST_S:
6608 fieldval = PPC_HIGHESTA (value);
6609 goto sign_extend_16;
6616 if (operand != NULL)
6618 /* Handle relocs in an insn. */
6622 switch (fixP->fx_r_type)
6625 /* The following relocs can't be calculated by the assembler.
6626 Leave the field zero. */
6627 case BFD_RELOC_PPC_TPREL16:
6628 case BFD_RELOC_PPC_TPREL16_LO:
6629 case BFD_RELOC_PPC_TPREL16_HI:
6630 case BFD_RELOC_PPC_TPREL16_HA:
6631 case BFD_RELOC_PPC_DTPREL16:
6632 case BFD_RELOC_PPC_DTPREL16_LO:
6633 case BFD_RELOC_PPC_DTPREL16_HI:
6634 case BFD_RELOC_PPC_DTPREL16_HA:
6635 case BFD_RELOC_PPC_GOT_TLSGD16:
6636 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
6637 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
6638 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
6639 case BFD_RELOC_PPC_GOT_TLSLD16:
6640 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
6641 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
6642 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
6643 case BFD_RELOC_PPC_GOT_TPREL16:
6644 case BFD_RELOC_PPC_GOT_TPREL16_LO:
6645 case BFD_RELOC_PPC_GOT_TPREL16_HI:
6646 case BFD_RELOC_PPC_GOT_TPREL16_HA:
6647 case BFD_RELOC_PPC_GOT_DTPREL16:
6648 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
6649 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
6650 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
6651 case BFD_RELOC_PPC64_TPREL16_DS:
6652 case BFD_RELOC_PPC64_TPREL16_LO_DS:
6653 case BFD_RELOC_PPC64_TPREL16_HIGH:
6654 case BFD_RELOC_PPC64_TPREL16_HIGHA:
6655 case BFD_RELOC_PPC64_TPREL16_HIGHER:
6656 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
6657 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
6658 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
6659 case BFD_RELOC_PPC64_DTPREL16_HIGH:
6660 case BFD_RELOC_PPC64_DTPREL16_HIGHA:
6661 case BFD_RELOC_PPC64_DTPREL16_DS:
6662 case BFD_RELOC_PPC64_DTPREL16_LO_DS:
6663 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
6664 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6665 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6666 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6667 gas_assert (fixP->fx_addsy != NULL);
6668 S_SET_THREAD_LOCAL (fixP->fx_addsy);
6672 /* These also should leave the field zero for the same
6673 reason. Note that older versions of gas wrote values
6674 here. If we want to go back to the old behaviour, then
6675 all _LO and _LO_DS cases will need to be treated like
6676 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6677 case BFD_RELOC_16_GOTOFF:
6678 case BFD_RELOC_LO16_GOTOFF:
6679 case BFD_RELOC_HI16_GOTOFF:
6680 case BFD_RELOC_HI16_S_GOTOFF:
6681 case BFD_RELOC_LO16_PLTOFF:
6682 case BFD_RELOC_HI16_PLTOFF:
6683 case BFD_RELOC_HI16_S_PLTOFF:
6684 case BFD_RELOC_GPREL16:
6685 case BFD_RELOC_16_BASEREL:
6686 case BFD_RELOC_LO16_BASEREL:
6687 case BFD_RELOC_HI16_BASEREL:
6688 case BFD_RELOC_HI16_S_BASEREL:
6689 case BFD_RELOC_PPC_TOC16:
6690 case BFD_RELOC_PPC64_TOC16_LO:
6691 case BFD_RELOC_PPC64_TOC16_HI:
6692 case BFD_RELOC_PPC64_TOC16_HA:
6693 case BFD_RELOC_PPC64_PLTGOT16:
6694 case BFD_RELOC_PPC64_PLTGOT16_LO:
6695 case BFD_RELOC_PPC64_PLTGOT16_HI:
6696 case BFD_RELOC_PPC64_PLTGOT16_HA:
6697 case BFD_RELOC_PPC64_GOT16_DS:
6698 case BFD_RELOC_PPC64_GOT16_LO_DS:
6699 case BFD_RELOC_PPC64_PLT16_LO_DS:
6700 case BFD_RELOC_PPC64_SECTOFF_DS:
6701 case BFD_RELOC_PPC64_SECTOFF_LO_DS:
6702 case BFD_RELOC_PPC64_TOC16_DS:
6703 case BFD_RELOC_PPC64_TOC16_LO_DS:
6704 case BFD_RELOC_PPC64_PLTGOT16_DS:
6705 case BFD_RELOC_PPC64_PLTGOT16_LO_DS:
6706 case BFD_RELOC_PPC_EMB_NADDR16:
6707 case BFD_RELOC_PPC_EMB_NADDR16_LO:
6708 case BFD_RELOC_PPC_EMB_NADDR16_HI:
6709 case BFD_RELOC_PPC_EMB_NADDR16_HA:
6710 case BFD_RELOC_PPC_EMB_SDAI16:
6711 case BFD_RELOC_PPC_EMB_SDA2I16:
6712 case BFD_RELOC_PPC_EMB_SDA2REL:
6713 case BFD_RELOC_PPC_EMB_SDA21:
6714 case BFD_RELOC_PPC_EMB_MRKREF:
6715 case BFD_RELOC_PPC_EMB_RELSEC16:
6716 case BFD_RELOC_PPC_EMB_RELST_LO:
6717 case BFD_RELOC_PPC_EMB_RELST_HI:
6718 case BFD_RELOC_PPC_EMB_RELST_HA:
6719 case BFD_RELOC_PPC_EMB_BIT_FLD:
6720 case BFD_RELOC_PPC_EMB_RELSDA:
6721 case BFD_RELOC_PPC_VLE_SDA21:
6722 case BFD_RELOC_PPC_VLE_SDA21_LO:
6723 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
6724 case BFD_RELOC_PPC_VLE_SDAREL_LO16D:
6725 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
6726 case BFD_RELOC_PPC_VLE_SDAREL_HI16D:
6727 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
6728 case BFD_RELOC_PPC_VLE_SDAREL_HA16D:
6729 gas_assert (fixP->fx_addsy != NULL);
6732 case BFD_RELOC_PPC_TLS:
6733 case BFD_RELOC_PPC_TLSGD:
6734 case BFD_RELOC_PPC_TLSLD:
6740 case BFD_RELOC_PPC_B16:
6741 /* Adjust the offset to the instruction boundary. */
6751 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6752 contents can stay at zero. */
6753 #define APPLY_RELOC fixP->fx_done
6755 #define APPLY_RELOC 1
6757 if ((fieldval != 0 && APPLY_RELOC) || operand->insert != NULL)
6759 /* Fetch the instruction, insert the fully resolved operand
6760 value, and stuff the instruction back again. */
6761 where = fixP->fx_frag->fr_literal + fixP->fx_where;
6762 if (target_big_endian)
6764 if (fixP->fx_size == 4)
6765 insn = bfd_getb32 ((unsigned char *) where);
6767 insn = bfd_getb16 ((unsigned char *) where);
6771 if (fixP->fx_size == 4)
6772 insn = bfd_getl32 ((unsigned char *) where);
6774 insn = bfd_getl16 ((unsigned char *) where);
6776 insn = ppc_insert_operand (insn, operand, fieldval,
6777 fixP->tc_fix_data.ppc_cpu,
6778 fixP->fx_file, fixP->fx_line);
6779 if (target_big_endian)
6781 if (fixP->fx_size == 4)
6782 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
6784 bfd_putb16 ((bfd_vma) insn, (unsigned char *) where);
6788 if (fixP->fx_size == 4)
6789 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
6791 bfd_putl16 ((bfd_vma) insn, (unsigned char *) where);
6796 /* Nothing else to do here. */
6799 gas_assert (fixP->fx_addsy != NULL);
6800 if (fixP->fx_r_type == BFD_RELOC_UNUSED)
6805 /* Use expr_symbol_where to see if this is an expression
6807 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
6808 as_bad_where (fixP->fx_file, fixP->fx_line,
6809 _("unresolved expression that must be resolved"));
6811 as_bad_where (fixP->fx_file, fixP->fx_line,
6812 _("unsupported relocation against %s"),
6813 S_GET_NAME (fixP->fx_addsy));
6820 /* Handle relocs in data. */
6821 switch (fixP->fx_r_type)
6823 case BFD_RELOC_VTABLE_INHERIT:
6825 && !S_IS_DEFINED (fixP->fx_addsy)
6826 && !S_IS_WEAK (fixP->fx_addsy))
6827 S_SET_WEAK (fixP->fx_addsy);
6830 case BFD_RELOC_VTABLE_ENTRY:
6835 /* These can appear with @l etc. in data. */
6836 case BFD_RELOC_LO16:
6837 case BFD_RELOC_LO16_PCREL:
6838 case BFD_RELOC_HI16:
6839 case BFD_RELOC_HI16_PCREL:
6840 case BFD_RELOC_HI16_S:
6841 case BFD_RELOC_HI16_S_PCREL:
6842 case BFD_RELOC_PPC64_HIGHER:
6843 case BFD_RELOC_PPC64_HIGHER_S:
6844 case BFD_RELOC_PPC64_HIGHEST:
6845 case BFD_RELOC_PPC64_HIGHEST_S:
6846 case BFD_RELOC_PPC64_ADDR16_HIGH:
6847 case BFD_RELOC_PPC64_ADDR16_HIGHA:
6848 case BFD_RELOC_PPC64_ADDR64_LOCAL:
6851 case BFD_RELOC_PPC_DTPMOD:
6852 case BFD_RELOC_PPC_TPREL:
6853 case BFD_RELOC_PPC_DTPREL:
6854 S_SET_THREAD_LOCAL (fixP->fx_addsy);
6857 /* Just punt all of these to the linker. */
6858 case BFD_RELOC_PPC_B16_BRTAKEN:
6859 case BFD_RELOC_PPC_B16_BRNTAKEN:
6860 case BFD_RELOC_16_GOTOFF:
6861 case BFD_RELOC_LO16_GOTOFF:
6862 case BFD_RELOC_HI16_GOTOFF:
6863 case BFD_RELOC_HI16_S_GOTOFF:
6864 case BFD_RELOC_LO16_PLTOFF:
6865 case BFD_RELOC_HI16_PLTOFF:
6866 case BFD_RELOC_HI16_S_PLTOFF:
6867 case BFD_RELOC_PPC_COPY:
6868 case BFD_RELOC_PPC_GLOB_DAT:
6869 case BFD_RELOC_16_BASEREL:
6870 case BFD_RELOC_LO16_BASEREL:
6871 case BFD_RELOC_HI16_BASEREL:
6872 case BFD_RELOC_HI16_S_BASEREL:
6873 case BFD_RELOC_PPC_TLS:
6874 case BFD_RELOC_PPC_DTPREL16_LO:
6875 case BFD_RELOC_PPC_DTPREL16_HI:
6876 case BFD_RELOC_PPC_DTPREL16_HA:
6877 case BFD_RELOC_PPC_TPREL16_LO:
6878 case BFD_RELOC_PPC_TPREL16_HI:
6879 case BFD_RELOC_PPC_TPREL16_HA:
6880 case BFD_RELOC_PPC_GOT_TLSGD16:
6881 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
6882 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
6883 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
6884 case BFD_RELOC_PPC_GOT_TLSLD16:
6885 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
6886 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
6887 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
6888 case BFD_RELOC_PPC_GOT_DTPREL16:
6889 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
6890 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
6891 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
6892 case BFD_RELOC_PPC_GOT_TPREL16:
6893 case BFD_RELOC_PPC_GOT_TPREL16_LO:
6894 case BFD_RELOC_PPC_GOT_TPREL16_HI:
6895 case BFD_RELOC_PPC_GOT_TPREL16_HA:
6896 case BFD_RELOC_24_PLT_PCREL:
6897 case BFD_RELOC_PPC_LOCAL24PC:
6898 case BFD_RELOC_32_PLT_PCREL:
6899 case BFD_RELOC_GPREL16:
6900 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
6901 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
6902 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
6903 case BFD_RELOC_PPC_EMB_NADDR32:
6904 case BFD_RELOC_PPC_EMB_NADDR16:
6905 case BFD_RELOC_PPC_EMB_NADDR16_LO:
6906 case BFD_RELOC_PPC_EMB_NADDR16_HI:
6907 case BFD_RELOC_PPC_EMB_NADDR16_HA:
6908 case BFD_RELOC_PPC_EMB_SDAI16:
6909 case BFD_RELOC_PPC_EMB_SDA2REL:
6910 case BFD_RELOC_PPC_EMB_SDA2I16:
6911 case BFD_RELOC_PPC_EMB_SDA21:
6912 case BFD_RELOC_PPC_VLE_SDA21_LO:
6913 case BFD_RELOC_PPC_EMB_MRKREF:
6914 case BFD_RELOC_PPC_EMB_RELSEC16:
6915 case BFD_RELOC_PPC_EMB_RELST_LO:
6916 case BFD_RELOC_PPC_EMB_RELST_HI:
6917 case BFD_RELOC_PPC_EMB_RELST_HA:
6918 case BFD_RELOC_PPC_EMB_BIT_FLD:
6919 case BFD_RELOC_PPC_EMB_RELSDA:
6920 case BFD_RELOC_PPC64_TOC:
6921 case BFD_RELOC_PPC_TOC16:
6922 case BFD_RELOC_PPC64_TOC16_LO:
6923 case BFD_RELOC_PPC64_TOC16_HI:
6924 case BFD_RELOC_PPC64_TOC16_HA:
6925 case BFD_RELOC_PPC64_DTPREL16_HIGH:
6926 case BFD_RELOC_PPC64_DTPREL16_HIGHA:
6927 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
6928 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6929 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6930 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6931 case BFD_RELOC_PPC64_TPREL16_HIGH:
6932 case BFD_RELOC_PPC64_TPREL16_HIGHA:
6933 case BFD_RELOC_PPC64_TPREL16_HIGHER:
6934 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
6935 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
6936 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
6942 case BFD_RELOC_NONE:
6944 case BFD_RELOC_CTOR:
6946 case BFD_RELOC_32_PCREL:
6949 case BFD_RELOC_64_PCREL:
6951 case BFD_RELOC_16_PCREL:
6957 _("Gas failure, reloc value %d\n"), fixP->fx_r_type);
6962 if (fixP->fx_size && APPLY_RELOC)
6963 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
6964 fieldval, fixP->fx_size);
6967 /* We are only able to convert some relocs to pc-relative. */
6968 if (!fixP->fx_done && fixP->fx_pcrel)
6970 switch (fixP->fx_r_type)
6972 case BFD_RELOC_LO16:
6973 fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
6976 case BFD_RELOC_HI16:
6977 fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
6980 case BFD_RELOC_HI16_S:
6981 fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
6985 fixP->fx_r_type = BFD_RELOC_64_PCREL;
6989 fixP->fx_r_type = BFD_RELOC_32_PCREL;
6993 fixP->fx_r_type = BFD_RELOC_16_PCREL;
6996 /* Some of course are already pc-relative. */
6997 case BFD_RELOC_LO16_PCREL:
6998 case BFD_RELOC_HI16_PCREL:
6999 case BFD_RELOC_HI16_S_PCREL:
7000 case BFD_RELOC_64_PCREL:
7001 case BFD_RELOC_32_PCREL:
7002 case BFD_RELOC_16_PCREL:
7003 case BFD_RELOC_PPC_B16:
7004 case BFD_RELOC_PPC_B16_BRTAKEN:
7005 case BFD_RELOC_PPC_B16_BRNTAKEN:
7006 case BFD_RELOC_PPC_B26:
7007 case BFD_RELOC_PPC_LOCAL24PC:
7008 case BFD_RELOC_24_PLT_PCREL:
7009 case BFD_RELOC_32_PLT_PCREL:
7010 case BFD_RELOC_64_PLT_PCREL:
7011 case BFD_RELOC_PPC_VLE_REL8:
7012 case BFD_RELOC_PPC_VLE_REL15:
7013 case BFD_RELOC_PPC_VLE_REL24:
7022 /* Use expr_symbol_where to see if this is an
7023 expression symbol. */
7024 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
7025 as_bad_where (fixP->fx_file, fixP->fx_line,
7026 _("unresolved expression that must"
7029 as_bad_where (fixP->fx_file, fixP->fx_line,
7030 _("cannot emit PC relative %s relocation"
7032 bfd_get_reloc_code_name (fixP->fx_r_type),
7033 S_GET_NAME (fixP->fx_addsy));
7036 as_bad_where (fixP->fx_file, fixP->fx_line,
7037 _("unable to resolve expression"));
7044 ppc_elf_validate_fix (fixP, seg);
7045 fixP->fx_addnumber = value;
7047 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
7048 from the section contents. If we are going to be emitting a reloc
7049 then the section contents are immaterial, so don't warn if they
7050 happen to overflow. Leave such warnings to ld. */
7053 fixP->fx_no_overflow = 1;
7055 /* Arrange to emit .TOC. as a normal symbol if used in anything
7056 but .TOC.@tocbase. */
7058 && fixP->fx_r_type != BFD_RELOC_PPC64_TOC
7059 && fixP->fx_addsy != NULL
7060 && strcmp (S_GET_NAME (fixP->fx_addsy), ".TOC.") == 0)
7061 symbol_get_bfdsym (fixP->fx_addsy)->flags |= BSF_KEEP;
7064 if (fixP->fx_r_type != BFD_RELOC_PPC_TOC16)
7065 fixP->fx_addnumber = 0;
7069 fixP->fx_addnumber = 0;
7071 /* We want to use the offset within the toc, not the actual VMA
7073 fixP->fx_addnumber =
7074 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixP->fx_addsy))
7075 - S_GET_VALUE (ppc_toc_csect);
7076 /* Set *valP to avoid errors. */
7083 /* Generate a reloc for a fixup. */
7086 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
7090 reloc = (arelent *) xmalloc (sizeof (arelent));
7092 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
7093 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
7094 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
7095 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
7096 if (reloc->howto == (reloc_howto_type *) NULL)
7098 as_bad_where (fixp->fx_file, fixp->fx_line,
7099 _("reloc %d not supported by object file format"),
7100 (int) fixp->fx_r_type);
7103 reloc->addend = fixp->fx_addnumber;
7109 ppc_cfi_frame_initial_instructions (void)
7111 cfi_add_CFA_def_cfa (1, 0);
7115 tc_ppc_regname_to_dw2regnum (char *regname)
7117 unsigned int regnum = -1;
7121 static struct { char *name; int dw2regnum; } regnames[] =
7123 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7124 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7125 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7126 { "spe_acc", 111 }, { "spefscr", 112 }
7129 for (i = 0; i < ARRAY_SIZE (regnames); ++i)
7130 if (strcmp (regnames[i].name, regname) == 0)
7131 return regnames[i].dw2regnum;
7133 if (regname[0] == 'r' || regname[0] == 'f' || regname[0] == 'v')
7135 p = regname + 1 + (regname[1] == '.');
7136 regnum = strtoul (p, &q, 10);
7137 if (p == q || *q || regnum >= 32)
7139 if (regname[0] == 'f')
7141 else if (regname[0] == 'v')
7144 else if (regname[0] == 'c' && regname[1] == 'r')
7146 p = regname + 2 + (regname[2] == '.');
7147 if (p[0] < '0' || p[0] > '7' || p[1])
7149 regnum = p[0] - '0' + 68;