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_abiversion (int);
141 static void ppc_previous (int);
142 static void ppc_pdata (int);
143 static void ppc_ydata (int);
144 static void ppc_reldata (int);
145 static void ppc_rdata (int);
146 static void ppc_ualong (int);
147 static void ppc_znop (int);
148 static void ppc_pe_comm (int);
149 static void ppc_pe_section (int);
150 static void ppc_pe_function (int);
151 static void ppc_pe_tocd (int);
154 /* Generic assembler global variables which must be defined by all
158 /* This string holds the chars that always start a comment. If the
159 pre-processor is disabled, these aren't very useful. The macro
160 tc_comment_chars points to this. We use this, rather than the
161 usual comment_chars, so that we can switch for Solaris conventions. */
162 static const char ppc_solaris_comment_chars
[] = "#!";
163 static const char ppc_eabi_comment_chars
[] = "#";
165 #ifdef TARGET_SOLARIS_COMMENT
166 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
168 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
171 const char comment_chars
[] = "#";
174 /* Characters which start a comment at the beginning of a line. */
175 const char line_comment_chars
[] = "#";
177 /* Characters which may be used to separate multiple commands on a
179 const char line_separator_chars
[] = ";";
181 /* Characters which are used to indicate an exponent in a floating
183 const char EXP_CHARS
[] = "eE";
185 /* Characters which mean that a number is a floating point constant,
187 const char FLT_CHARS
[] = "dD";
189 /* Anything that can start an operand needs to be mentioned here,
190 to stop the input scrubber eating whitespace. */
191 const char ppc_symbol_chars
[] = "%[";
193 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
194 int ppc_cie_data_alignment
;
196 /* The dwarf2 minimum instruction length. */
197 int ppc_dwarf2_line_min_insn_length
;
199 /* More than this number of nops in an alignment op gets a branch
201 unsigned long nop_limit
= 4;
203 /* The type of processor we are assembling for. This is one or more
204 of the PPC_OPCODE flags defined in opcode/ppc.h. */
205 ppc_cpu_t ppc_cpu
= 0;
206 ppc_cpu_t sticky
= 0;
208 /* Value for ELF e_flags EF_PPC64_ABI. */
209 unsigned int ppc_abiversion
= 0;
211 /* Flags set on encountering toc relocs. */
213 has_large_toc_reloc
= 1,
214 has_small_toc_reloc
= 2
217 /* The target specific pseudo-ops which we support. */
219 const pseudo_typeS md_pseudo_table
[] =
221 /* Pseudo-ops which must be overridden. */
222 { "byte", ppc_byte
, 0 },
225 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
226 legitimately belong in the obj-*.c file. However, XCOFF is based
227 on COFF, and is only implemented for the RS/6000. We just use
228 obj-coff.c, and add what we need here. */
229 { "comm", ppc_comm
, 0 },
230 { "lcomm", ppc_comm
, 1 },
234 { "bi", ppc_biei
, 0 },
236 { "csect", ppc_csect
, 0 },
237 { "dwsect", ppc_dwsect
, 0 },
238 { "data", ppc_section
, 'd' },
242 { "ei", ppc_biei
, 1 },
244 { "extern", ppc_extern
, 0 },
245 { "function", ppc_function
, 0 },
246 { "lglobl", ppc_lglobl
, 0 },
247 { "ref", ppc_ref
, 0 },
248 { "rename", ppc_rename
, 0 },
249 { "section", ppc_named_section
, 0 },
250 { "stabx", ppc_stabx
, 0 },
251 { "text", ppc_section
, 't' },
252 { "toc", ppc_toc
, 0 },
253 { "long", ppc_xcoff_cons
, 2 },
254 { "llong", ppc_xcoff_cons
, 3 },
255 { "word", ppc_xcoff_cons
, 1 },
256 { "short", ppc_xcoff_cons
, 1 },
257 { "vbyte", ppc_vbyte
, 0 },
261 { "llong", ppc_elf_cons
, 8 },
262 { "quad", ppc_elf_cons
, 8 },
263 { "long", ppc_elf_cons
, 4 },
264 { "word", ppc_elf_cons
, 2 },
265 { "short", ppc_elf_cons
, 2 },
266 { "rdata", ppc_elf_rdata
, 0 },
267 { "rodata", ppc_elf_rdata
, 0 },
268 { "lcomm", ppc_elf_lcomm
, 0 },
269 { "abiversion", ppc_elf_abiversion
, 0 },
273 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
274 { "previous", ppc_previous
, 0 },
275 { "pdata", ppc_pdata
, 0 },
276 { "ydata", ppc_ydata
, 0 },
277 { "reldata", ppc_reldata
, 0 },
278 { "rdata", ppc_rdata
, 0 },
279 { "ualong", ppc_ualong
, 0 },
280 { "znop", ppc_znop
, 0 },
281 { "comm", ppc_pe_comm
, 0 },
282 { "lcomm", ppc_pe_comm
, 1 },
283 { "section", ppc_pe_section
, 0 },
284 { "function", ppc_pe_function
,0 },
285 { "tocd", ppc_pe_tocd
, 0 },
288 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
290 { "machine", ppc_machine
, 0 },
297 /* Predefined register names if -mregnames (or default for Windows NT).
298 In general, there are lots of them, in an attempt to be compatible
299 with a number of other Windows NT assemblers. */
301 /* Structure to hold information about predefined registers. */
308 /* List of registers that are pre-defined:
310 Each general register has predefined names of the form:
311 1. r<reg_num> which has the value <reg_num>.
312 2. r.<reg_num> which has the value <reg_num>.
314 Each floating point register has predefined names of the form:
315 1. f<reg_num> which has the value <reg_num>.
316 2. f.<reg_num> which has the value <reg_num>.
318 Each vector unit register has predefined names of the form:
319 1. v<reg_num> which has the value <reg_num>.
320 2. v.<reg_num> which has the value <reg_num>.
322 Each condition register has predefined names of the form:
323 1. cr<reg_num> which has the value <reg_num>.
324 2. cr.<reg_num> which has the value <reg_num>.
326 There are individual registers as well:
327 sp or r.sp has the value 1
328 rtoc or r.toc has the value 2
329 fpscr has the value 0
335 dsisr has the value 18
337 sdr1 has the value 25
338 srr0 has the value 26
339 srr1 has the value 27
341 The table is sorted. Suitable for searching by a binary search. */
343 static const struct pd_reg pre_defined_registers
[] =
345 { "cr.0", 0 }, /* Condition Registers */
365 { "dar", 19 }, /* Data Access Register */
366 { "dec", 22 }, /* Decrementer */
367 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
369 { "f.0", 0 }, /* Floating point registers */
396 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
462 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
503 /* Quantization registers used with pair single instructions. */
521 { "lr", 8 }, /* Link Register */
525 { "r.0", 0 }, /* General Purpose Registers */
558 { "r.sp", 1 }, /* Stack Pointer */
560 { "r.toc", 2 }, /* Pointer to the table of contents */
562 { "r0", 0 }, /* More general purpose registers */
595 { "rtoc", 2 }, /* Table of contents */
597 { "sdr1", 25 }, /* Storage Description Register 1 */
601 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
602 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
604 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
670 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
804 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
806 /* Given NAME, find the register number associated with that name, return
807 the integer value associated with the given name or -1 on failure. */
810 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
812 int middle
, low
, high
;
820 middle
= (low
+ high
) / 2;
821 cmp
= strcasecmp (name
, regs
[middle
].name
);
827 return regs
[middle
].value
;
835 * Summary of register_name.
837 * in: Input_line_pointer points to 1st char of operand.
839 * out: A expressionS.
840 * The operand may have been a register: in this case, X_op == O_register,
841 * X_add_number is set to the register number, and truth is returned.
842 * Input_line_pointer->(next non-blank) char after operand, or is in its
847 register_name (expressionS
*expressionP
)
854 /* Find the spelling of the operand. */
855 start
= name
= input_line_pointer
;
856 if (name
[0] == '%' && ISALPHA (name
[1]))
857 name
= ++input_line_pointer
;
859 else if (!reg_names_p
|| !ISALPHA (name
[0]))
862 c
= get_symbol_end ();
863 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
865 /* Put back the delimiting char. */
866 *input_line_pointer
= c
;
868 /* Look to see if it's in the register table. */
871 expressionP
->X_op
= O_register
;
872 expressionP
->X_add_number
= reg_number
;
874 /* Make the rest nice. */
875 expressionP
->X_add_symbol
= NULL
;
876 expressionP
->X_op_symbol
= NULL
;
880 /* Reset the line as if we had not done anything. */
881 input_line_pointer
= start
;
885 /* This function is called for each symbol seen in an expression. It
886 handles the special parsing which PowerPC assemblers are supposed
887 to use for condition codes. */
889 /* Whether to do the special parsing. */
890 static bfd_boolean cr_operand
;
892 /* Names to recognize in a condition code. This table is sorted. */
893 static const struct pd_reg cr_names
[] =
910 /* Parsing function. This returns non-zero if it recognized an
914 ppc_parse_name (const char *name
, expressionS
*exp
)
923 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
928 exp
->X_op
= O_constant
;
929 exp
->X_add_number
= val
;
934 /* Local variables. */
936 /* Whether to target xcoff64/elf64. */
937 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
939 /* Opcode hash table. */
940 static struct hash_control
*ppc_hash
;
942 /* Macro hash table. */
943 static struct hash_control
*ppc_macro_hash
;
946 /* What type of shared library support to use. */
947 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
949 /* Flags to set in the elf header. */
950 static flagword ppc_flags
= 0;
952 /* Whether this is Solaris or not. */
953 #ifdef TARGET_SOLARIS_COMMENT
954 #define SOLARIS_P TRUE
956 #define SOLARIS_P FALSE
959 static bfd_boolean msolaris
= SOLARIS_P
;
964 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
965 using a bunch of different sections. These assembler sections,
966 however, are all encompassed within the .text or .data sections of
967 the final output file. We handle this by using different
968 subsegments within these main segments. */
970 /* Next subsegment to allocate within the .text segment. */
971 static subsegT ppc_text_subsegment
= 2;
973 /* Linked list of csects in the text section. */
974 static symbolS
*ppc_text_csects
;
976 /* Next subsegment to allocate within the .data segment. */
977 static subsegT ppc_data_subsegment
= 2;
979 /* Linked list of csects in the data section. */
980 static symbolS
*ppc_data_csects
;
982 /* The current csect. */
983 static symbolS
*ppc_current_csect
;
985 /* The RS/6000 assembler uses a TOC which holds addresses of functions
986 and variables. Symbols are put in the TOC with the .tc pseudo-op.
987 A special relocation is used when accessing TOC entries. We handle
988 the TOC as a subsegment within the .data segment. We set it up if
989 we see a .toc pseudo-op, and save the csect symbol here. */
990 static symbolS
*ppc_toc_csect
;
992 /* The first frag in the TOC subsegment. */
993 static fragS
*ppc_toc_frag
;
995 /* The first frag in the first subsegment after the TOC in the .data
996 segment. NULL if there are no subsegments after the TOC. */
997 static fragS
*ppc_after_toc_frag
;
999 /* The current static block. */
1000 static symbolS
*ppc_current_block
;
1002 /* The COFF debugging section; set by md_begin. This is not the
1003 .debug section, but is instead the secret BFD section which will
1004 cause BFD to set the section number of a symbol to N_DEBUG. */
1005 static asection
*ppc_coff_debug_section
;
1007 /* Structure to set the length field of the dwarf sections. */
1008 struct dw_subsection
{
1009 /* Subsections are simply linked. */
1010 struct dw_subsection
*link
;
1012 /* The subsection number. */
1015 /* Expression to compute the length of the section. */
1016 expressionS end_exp
;
1019 static struct dw_section
{
1020 /* Corresponding section. */
1023 /* Simply linked list of subsections with a label. */
1024 struct dw_subsection
*list_subseg
;
1026 /* The anonymous subsection. */
1027 struct dw_subsection
*anon_subseg
;
1028 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1029 #endif /* OBJ_XCOFF */
1033 /* Various sections that we need for PE coff support. */
1034 static segT ydata_section
;
1035 static segT pdata_section
;
1036 static segT reldata_section
;
1037 static segT rdata_section
;
1038 static segT tocdata_section
;
1040 /* The current section and the previous section. See ppc_previous. */
1041 static segT ppc_previous_section
;
1042 static segT ppc_current_section
;
1047 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1048 #define PPC_APUINFO_ISEL 0x40
1049 #define PPC_APUINFO_PMR 0x41
1050 #define PPC_APUINFO_RFMCI 0x42
1051 #define PPC_APUINFO_CACHELCK 0x43
1052 #define PPC_APUINFO_SPE 0x100
1053 #define PPC_APUINFO_EFS 0x101
1054 #define PPC_APUINFO_BRLOCK 0x102
1055 #define PPC_APUINFO_VLE 0x104
1058 * We keep a list of APUinfo
1060 unsigned long *ppc_apuinfo_list
;
1061 unsigned int ppc_apuinfo_num
;
1062 unsigned int ppc_apuinfo_num_alloc
;
1063 #endif /* OBJ_ELF */
1066 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1068 const char *const md_shortopts
= "um:";
1070 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1071 const struct option md_longopts
[] = {
1072 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1073 {NULL
, no_argument
, NULL
, 0}
1075 const size_t md_longopts_size
= sizeof (md_longopts
);
1078 md_parse_option (int c
, char *arg
)
1085 /* -u means that any undefined symbols should be treated as
1086 external, which is the default for gas anyhow. */
1091 /* Solaris as takes -le (presumably for little endian). For completeness
1092 sake, recognize -be also. */
1093 if (strcmp (arg
, "e") == 0)
1095 target_big_endian
= 0;
1096 set_target_endian
= 1;
1097 if (ppc_cpu
& PPC_OPCODE_VLE
)
1098 as_bad (_("the use of -mvle requires big endian."));
1106 if (strcmp (arg
, "e") == 0)
1108 target_big_endian
= 1;
1109 set_target_endian
= 1;
1117 /* Recognize -K PIC. */
1118 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1121 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1129 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1131 if (strcmp (arg
, "64") == 0)
1135 if (ppc_cpu
& PPC_OPCODE_VLE
)
1136 as_bad (_("the use of -mvle requires -a32."));
1138 as_fatal (_("%s unsupported"), "-a64");
1141 else if (strcmp (arg
, "32") == 0)
1148 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1152 if (strcmp (arg
, "vle") == 0)
1154 if (set_target_endian
&& target_big_endian
== 0)
1155 as_bad (_("the use of -mvle requires big endian."));
1157 as_bad (_("the use of -mvle requires -a32."));
1161 else if (strcmp (arg
, "regnames") == 0)
1164 else if (strcmp (arg
, "no-regnames") == 0)
1165 reg_names_p
= FALSE
;
1168 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1169 that require relocation. */
1170 else if (strcmp (arg
, "relocatable") == 0)
1172 shlib
= SHLIB_MRELOCATABLE
;
1173 ppc_flags
|= EF_PPC_RELOCATABLE
;
1176 else if (strcmp (arg
, "relocatable-lib") == 0)
1178 shlib
= SHLIB_MRELOCATABLE
;
1179 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1182 /* -memb, set embedded bit. */
1183 else if (strcmp (arg
, "emb") == 0)
1184 ppc_flags
|= EF_PPC_EMB
;
1186 /* -mlittle/-mbig set the endianness. */
1187 else if (strcmp (arg
, "little") == 0
1188 || strcmp (arg
, "little-endian") == 0)
1190 target_big_endian
= 0;
1191 set_target_endian
= 1;
1192 if (ppc_cpu
& PPC_OPCODE_VLE
)
1193 as_bad (_("the use of -mvle requires big endian."));
1196 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1198 target_big_endian
= 1;
1199 set_target_endian
= 1;
1202 else if (strcmp (arg
, "solaris") == 0)
1205 ppc_comment_chars
= ppc_solaris_comment_chars
;
1208 else if (strcmp (arg
, "no-solaris") == 0)
1211 ppc_comment_chars
= ppc_eabi_comment_chars
;
1216 as_bad (_("invalid switch -m%s"), arg
);
1222 /* -V: SVR4 argument to print version ID. */
1224 print_version_id ();
1227 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1228 should be emitted or not. FIXME: Not implemented. */
1232 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1233 rather than .stabs.excl, which is ignored by the linker.
1234 FIXME: Not implemented. */
1245 nop_limit
= strtoul (optarg
, &end
, 0);
1247 as_bad (_("--nops needs a numeric argument"));
1259 md_show_usage (FILE *stream
)
1261 fprintf (stream
, _("\
1263 -a32 generate ELF32/XCOFF32\n\
1264 -a64 generate ELF64/XCOFF64\n\
1266 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1267 -mpwr generate code for POWER (RIOS1)\n\
1268 -m601 generate code for PowerPC 601\n\
1269 -mppc, -mppc32, -m603, -m604\n\
1270 generate code for PowerPC 603/604\n\
1271 -m403 generate code for PowerPC 403\n\
1272 -m405 generate code for PowerPC 405\n\
1273 -m440 generate code for PowerPC 440\n\
1274 -m464 generate code for PowerPC 464\n\
1275 -m476 generate code for PowerPC 476\n\
1276 -m7400, -m7410, -m7450, -m7455\n\
1277 generate code for PowerPC 7400/7410/7450/7455\n\
1278 -m750cl generate code for PowerPC 750cl\n"));
1279 fprintf (stream
, _("\
1280 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1281 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1282 -mbooke generate code for 32-bit PowerPC BookE\n\
1283 -ma2 generate code for A2 architecture\n\
1284 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1285 -mpower5, -mpwr5, -mpwr5x\n\
1286 generate code for Power5 architecture\n\
1287 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1288 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1289 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1290 -mcell generate code for Cell Broadband Engine architecture\n\
1291 -mcom generate code Power/PowerPC common instructions\n\
1292 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1293 fprintf (stream
, _("\
1294 -maltivec generate code for AltiVec\n\
1295 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1296 -mhtm generate code for Hardware Transactional Memory\n\
1297 -me300 generate code for PowerPC e300 family\n\
1298 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1299 -me500mc, generate code for Freescale e500mc core complex\n\
1300 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1301 -me5500, generate code for Freescale e5500 core complex\n\
1302 -me6500, generate code for Freescale e6500 core complex\n\
1303 -mspe generate code for Motorola SPE instructions\n\
1304 -mvle generate code for Freescale VLE instructions\n\
1305 -mtitan generate code for AppliedMicro Titan core complex\n\
1306 -mregnames Allow symbolic names for registers\n\
1307 -mno-regnames Do not allow symbolic names for registers\n"));
1309 fprintf (stream
, _("\
1310 -mrelocatable support for GCC's -mrelocatble option\n\
1311 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1312 -memb set PPC_EMB bit in ELF flags\n\
1313 -mlittle, -mlittle-endian, -le\n\
1314 generate code for a little endian machine\n\
1315 -mbig, -mbig-endian, -be\n\
1316 generate code for a big endian machine\n\
1317 -msolaris generate code for Solaris\n\
1318 -mno-solaris do not generate code for Solaris\n\
1319 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1320 -V print assembler version number\n\
1321 -Qy, -Qn ignored\n"));
1323 fprintf (stream
, _("\
1324 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1327 /* Set ppc_cpu if it is not already set. */
1332 const char *default_os
= TARGET_OS
;
1333 const char *default_cpu
= TARGET_CPU
;
1335 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1338 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1339 else if (strncmp (default_os
, "aix", 3) == 0
1340 && default_os
[3] >= '4' && default_os
[3] <= '9')
1341 ppc_cpu
|= PPC_OPCODE_COMMON
;
1342 else if (strncmp (default_os
, "aix3", 4) == 0)
1343 ppc_cpu
|= PPC_OPCODE_POWER
;
1344 else if (strcmp (default_cpu
, "rs6000") == 0)
1345 ppc_cpu
|= PPC_OPCODE_POWER
;
1346 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1347 ppc_cpu
|= PPC_OPCODE_PPC
;
1349 as_fatal (_("unknown default cpu = %s, os = %s"),
1350 default_cpu
, default_os
);
1354 /* Figure out the BFD architecture to use. This function and ppc_mach
1355 are called well before md_begin, when the output file is opened. */
1357 enum bfd_architecture
1360 const char *default_cpu
= TARGET_CPU
;
1363 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1364 return bfd_arch_powerpc
;
1365 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1366 return bfd_arch_powerpc
;
1367 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1368 return bfd_arch_rs6000
;
1369 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1371 if (strcmp (default_cpu
, "rs6000") == 0)
1372 return bfd_arch_rs6000
;
1373 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1374 return bfd_arch_powerpc
;
1377 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1378 return bfd_arch_unknown
;
1385 return bfd_mach_ppc64
;
1386 else if (ppc_arch () == bfd_arch_rs6000
)
1387 return bfd_mach_rs6k
;
1388 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1389 return bfd_mach_ppc_titan
;
1390 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1391 return bfd_mach_ppc_vle
;
1393 return bfd_mach_ppc
;
1397 ppc_target_format (void)
1401 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1403 return "xcoff-powermac";
1406 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1408 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1414 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1415 # elif defined (TE_VXWORKS)
1416 return "elf32-powerpc-vxworks";
1418 return (target_big_endian
1419 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1420 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1425 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1426 Return TRUE if there's a problem, otherwise FALSE. */
1429 insn_validate (const struct powerpc_opcode
*op
)
1431 const unsigned char *o
;
1432 unsigned long omask
= op
->mask
;
1434 /* The mask had better not trim off opcode bits. */
1435 if ((op
->opcode
& omask
) != op
->opcode
)
1437 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1441 /* The operands must not overlap the opcode or each other. */
1442 for (o
= op
->operands
; *o
; ++o
)
1444 if (*o
>= num_powerpc_operands
)
1446 as_bad (_("operand index error for %s"), op
->name
);
1451 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1452 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1456 if (operand
->shift
>= 0)
1457 mask
= operand
->bitm
<< operand
->shift
;
1459 mask
= operand
->bitm
>> -operand
->shift
;
1462 as_bad (_("operand %d overlap in %s"),
1463 (int) (o
- op
->operands
), op
->name
);
1473 /* Insert opcodes and macros into hash tables. Called at startup and
1474 for .machine pseudo. */
1477 ppc_setup_opcodes (void)
1479 const struct powerpc_opcode
*op
;
1480 const struct powerpc_opcode
*op_end
;
1481 const struct powerpc_macro
*macro
;
1482 const struct powerpc_macro
*macro_end
;
1483 bfd_boolean bad_insn
= FALSE
;
1485 if (ppc_hash
!= NULL
)
1486 hash_die (ppc_hash
);
1487 if (ppc_macro_hash
!= NULL
)
1488 hash_die (ppc_macro_hash
);
1490 /* Insert the opcodes into a hash table. */
1491 ppc_hash
= hash_new ();
1493 if (ENABLE_CHECKING
)
1497 /* An index into powerpc_operands is stored in struct fix
1498 fx_pcrel_adjust which is 8 bits wide. */
1499 gas_assert (num_powerpc_operands
< 256);
1501 /* Check operand masks. Code here and in the disassembler assumes
1502 all the 1's in the mask are contiguous. */
1503 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1505 unsigned long mask
= powerpc_operands
[i
].bitm
;
1506 unsigned long right_bit
;
1509 right_bit
= mask
& -mask
;
1511 right_bit
= mask
& -mask
;
1512 if (mask
!= right_bit
)
1514 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1517 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1518 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1519 sizeof (powerpc_operands
[0])) == 0)
1521 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1528 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1529 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1531 if (ENABLE_CHECKING
)
1533 if (op
!= powerpc_opcodes
)
1535 int old_opcode
= PPC_OP (op
[-1].opcode
);
1536 int new_opcode
= PPC_OP (op
[0].opcode
);
1538 #ifdef PRINT_OPCODE_TABLE
1539 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1540 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1541 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1542 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1545 /* The major opcodes had better be sorted. Code in the
1546 disassembler assumes the insns are sorted according to
1548 if (new_opcode
< old_opcode
)
1550 as_bad (_("major opcode is not sorted for %s"),
1555 bad_insn
|= insn_validate (op
);
1558 if ((ppc_cpu
& op
->flags
) != 0
1559 && !(ppc_cpu
& op
->deprecated
))
1563 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1566 as_bad (_("duplicate instruction %s"),
1573 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1574 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1575 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1577 op_end
= vle_opcodes
+ vle_num_opcodes
;
1578 for (op
= vle_opcodes
; op
< op_end
; op
++)
1580 if (ENABLE_CHECKING
)
1582 if (op
!= vle_opcodes
)
1584 unsigned old_seg
, new_seg
;
1586 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1587 old_seg
= VLE_OP_TO_SEG (old_seg
);
1588 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1589 new_seg
= VLE_OP_TO_SEG (new_seg
);
1591 #ifdef PRINT_OPCODE_TABLE
1592 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1593 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1594 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1595 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1597 /* The major opcodes had better be sorted. Code in the
1598 disassembler assumes the insns are sorted according to
1600 if (new_seg
< old_seg
)
1602 as_bad (_("major opcode is not sorted for %s"),
1608 bad_insn
|= insn_validate (op
);
1611 if ((ppc_cpu
& op
->flags
) != 0
1612 && !(ppc_cpu
& op
->deprecated
))
1616 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1619 as_bad (_("duplicate instruction %s"),
1626 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1627 for (op
= vle_opcodes
; op
< op_end
; op
++)
1628 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1630 /* Insert the macros into a hash table. */
1631 ppc_macro_hash
= hash_new ();
1633 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1634 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1636 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1640 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1641 if (retval
!= (const char *) NULL
)
1643 as_bad (_("duplicate macro %s"), macro
->name
);
1653 /* This function is called when the assembler starts up. It is called
1654 after the options have been parsed and the output file has been
1662 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1663 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1666 /* Set the ELF flags if desired. */
1667 if (ppc_flags
&& !msolaris
)
1668 bfd_set_private_flags (stdoutput
, ppc_flags
);
1671 ppc_setup_opcodes ();
1673 /* Tell the main code what the endianness is if it is not overridden
1675 if (!set_target_endian
)
1677 set_target_endian
= 1;
1678 target_big_endian
= PPC_BIG_ENDIAN
;
1682 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1684 /* Create dummy symbols to serve as initial csects. This forces the
1685 text csects to precede the data csects. These symbols will not
1687 ppc_text_csects
= symbol_make ("dummy\001");
1688 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1689 ppc_data_csects
= symbol_make ("dummy\001");
1690 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1695 ppc_current_section
= text_section
;
1696 ppc_previous_section
= 0;
1705 if (ppc_apuinfo_list
== NULL
)
1708 /* Ok, so write the section info out. We have this layout:
1712 0 8 length of "APUinfo\0"
1713 4 (n*4) number of APU's (4 bytes each)
1716 20 APU#1 first APU's info
1717 24 APU#2 second APU's info
1722 asection
*seg
= now_seg
;
1723 subsegT subseg
= now_subseg
;
1724 asection
*apuinfo_secp
= (asection
*) NULL
;
1727 /* Create the .PPC.EMB.apuinfo section. */
1728 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1729 bfd_set_section_flags (stdoutput
,
1731 SEC_HAS_CONTENTS
| SEC_READONLY
);
1734 md_number_to_chars (p
, (valueT
) 8, 4);
1737 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1740 md_number_to_chars (p
, (valueT
) 2, 4);
1743 strcpy (p
, "APUinfo");
1745 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1748 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1751 frag_align (2, 0, 0);
1753 /* We probably can't restore the current segment, for there likely
1756 subseg_set (seg
, subseg
);
1761 /* Insert an operand value into an instruction. */
1763 static unsigned long
1764 ppc_insert_operand (unsigned long insn
,
1765 const struct powerpc_operand
*operand
,
1771 long min
, max
, right
;
1773 max
= operand
->bitm
;
1777 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1779 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1780 max
= (max
>> 1) & -right
;
1781 min
= ~max
& -right
;
1784 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1787 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1796 /* Some people write constants with the sign extension done by
1797 hand but only up to 32 bits. This shouldn't really be valid,
1798 but, to permit this code to assemble on a 64-bit host, we
1799 sign extend the 32-bit value to 64 bits if so doing makes the
1802 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1803 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1804 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1805 val
= val
- 0x80000000 - 0x80000000;
1807 /* Similarly, people write expressions like ~(1<<15), and expect
1808 this to be OK for a 32-bit unsigned value. */
1810 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1811 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1812 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1813 val
= val
+ 0x80000000 + 0x80000000;
1817 || (val
& (right
- 1)) != 0)
1818 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1821 if (operand
->insert
)
1826 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1827 if (errmsg
!= (const char *) NULL
)
1828 as_bad_where (file
, line
, "%s", errmsg
);
1830 else if (operand
->shift
>= 0)
1831 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1833 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1840 /* Parse @got, etc. and return the desired relocation. */
1841 static bfd_reloc_code_real_type
1842 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1846 unsigned int length
: 8;
1847 unsigned int valid32
: 1;
1848 unsigned int valid64
: 1;
1857 const struct map_bfd
*ptr
;
1859 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1860 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1861 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1863 static const struct map_bfd mapping
[] = {
1864 MAP ("l", BFD_RELOC_LO16
),
1865 MAP ("h", BFD_RELOC_HI16
),
1866 MAP ("ha", BFD_RELOC_HI16_S
),
1867 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1868 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1869 MAP ("got", BFD_RELOC_16_GOTOFF
),
1870 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1871 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1872 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1873 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1874 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1875 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1876 MAP ("copy", BFD_RELOC_PPC_COPY
),
1877 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1878 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1879 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1880 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1881 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1882 MAP ("tls", BFD_RELOC_PPC_TLS
),
1883 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1884 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1885 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1886 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1887 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1888 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1889 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1890 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1891 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1892 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1893 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1894 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1895 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1896 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1897 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1898 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1899 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1900 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1901 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1902 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1903 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1904 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1905 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1906 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1907 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1908 MAP32 ("fixup", BFD_RELOC_CTOR
),
1909 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1910 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1911 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1912 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1913 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1914 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1915 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1916 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1917 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1918 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1919 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1920 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1921 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1922 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1923 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1924 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1925 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1926 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1927 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1928 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1929 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1930 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1931 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1932 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1933 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1934 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1935 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1936 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1937 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1938 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1939 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1940 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1941 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1942 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1943 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1944 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1945 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1946 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1947 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1948 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1949 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1950 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1951 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1952 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1953 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1954 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1955 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1956 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1957 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1958 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1959 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1963 return BFD_RELOC_UNUSED
;
1965 for (ch
= *str
, str2
= ident
;
1966 (str2
< ident
+ sizeof (ident
) - 1
1967 && (ISALNUM (ch
) || ch
== '@'));
1970 *str2
++ = TOLOWER (ch
);
1977 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1978 if (ch
== ptr
->string
[0]
1979 && len
== ptr
->length
1980 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1981 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1983 int reloc
= ptr
->reloc
;
1985 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1989 case BFD_RELOC_16_GOTOFF
:
1990 case BFD_RELOC_LO16_GOTOFF
:
1991 case BFD_RELOC_HI16_GOTOFF
:
1992 case BFD_RELOC_HI16_S_GOTOFF
:
1993 as_warn (_("identifier+constant@got means "
1994 "identifier@got+constant"));
1997 case BFD_RELOC_PPC_GOT_TLSGD16
:
1998 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
1999 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2000 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2001 case BFD_RELOC_PPC_GOT_TLSLD16
:
2002 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2003 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2004 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2005 case BFD_RELOC_PPC_GOT_DTPREL16
:
2006 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2007 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2008 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2009 case BFD_RELOC_PPC_GOT_TPREL16
:
2010 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2011 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2012 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2013 as_bad (_("symbol+offset not supported for got tls"));
2018 /* Now check for identifier@suffix+constant. */
2019 if (*str
== '-' || *str
== '+')
2021 char *orig_line
= input_line_pointer
;
2022 expressionS new_exp
;
2024 input_line_pointer
= str
;
2025 expression (&new_exp
);
2026 if (new_exp
.X_op
== O_constant
)
2028 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2029 str
= input_line_pointer
;
2032 if (&input_line_pointer
!= str_p
)
2033 input_line_pointer
= orig_line
;
2037 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2038 && exp_p
->X_op
== O_symbol
2039 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2041 /* Change the symbol so that the dummy .TOC. symbol can be
2042 omitted from the object file. */
2043 exp_p
->X_add_symbol
= &abs_symbol
;
2046 return (bfd_reloc_code_real_type
) reloc
;
2049 return BFD_RELOC_UNUSED
;
2052 /* Like normal .long/.short/.word, except support @got, etc.
2053 Clobbers input_line_pointer, checks end-of-line. */
2055 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2058 bfd_reloc_code_real_type reloc
;
2060 if (is_it_end_of_statement ())
2062 demand_empty_rest_of_line ();
2069 if (*input_line_pointer
== '@'
2070 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2071 &exp
)) != BFD_RELOC_UNUSED
)
2073 reloc_howto_type
*reloc_howto
;
2076 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2077 size
= bfd_get_reloc_size (reloc_howto
);
2081 as_bad (_("%s relocations do not fit in %d bytes\n"),
2082 reloc_howto
->name
, nbytes
);
2089 p
= frag_more (nbytes
);
2090 memset (p
, 0, nbytes
);
2092 if (target_big_endian
)
2093 offset
= nbytes
- size
;
2094 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2099 emit_expr (&exp
, (unsigned int) nbytes
);
2101 while (*input_line_pointer
++ == ',');
2103 /* Put terminator back into stream. */
2104 input_line_pointer
--;
2105 demand_empty_rest_of_line ();
2108 /* Solaris pseduo op to change to the .rodata section. */
2110 ppc_elf_rdata (int xxx
)
2112 char *save_line
= input_line_pointer
;
2113 static char section
[] = ".rodata\n";
2115 /* Just pretend this is .section .rodata */
2116 input_line_pointer
= section
;
2117 obj_elf_section (xxx
);
2119 input_line_pointer
= save_line
;
2122 /* Pseudo op to make file scope bss items. */
2124 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2137 name
= input_line_pointer
;
2138 c
= get_symbol_end ();
2140 /* just after name is now '\0'. */
2141 p
= input_line_pointer
;
2144 if (*input_line_pointer
!= ',')
2146 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2147 ignore_rest_of_line ();
2151 input_line_pointer
++; /* skip ',' */
2152 if ((size
= get_absolute_expression ()) < 0)
2154 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2155 ignore_rest_of_line ();
2159 /* The third argument to .lcomm is the alignment. */
2160 if (*input_line_pointer
!= ',')
2164 ++input_line_pointer
;
2165 align
= get_absolute_expression ();
2168 as_warn (_("ignoring bad alignment"));
2174 symbolP
= symbol_find_or_make (name
);
2177 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2179 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2180 S_GET_NAME (symbolP
));
2181 ignore_rest_of_line ();
2185 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2187 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2188 S_GET_NAME (symbolP
),
2189 (long) S_GET_VALUE (symbolP
),
2192 ignore_rest_of_line ();
2198 old_subsec
= now_subseg
;
2201 /* Convert to a power of 2 alignment. */
2202 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2205 as_bad (_("common alignment not a power of 2"));
2206 ignore_rest_of_line ();
2213 record_alignment (bss_section
, align2
);
2214 subseg_set (bss_section
, 1);
2216 frag_align (align2
, 0, 0);
2217 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2218 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2219 symbol_set_frag (symbolP
, frag_now
);
2220 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2223 S_SET_SIZE (symbolP
, size
);
2224 S_SET_SEGMENT (symbolP
, bss_section
);
2225 subseg_set (old_sec
, old_subsec
);
2226 demand_empty_rest_of_line ();
2229 /* Pseudo op to set ABI version. */
2231 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2236 if (exp
.X_op
== O_absent
)
2238 as_bad (_("missing expression in .abiversion directive"));
2239 exp
.X_op
= O_constant
;
2240 exp
.X_add_number
= 0;
2243 if (resolve_expression (&exp
)
2244 && exp
.X_op
== O_constant
)
2245 ppc_abiversion
= exp
.X_add_number
;
2247 as_bad (_(".abiversion expression does not evaluate to a constant"));
2248 demand_empty_rest_of_line ();
2251 /* Set ABI version in output file. */
2255 if (ppc_obj64
&& ppc_abiversion
!= 0)
2257 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2258 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2262 /* Validate any relocations emitted for -mrelocatable, possibly adding
2263 fixups for word relocations in writable segments, so we can adjust
2266 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2268 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2277 case SHLIB_MRELOCATABLE
:
2278 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2279 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2280 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2281 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2282 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2283 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2284 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2285 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2286 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2287 && (seg
->flags
& SEC_LOAD
) != 0
2288 && strcmp (segment_name (seg
), ".got2") != 0
2289 && strcmp (segment_name (seg
), ".dtors") != 0
2290 && strcmp (segment_name (seg
), ".ctors") != 0
2291 && strcmp (segment_name (seg
), ".fixup") != 0
2292 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2293 && strcmp (segment_name (seg
), ".eh_frame") != 0
2294 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2296 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2297 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2299 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2300 _("relocation cannot be done when using -mrelocatable"));
2307 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2308 function descriptor sym if the corresponding code sym is used. */
2311 ppc_frob_file_before_adjust (void)
2319 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2326 name
= S_GET_NAME (symp
);
2330 if (! S_IS_WEAK (symp
)
2331 || S_IS_DEFINED (symp
))
2334 len
= strlen (name
) + 1;
2335 dotname
= xmalloc (len
+ 1);
2337 memcpy (dotname
+ 1, name
, len
);
2338 dotsym
= symbol_find_noref (dotname
, 1);
2340 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2341 || symbol_used_in_reloc_p (dotsym
)))
2342 symbol_mark_used (symp
);
2346 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2348 && toc_reloc_types
!= has_large_toc_reloc
2349 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2350 as_warn (_("TOC section size exceeds 64k"));
2353 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2354 emitted. Other uses of .TOC. will cause the symbol to be marked
2355 with BSF_KEEP in md_apply_fix. */
2358 ppc_elf_adjust_symtab (void)
2363 symp
= symbol_find (".TOC.");
2366 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2367 if ((bsym
->flags
& BSF_KEEP
) == 0)
2368 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2372 #endif /* OBJ_ELF */
2377 * Summary of parse_toc_entry.
2379 * in: Input_line_pointer points to the '[' in one of:
2381 * [toc] [tocv] [toc32] [toc64]
2383 * Anything else is an error of one kind or another.
2386 * return value: success or failure
2387 * toc_kind: kind of toc reference
2388 * input_line_pointer:
2389 * success: first char after the ']'
2390 * failure: unchanged
2394 * [toc] - rv == success, toc_kind = default_toc
2395 * [tocv] - rv == success, toc_kind = data_in_toc
2396 * [toc32] - rv == success, toc_kind = must_be_32
2397 * [toc64] - rv == success, toc_kind = must_be_64
2401 enum toc_size_qualifier
2403 default_toc
, /* The toc cell constructed should be the system default size */
2404 data_in_toc
, /* This is a direct reference to a toc cell */
2405 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2406 must_be_64
/* The toc cell constructed must be 64 bits wide */
2410 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2415 enum toc_size_qualifier t
;
2417 /* Save the input_line_pointer. */
2418 start
= input_line_pointer
;
2420 /* Skip over the '[' , and whitespace. */
2421 ++input_line_pointer
;
2424 /* Find the spelling of the operand. */
2425 toc_spec
= input_line_pointer
;
2426 c
= get_symbol_end ();
2428 if (strcmp (toc_spec
, "toc") == 0)
2432 else if (strcmp (toc_spec
, "tocv") == 0)
2436 else if (strcmp (toc_spec
, "toc32") == 0)
2440 else if (strcmp (toc_spec
, "toc64") == 0)
2446 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2447 *input_line_pointer
= c
;
2448 input_line_pointer
= start
;
2452 /* Now find the ']'. */
2453 *input_line_pointer
= c
;
2455 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2456 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2460 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2461 input_line_pointer
= start
;
2470 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2471 /* See whether a symbol is in the TOC section. */
2474 ppc_is_toc_sym (symbolS
*sym
)
2477 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2478 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2481 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2483 return strcmp (sname
, ".toc") == 0;
2485 return strcmp (sname
, ".got") == 0;
2488 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2492 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2494 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2498 /* Check we don't already exist. */
2499 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2500 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2503 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2505 if (ppc_apuinfo_num_alloc
== 0)
2507 ppc_apuinfo_num_alloc
= 4;
2508 ppc_apuinfo_list
= (unsigned long *)
2509 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2513 ppc_apuinfo_num_alloc
+= 4;
2514 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2515 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2518 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2524 /* We need to keep a list of fixups. We can't simply generate them as
2525 we go, because that would require us to first create the frag, and
2526 that would screw up references to ``.''. */
2532 bfd_reloc_code_real_type reloc
;
2535 #define MAX_INSN_FIXUPS (5)
2538 #define E_OR2I_INSN 0x7000C000
2539 #define E_AND2I_DOT_INSN 0x7000C800
2540 #define E_OR2IS_INSN 0x7000D000
2541 #define E_LIS_INSN 0x7000E000
2542 #define E_AND2IS_DOT_INSN 0x7000E800
2545 #define E_ADD2I_DOT_INSN 0x70008800
2546 #define E_ADD2IS_INSN 0x70009000
2547 #define E_CMP16I_INSN 0x70009800
2548 #define E_MULL2I_INSN 0x7000A000
2549 #define E_CMPL16I_INSN 0x7000A800
2550 #define E_CMPH16I_INSN 0x7000B000
2551 #define E_CMPHL16I_INSN 0x7000B800
2553 /* This routine is called for each instruction to be assembled. */
2556 md_assemble (char *str
)
2559 const struct powerpc_opcode
*opcode
;
2561 const unsigned char *opindex_ptr
;
2565 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2570 unsigned int insn_length
;
2572 /* Get the opcode. */
2573 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2578 /* Look up the opcode in the hash table. */
2579 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2580 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2582 const struct powerpc_macro
*macro
;
2584 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2585 if (macro
== (const struct powerpc_macro
*) NULL
)
2586 as_bad (_("unrecognized opcode: `%s'"), str
);
2588 ppc_macro (s
, macro
);
2593 insn
= opcode
->opcode
;
2596 while (ISSPACE (*str
))
2599 /* PowerPC operands are just expressions. The only real issue is
2600 that a few operand types are optional. All cases which might use
2601 an optional operand separate the operands only with commas (in some
2602 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2603 have optional operands). Most instructions with optional operands
2604 have only one. Those that have more than one optional operand can
2605 take either all their operands or none. So, before we start seriously
2606 parsing the operands, we check to see if we have optional operands,
2607 and if we do, we count the number of commas to see which operands
2608 have been omitted. */
2610 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2612 const struct powerpc_operand
*operand
;
2614 operand
= &powerpc_operands
[*opindex_ptr
];
2615 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2617 unsigned int opcount
;
2618 unsigned int num_operands_expected
;
2620 /* There is an optional operand. Count the number of
2621 commas in the input line. */
2628 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2635 /* Compute the number of expected operands.
2636 Do not count fake operands. */
2637 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2638 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2639 ++ num_operands_expected
;
2641 /* If there are fewer operands in the line then are called
2642 for by the instruction, we want to skip the optional
2644 if (opcount
< num_operands_expected
)
2651 /* Gather the operands. */
2655 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2657 const struct powerpc_operand
*operand
;
2663 if (next_opindex
== 0)
2664 operand
= &powerpc_operands
[*opindex_ptr
];
2667 operand
= &powerpc_operands
[next_opindex
];
2672 /* If this is a fake operand, then we do not expect anything
2674 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2676 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2677 if (errmsg
!= (const char *) NULL
)
2678 as_bad ("%s", errmsg
);
2682 /* If this is an optional operand, and we are skipping it, just
2684 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2687 if (operand
->insert
)
2689 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2690 if (errmsg
!= (const char *) NULL
)
2691 as_bad ("%s", errmsg
);
2693 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2694 next_opindex
= *opindex_ptr
+ 1;
2698 /* Gather the operand. */
2699 hold
= input_line_pointer
;
2700 input_line_pointer
= str
;
2703 if (*input_line_pointer
== '[')
2705 /* We are expecting something like the second argument here:
2707 * lwz r4,[toc].GS.0.static_int(rtoc)
2708 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2709 * The argument following the `]' must be a symbol name, and the
2710 * register must be the toc register: 'rtoc' or '2'
2712 * The effect is to 0 as the displacement field
2713 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2714 * the appropriate variation) reloc against it based on the symbol.
2715 * The linker will build the toc, and insert the resolved toc offset.
2718 * o The size of the toc entry is currently assumed to be
2719 * 32 bits. This should not be assumed to be a hard coded
2721 * o In an effort to cope with a change from 32 to 64 bits,
2722 * there are also toc entries that are specified to be
2723 * either 32 or 64 bits:
2724 * lwz r4,[toc32].GS.0.static_int(rtoc)
2725 * lwz r4,[toc64].GS.0.static_int(rtoc)
2726 * These demand toc entries of the specified size, and the
2727 * instruction probably requires it.
2731 enum toc_size_qualifier toc_kind
;
2732 bfd_reloc_code_real_type toc_reloc
;
2734 /* Go parse off the [tocXX] part. */
2735 valid_toc
= parse_toc_entry (&toc_kind
);
2739 ignore_rest_of_line ();
2743 /* Now get the symbol following the ']'. */
2749 /* In this case, we may not have seen the symbol yet,
2750 since it is allowed to appear on a .extern or .globl
2751 or just be a label in the .data section. */
2752 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2755 /* 1. The symbol must be defined and either in the toc
2756 section, or a global.
2757 2. The reloc generated must have the TOCDEFN flag set
2758 in upper bit mess of the reloc type.
2759 FIXME: It's a little confusing what the tocv
2760 qualifier can be used for. At the very least, I've
2761 seen three uses, only one of which I'm sure I can
2763 if (ex
.X_op
== O_symbol
)
2765 gas_assert (ex
.X_add_symbol
!= NULL
);
2766 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2769 as_bad (_("[tocv] symbol is not a toc symbol"));
2773 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2776 /* FIXME: these next two specifically specify 32/64 bit
2777 toc entries. We don't support them today. Is this
2778 the right way to say that? */
2779 toc_reloc
= BFD_RELOC_UNUSED
;
2780 as_bad (_("unimplemented toc32 expression modifier"));
2783 /* FIXME: see above. */
2784 toc_reloc
= BFD_RELOC_UNUSED
;
2785 as_bad (_("unimplemented toc64 expression modifier"));
2789 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2795 /* We need to generate a fixup for this expression. */
2796 if (fc
>= MAX_INSN_FIXUPS
)
2797 as_fatal (_("too many fixups"));
2799 fixups
[fc
].reloc
= toc_reloc
;
2800 fixups
[fc
].exp
= ex
;
2801 fixups
[fc
].opindex
= *opindex_ptr
;
2804 /* Ok. We've set up the fixup for the instruction. Now make it
2805 look like the constant 0 was found here. */
2807 ex
.X_op
= O_constant
;
2808 ex
.X_add_number
= 0;
2809 ex
.X_add_symbol
= NULL
;
2810 ex
.X_op_symbol
= NULL
;
2817 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2818 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2819 || !register_name (&ex
))
2821 char save_lex
= lex_type
['%'];
2823 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2824 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2827 lex_type
['%'] |= LEX_BEGIN_NAME
;
2831 lex_type
['%'] = save_lex
;
2835 str
= input_line_pointer
;
2836 input_line_pointer
= hold
;
2838 if (ex
.X_op
== O_illegal
)
2839 as_bad (_("illegal operand"));
2840 else if (ex
.X_op
== O_absent
)
2841 as_bad (_("missing operand"));
2842 else if (ex
.X_op
== O_register
)
2844 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2845 ppc_cpu
, (char *) NULL
, 0);
2847 else if (ex
.X_op
== O_constant
)
2850 /* Allow @HA, @L, @H on constants. */
2851 bfd_reloc_code_real_type reloc
;
2852 char *orig_str
= str
;
2854 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2861 case BFD_RELOC_LO16
:
2862 ex
.X_add_number
&= 0xffff;
2863 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2864 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2867 case BFD_RELOC_HI16
:
2868 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2870 /* PowerPC64 @h is tested for overflow. */
2871 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2872 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2874 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2876 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2882 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2883 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2884 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2885 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2888 case BFD_RELOC_HI16_S
:
2889 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2891 /* PowerPC64 @ha is tested for overflow. */
2893 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2894 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2896 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2898 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2904 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2905 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2906 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2907 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2910 case BFD_RELOC_PPC64_HIGHER
:
2911 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2912 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2913 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2916 case BFD_RELOC_PPC64_HIGHER_S
:
2917 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2918 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2919 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2922 case BFD_RELOC_PPC64_HIGHEST
:
2923 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2924 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2925 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2928 case BFD_RELOC_PPC64_HIGHEST_S
:
2929 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2930 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2931 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2934 #endif /* OBJ_ELF */
2935 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2936 ppc_cpu
, (char *) NULL
, 0);
2940 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
2942 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2944 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2945 if (sym_name
[0] == '.')
2948 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2950 expressionS tls_exp
;
2952 hold
= input_line_pointer
;
2953 input_line_pointer
= str
+ 1;
2954 expression (&tls_exp
);
2955 if (tls_exp
.X_op
== O_symbol
)
2957 reloc
= BFD_RELOC_UNUSED
;
2958 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2960 reloc
= BFD_RELOC_PPC_TLSGD
;
2961 input_line_pointer
+= 7;
2963 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2965 reloc
= BFD_RELOC_PPC_TLSLD
;
2966 input_line_pointer
+= 7;
2968 if (reloc
!= BFD_RELOC_UNUSED
)
2971 str
= input_line_pointer
;
2973 if (fc
>= MAX_INSN_FIXUPS
)
2974 as_fatal (_("too many fixups"));
2975 fixups
[fc
].exp
= tls_exp
;
2976 fixups
[fc
].opindex
= *opindex_ptr
;
2977 fixups
[fc
].reloc
= reloc
;
2981 input_line_pointer
= hold
;
2985 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2987 /* Some TLS tweaks. */
2993 case BFD_RELOC_PPC_TLS
:
2994 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2995 as_bad (_("@tls may not be used with \"%s\" operands"),
2997 else if (operand
->shift
!= 11)
2998 as_bad (_("@tls may only be used in last operand"));
3000 insn
= ppc_insert_operand (insn
, operand
,
3002 ppc_cpu
, (char *) NULL
, 0);
3005 /* We'll only use the 32 (or 64) bit form of these relocations
3006 in constants. Instructions get the 16 bit form. */
3007 case BFD_RELOC_PPC_DTPREL
:
3008 reloc
= BFD_RELOC_PPC_DTPREL16
;
3010 case BFD_RELOC_PPC_TPREL
:
3011 reloc
= BFD_RELOC_PPC_TPREL16
;
3015 /* If VLE-mode convert LO/HI/HA relocations. */
3016 if (opcode
->flags
& PPC_OPCODE_VLE
)
3018 int tmp_insn
= insn
& opcode
->mask
;
3020 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3021 || tmp_insn
== E_AND2I_DOT_INSN
3022 || tmp_insn
== E_OR2IS_INSN
3023 || tmp_insn
== E_LIS_INSN
3024 || tmp_insn
== E_AND2IS_DOT_INSN
);
3027 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3028 || tmp_insn
== E_ADD2IS_INSN
3029 || tmp_insn
== E_CMP16I_INSN
3030 || tmp_insn
== E_MULL2I_INSN
3031 || tmp_insn
== E_CMPL16I_INSN
3032 || tmp_insn
== E_CMPH16I_INSN
3033 || tmp_insn
== E_CMPHL16I_INSN
);
3040 case BFD_RELOC_PPC_EMB_SDA21
:
3041 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3044 case BFD_RELOC_LO16
:
3046 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3047 else if (use_a_reloc
)
3048 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3051 case BFD_RELOC_HI16
:
3053 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3054 else if (use_a_reloc
)
3055 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3058 case BFD_RELOC_HI16_S
:
3060 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3061 else if (use_a_reloc
)
3062 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3065 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3067 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3070 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3072 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3075 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3077 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3082 /* For the absolute forms of branches, convert the PC
3083 relative form back into the absolute. */
3084 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3088 case BFD_RELOC_PPC_B26
:
3089 reloc
= BFD_RELOC_PPC_BA26
;
3091 case BFD_RELOC_PPC_B16
:
3092 reloc
= BFD_RELOC_PPC_BA16
;
3094 case BFD_RELOC_PPC_B16_BRTAKEN
:
3095 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3097 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3098 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3107 case BFD_RELOC_PPC_TOC16
:
3108 toc_reloc_types
|= has_small_toc_reloc
;
3110 case BFD_RELOC_PPC64_TOC16_LO
:
3111 case BFD_RELOC_PPC64_TOC16_HI
:
3112 case BFD_RELOC_PPC64_TOC16_HA
:
3113 toc_reloc_types
|= has_large_toc_reloc
;
3119 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3124 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3126 case BFD_RELOC_LO16
:
3127 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3129 case BFD_RELOC_16_GOTOFF
:
3130 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3132 case BFD_RELOC_LO16_GOTOFF
:
3133 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3135 case BFD_RELOC_LO16_PLTOFF
:
3136 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3138 case BFD_RELOC_16_BASEREL
:
3139 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3141 case BFD_RELOC_LO16_BASEREL
:
3142 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3144 case BFD_RELOC_PPC_TOC16
:
3145 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3147 case BFD_RELOC_PPC64_TOC16_LO
:
3148 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3150 case BFD_RELOC_PPC64_PLTGOT16
:
3151 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3153 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3154 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3156 case BFD_RELOC_PPC_DTPREL16
:
3157 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3159 case BFD_RELOC_PPC_DTPREL16_LO
:
3160 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3162 case BFD_RELOC_PPC_TPREL16
:
3163 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3165 case BFD_RELOC_PPC_TPREL16_LO
:
3166 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3168 case BFD_RELOC_PPC_GOT_DTPREL16
:
3169 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3170 case BFD_RELOC_PPC_GOT_TPREL16
:
3171 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3174 as_bad (_("unsupported relocation for DS offset field"));
3179 #endif /* OBJ_ELF */
3181 if (reloc
!= BFD_RELOC_UNUSED
)
3183 /* Determine a BFD reloc value based on the operand information.
3184 We are only prepared to turn a few of the operands into
3186 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3187 && operand
->bitm
== 0x3fffffc
3188 && operand
->shift
== 0)
3189 reloc
= BFD_RELOC_PPC_B26
;
3190 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3191 && operand
->bitm
== 0xfffc
3192 && operand
->shift
== 0)
3193 reloc
= BFD_RELOC_PPC_B16
;
3194 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3195 && operand
->bitm
== 0x1fe
3196 && operand
->shift
== -1)
3197 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3198 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3199 && operand
->bitm
== 0xfffe
3200 && operand
->shift
== 0)
3201 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3202 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3203 && operand
->bitm
== 0x1fffffe
3204 && operand
->shift
== 0)
3205 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3206 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3207 && operand
->bitm
== 0x3fffffc
3208 && operand
->shift
== 0)
3209 reloc
= BFD_RELOC_PPC_BA26
;
3210 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3211 && operand
->bitm
== 0xfffc
3212 && operand
->shift
== 0)
3213 reloc
= BFD_RELOC_PPC_BA16
;
3214 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3215 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3216 && (operand
->bitm
& 0xfff0) == 0xfff0
3217 && operand
->shift
== 0)
3219 /* Note: the symbol may be not yet defined. */
3220 if (ppc_is_toc_sym (ex
.X_add_symbol
))
3222 reloc
= BFD_RELOC_PPC_TOC16
;
3225 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3226 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3231 reloc
= BFD_RELOC_16
;
3234 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3235 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3239 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3241 /* We need to generate a fixup for this expression. */
3242 if (fc
>= MAX_INSN_FIXUPS
)
3243 as_fatal (_("too many fixups"));
3244 fixups
[fc
].exp
= ex
;
3245 fixups
[fc
].opindex
= *opindex_ptr
;
3246 fixups
[fc
].reloc
= reloc
;
3254 /* If expecting more operands, then we want to see "),". */
3255 if (*str
== endc
&& opindex_ptr
[1] != 0)
3259 while (ISSPACE (*str
));
3263 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3271 /* The call to expression should have advanced str past any
3274 && (endc
!= ',' || *str
!= '\0'))
3277 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3279 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3287 while (ISSPACE (*str
))
3291 as_bad (_("junk at end of line: `%s'"), str
);
3294 /* Do we need/want an APUinfo section? */
3295 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3298 /* These are all version "1". */
3299 if (opcode
->flags
& PPC_OPCODE_SPE
)
3300 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3301 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3302 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3303 if (opcode
->flags
& PPC_OPCODE_EFS
)
3304 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3305 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3306 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3307 if (opcode
->flags
& PPC_OPCODE_PMR
)
3308 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3309 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3310 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3311 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3312 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3313 if (opcode
->flags
& PPC_OPCODE_VLE
)
3314 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3318 /* Write out the instruction. */
3319 /* Differentiate between two and four byte insns. */
3320 if (ppc_mach () == bfd_mach_ppc_vle
)
3322 if (PPC_OP_SE_VLE (insn
))
3326 addr_mod
= frag_now_fix () & 1;
3331 addr_mod
= frag_now_fix () & 3;
3333 /* All instructions can start on a 2 byte boundary for VLE. */
3334 f
= frag_more (insn_length
);
3335 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3337 if (ppc_mach() == bfd_mach_ppc_vle
)
3338 as_bad (_("instruction address is not a multiple of 2"));
3340 as_bad (_("instruction address is not a multiple of 4"));
3342 frag_now
->insn_addr
= addr_mod
;
3343 frag_now
->has_code
= 1;
3344 md_number_to_chars (f
, insn
, insn_length
);
3347 dwarf2_emit_insn (insn_length
);
3350 /* Create any fixups. */
3351 for (i
= 0; i
< fc
; i
++)
3354 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3356 reloc_howto_type
*reloc_howto
;
3360 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3364 size
= bfd_get_reloc_size (reloc_howto
);
3365 offset
= target_big_endian
? (insn_length
- size
) : 0;
3367 if (size
< 1 || size
> 4)
3370 fixP
= fix_new_exp (frag_now
,
3371 f
- frag_now
->fr_literal
+ offset
,
3374 reloc_howto
->pc_relative
,
3379 const struct powerpc_operand
*operand
;
3381 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3382 fixP
= fix_new_exp (frag_now
,
3383 f
- frag_now
->fr_literal
,
3386 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3389 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3393 /* Handle a macro. Gather all the operands, transform them as
3394 described by the macro, and call md_assemble recursively. All the
3395 operands are separated by commas; we don't accept parentheses
3396 around operands here. */
3399 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3410 /* Gather the users operands into the operands array. */
3415 if (count
>= sizeof operands
/ sizeof operands
[0])
3417 operands
[count
++] = s
;
3418 s
= strchr (s
, ',');
3419 if (s
== (char *) NULL
)
3424 if (count
!= macro
->operands
)
3426 as_bad (_("wrong number of operands"));
3430 /* Work out how large the string must be (the size is unbounded
3431 because it includes user input). */
3433 format
= macro
->format
;
3434 while (*format
!= '\0')
3443 arg
= strtol (format
+ 1, &send
, 10);
3444 know (send
!= format
&& arg
< count
);
3445 len
+= strlen (operands
[arg
]);
3450 /* Put the string together. */
3451 complete
= s
= (char *) alloca (len
+ 1);
3452 format
= macro
->format
;
3453 while (*format
!= '\0')
3459 arg
= strtol (format
+ 1, &send
, 10);
3460 strcpy (s
, operands
[arg
]);
3467 /* Assemble the constructed instruction. */
3468 md_assemble (complete
);
3472 /* For ELF, add support for SHT_ORDERED. */
3475 ppc_section_type (char *str
, size_t len
)
3477 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3484 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3486 if (type
== SHT_ORDERED
)
3487 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3491 #endif /* OBJ_ELF */
3494 /* Pseudo-op handling. */
3496 /* The .byte pseudo-op. This is similar to the normal .byte
3497 pseudo-op, but it can also take a single ASCII string. */
3500 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3502 if (*input_line_pointer
!= '\"')
3508 /* Gather characters. A real double quote is doubled. Unusual
3509 characters are not permitted. */
3510 ++input_line_pointer
;
3515 c
= *input_line_pointer
++;
3519 if (*input_line_pointer
!= '\"')
3521 ++input_line_pointer
;
3524 FRAG_APPEND_1_CHAR (c
);
3527 demand_empty_rest_of_line ();
3532 /* XCOFF specific pseudo-op handling. */
3534 /* This is set if we are creating a .stabx symbol, since we don't want
3535 to handle symbol suffixes for such symbols. */
3536 static bfd_boolean ppc_stab_symbol
;
3538 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3539 symbols in the .bss segment as though they were local common
3540 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3541 aligns .comm and .lcomm to 4 bytes. */
3544 ppc_comm (int lcomm
)
3546 asection
*current_seg
= now_seg
;
3547 subsegT current_subseg
= now_subseg
;
3553 symbolS
*lcomm_sym
= NULL
;
3557 name
= input_line_pointer
;
3558 endc
= get_symbol_end ();
3559 end_name
= input_line_pointer
;
3562 if (*input_line_pointer
!= ',')
3564 as_bad (_("missing size"));
3565 ignore_rest_of_line ();
3568 ++input_line_pointer
;
3570 size
= get_absolute_expression ();
3573 as_bad (_("negative size"));
3574 ignore_rest_of_line ();
3580 /* The third argument to .comm is the alignment. */
3581 if (*input_line_pointer
!= ',')
3585 ++input_line_pointer
;
3586 align
= get_absolute_expression ();
3589 as_warn (_("ignoring bad alignment"));
3599 /* The third argument to .lcomm appears to be the real local
3600 common symbol to create. References to the symbol named in
3601 the first argument are turned into references to the third
3603 if (*input_line_pointer
!= ',')
3605 as_bad (_("missing real symbol name"));
3606 ignore_rest_of_line ();
3609 ++input_line_pointer
;
3611 lcomm_name
= input_line_pointer
;
3612 lcomm_endc
= get_symbol_end ();
3614 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3616 *input_line_pointer
= lcomm_endc
;
3618 /* The fourth argument to .lcomm is the alignment. */
3619 if (*input_line_pointer
!= ',')
3628 ++input_line_pointer
;
3629 align
= get_absolute_expression ();
3632 as_warn (_("ignoring bad alignment"));
3639 sym
= symbol_find_or_make (name
);
3642 if (S_IS_DEFINED (sym
)
3643 || S_GET_VALUE (sym
) != 0)
3645 as_bad (_("attempt to redefine symbol"));
3646 ignore_rest_of_line ();
3650 record_alignment (bss_section
, align
);
3653 || ! S_IS_DEFINED (lcomm_sym
))
3662 S_SET_EXTERNAL (sym
);
3666 symbol_get_tc (lcomm_sym
)->output
= 1;
3667 def_sym
= lcomm_sym
;
3671 subseg_set (bss_section
, 1);
3672 frag_align (align
, 0, 0);
3674 symbol_set_frag (def_sym
, frag_now
);
3675 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3676 def_size
, (char *) NULL
);
3678 S_SET_SEGMENT (def_sym
, bss_section
);
3679 symbol_get_tc (def_sym
)->align
= align
;
3683 /* Align the size of lcomm_sym. */
3684 symbol_get_frag (lcomm_sym
)->fr_offset
=
3685 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3686 &~ ((1 << align
) - 1));
3687 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3688 symbol_get_tc (lcomm_sym
)->align
= align
;
3693 /* Make sym an offset from lcomm_sym. */
3694 S_SET_SEGMENT (sym
, bss_section
);
3695 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3696 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3697 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3700 subseg_set (current_seg
, current_subseg
);
3702 demand_empty_rest_of_line ();
3705 /* The .csect pseudo-op. This switches us into a different
3706 subsegment. The first argument is a symbol whose value is the
3707 start of the .csect. In COFF, csect symbols get special aux
3708 entries defined by the x_csect field of union internal_auxent. The
3709 optional second argument is the alignment (the default is 2). */
3712 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3719 name
= input_line_pointer
;
3720 endc
= get_symbol_end ();
3722 sym
= symbol_find_or_make (name
);
3724 *input_line_pointer
= endc
;
3726 if (S_GET_NAME (sym
)[0] == '\0')
3728 /* An unnamed csect is assumed to be [PR]. */
3729 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3733 if (*input_line_pointer
== ',')
3735 ++input_line_pointer
;
3736 align
= get_absolute_expression ();
3739 ppc_change_csect (sym
, align
);
3741 demand_empty_rest_of_line ();
3744 /* Change to a different csect. */
3747 ppc_change_csect (symbolS
*sym
, offsetT align
)
3749 if (S_IS_DEFINED (sym
))
3750 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3760 /* This is a new csect. We need to look at the symbol class to
3761 figure out whether it should go in the text section or the
3765 switch (symbol_get_tc (sym
)->symbol_class
)
3775 S_SET_SEGMENT (sym
, text_section
);
3776 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3777 ++ppc_text_subsegment
;
3778 list_ptr
= &ppc_text_csects
;
3788 if (ppc_toc_csect
!= NULL
3789 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3790 == ppc_data_subsegment
))
3792 S_SET_SEGMENT (sym
, data_section
);
3793 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3794 ++ppc_data_subsegment
;
3795 list_ptr
= &ppc_data_csects
;
3801 /* We set the obstack chunk size to a small value before
3802 changing subsegments, so that we don't use a lot of memory
3803 space for what may be a small section. */
3804 hold_chunksize
= chunksize
;
3807 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3808 symbol_get_tc (sym
)->subseg
);
3810 chunksize
= hold_chunksize
;
3813 ppc_after_toc_frag
= frag_now
;
3815 record_alignment (sec
, align
);
3817 frag_align_code (align
, 0);
3819 frag_align (align
, 0, 0);
3821 symbol_set_frag (sym
, frag_now
);
3822 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3824 symbol_get_tc (sym
)->align
= align
;
3825 symbol_get_tc (sym
)->output
= 1;
3826 symbol_get_tc (sym
)->within
= sym
;
3828 for (list
= *list_ptr
;
3829 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3830 list
= symbol_get_tc (list
)->next
)
3832 symbol_get_tc (list
)->next
= sym
;
3834 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3835 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3839 ppc_current_csect
= sym
;
3843 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3847 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3849 sec
= subseg_new (dw
->name
, subseg
);
3850 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3851 if (oldflags
== SEC_NO_FLAGS
)
3853 /* Just created section. */
3854 gas_assert (dw_sections
[idx
].sect
== NULL
);
3856 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3857 bfd_set_section_alignment (stdoutput
, sec
, 0);
3858 dw_sections
[idx
].sect
= sec
;
3861 /* Not anymore in a csect. */
3862 ppc_current_csect
= NULL
;
3865 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3866 .dwsect flag [, opt-label ]
3870 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3874 const struct xcoff_dwsect_name
*dw
;
3875 struct dw_subsection
*subseg
;
3876 struct dw_section
*dws
;
3880 flag
= get_absolute_expression ();
3882 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3883 if (xcoff_dwsect_names
[i
].flag
== flag
)
3885 dw
= &xcoff_dwsect_names
[i
];
3889 /* Parse opt-label. */
3890 if (*input_line_pointer
== ',')
3895 ++input_line_pointer
;
3897 label
= input_line_pointer
;
3898 c
= get_symbol_end ();
3899 opt_label
= symbol_find_or_make (label
);
3900 *input_line_pointer
= c
;
3905 demand_empty_rest_of_line ();
3907 /* Return now in case of unknown subsection. */
3910 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3915 /* Find the subsection. */
3916 dws
= &dw_sections
[i
];
3918 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3920 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3921 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3923 as_bad (_("label %s was not defined in this dwarf section"),
3924 S_GET_NAME (opt_label
));
3925 subseg
= dws
->anon_subseg
;
3929 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3934 /* Switch to the subsection. */
3935 ppc_change_debug_section (i
, subseg
->subseg
);
3939 /* Create a new dw subsection. */
3940 subseg
= (struct dw_subsection
*)
3941 xmalloc (sizeof (struct dw_subsection
));
3943 if (opt_label
== NULL
)
3945 /* The anonymous one. */
3947 subseg
->link
= NULL
;
3948 dws
->anon_subseg
= subseg
;
3953 if (dws
->list_subseg
!= NULL
)
3954 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3958 subseg
->link
= dws
->list_subseg
;
3959 dws
->list_subseg
= subseg
;
3960 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3963 ppc_change_debug_section (i
, subseg
->subseg
);
3967 /* Add the length field. */
3968 expressionS
*exp
= &subseg
->end_exp
;
3971 if (opt_label
!= NULL
)
3972 symbol_set_value_now (opt_label
);
3974 /* Add the length field. Note that according to the AIX assembler
3975 manual, the size of the length field is 4 for powerpc32 but
3976 12 for powerpc64. */
3979 /* Write the 64bit marker. */
3980 md_number_to_chars (frag_more (4), -1, 4);
3983 exp
->X_op
= O_subtract
;
3984 exp
->X_op_symbol
= symbol_temp_new_now ();
3985 exp
->X_add_symbol
= symbol_temp_make ();
3987 sz
= ppc_obj64
? 8 : 4;
3988 exp
->X_add_number
= -sz
;
3989 emit_expr (exp
, sz
);
3994 /* This function handles the .text and .data pseudo-ops. These
3995 pseudo-ops aren't really used by XCOFF; we implement them for the
3996 convenience of people who aren't used to XCOFF. */
3999 ppc_section (int type
)
4006 else if (type
== 'd')
4011 sym
= symbol_find_or_make (name
);
4013 ppc_change_csect (sym
, 2);
4015 demand_empty_rest_of_line ();
4018 /* This function handles the .section pseudo-op. This is mostly to
4019 give an error, since XCOFF only supports .text, .data and .bss, but
4020 we do permit the user to name the text or data section. */
4023 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4026 const char *real_name
;
4030 user_name
= input_line_pointer
;
4031 c
= get_symbol_end ();
4033 if (strcmp (user_name
, ".text") == 0)
4034 real_name
= ".text[PR]";
4035 else if (strcmp (user_name
, ".data") == 0)
4036 real_name
= ".data[RW]";
4039 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4040 *input_line_pointer
= c
;
4041 ignore_rest_of_line ();
4045 *input_line_pointer
= c
;
4047 sym
= symbol_find_or_make (real_name
);
4049 ppc_change_csect (sym
, 2);
4051 demand_empty_rest_of_line ();
4054 /* The .extern pseudo-op. We create an undefined symbol. */
4057 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4062 name
= input_line_pointer
;
4063 endc
= get_symbol_end ();
4065 (void) symbol_find_or_make (name
);
4067 *input_line_pointer
= endc
;
4069 demand_empty_rest_of_line ();
4072 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4075 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4081 name
= input_line_pointer
;
4082 endc
= get_symbol_end ();
4084 sym
= symbol_find_or_make (name
);
4086 *input_line_pointer
= endc
;
4088 symbol_get_tc (sym
)->output
= 1;
4090 demand_empty_rest_of_line ();
4093 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4094 relocations at the beginning of the current csect.
4096 (In principle, there's no reason why the relocations _have_ to be at
4097 the beginning. Anywhere in the csect would do. However, inserting
4098 at the beginning is what the native assmebler does, and it helps to
4099 deal with cases where the .ref statements follow the section contents.)
4101 ??? .refs don't work for empty .csects. However, the native assembler
4102 doesn't report an error in this case, and neither yet do we. */
4105 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4110 if (ppc_current_csect
== NULL
)
4112 as_bad (_(".ref outside .csect"));
4113 ignore_rest_of_line ();
4119 name
= input_line_pointer
;
4120 c
= get_symbol_end ();
4122 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4123 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4125 *input_line_pointer
= c
;
4127 c
= *input_line_pointer
;
4130 input_line_pointer
++;
4132 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4134 as_bad (_("missing symbol name"));
4135 ignore_rest_of_line ();
4142 demand_empty_rest_of_line ();
4145 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4146 although I don't know why it bothers. */
4149 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4156 name
= input_line_pointer
;
4157 endc
= get_symbol_end ();
4159 sym
= symbol_find_or_make (name
);
4161 *input_line_pointer
= endc
;
4163 if (*input_line_pointer
!= ',')
4165 as_bad (_("missing rename string"));
4166 ignore_rest_of_line ();
4169 ++input_line_pointer
;
4171 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4173 demand_empty_rest_of_line ();
4176 /* The .stabx pseudo-op. This is similar to a normal .stabs
4177 pseudo-op, but slightly different. A sample is
4178 .stabx "main:F-1",.main,142,0
4179 The first argument is the symbol name to create. The second is the
4180 value, and the third is the storage class. The fourth seems to be
4181 always zero, and I am assuming it is the type. */
4184 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4191 name
= demand_copy_C_string (&len
);
4193 if (*input_line_pointer
!= ',')
4195 as_bad (_("missing value"));
4198 ++input_line_pointer
;
4200 ppc_stab_symbol
= TRUE
;
4201 sym
= symbol_make (name
);
4202 ppc_stab_symbol
= FALSE
;
4204 symbol_get_tc (sym
)->real_name
= name
;
4206 (void) expression (&exp
);
4213 as_bad (_("illegal .stabx expression; zero assumed"));
4214 exp
.X_add_number
= 0;
4217 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4218 symbol_set_frag (sym
, &zero_address_frag
);
4222 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4223 symbol_set_value_expression (sym
, &exp
);
4227 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4228 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4233 /* The value is some complex expression. This will probably
4234 fail at some later point, but this is probably the right
4235 thing to do here. */
4236 symbol_set_value_expression (sym
, &exp
);
4240 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4241 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4243 if (*input_line_pointer
!= ',')
4245 as_bad (_("missing class"));
4248 ++input_line_pointer
;
4250 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4252 if (*input_line_pointer
!= ',')
4254 as_bad (_("missing type"));
4257 ++input_line_pointer
;
4259 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4261 symbol_get_tc (sym
)->output
= 1;
4263 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4268 .stabx "z",arrays_,133,0
4271 .comm arrays_,13768,3
4273 resolve_symbol_value will copy the exp's "within" into sym's when the
4274 offset is 0. Since this seems to be corner case problem,
4275 only do the correction for storage class C_STSYM. A better solution
4276 would be to have the tc field updated in ppc_symbol_new_hook. */
4278 if (exp
.X_op
== O_symbol
)
4280 if (ppc_current_block
== NULL
)
4281 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4283 symbol_get_tc (sym
)->within
= ppc_current_block
;
4284 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4288 if (exp
.X_op
!= O_symbol
4289 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4290 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4291 ppc_frob_label (sym
);
4294 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4295 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4296 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4297 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4300 demand_empty_rest_of_line ();
4303 /* The .function pseudo-op. This takes several arguments. The first
4304 argument seems to be the external name of the symbol. The second
4305 argument seems to be the label for the start of the function. gcc
4306 uses the same name for both. I have no idea what the third and
4307 fourth arguments are meant to be. The optional fifth argument is
4308 an expression for the size of the function. In COFF this symbol
4309 gets an aux entry like that used for a csect. */
4312 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4320 name
= input_line_pointer
;
4321 endc
= get_symbol_end ();
4323 /* Ignore any [PR] suffix. */
4324 name
= ppc_canonicalize_symbol_name (name
);
4325 s
= strchr (name
, '[');
4326 if (s
!= (char *) NULL
4327 && strcmp (s
+ 1, "PR]") == 0)
4330 ext_sym
= symbol_find_or_make (name
);
4332 *input_line_pointer
= endc
;
4334 if (*input_line_pointer
!= ',')
4336 as_bad (_("missing symbol name"));
4337 ignore_rest_of_line ();
4340 ++input_line_pointer
;
4342 name
= input_line_pointer
;
4343 endc
= get_symbol_end ();
4345 lab_sym
= symbol_find_or_make (name
);
4347 *input_line_pointer
= endc
;
4349 if (ext_sym
!= lab_sym
)
4353 exp
.X_op
= O_symbol
;
4354 exp
.X_add_symbol
= lab_sym
;
4355 exp
.X_op_symbol
= NULL
;
4356 exp
.X_add_number
= 0;
4358 symbol_set_value_expression (ext_sym
, &exp
);
4361 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4362 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4363 symbol_get_tc (ext_sym
)->output
= 1;
4365 if (*input_line_pointer
== ',')
4369 /* Ignore the third argument. */
4370 ++input_line_pointer
;
4372 if (*input_line_pointer
== ',')
4374 /* Ignore the fourth argument. */
4375 ++input_line_pointer
;
4377 if (*input_line_pointer
== ',')
4379 /* The fifth argument is the function size. */
4380 ++input_line_pointer
;
4381 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4382 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4383 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4388 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4389 SF_SET_FUNCTION (ext_sym
);
4390 SF_SET_PROCESS (ext_sym
);
4391 coff_add_linesym (ext_sym
);
4393 demand_empty_rest_of_line ();
4396 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4397 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4398 with the correct line number */
4400 static symbolS
*saved_bi_sym
= 0;
4403 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4407 sym
= symbol_make (".bf");
4408 S_SET_SEGMENT (sym
, text_section
);
4409 symbol_set_frag (sym
, frag_now
);
4410 S_SET_VALUE (sym
, frag_now_fix ());
4411 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4413 coff_line_base
= get_absolute_expression ();
4415 S_SET_NUMBER_AUXILIARY (sym
, 1);
4416 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4418 /* Line number for bi. */
4421 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4426 symbol_get_tc (sym
)->output
= 1;
4428 ppc_frob_label (sym
);
4430 demand_empty_rest_of_line ();
4433 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4434 ".ef", except that the line number is absolute, not relative to the
4435 most recent ".bf" symbol. */
4438 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4442 sym
= symbol_make (".ef");
4443 S_SET_SEGMENT (sym
, text_section
);
4444 symbol_set_frag (sym
, frag_now
);
4445 S_SET_VALUE (sym
, frag_now_fix ());
4446 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4447 S_SET_NUMBER_AUXILIARY (sym
, 1);
4448 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4449 symbol_get_tc (sym
)->output
= 1;
4451 ppc_frob_label (sym
);
4453 demand_empty_rest_of_line ();
4456 /* The .bi and .ei pseudo-ops. These take a string argument and
4457 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4458 the symbol list. The value of .bi will be know when the next .bf
4464 static symbolS
*last_biei
;
4471 name
= demand_copy_C_string (&len
);
4473 /* The value of these symbols is actually file offset. Here we set
4474 the value to the index into the line number entries. In
4475 ppc_frob_symbols we set the fix_line field, which will cause BFD
4476 to do the right thing. */
4478 sym
= symbol_make (name
);
4479 /* obj-coff.c currently only handles line numbers correctly in the
4481 S_SET_SEGMENT (sym
, text_section
);
4482 S_SET_VALUE (sym
, coff_n_line_nos
);
4483 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4485 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4486 symbol_get_tc (sym
)->output
= 1;
4494 for (look
= last_biei
? last_biei
: symbol_rootP
;
4495 (look
!= (symbolS
*) NULL
4496 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4497 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4498 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4499 look
= symbol_next (look
))
4501 if (look
!= (symbolS
*) NULL
)
4503 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4504 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4508 demand_empty_rest_of_line ();
4511 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4512 There is one argument, which is a csect symbol. The value of the
4513 .bs symbol is the index of this csect symbol. */
4516 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4523 if (ppc_current_block
!= NULL
)
4524 as_bad (_("nested .bs blocks"));
4526 name
= input_line_pointer
;
4527 endc
= get_symbol_end ();
4529 csect
= symbol_find_or_make (name
);
4531 *input_line_pointer
= endc
;
4533 sym
= symbol_make (".bs");
4534 S_SET_SEGMENT (sym
, now_seg
);
4535 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4536 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4537 symbol_get_tc (sym
)->output
= 1;
4539 symbol_get_tc (sym
)->within
= csect
;
4541 ppc_frob_label (sym
);
4543 ppc_current_block
= sym
;
4545 demand_empty_rest_of_line ();
4548 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4551 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4555 if (ppc_current_block
== NULL
)
4556 as_bad (_(".es without preceding .bs"));
4558 sym
= symbol_make (".es");
4559 S_SET_SEGMENT (sym
, now_seg
);
4560 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4561 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4562 symbol_get_tc (sym
)->output
= 1;
4564 ppc_frob_label (sym
);
4566 ppc_current_block
= NULL
;
4568 demand_empty_rest_of_line ();
4571 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4575 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4579 sym
= symbol_make (".bb");
4580 S_SET_SEGMENT (sym
, text_section
);
4581 symbol_set_frag (sym
, frag_now
);
4582 S_SET_VALUE (sym
, frag_now_fix ());
4583 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4585 S_SET_NUMBER_AUXILIARY (sym
, 1);
4586 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4588 symbol_get_tc (sym
)->output
= 1;
4590 SF_SET_PROCESS (sym
);
4592 ppc_frob_label (sym
);
4594 demand_empty_rest_of_line ();
4597 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4601 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4605 sym
= symbol_make (".eb");
4606 S_SET_SEGMENT (sym
, text_section
);
4607 symbol_set_frag (sym
, frag_now
);
4608 S_SET_VALUE (sym
, frag_now_fix ());
4609 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4610 S_SET_NUMBER_AUXILIARY (sym
, 1);
4611 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4612 symbol_get_tc (sym
)->output
= 1;
4614 SF_SET_PROCESS (sym
);
4616 ppc_frob_label (sym
);
4618 demand_empty_rest_of_line ();
4621 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4625 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4631 name
= demand_copy_C_string (&len
);
4632 sym
= symbol_make (name
);
4633 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4634 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4635 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4636 S_SET_VALUE (sym
, 0);
4637 symbol_get_tc (sym
)->output
= 1;
4639 ppc_frob_label (sym
);
4641 demand_empty_rest_of_line ();
4644 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4647 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4651 sym
= symbol_make (".ec");
4652 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4653 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4654 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4655 S_SET_VALUE (sym
, 0);
4656 symbol_get_tc (sym
)->output
= 1;
4658 ppc_frob_label (sym
);
4660 demand_empty_rest_of_line ();
4663 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4666 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4668 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4669 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4676 subseg
= ppc_data_subsegment
;
4677 ++ppc_data_subsegment
;
4679 subseg_new (segment_name (data_section
), subseg
);
4680 ppc_toc_frag
= frag_now
;
4682 sym
= symbol_find_or_make ("TOC[TC0]");
4683 symbol_set_frag (sym
, frag_now
);
4684 S_SET_SEGMENT (sym
, data_section
);
4685 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4686 symbol_get_tc (sym
)->subseg
= subseg
;
4687 symbol_get_tc (sym
)->output
= 1;
4688 symbol_get_tc (sym
)->within
= sym
;
4690 ppc_toc_csect
= sym
;
4692 for (list
= ppc_data_csects
;
4693 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4694 list
= symbol_get_tc (list
)->next
)
4696 symbol_get_tc (list
)->next
= sym
;
4698 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4699 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4703 ppc_current_csect
= ppc_toc_csect
;
4705 demand_empty_rest_of_line ();
4708 /* The AIX assembler automatically aligns the operands of a .long or
4709 .short pseudo-op, and we want to be compatible. */
4712 ppc_xcoff_cons (int log_size
)
4714 frag_align (log_size
, 0, 0);
4715 record_alignment (now_seg
, log_size
);
4716 cons (1 << log_size
);
4720 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4725 (void) expression (&exp
);
4727 if (exp
.X_op
!= O_constant
)
4729 as_bad (_("non-constant byte count"));
4733 byte_count
= exp
.X_add_number
;
4735 if (*input_line_pointer
!= ',')
4737 as_bad (_("missing value"));
4741 ++input_line_pointer
;
4746 ppc_xcoff_end (void)
4750 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4752 struct dw_section
*dws
= &dw_sections
[i
];
4753 struct dw_subsection
*dwss
;
4755 if (dws
->anon_subseg
)
4757 dwss
= dws
->anon_subseg
;
4758 dwss
->link
= dws
->list_subseg
;
4761 dwss
= dws
->list_subseg
;
4763 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4764 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4766 subseg_set (dws
->sect
, dwss
->subseg
);
4767 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4772 #endif /* OBJ_XCOFF */
4773 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4775 /* The .tc pseudo-op. This is used when generating either XCOFF or
4776 ELF. This takes two or more arguments.
4778 When generating XCOFF output, the first argument is the name to
4779 give to this location in the toc; this will be a symbol with class
4780 TC. The rest of the arguments are N-byte values to actually put at
4781 this location in the TOC; often there is just one more argument, a
4782 relocatable symbol reference. The size of the value to store
4783 depends on target word size. A 32-bit target uses 4-byte values, a
4784 64-bit target uses 8-byte values.
4786 When not generating XCOFF output, the arguments are the same, but
4787 the first argument is simply ignored. */
4790 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4794 /* Define the TOC symbol name. */
4800 if (ppc_toc_csect
== (symbolS
*) NULL
4801 || ppc_toc_csect
!= ppc_current_csect
)
4803 as_bad (_(".tc not in .toc section"));
4804 ignore_rest_of_line ();
4808 name
= input_line_pointer
;
4809 endc
= get_symbol_end ();
4811 sym
= symbol_find_or_make (name
);
4813 *input_line_pointer
= endc
;
4815 if (S_IS_DEFINED (sym
))
4819 label
= symbol_get_tc (ppc_current_csect
)->within
;
4820 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4822 as_bad (_(".tc with no label"));
4823 ignore_rest_of_line ();
4827 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4828 symbol_set_frag (label
, symbol_get_frag (sym
));
4829 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4831 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4832 ++input_line_pointer
;
4837 S_SET_SEGMENT (sym
, now_seg
);
4838 symbol_set_frag (sym
, frag_now
);
4839 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4840 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4841 symbol_get_tc (sym
)->output
= 1;
4843 ppc_frob_label (sym
);
4846 #endif /* OBJ_XCOFF */
4850 /* Skip the TOC symbol name. */
4851 while (is_part_of_name (*input_line_pointer
)
4852 || *input_line_pointer
== ' '
4853 || *input_line_pointer
== '['
4854 || *input_line_pointer
== ']'
4855 || *input_line_pointer
== '{'
4856 || *input_line_pointer
== '}')
4857 ++input_line_pointer
;
4859 /* Align to a four/eight byte boundary. */
4860 align
= ppc_obj64
? 3 : 2;
4861 frag_align (align
, 0, 0);
4862 record_alignment (now_seg
, align
);
4863 #endif /* OBJ_ELF */
4865 if (*input_line_pointer
!= ',')
4866 demand_empty_rest_of_line ();
4869 ++input_line_pointer
;
4870 cons (ppc_obj64
? 8 : 4);
4874 /* Pseudo-op .machine. */
4877 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4880 #define MAX_HISTORY 100
4881 static ppc_cpu_t
*cpu_history
;
4882 static int curr_hist
;
4886 if (*input_line_pointer
== '"')
4889 cpu_string
= demand_copy_C_string (&len
);
4894 cpu_string
= input_line_pointer
;
4895 c
= get_symbol_end ();
4896 cpu_string
= xstrdup (cpu_string
);
4897 *input_line_pointer
= c
;
4900 if (cpu_string
!= NULL
)
4902 ppc_cpu_t old_cpu
= ppc_cpu
;
4906 for (p
= cpu_string
; *p
!= 0; p
++)
4909 if (strcmp (cpu_string
, "push") == 0)
4911 if (cpu_history
== NULL
)
4912 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4914 if (curr_hist
>= MAX_HISTORY
)
4915 as_bad (_(".machine stack overflow"));
4917 cpu_history
[curr_hist
++] = ppc_cpu
;
4919 else if (strcmp (cpu_string
, "pop") == 0)
4922 as_bad (_(".machine stack underflow"));
4924 ppc_cpu
= cpu_history
[--curr_hist
];
4926 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4929 as_bad (_("invalid machine `%s'"), cpu_string
);
4931 if (ppc_cpu
!= old_cpu
)
4932 ppc_setup_opcodes ();
4935 demand_empty_rest_of_line ();
4937 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4941 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4943 /* Set the current section. */
4945 ppc_set_current_section (segT
new)
4947 ppc_previous_section
= ppc_current_section
;
4948 ppc_current_section
= new;
4951 /* pseudo-op: .previous
4952 behaviour: toggles the current section with the previous section.
4954 warnings: "No previous section" */
4957 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4959 if (ppc_previous_section
== NULL
)
4961 as_warn (_("no previous section to return to, ignored."));
4965 subseg_set (ppc_previous_section
, 0);
4967 ppc_set_current_section (ppc_previous_section
);
4970 /* pseudo-op: .pdata
4971 behaviour: predefined read only data section
4975 initial: .section .pdata "adr3"
4976 a - don't know -- maybe a misprint
4977 d - initialized data
4979 3 - double word aligned (that would be 4 byte boundary)
4982 Tag index tables (also known as the function table) for exception
4983 handling, debugging, etc. */
4986 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4988 if (pdata_section
== 0)
4990 pdata_section
= subseg_new (".pdata", 0);
4992 bfd_set_section_flags (stdoutput
, pdata_section
,
4993 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4994 | SEC_READONLY
| SEC_DATA
));
4996 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5000 pdata_section
= subseg_new (".pdata", 0);
5002 ppc_set_current_section (pdata_section
);
5005 /* pseudo-op: .ydata
5006 behaviour: predefined read only data section
5010 initial: .section .ydata "drw3"
5011 a - don't know -- maybe a misprint
5012 d - initialized data
5014 3 - double word aligned (that would be 4 byte boundary)
5016 Tag tables (also known as the scope table) for exception handling,
5020 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5022 if (ydata_section
== 0)
5024 ydata_section
= subseg_new (".ydata", 0);
5025 bfd_set_section_flags (stdoutput
, ydata_section
,
5026 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5027 | SEC_READONLY
| SEC_DATA
));
5029 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5033 ydata_section
= subseg_new (".ydata", 0);
5035 ppc_set_current_section (ydata_section
);
5038 /* pseudo-op: .reldata
5039 behaviour: predefined read write data section
5040 double word aligned (4-byte)
5041 FIXME: relocation is applied to it
5042 FIXME: what's the difference between this and .data?
5045 initial: .section .reldata "drw3"
5046 d - initialized data
5049 3 - double word aligned (that would be 8 byte boundary)
5052 Like .data, but intended to hold data subject to relocation, such as
5053 function descriptors, etc. */
5056 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5058 if (reldata_section
== 0)
5060 reldata_section
= subseg_new (".reldata", 0);
5062 bfd_set_section_flags (stdoutput
, reldata_section
,
5063 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5066 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5070 reldata_section
= subseg_new (".reldata", 0);
5072 ppc_set_current_section (reldata_section
);
5075 /* pseudo-op: .rdata
5076 behaviour: predefined read only data section
5080 initial: .section .rdata "dr3"
5081 d - initialized data
5083 3 - double word aligned (that would be 4 byte boundary) */
5086 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5088 if (rdata_section
== 0)
5090 rdata_section
= subseg_new (".rdata", 0);
5091 bfd_set_section_flags (stdoutput
, rdata_section
,
5092 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5093 | SEC_READONLY
| SEC_DATA
));
5095 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5099 rdata_section
= subseg_new (".rdata", 0);
5101 ppc_set_current_section (rdata_section
);
5104 /* pseudo-op: .ualong
5105 behaviour: much like .int, with the exception that no alignment is
5107 FIXME: test the alignment statement
5112 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5118 /* pseudo-op: .znop <symbol name>
5119 behaviour: Issue a nop instruction
5120 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5121 the supplied symbol name.
5123 warnings: Missing symbol name */
5126 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5129 const struct powerpc_opcode
*opcode
;
5136 /* Strip out the symbol name. */
5137 symbol_name
= input_line_pointer
;
5138 c
= get_symbol_end ();
5140 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5141 strcpy (name
, symbol_name
);
5143 sym
= symbol_find_or_make (name
);
5145 *input_line_pointer
= c
;
5149 /* Look up the opcode in the hash table. */
5150 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5152 /* Stick in the nop. */
5153 insn
= opcode
->opcode
;
5155 /* Write out the instruction. */
5157 md_number_to_chars (f
, insn
, 4);
5159 f
- frag_now
->fr_literal
,
5164 BFD_RELOC_16_GOT_PCREL
);
5174 ppc_pe_comm (int lcomm
)
5183 name
= input_line_pointer
;
5184 c
= get_symbol_end ();
5186 /* just after name is now '\0'. */
5187 p
= input_line_pointer
;
5190 if (*input_line_pointer
!= ',')
5192 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5193 ignore_rest_of_line ();
5197 input_line_pointer
++; /* skip ',' */
5198 if ((temp
= get_absolute_expression ()) < 0)
5200 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5201 ignore_rest_of_line ();
5207 /* The third argument to .comm is the alignment. */
5208 if (*input_line_pointer
!= ',')
5212 ++input_line_pointer
;
5213 align
= get_absolute_expression ();
5216 as_warn (_("ignoring bad alignment"));
5223 symbolP
= symbol_find_or_make (name
);
5226 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5228 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5229 S_GET_NAME (symbolP
));
5230 ignore_rest_of_line ();
5234 if (S_GET_VALUE (symbolP
))
5236 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5237 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5238 S_GET_NAME (symbolP
),
5239 (long) S_GET_VALUE (symbolP
),
5244 S_SET_VALUE (symbolP
, (valueT
) temp
);
5245 S_SET_EXTERNAL (symbolP
);
5246 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5249 demand_empty_rest_of_line ();
5253 * implement the .section pseudo op:
5254 * .section name {, "flags"}
5256 * | +--- optional flags: 'b' for bss
5258 * +-- section name 'l' for lib
5262 * 'd' (apparently m88k for data)
5264 * But if the argument is not a quoted string, treat it as a
5265 * subsegment number.
5267 * FIXME: this is a copy of the section processing from obj-coff.c, with
5268 * additions/changes for the moto-pas assembler support. There are three
5271 * FIXME: I just noticed this. This doesn't work at all really. It it
5272 * setting bits that bfd probably neither understands or uses. The
5273 * correct approach (?) will have to incorporate extra fields attached
5274 * to the section to hold the system specific stuff. (krk)
5277 * 'a' - unknown - referred to in documentation, but no definition supplied
5278 * 'c' - section has code
5279 * 'd' - section has initialized data
5280 * 'u' - section has uninitialized data
5281 * 'i' - section contains directives (info)
5282 * 'n' - section can be discarded
5283 * 'R' - remove section at link time
5285 * Section Protection:
5286 * 'r' - section is readable
5287 * 'w' - section is writeable
5288 * 'x' - section is executable
5289 * 's' - section is sharable
5291 * Section Alignment:
5292 * '0' - align to byte boundary
5293 * '1' - align to halfword undary
5294 * '2' - align to word boundary
5295 * '3' - align to doubleword boundary
5296 * '4' - align to quadword boundary
5297 * '5' - align to 32 byte boundary
5298 * '6' - align to 64 byte boundary
5303 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5305 /* Strip out the section name. */
5314 section_name
= input_line_pointer
;
5315 c
= get_symbol_end ();
5317 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5318 strcpy (name
, section_name
);
5320 *input_line_pointer
= c
;
5325 flags
= SEC_NO_FLAGS
;
5327 if (strcmp (name
, ".idata$2") == 0)
5331 else if (strcmp (name
, ".idata$3") == 0)
5335 else if (strcmp (name
, ".idata$4") == 0)
5339 else if (strcmp (name
, ".idata$5") == 0)
5343 else if (strcmp (name
, ".idata$6") == 0)
5348 /* Default alignment to 16 byte boundary. */
5351 if (*input_line_pointer
== ',')
5353 ++input_line_pointer
;
5355 if (*input_line_pointer
!= '"')
5356 exp
= get_absolute_expression ();
5359 ++input_line_pointer
;
5360 while (*input_line_pointer
!= '"'
5361 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5363 switch (*input_line_pointer
)
5365 /* Section Contents */
5366 case 'a': /* unknown */
5367 as_bad (_("unsupported section attribute -- 'a'"));
5369 case 'c': /* code section */
5372 case 'd': /* section has initialized data */
5375 case 'u': /* section has uninitialized data */
5376 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5380 case 'i': /* section contains directives (info) */
5381 /* FIXME: This is IMAGE_SCN_LNK_INFO
5383 flags
|= SEC_HAS_CONTENTS
;
5385 case 'n': /* section can be discarded */
5388 case 'R': /* Remove section at link time */
5389 flags
|= SEC_NEVER_LOAD
;
5391 #if IFLICT_BRAIN_DAMAGE
5392 /* Section Protection */
5393 case 'r': /* section is readable */
5394 flags
|= IMAGE_SCN_MEM_READ
;
5396 case 'w': /* section is writeable */
5397 flags
|= IMAGE_SCN_MEM_WRITE
;
5399 case 'x': /* section is executable */
5400 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5402 case 's': /* section is sharable */
5403 flags
|= IMAGE_SCN_MEM_SHARED
;
5406 /* Section Alignment */
5407 case '0': /* align to byte boundary */
5408 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5411 case '1': /* align to halfword boundary */
5412 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5415 case '2': /* align to word boundary */
5416 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5419 case '3': /* align to doubleword boundary */
5420 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5423 case '4': /* align to quadword boundary */
5424 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5427 case '5': /* align to 32 byte boundary */
5428 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5431 case '6': /* align to 64 byte boundary */
5432 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5437 as_bad (_("unknown section attribute '%c'"),
5438 *input_line_pointer
);
5441 ++input_line_pointer
;
5443 if (*input_line_pointer
== '"')
5444 ++input_line_pointer
;
5448 sec
= subseg_new (name
, (subsegT
) exp
);
5450 ppc_set_current_section (sec
);
5452 if (flags
!= SEC_NO_FLAGS
)
5454 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5455 as_bad (_("error setting flags for \"%s\": %s"),
5456 bfd_section_name (stdoutput
, sec
),
5457 bfd_errmsg (bfd_get_error ()));
5460 bfd_set_section_alignment (stdoutput
, sec
, align
);
5464 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5470 name
= input_line_pointer
;
5471 endc
= get_symbol_end ();
5473 ext_sym
= symbol_find_or_make (name
);
5475 *input_line_pointer
= endc
;
5477 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5478 SF_SET_FUNCTION (ext_sym
);
5479 SF_SET_PROCESS (ext_sym
);
5480 coff_add_linesym (ext_sym
);
5482 demand_empty_rest_of_line ();
5486 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5488 if (tocdata_section
== 0)
5490 tocdata_section
= subseg_new (".tocd", 0);
5491 /* FIXME: section flags won't work. */
5492 bfd_set_section_flags (stdoutput
, tocdata_section
,
5493 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5494 | SEC_READONLY
| SEC_DATA
));
5496 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5500 rdata_section
= subseg_new (".tocd", 0);
5503 ppc_set_current_section (tocdata_section
);
5505 demand_empty_rest_of_line ();
5508 /* Don't adjust TOC relocs to use the section symbol. */
5511 ppc_pe_fix_adjustable (fixS
*fix
)
5513 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5520 /* XCOFF specific symbol and file handling. */
5522 /* Canonicalize the symbol name. We use the to force the suffix, if
5523 any, to use square brackets, and to be in upper case. */
5526 ppc_canonicalize_symbol_name (char *name
)
5530 if (ppc_stab_symbol
)
5533 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5547 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5550 if (*s
== '\0' || s
[1] != '\0')
5551 as_bad (_("bad symbol suffix"));
5559 /* Set the class of a symbol based on the suffix, if any. This is
5560 called whenever a new symbol is created. */
5563 ppc_symbol_new_hook (symbolS
*sym
)
5565 struct ppc_tc_sy
*tc
;
5568 tc
= symbol_get_tc (sym
);
5571 tc
->symbol_class
= -1;
5572 tc
->real_name
= NULL
;
5579 if (ppc_stab_symbol
)
5582 s
= strchr (S_GET_NAME (sym
), '[');
5583 if (s
== (const char *) NULL
)
5585 /* There is no suffix. */
5594 if (strcmp (s
, "BS]") == 0)
5595 tc
->symbol_class
= XMC_BS
;
5598 if (strcmp (s
, "DB]") == 0)
5599 tc
->symbol_class
= XMC_DB
;
5600 else if (strcmp (s
, "DS]") == 0)
5601 tc
->symbol_class
= XMC_DS
;
5604 if (strcmp (s
, "GL]") == 0)
5605 tc
->symbol_class
= XMC_GL
;
5608 if (strcmp (s
, "PR]") == 0)
5609 tc
->symbol_class
= XMC_PR
;
5612 if (strcmp (s
, "RO]") == 0)
5613 tc
->symbol_class
= XMC_RO
;
5614 else if (strcmp (s
, "RW]") == 0)
5615 tc
->symbol_class
= XMC_RW
;
5618 if (strcmp (s
, "SV]") == 0)
5619 tc
->symbol_class
= XMC_SV
;
5622 if (strcmp (s
, "TC]") == 0)
5623 tc
->symbol_class
= XMC_TC
;
5624 else if (strcmp (s
, "TI]") == 0)
5625 tc
->symbol_class
= XMC_TI
;
5626 else if (strcmp (s
, "TB]") == 0)
5627 tc
->symbol_class
= XMC_TB
;
5628 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5629 tc
->symbol_class
= XMC_TC0
;
5632 if (strcmp (s
, "UA]") == 0)
5633 tc
->symbol_class
= XMC_UA
;
5634 else if (strcmp (s
, "UC]") == 0)
5635 tc
->symbol_class
= XMC_UC
;
5638 if (strcmp (s
, "XO]") == 0)
5639 tc
->symbol_class
= XMC_XO
;
5643 if (tc
->symbol_class
== -1)
5644 as_bad (_("unrecognized symbol suffix"));
5647 /* Set the class of a label based on where it is defined. This
5648 handles symbols without suffixes. Also, move the symbol so that it
5649 follows the csect symbol. */
5652 ppc_frob_label (symbolS
*sym
)
5654 if (ppc_current_csect
!= (symbolS
*) NULL
)
5656 if (symbol_get_tc (sym
)->symbol_class
== -1)
5657 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5659 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5660 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5661 &symbol_rootP
, &symbol_lastP
);
5662 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5663 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5667 dwarf2_emit_label (sym
);
5671 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5672 seen. It tells ppc_adjust_symtab whether it needs to look through
5675 static bfd_boolean ppc_saw_abs
;
5677 /* Change the name of a symbol just before writing it out. Set the
5678 real name if the .rename pseudo-op was used. Otherwise, remove any
5679 class suffix. Return 1 if the symbol should not be included in the
5683 ppc_frob_symbol (symbolS
*sym
)
5685 static symbolS
*ppc_last_function
;
5686 static symbolS
*set_end
;
5688 /* Discard symbols that should not be included in the output symbol
5690 if (! symbol_used_in_reloc_p (sym
)
5691 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5692 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5693 && ! symbol_get_tc (sym
)->output
5694 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5697 /* This one will disappear anyway. Don't make a csect sym for it. */
5698 if (sym
== abs_section_sym
)
5701 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5702 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5708 name
= S_GET_NAME (sym
);
5709 s
= strchr (name
, '[');
5710 if (s
!= (char *) NULL
)
5716 snew
= xmalloc (len
+ 1);
5717 memcpy (snew
, name
, len
);
5720 S_SET_NAME (sym
, snew
);
5724 if (set_end
!= (symbolS
*) NULL
)
5726 SA_SET_SYM_ENDNDX (set_end
, sym
);
5730 if (SF_GET_FUNCTION (sym
))
5732 if (ppc_last_function
!= (symbolS
*) NULL
)
5733 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5734 ppc_last_function
= sym
;
5735 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5737 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5738 SA_SET_SYM_FSIZE (sym
,
5739 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5742 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5743 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5745 if (ppc_last_function
== (symbolS
*) NULL
)
5746 as_bad (_(".ef with no preceding .function"));
5749 set_end
= ppc_last_function
;
5750 ppc_last_function
= NULL
;
5752 /* We don't have a C_EFCN symbol, but we need to force the
5753 COFF backend to believe that it has seen one. */
5754 coff_last_function
= NULL
;
5758 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5759 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5760 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5761 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5762 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5763 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5764 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5765 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5766 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5767 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5768 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5770 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5771 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5772 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5775 union internal_auxent
*a
;
5777 /* Create a csect aux. */
5778 i
= S_GET_NUMBER_AUXILIARY (sym
);
5779 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5780 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5781 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5783 /* This is the TOC table. */
5784 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5785 a
->x_csect
.x_scnlen
.l
= 0;
5786 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5788 else if (symbol_get_tc (sym
)->subseg
!= 0)
5790 /* This is a csect symbol. x_scnlen is the size of the
5792 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5793 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5794 S_GET_SEGMENT (sym
))
5795 - S_GET_VALUE (sym
));
5798 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5799 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5800 - S_GET_VALUE (sym
));
5802 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5804 else if (S_GET_SEGMENT (sym
) == bss_section
)
5806 /* This is a common symbol. */
5807 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5808 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5809 if (S_IS_EXTERNAL (sym
))
5810 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5812 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5814 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5816 /* This is an absolute symbol. The csect will be created by
5817 ppc_adjust_symtab. */
5819 a
->x_csect
.x_smtyp
= XTY_LD
;
5820 if (symbol_get_tc (sym
)->symbol_class
== -1)
5821 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5823 else if (! S_IS_DEFINED (sym
))
5825 /* This is an external symbol. */
5826 a
->x_csect
.x_scnlen
.l
= 0;
5827 a
->x_csect
.x_smtyp
= XTY_ER
;
5829 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5833 /* This is a TOC definition. x_scnlen is the size of the
5835 next
= symbol_next (sym
);
5836 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5837 next
= symbol_next (next
);
5838 if (next
== (symbolS
*) NULL
5839 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5841 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5842 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5844 - S_GET_VALUE (sym
));
5846 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5847 - S_GET_VALUE (sym
));
5851 resolve_symbol_value (next
);
5852 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5853 - S_GET_VALUE (sym
));
5855 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5861 /* This is a normal symbol definition. x_scnlen is the
5862 symbol index of the containing csect. */
5863 if (S_GET_SEGMENT (sym
) == text_section
)
5864 csect
= ppc_text_csects
;
5865 else if (S_GET_SEGMENT (sym
) == data_section
)
5866 csect
= ppc_data_csects
;
5870 /* Skip the initial dummy symbol. */
5871 csect
= symbol_get_tc (csect
)->next
;
5873 if (csect
== (symbolS
*) NULL
)
5875 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5876 a
->x_csect
.x_scnlen
.l
= 0;
5880 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5882 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5883 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5884 > S_GET_VALUE (sym
))
5886 csect
= symbol_get_tc (csect
)->next
;
5889 a
->x_csect
.x_scnlen
.p
=
5890 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5891 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5894 a
->x_csect
.x_smtyp
= XTY_LD
;
5897 a
->x_csect
.x_parmhash
= 0;
5898 a
->x_csect
.x_snhash
= 0;
5899 if (symbol_get_tc (sym
)->symbol_class
== -1)
5900 a
->x_csect
.x_smclas
= XMC_PR
;
5902 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5903 a
->x_csect
.x_stab
= 0;
5904 a
->x_csect
.x_snstab
= 0;
5906 /* Don't let the COFF backend resort these symbols. */
5907 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5909 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5911 /* We want the value to be the symbol index of the referenced
5912 csect symbol. BFD will do that for us if we set the right
5914 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5915 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5917 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5918 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5920 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5925 block
= symbol_get_tc (sym
)->within
;
5928 /* The value is the offset from the enclosing csect. */
5931 csect
= symbol_get_tc (block
)->within
;
5932 resolve_symbol_value (csect
);
5933 base
= S_GET_VALUE (csect
);
5938 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5940 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5941 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5943 /* We want the value to be a file offset into the line numbers.
5944 BFD will do that for us if we set the right flags. We have
5945 already set the value correctly. */
5946 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5952 /* Adjust the symbol table. This creates csect symbols for all
5953 absolute symbols. */
5956 ppc_adjust_symtab (void)
5963 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5967 union internal_auxent
*a
;
5969 if (S_GET_SEGMENT (sym
) != absolute_section
)
5972 csect
= symbol_create (".abs[XO]", absolute_section
,
5973 S_GET_VALUE (sym
), &zero_address_frag
);
5974 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5975 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5976 i
= S_GET_NUMBER_AUXILIARY (csect
);
5977 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5978 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5979 a
->x_csect
.x_scnlen
.l
= 0;
5980 a
->x_csect
.x_smtyp
= XTY_SD
;
5981 a
->x_csect
.x_parmhash
= 0;
5982 a
->x_csect
.x_snhash
= 0;
5983 a
->x_csect
.x_smclas
= XMC_XO
;
5984 a
->x_csect
.x_stab
= 0;
5985 a
->x_csect
.x_snstab
= 0;
5987 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5989 i
= S_GET_NUMBER_AUXILIARY (sym
);
5990 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5991 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5992 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5995 ppc_saw_abs
= FALSE
;
5998 /* Set the VMA for a section. This is called on all the sections in
6002 ppc_frob_section (asection
*sec
)
6004 static bfd_vma vma
= 0;
6006 /* Dwarf sections start at 0. */
6007 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6010 vma
= md_section_align (sec
, vma
);
6011 bfd_set_section_vma (stdoutput
, sec
, vma
);
6012 vma
+= bfd_section_size (stdoutput
, sec
);
6015 #endif /* OBJ_XCOFF */
6018 md_atof (int type
, char *litp
, int *sizep
)
6020 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6023 /* Write a value out to the object file, using the appropriate
6027 md_number_to_chars (char *buf
, valueT val
, int n
)
6029 if (target_big_endian
)
6030 number_to_chars_bigendian (buf
, val
, n
);
6032 number_to_chars_littleendian (buf
, val
, n
);
6035 /* Align a section (I don't know why this is machine dependent). */
6038 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6043 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6045 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
6049 /* We don't have any form of relaxing. */
6052 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6053 asection
*seg ATTRIBUTE_UNUSED
)
6059 /* Convert a machine dependent frag. We never generate these. */
6062 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6063 asection
*sec ATTRIBUTE_UNUSED
,
6064 fragS
*fragp ATTRIBUTE_UNUSED
)
6069 /* We have no need to default values of symbols. */
6072 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6077 /* Functions concerning relocs. */
6079 /* The location from which a PC relative jump should be calculated,
6080 given a PC relative reloc. */
6083 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6085 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6090 /* This is called to see whether a fixup should be adjusted to use a
6091 section symbol. We take the opportunity to change a fixup against
6092 a symbol in the TOC subsegment into a reloc against the
6093 corresponding .tc symbol. */
6096 ppc_fix_adjustable (fixS
*fix
)
6098 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6099 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6100 TC_SYMFIELD_TYPE
*tc
;
6102 if (symseg
== absolute_section
)
6105 /* Always adjust symbols in debugging sections. */
6106 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6109 if (ppc_toc_csect
!= (symbolS
*) NULL
6110 && fix
->fx_addsy
!= ppc_toc_csect
6111 && symseg
== data_section
6112 && val
>= ppc_toc_frag
->fr_address
6113 && (ppc_after_toc_frag
== (fragS
*) NULL
6114 || val
< ppc_after_toc_frag
->fr_address
))
6118 for (sy
= symbol_next (ppc_toc_csect
);
6119 sy
!= (symbolS
*) NULL
;
6120 sy
= symbol_next (sy
))
6122 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6124 if (sy_tc
->symbol_class
== XMC_TC0
)
6126 if (sy_tc
->symbol_class
!= XMC_TC
)
6128 if (val
== resolve_symbol_value (sy
))
6131 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6136 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6137 _("symbol in .toc does not match any .tc"));
6140 /* Possibly adjust the reloc to be against the csect. */
6141 tc
= symbol_get_tc (fix
->fx_addsy
);
6143 && tc
->symbol_class
!= XMC_TC0
6144 && tc
->symbol_class
!= XMC_TC
6145 && symseg
!= bss_section
6146 /* Don't adjust if this is a reloc in the toc section. */
6147 && (symseg
!= data_section
6148 || ppc_toc_csect
== NULL
6149 || val
< ppc_toc_frag
->fr_address
6150 || (ppc_after_toc_frag
!= NULL
6151 && val
>= ppc_after_toc_frag
->fr_address
)))
6153 symbolS
*csect
= tc
->within
;
6155 /* If the symbol was not declared by a label (eg: a section symbol),
6156 use the section instead of the csect. This doesn't happen in
6157 normal AIX assembly code. */
6159 csect
= seg_info (symseg
)->sym
;
6161 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6162 fix
->fx_addsy
= csect
;
6167 /* Adjust a reloc against a .lcomm symbol to be against the base
6169 if (symseg
== bss_section
6170 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6172 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6174 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6181 /* A reloc from one csect to another must be kept. The assembler
6182 will, of course, keep relocs between sections, and it will keep
6183 absolute relocs, but we need to force it to keep PC relative relocs
6184 between two csects in the same section. */
6187 ppc_force_relocation (fixS
*fix
)
6189 /* At this point fix->fx_addsy should already have been converted to
6190 a csect symbol. If the csect does not include the fragment, then
6191 we need to force the relocation. */
6193 && fix
->fx_addsy
!= NULL
6194 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6195 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6196 > fix
->fx_frag
->fr_address
)
6197 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6198 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6199 <= fix
->fx_frag
->fr_address
))))
6202 return generic_force_reloc (fix
);
6206 ppc_new_dot_label (symbolS
*sym
)
6208 /* Anchor this label to the current csect for relocations. */
6209 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6212 #endif /* OBJ_XCOFF */
6215 /* If this function returns non-zero, it guarantees that a relocation
6216 will be emitted for a fixup. */
6219 ppc_force_relocation (fixS
*fix
)
6221 /* Branch prediction relocations must force a relocation, as must
6222 the vtable description relocs. */
6223 switch (fix
->fx_r_type
)
6225 case BFD_RELOC_PPC_B16_BRTAKEN
:
6226 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6227 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6228 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6229 case BFD_RELOC_24_PLT_PCREL
:
6230 case BFD_RELOC_PPC64_TOC
:
6236 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6237 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6240 return generic_force_reloc (fix
);
6244 ppc_fix_adjustable (fixS
*fix
)
6246 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6247 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6248 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6249 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6250 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6251 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6252 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6253 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6254 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6255 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6256 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6261 ppc_frag_check (struct frag
*fragP
)
6263 if (!fragP
->has_code
)
6266 if (ppc_mach() == bfd_mach_ppc_vle
)
6268 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6269 as_bad (_("instruction address is not a multiple of 2"));
6273 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6274 as_bad (_("instruction address is not a multiple of 4"));
6278 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6279 rs_align_code frag. */
6282 ppc_handle_align (struct frag
*fragP
)
6284 valueT count
= (fragP
->fr_next
->fr_address
6285 - (fragP
->fr_address
+ fragP
->fr_fix
));
6287 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6289 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6292 md_number_to_chars (dest
, 0x4400, 2);
6294 else if (count
!= 0 && (count
& 3) == 0)
6296 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6300 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6304 /* Make a branch, then follow with nops. Insert another
6305 frag to handle the nops. */
6306 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6311 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6312 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6313 fragP
->fr_next
= rest
;
6315 rest
->fr_address
+= rest
->fr_fix
+ 4;
6317 /* If we leave the next frag as rs_align_code we'll come here
6318 again, resulting in a bunch of branches rather than a
6319 branch followed by nops. */
6320 rest
->fr_type
= rs_align
;
6321 dest
= rest
->fr_literal
;
6324 md_number_to_chars (dest
, 0x60000000, 4);
6326 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6327 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6328 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6330 /* For power6, power7 and power8, we want the last nop to be a group
6331 terminating one. Do this by inserting an rs_fill frag immediately
6332 after this one, with its address set to the last nop location.
6333 This will automatically reduce the number of nops in the current
6337 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6339 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6340 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6341 group_nop
->fr_fix
= 0;
6342 group_nop
->fr_offset
= 1;
6343 group_nop
->fr_type
= rs_fill
;
6344 fragP
->fr_next
= group_nop
;
6345 dest
= group_nop
->fr_literal
;
6348 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6349 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6351 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6352 /* e500mc group terminating nop: "ori 0,0,0". */
6353 md_number_to_chars (dest
, 0x60000000, 4);
6355 /* power7/power8 group terminating nop: "ori 2,2,0". */
6356 md_number_to_chars (dest
, 0x60420000, 4);
6359 /* power6 group terminating nop: "ori 1,1,0". */
6360 md_number_to_chars (dest
, 0x60210000, 4);
6365 /* Apply a fixup to the object code. This is called for all the
6366 fixups we generated by the calls to fix_new_exp, above. */
6369 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6371 valueT value
= * valP
;
6373 const struct powerpc_operand
*operand
;
6376 if (fixP
->fx_addsy
!= NULL
)
6378 /* Hack around bfd_install_relocation brain damage. */
6380 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6385 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6386 the symbol values. If we are doing this relocation the code in
6387 write.c is going to call bfd_install_relocation, which is also
6388 going to use the symbol value. That means that if the reloc is
6389 fully resolved we want to use *valP since bfd_install_relocation is
6391 However, if the reloc is not fully resolved we do not want to
6392 use *valP, and must use fx_offset instead. If the relocation
6393 is PC-relative, we then need to re-apply md_pcrel_from_section
6394 to this new relocation value. */
6395 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6400 value
= fixP
->fx_offset
;
6402 value
-= md_pcrel_from_section (fixP
, seg
);
6406 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6408 /* We can't actually support subtracting a symbol. */
6409 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6413 if (fixP
->fx_pcrel_adjust
!= 0)
6415 /* This is a fixup on an instruction. */
6416 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6418 operand
= &powerpc_operands
[opindex
];
6420 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6421 does not generate a reloc. It uses the offset of `sym' within its
6422 csect. Other usages, such as `.long sym', generate relocs. This
6423 is the documented behaviour of non-TOC symbols. */
6424 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6425 && (operand
->bitm
& 0xfff0) == 0xfff0
6426 && operand
->shift
== 0
6427 && (operand
->insert
== NULL
|| ppc_obj64
)
6428 && fixP
->fx_addsy
!= NULL
6429 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6430 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6431 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6432 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6434 value
= fixP
->fx_offset
;
6438 /* During parsing of instructions, a TOC16 reloc is generated for
6439 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6440 in the toc. But at parse time, SYM may be not yet defined, so
6441 check again here. */
6442 if (fixP
->fx_r_type
== BFD_RELOC_16
6443 && fixP
->fx_addsy
!= NULL
6444 && ppc_is_toc_sym (fixP
->fx_addsy
))
6445 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6449 /* Calculate value to be stored in field. */
6451 switch (fixP
->fx_r_type
)
6454 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6455 case BFD_RELOC_PPC_VLE_LO16A
:
6456 case BFD_RELOC_PPC_VLE_LO16D
:
6458 case BFD_RELOC_LO16
:
6459 case BFD_RELOC_LO16_PCREL
:
6460 fieldval
= value
& 0xffff;
6462 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6463 fieldval
= SEX16 (fieldval
);
6464 fixP
->fx_no_overflow
= 1;
6467 case BFD_RELOC_HI16
:
6468 case BFD_RELOC_HI16_PCREL
:
6470 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6472 fieldval
= value
>> 16;
6473 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6475 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6476 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6482 case BFD_RELOC_PPC_VLE_HI16A
:
6483 case BFD_RELOC_PPC_VLE_HI16D
:
6484 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6486 fieldval
= PPC_HI (value
);
6487 goto sign_extend_16
;
6489 case BFD_RELOC_HI16_S
:
6490 case BFD_RELOC_HI16_S_PCREL
:
6492 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6494 fieldval
= (value
+ 0x8000) >> 16;
6495 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6497 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6498 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6504 case BFD_RELOC_PPC_VLE_HA16A
:
6505 case BFD_RELOC_PPC_VLE_HA16D
:
6506 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6508 fieldval
= PPC_HA (value
);
6509 goto sign_extend_16
;
6512 case BFD_RELOC_PPC64_HIGHER
:
6513 fieldval
= PPC_HIGHER (value
);
6514 goto sign_extend_16
;
6516 case BFD_RELOC_PPC64_HIGHER_S
:
6517 fieldval
= PPC_HIGHERA (value
);
6518 goto sign_extend_16
;
6520 case BFD_RELOC_PPC64_HIGHEST
:
6521 fieldval
= PPC_HIGHEST (value
);
6522 goto sign_extend_16
;
6524 case BFD_RELOC_PPC64_HIGHEST_S
:
6525 fieldval
= PPC_HIGHESTA (value
);
6526 goto sign_extend_16
;
6533 if (operand
!= NULL
)
6535 /* Handle relocs in an insn. */
6539 switch (fixP
->fx_r_type
)
6542 /* The following relocs can't be calculated by the assembler.
6543 Leave the field zero. */
6544 case BFD_RELOC_PPC_TPREL16
:
6545 case BFD_RELOC_PPC_TPREL16_LO
:
6546 case BFD_RELOC_PPC_TPREL16_HI
:
6547 case BFD_RELOC_PPC_TPREL16_HA
:
6548 case BFD_RELOC_PPC_DTPREL16
:
6549 case BFD_RELOC_PPC_DTPREL16_LO
:
6550 case BFD_RELOC_PPC_DTPREL16_HI
:
6551 case BFD_RELOC_PPC_DTPREL16_HA
:
6552 case BFD_RELOC_PPC_GOT_TLSGD16
:
6553 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6554 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6555 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6556 case BFD_RELOC_PPC_GOT_TLSLD16
:
6557 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6558 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6559 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6560 case BFD_RELOC_PPC_GOT_TPREL16
:
6561 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6562 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6563 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6564 case BFD_RELOC_PPC_GOT_DTPREL16
:
6565 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6566 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6567 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6568 case BFD_RELOC_PPC64_TPREL16_DS
:
6569 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6570 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6571 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6572 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6573 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6574 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6575 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6576 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6577 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6578 case BFD_RELOC_PPC64_DTPREL16_DS
:
6579 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6580 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6581 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6582 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6583 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6584 gas_assert (fixP
->fx_addsy
!= NULL
);
6585 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6589 /* These also should leave the field zero for the same
6590 reason. Note that older versions of gas wrote values
6591 here. If we want to go back to the old behaviour, then
6592 all _LO and _LO_DS cases will need to be treated like
6593 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6594 case BFD_RELOC_16_GOTOFF
:
6595 case BFD_RELOC_LO16_GOTOFF
:
6596 case BFD_RELOC_HI16_GOTOFF
:
6597 case BFD_RELOC_HI16_S_GOTOFF
:
6598 case BFD_RELOC_LO16_PLTOFF
:
6599 case BFD_RELOC_HI16_PLTOFF
:
6600 case BFD_RELOC_HI16_S_PLTOFF
:
6601 case BFD_RELOC_GPREL16
:
6602 case BFD_RELOC_16_BASEREL
:
6603 case BFD_RELOC_LO16_BASEREL
:
6604 case BFD_RELOC_HI16_BASEREL
:
6605 case BFD_RELOC_HI16_S_BASEREL
:
6606 case BFD_RELOC_PPC_TOC16
:
6607 case BFD_RELOC_PPC64_TOC16_LO
:
6608 case BFD_RELOC_PPC64_TOC16_HI
:
6609 case BFD_RELOC_PPC64_TOC16_HA
:
6610 case BFD_RELOC_PPC64_PLTGOT16
:
6611 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6612 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6613 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6614 case BFD_RELOC_PPC64_GOT16_DS
:
6615 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6616 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6617 case BFD_RELOC_PPC64_SECTOFF_DS
:
6618 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6619 case BFD_RELOC_PPC64_TOC16_DS
:
6620 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6621 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6622 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6623 case BFD_RELOC_PPC_EMB_NADDR16
:
6624 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6625 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6626 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6627 case BFD_RELOC_PPC_EMB_SDAI16
:
6628 case BFD_RELOC_PPC_EMB_SDA2I16
:
6629 case BFD_RELOC_PPC_EMB_SDA2REL
:
6630 case BFD_RELOC_PPC_EMB_SDA21
:
6631 case BFD_RELOC_PPC_EMB_MRKREF
:
6632 case BFD_RELOC_PPC_EMB_RELSEC16
:
6633 case BFD_RELOC_PPC_EMB_RELST_LO
:
6634 case BFD_RELOC_PPC_EMB_RELST_HI
:
6635 case BFD_RELOC_PPC_EMB_RELST_HA
:
6636 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6637 case BFD_RELOC_PPC_EMB_RELSDA
:
6638 case BFD_RELOC_PPC_VLE_SDA21
:
6639 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6640 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6641 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6642 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6643 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6644 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6645 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6646 gas_assert (fixP
->fx_addsy
!= NULL
);
6649 case BFD_RELOC_PPC_TLS
:
6650 case BFD_RELOC_PPC_TLSGD
:
6651 case BFD_RELOC_PPC_TLSLD
:
6657 case BFD_RELOC_PPC_B16
:
6658 /* Adjust the offset to the instruction boundary. */
6668 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6669 contents can stay at zero. */
6670 #define APPLY_RELOC fixP->fx_done
6672 #define APPLY_RELOC 1
6674 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6676 /* Fetch the instruction, insert the fully resolved operand
6677 value, and stuff the instruction back again. */
6678 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6679 if (target_big_endian
)
6681 if (fixP
->fx_size
== 4)
6682 insn
= bfd_getb32 ((unsigned char *) where
);
6684 insn
= bfd_getb16 ((unsigned char *) where
);
6688 if (fixP
->fx_size
== 4)
6689 insn
= bfd_getl32 ((unsigned char *) where
);
6691 insn
= bfd_getl16 ((unsigned char *) where
);
6693 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6694 fixP
->tc_fix_data
.ppc_cpu
,
6695 fixP
->fx_file
, fixP
->fx_line
);
6696 if (target_big_endian
)
6698 if (fixP
->fx_size
== 4)
6699 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6701 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6705 if (fixP
->fx_size
== 4)
6706 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6708 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6713 /* Nothing else to do here. */
6716 gas_assert (fixP
->fx_addsy
!= NULL
);
6717 if (fixP
->fx_r_type
== BFD_RELOC_UNUSED
)
6722 /* Use expr_symbol_where to see if this is an expression
6724 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6725 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6726 _("unresolved expression that must be resolved"));
6728 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6729 _("unsupported relocation against %s"),
6730 S_GET_NAME (fixP
->fx_addsy
));
6737 /* Handle relocs in data. */
6738 switch (fixP
->fx_r_type
)
6740 case BFD_RELOC_VTABLE_INHERIT
:
6742 && !S_IS_DEFINED (fixP
->fx_addsy
)
6743 && !S_IS_WEAK (fixP
->fx_addsy
))
6744 S_SET_WEAK (fixP
->fx_addsy
);
6747 case BFD_RELOC_VTABLE_ENTRY
:
6752 /* These can appear with @l etc. in data. */
6753 case BFD_RELOC_LO16
:
6754 case BFD_RELOC_LO16_PCREL
:
6755 case BFD_RELOC_HI16
:
6756 case BFD_RELOC_HI16_PCREL
:
6757 case BFD_RELOC_HI16_S
:
6758 case BFD_RELOC_HI16_S_PCREL
:
6759 case BFD_RELOC_PPC64_HIGHER
:
6760 case BFD_RELOC_PPC64_HIGHER_S
:
6761 case BFD_RELOC_PPC64_HIGHEST
:
6762 case BFD_RELOC_PPC64_HIGHEST_S
:
6763 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6764 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6767 case BFD_RELOC_PPC_DTPMOD
:
6768 case BFD_RELOC_PPC_TPREL
:
6769 case BFD_RELOC_PPC_DTPREL
:
6770 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6773 /* Just punt all of these to the linker. */
6774 case BFD_RELOC_PPC_B16_BRTAKEN
:
6775 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6776 case BFD_RELOC_16_GOTOFF
:
6777 case BFD_RELOC_LO16_GOTOFF
:
6778 case BFD_RELOC_HI16_GOTOFF
:
6779 case BFD_RELOC_HI16_S_GOTOFF
:
6780 case BFD_RELOC_LO16_PLTOFF
:
6781 case BFD_RELOC_HI16_PLTOFF
:
6782 case BFD_RELOC_HI16_S_PLTOFF
:
6783 case BFD_RELOC_PPC_COPY
:
6784 case BFD_RELOC_PPC_GLOB_DAT
:
6785 case BFD_RELOC_16_BASEREL
:
6786 case BFD_RELOC_LO16_BASEREL
:
6787 case BFD_RELOC_HI16_BASEREL
:
6788 case BFD_RELOC_HI16_S_BASEREL
:
6789 case BFD_RELOC_PPC_TLS
:
6790 case BFD_RELOC_PPC_DTPREL16_LO
:
6791 case BFD_RELOC_PPC_DTPREL16_HI
:
6792 case BFD_RELOC_PPC_DTPREL16_HA
:
6793 case BFD_RELOC_PPC_TPREL16_LO
:
6794 case BFD_RELOC_PPC_TPREL16_HI
:
6795 case BFD_RELOC_PPC_TPREL16_HA
:
6796 case BFD_RELOC_PPC_GOT_TLSGD16
:
6797 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6798 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6799 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6800 case BFD_RELOC_PPC_GOT_TLSLD16
:
6801 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6802 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6803 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6804 case BFD_RELOC_PPC_GOT_DTPREL16
:
6805 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6806 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6807 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6808 case BFD_RELOC_PPC_GOT_TPREL16
:
6809 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6810 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6811 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6812 case BFD_RELOC_24_PLT_PCREL
:
6813 case BFD_RELOC_PPC_LOCAL24PC
:
6814 case BFD_RELOC_32_PLT_PCREL
:
6815 case BFD_RELOC_GPREL16
:
6816 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6817 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6818 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6819 case BFD_RELOC_PPC_EMB_NADDR32
:
6820 case BFD_RELOC_PPC_EMB_NADDR16
:
6821 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6822 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6823 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6824 case BFD_RELOC_PPC_EMB_SDAI16
:
6825 case BFD_RELOC_PPC_EMB_SDA2REL
:
6826 case BFD_RELOC_PPC_EMB_SDA2I16
:
6827 case BFD_RELOC_PPC_EMB_SDA21
:
6828 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6829 case BFD_RELOC_PPC_EMB_MRKREF
:
6830 case BFD_RELOC_PPC_EMB_RELSEC16
:
6831 case BFD_RELOC_PPC_EMB_RELST_LO
:
6832 case BFD_RELOC_PPC_EMB_RELST_HI
:
6833 case BFD_RELOC_PPC_EMB_RELST_HA
:
6834 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6835 case BFD_RELOC_PPC_EMB_RELSDA
:
6836 case BFD_RELOC_PPC64_TOC
:
6837 case BFD_RELOC_PPC_TOC16
:
6838 case BFD_RELOC_PPC64_TOC16_LO
:
6839 case BFD_RELOC_PPC64_TOC16_HI
:
6840 case BFD_RELOC_PPC64_TOC16_HA
:
6841 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6842 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6843 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6844 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6845 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6846 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6847 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6848 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6849 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6850 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6851 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6852 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6858 case BFD_RELOC_NONE
:
6860 case BFD_RELOC_CTOR
:
6862 case BFD_RELOC_32_PCREL
:
6865 case BFD_RELOC_64_PCREL
:
6867 case BFD_RELOC_16_PCREL
:
6873 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6878 if (fixP
->fx_size
&& APPLY_RELOC
)
6879 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6880 fieldval
, fixP
->fx_size
);
6883 /* We are only able to convert some relocs to pc-relative. */
6884 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
6886 switch (fixP
->fx_r_type
)
6888 case BFD_RELOC_LO16
:
6889 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6892 case BFD_RELOC_HI16
:
6893 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6896 case BFD_RELOC_HI16_S
:
6897 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6901 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6905 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6909 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6912 /* Some of course are already pc-relative. */
6913 case BFD_RELOC_LO16_PCREL
:
6914 case BFD_RELOC_HI16_PCREL
:
6915 case BFD_RELOC_HI16_S_PCREL
:
6916 case BFD_RELOC_64_PCREL
:
6917 case BFD_RELOC_32_PCREL
:
6918 case BFD_RELOC_16_PCREL
:
6919 case BFD_RELOC_PPC_B16
:
6920 case BFD_RELOC_PPC_B16_BRTAKEN
:
6921 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6922 case BFD_RELOC_PPC_B26
:
6923 case BFD_RELOC_PPC_LOCAL24PC
:
6924 case BFD_RELOC_24_PLT_PCREL
:
6925 case BFD_RELOC_32_PLT_PCREL
:
6926 case BFD_RELOC_64_PLT_PCREL
:
6927 case BFD_RELOC_PPC_VLE_REL8
:
6928 case BFD_RELOC_PPC_VLE_REL15
:
6929 case BFD_RELOC_PPC_VLE_REL24
:
6938 /* Use expr_symbol_where to see if this is an
6939 expression symbol. */
6940 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6941 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6942 _("unresolved expression that must"
6945 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6946 _("cannot emit PC relative %s relocation"
6948 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6949 S_GET_NAME (fixP
->fx_addsy
));
6952 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6953 _("unable to resolve expression"));
6960 ppc_elf_validate_fix (fixP
, seg
);
6961 fixP
->fx_addnumber
= value
;
6963 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6964 from the section contents. If we are going to be emitting a reloc
6965 then the section contents are immaterial, so don't warn if they
6966 happen to overflow. Leave such warnings to ld. */
6969 fixP
->fx_no_overflow
= 1;
6971 /* Arrange to emit .TOC. as a normal symbol if used in anything
6972 but .TOC.@tocbase. */
6974 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
6975 && fixP
->fx_addsy
!= NULL
6976 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
6977 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
6980 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6981 fixP
->fx_addnumber
= 0;
6985 fixP
->fx_addnumber
= 0;
6987 /* We want to use the offset within the toc, not the actual VMA
6989 fixP
->fx_addnumber
=
6990 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6991 - S_GET_VALUE (ppc_toc_csect
);
6992 /* Set *valP to avoid errors. */
6999 /* Generate a reloc for a fixup. */
7002 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
7006 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
7008 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
7009 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
7010 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
7011 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
7012 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
7014 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
7015 _("reloc %d not supported by object file format"),
7016 (int) fixp
->fx_r_type
);
7019 reloc
->addend
= fixp
->fx_addnumber
;
7025 ppc_cfi_frame_initial_instructions (void)
7027 cfi_add_CFA_def_cfa (1, 0);
7031 tc_ppc_regname_to_dw2regnum (char *regname
)
7033 unsigned int regnum
= -1;
7037 static struct { char *name
; int dw2regnum
; } regnames
[] =
7039 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7040 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7041 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7042 { "spe_acc", 111 }, { "spefscr", 112 }
7045 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7046 if (strcmp (regnames
[i
].name
, regname
) == 0)
7047 return regnames
[i
].dw2regnum
;
7049 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7051 p
= regname
+ 1 + (regname
[1] == '.');
7052 regnum
= strtoul (p
, &q
, 10);
7053 if (p
== q
|| *q
|| regnum
>= 32)
7055 if (regname
[0] == 'f')
7057 else if (regname
[0] == 'v')
7060 else if (regname
[0] == 'c' && regname
[1] == 'r')
7062 p
= regname
+ 2 + (regname
[2] == '.');
7063 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7065 regnum
= p
[0] - '0' + 68;