1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
7 This file is part of GAS, the GNU Assembler.
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "safe-ctype.h"
27 #include "dw2gencfi.h"
28 #include "opcode/ppc.h"
32 #include "dwarf2dbg.h"
40 #include "coff/xcoff.h"
44 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
46 /* Tell the main code what the endianness is. */
47 extern int target_big_endian
;
49 /* Whether or not, we've set target_big_endian. */
50 static int set_target_endian
= 0;
52 /* Whether to use user friendly register names. */
53 #ifndef TARGET_REG_NAMES_P
55 #define TARGET_REG_NAMES_P TRUE
57 #define TARGET_REG_NAMES_P FALSE
61 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
64 /* #lo(value) denotes the least significant 16 bits of the indicated. */
65 #define PPC_LO(v) ((v) & 0xffff)
67 /* Split the indicated value with the msbs in bits 11-15
68 and the lsbs in bits 21-31. */
69 #define PPC_VLE_SPLIT16A(v) ((v & 0xf800) << 11) | (v & 0x7ff)
71 /* Split the indicated value with the msbs in bits 6-10
72 and the lsbs in bits 21-31. */
73 #define PPC_VLE_SPLIT16D(v) ((v & 0xf800) << 5) | (v & 0x7ff)
75 /* #lo(value) denotes the lsb 16 bits in split16a format. */
76 #define PPC_VLE_LO16A(v) PPC_VLE_SPLIT16A(PPC_LO(v))
78 /* #lo(value) denotes the lsb 16 bits in split16d format. */
79 #define PPC_VLE_LO16D(v) PPC_VLE_SPLIT16D(PPC_LO(v))
81 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
82 #define PPC_HI(v) (((v) >> 16) & 0xffff)
84 /* #lo(value) denotes the msb 16 bits in split16a format. */
85 #define PPC_VLE_HI16A(v) PPC_VLE_SPLIT16A(PPC_HI(v))
87 /* #lo(value) denotes the msb 16 bits in split16d format. */
88 #define PPC_VLE_HI16D(v) PPC_VLE_SPLIT16D(PPC_HI(v))
90 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
91 the indicated value, compensating for #lo() being treated as a
93 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
95 /* #ha(value) denotes the high adjusted value in split16a format. */
96 #define PPC_VLE_HA16A(v) PPC_VLE_SPLIT16A(PPC_HA(v))
98 /* #ha(value) denotes the high adjusted value in split16d format. */
99 #define PPC_VLE_HA16D(v) PPC_VLE_SPLIT16D(PPC_HA(v))
101 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
102 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
104 /* #highera(value) denotes bits 32 through 47 of the indicated value,
105 compensating for #lo() being treated as a signed number. */
106 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
108 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
109 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
111 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
112 compensating for #lo being treated as a signed number. */
113 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
115 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
117 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
119 static void ppc_macro (char *, const struct powerpc_macro
*);
120 static void ppc_byte (int);
122 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
123 static void ppc_tc (int);
124 static void ppc_machine (int);
128 static void ppc_comm (int);
129 static void ppc_bb (int);
130 static void ppc_bc (int);
131 static void ppc_bf (int);
132 static void ppc_biei (int);
133 static void ppc_bs (int);
134 static void ppc_eb (int);
135 static void ppc_ec (int);
136 static void ppc_ef (int);
137 static void ppc_es (int);
138 static void ppc_csect (int);
139 static void ppc_dwsect (int);
140 static void ppc_change_csect (symbolS
*, offsetT
);
141 static void ppc_function (int);
142 static void ppc_extern (int);
143 static void ppc_lglobl (int);
144 static void ppc_ref (int);
145 static void ppc_section (int);
146 static void ppc_named_section (int);
147 static void ppc_stabx (int);
148 static void ppc_rename (int);
149 static void ppc_toc (int);
150 static void ppc_xcoff_cons (int);
151 static void ppc_vbyte (int);
155 static void ppc_elf_cons (int);
156 static void ppc_elf_rdata (int);
157 static void ppc_elf_lcomm (int);
161 static void ppc_previous (int);
162 static void ppc_pdata (int);
163 static void ppc_ydata (int);
164 static void ppc_reldata (int);
165 static void ppc_rdata (int);
166 static void ppc_ualong (int);
167 static void ppc_znop (int);
168 static void ppc_pe_comm (int);
169 static void ppc_pe_section (int);
170 static void ppc_pe_function (int);
171 static void ppc_pe_tocd (int);
174 /* Generic assembler global variables which must be defined by all
178 /* This string holds the chars that always start a comment. If the
179 pre-processor is disabled, these aren't very useful. The macro
180 tc_comment_chars points to this. We use this, rather than the
181 usual comment_chars, so that we can switch for Solaris conventions. */
182 static const char ppc_solaris_comment_chars
[] = "#!";
183 static const char ppc_eabi_comment_chars
[] = "#";
185 #ifdef TARGET_SOLARIS_COMMENT
186 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
188 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
191 const char comment_chars
[] = "#";
194 /* Characters which start a comment at the beginning of a line. */
195 const char line_comment_chars
[] = "#";
197 /* Characters which may be used to separate multiple commands on a
199 const char line_separator_chars
[] = ";";
201 /* Characters which are used to indicate an exponent in a floating
203 const char EXP_CHARS
[] = "eE";
205 /* Characters which mean that a number is a floating point constant,
207 const char FLT_CHARS
[] = "dD";
209 /* Anything that can start an operand needs to be mentioned here,
210 to stop the input scrubber eating whitespace. */
211 const char ppc_symbol_chars
[] = "%[";
213 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
214 int ppc_cie_data_alignment
;
216 /* The dwarf2 minimum instruction length. */
217 int ppc_dwarf2_line_min_insn_length
;
219 /* More than this number of nops in an alignment op gets a branch
221 unsigned long nop_limit
= 4;
223 /* The type of processor we are assembling for. This is one or more
224 of the PPC_OPCODE flags defined in opcode/ppc.h. */
225 ppc_cpu_t ppc_cpu
= 0;
226 ppc_cpu_t sticky
= 0;
228 /* Flags set on encountering toc relocs. */
230 has_large_toc_reloc
= 1,
231 has_small_toc_reloc
= 2
234 /* The target specific pseudo-ops which we support. */
236 const pseudo_typeS md_pseudo_table
[] =
238 /* Pseudo-ops which must be overridden. */
239 { "byte", ppc_byte
, 0 },
242 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
243 legitimately belong in the obj-*.c file. However, XCOFF is based
244 on COFF, and is only implemented for the RS/6000. We just use
245 obj-coff.c, and add what we need here. */
246 { "comm", ppc_comm
, 0 },
247 { "lcomm", ppc_comm
, 1 },
251 { "bi", ppc_biei
, 0 },
253 { "csect", ppc_csect
, 0 },
254 { "dwsect", ppc_dwsect
, 0 },
255 { "data", ppc_section
, 'd' },
259 { "ei", ppc_biei
, 1 },
261 { "extern", ppc_extern
, 0 },
262 { "function", ppc_function
, 0 },
263 { "lglobl", ppc_lglobl
, 0 },
264 { "ref", ppc_ref
, 0 },
265 { "rename", ppc_rename
, 0 },
266 { "section", ppc_named_section
, 0 },
267 { "stabx", ppc_stabx
, 0 },
268 { "text", ppc_section
, 't' },
269 { "toc", ppc_toc
, 0 },
270 { "long", ppc_xcoff_cons
, 2 },
271 { "llong", ppc_xcoff_cons
, 3 },
272 { "word", ppc_xcoff_cons
, 1 },
273 { "short", ppc_xcoff_cons
, 1 },
274 { "vbyte", ppc_vbyte
, 0 },
278 { "llong", ppc_elf_cons
, 8 },
279 { "quad", ppc_elf_cons
, 8 },
280 { "long", ppc_elf_cons
, 4 },
281 { "word", ppc_elf_cons
, 2 },
282 { "short", ppc_elf_cons
, 2 },
283 { "rdata", ppc_elf_rdata
, 0 },
284 { "rodata", ppc_elf_rdata
, 0 },
285 { "lcomm", ppc_elf_lcomm
, 0 },
289 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
290 { "previous", ppc_previous
, 0 },
291 { "pdata", ppc_pdata
, 0 },
292 { "ydata", ppc_ydata
, 0 },
293 { "reldata", ppc_reldata
, 0 },
294 { "rdata", ppc_rdata
, 0 },
295 { "ualong", ppc_ualong
, 0 },
296 { "znop", ppc_znop
, 0 },
297 { "comm", ppc_pe_comm
, 0 },
298 { "lcomm", ppc_pe_comm
, 1 },
299 { "section", ppc_pe_section
, 0 },
300 { "function", ppc_pe_function
,0 },
301 { "tocd", ppc_pe_tocd
, 0 },
304 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
306 { "machine", ppc_machine
, 0 },
313 /* Predefined register names if -mregnames (or default for Windows NT).
314 In general, there are lots of them, in an attempt to be compatible
315 with a number of other Windows NT assemblers. */
317 /* Structure to hold information about predefined registers. */
324 /* List of registers that are pre-defined:
326 Each general register has predefined names of the form:
327 1. r<reg_num> which has the value <reg_num>.
328 2. r.<reg_num> which has the value <reg_num>.
330 Each floating point register has predefined names of the form:
331 1. f<reg_num> which has the value <reg_num>.
332 2. f.<reg_num> which has the value <reg_num>.
334 Each vector unit register has predefined names of the form:
335 1. v<reg_num> which has the value <reg_num>.
336 2. v.<reg_num> which has the value <reg_num>.
338 Each condition register has predefined names of the form:
339 1. cr<reg_num> which has the value <reg_num>.
340 2. cr.<reg_num> which has the value <reg_num>.
342 There are individual registers as well:
343 sp or r.sp has the value 1
344 rtoc or r.toc has the value 2
345 fpscr has the value 0
351 dsisr has the value 18
353 sdr1 has the value 25
354 srr0 has the value 26
355 srr1 has the value 27
357 The table is sorted. Suitable for searching by a binary search. */
359 static const struct pd_reg pre_defined_registers
[] =
361 { "cr.0", 0 }, /* Condition Registers */
381 { "dar", 19 }, /* Data Access Register */
382 { "dec", 22 }, /* Decrementer */
383 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
385 { "f.0", 0 }, /* Floating point registers */
412 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
478 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
519 /* Quantization registers used with pair single instructions. */
537 { "lr", 8 }, /* Link Register */
541 { "r.0", 0 }, /* General Purpose Registers */
574 { "r.sp", 1 }, /* Stack Pointer */
576 { "r.toc", 2 }, /* Pointer to the table of contents */
578 { "r0", 0 }, /* More general purpose registers */
611 { "rtoc", 2 }, /* Table of contents */
613 { "sdr1", 25 }, /* Storage Description Register 1 */
617 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
618 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
620 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
686 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
820 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
822 /* Given NAME, find the register number associated with that name, return
823 the integer value associated with the given name or -1 on failure. */
826 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
828 int middle
, low
, high
;
836 middle
= (low
+ high
) / 2;
837 cmp
= strcasecmp (name
, regs
[middle
].name
);
843 return regs
[middle
].value
;
851 * Summary of register_name.
853 * in: Input_line_pointer points to 1st char of operand.
855 * out: A expressionS.
856 * The operand may have been a register: in this case, X_op == O_register,
857 * X_add_number is set to the register number, and truth is returned.
858 * Input_line_pointer->(next non-blank) char after operand, or is in its
863 register_name (expressionS
*expressionP
)
870 /* Find the spelling of the operand. */
871 start
= name
= input_line_pointer
;
872 if (name
[0] == '%' && ISALPHA (name
[1]))
873 name
= ++input_line_pointer
;
875 else if (!reg_names_p
|| !ISALPHA (name
[0]))
878 c
= get_symbol_end ();
879 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
881 /* Put back the delimiting char. */
882 *input_line_pointer
= c
;
884 /* Look to see if it's in the register table. */
887 expressionP
->X_op
= O_register
;
888 expressionP
->X_add_number
= reg_number
;
890 /* Make the rest nice. */
891 expressionP
->X_add_symbol
= NULL
;
892 expressionP
->X_op_symbol
= NULL
;
896 /* Reset the line as if we had not done anything. */
897 input_line_pointer
= start
;
901 /* This function is called for each symbol seen in an expression. It
902 handles the special parsing which PowerPC assemblers are supposed
903 to use for condition codes. */
905 /* Whether to do the special parsing. */
906 static bfd_boolean cr_operand
;
908 /* Names to recognize in a condition code. This table is sorted. */
909 static const struct pd_reg cr_names
[] =
926 /* Parsing function. This returns non-zero if it recognized an
930 ppc_parse_name (const char *name
, expressionS
*exp
)
939 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
944 exp
->X_op
= O_constant
;
945 exp
->X_add_number
= val
;
950 /* Local variables. */
952 /* Whether to target xcoff64/elf64. */
953 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
955 /* Opcode hash table. */
956 static struct hash_control
*ppc_hash
;
958 /* Macro hash table. */
959 static struct hash_control
*ppc_macro_hash
;
962 /* What type of shared library support to use. */
963 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
965 /* Flags to set in the elf header. */
966 static flagword ppc_flags
= 0;
968 /* Whether this is Solaris or not. */
969 #ifdef TARGET_SOLARIS_COMMENT
970 #define SOLARIS_P TRUE
972 #define SOLARIS_P FALSE
975 static bfd_boolean msolaris
= SOLARIS_P
;
980 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
981 using a bunch of different sections. These assembler sections,
982 however, are all encompassed within the .text or .data sections of
983 the final output file. We handle this by using different
984 subsegments within these main segments. */
986 /* Next subsegment to allocate within the .text segment. */
987 static subsegT ppc_text_subsegment
= 2;
989 /* Linked list of csects in the text section. */
990 static symbolS
*ppc_text_csects
;
992 /* Next subsegment to allocate within the .data segment. */
993 static subsegT ppc_data_subsegment
= 2;
995 /* Linked list of csects in the data section. */
996 static symbolS
*ppc_data_csects
;
998 /* The current csect. */
999 static symbolS
*ppc_current_csect
;
1001 /* The RS/6000 assembler uses a TOC which holds addresses of functions
1002 and variables. Symbols are put in the TOC with the .tc pseudo-op.
1003 A special relocation is used when accessing TOC entries. We handle
1004 the TOC as a subsegment within the .data segment. We set it up if
1005 we see a .toc pseudo-op, and save the csect symbol here. */
1006 static symbolS
*ppc_toc_csect
;
1008 /* The first frag in the TOC subsegment. */
1009 static fragS
*ppc_toc_frag
;
1011 /* The first frag in the first subsegment after the TOC in the .data
1012 segment. NULL if there are no subsegments after the TOC. */
1013 static fragS
*ppc_after_toc_frag
;
1015 /* The current static block. */
1016 static symbolS
*ppc_current_block
;
1018 /* The COFF debugging section; set by md_begin. This is not the
1019 .debug section, but is instead the secret BFD section which will
1020 cause BFD to set the section number of a symbol to N_DEBUG. */
1021 static asection
*ppc_coff_debug_section
;
1023 /* Structure to set the length field of the dwarf sections. */
1024 struct dw_subsection
{
1025 /* Subsections are simply linked. */
1026 struct dw_subsection
*link
;
1028 /* The subsection number. */
1031 /* Expression to compute the length of the section. */
1032 expressionS end_exp
;
1035 static struct dw_section
{
1036 /* Corresponding section. */
1039 /* Simply linked list of subsections with a label. */
1040 struct dw_subsection
*list_subseg
;
1042 /* The anonymous subsection. */
1043 struct dw_subsection
*anon_subseg
;
1044 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1045 #endif /* OBJ_XCOFF */
1049 /* Various sections that we need for PE coff support. */
1050 static segT ydata_section
;
1051 static segT pdata_section
;
1052 static segT reldata_section
;
1053 static segT rdata_section
;
1054 static segT tocdata_section
;
1056 /* The current section and the previous section. See ppc_previous. */
1057 static segT ppc_previous_section
;
1058 static segT ppc_current_section
;
1063 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1064 #define PPC_APUINFO_ISEL 0x40
1065 #define PPC_APUINFO_PMR 0x41
1066 #define PPC_APUINFO_RFMCI 0x42
1067 #define PPC_APUINFO_CACHELCK 0x43
1068 #define PPC_APUINFO_SPE 0x100
1069 #define PPC_APUINFO_EFS 0x101
1070 #define PPC_APUINFO_BRLOCK 0x102
1071 #define PPC_APUINFO_VLE 0x104
1074 * We keep a list of APUinfo
1076 unsigned long *ppc_apuinfo_list
;
1077 unsigned int ppc_apuinfo_num
;
1078 unsigned int ppc_apuinfo_num_alloc
;
1079 #endif /* OBJ_ELF */
1082 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1084 const char *const md_shortopts
= "um:";
1086 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1087 const struct option md_longopts
[] = {
1088 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1089 {NULL
, no_argument
, NULL
, 0}
1091 const size_t md_longopts_size
= sizeof (md_longopts
);
1094 md_parse_option (int c
, char *arg
)
1101 /* -u means that any undefined symbols should be treated as
1102 external, which is the default for gas anyhow. */
1107 /* Solaris as takes -le (presumably for little endian). For completeness
1108 sake, recognize -be also. */
1109 if (strcmp (arg
, "e") == 0)
1111 target_big_endian
= 0;
1112 set_target_endian
= 1;
1113 if (ppc_cpu
& PPC_OPCODE_VLE
)
1114 as_bad (_("the use of -mvle requires big endian."));
1122 if (strcmp (arg
, "e") == 0)
1124 target_big_endian
= 1;
1125 set_target_endian
= 1;
1133 /* Recognize -K PIC. */
1134 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1137 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1145 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1147 if (strcmp (arg
, "64") == 0)
1151 if (ppc_cpu
& PPC_OPCODE_VLE
)
1152 as_bad (_("the use of -mvle requires -a32."));
1154 as_fatal (_("%s unsupported"), "-a64");
1157 else if (strcmp (arg
, "32") == 0)
1164 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1168 if (strcmp (arg
, "vle") == 0)
1170 if (set_target_endian
&& target_big_endian
== 0)
1171 as_bad (_("the use of -mvle requires big endian."));
1173 as_bad (_("the use of -mvle requires -a32."));
1177 else if (strcmp (arg
, "regnames") == 0)
1180 else if (strcmp (arg
, "no-regnames") == 0)
1181 reg_names_p
= FALSE
;
1184 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1185 that require relocation. */
1186 else if (strcmp (arg
, "relocatable") == 0)
1188 shlib
= SHLIB_MRELOCATABLE
;
1189 ppc_flags
|= EF_PPC_RELOCATABLE
;
1192 else if (strcmp (arg
, "relocatable-lib") == 0)
1194 shlib
= SHLIB_MRELOCATABLE
;
1195 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1198 /* -memb, set embedded bit. */
1199 else if (strcmp (arg
, "emb") == 0)
1200 ppc_flags
|= EF_PPC_EMB
;
1202 /* -mlittle/-mbig set the endianness. */
1203 else if (strcmp (arg
, "little") == 0
1204 || strcmp (arg
, "little-endian") == 0)
1206 target_big_endian
= 0;
1207 set_target_endian
= 1;
1208 if (ppc_cpu
& PPC_OPCODE_VLE
)
1209 as_bad (_("the use of -mvle requires big endian."));
1212 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1214 target_big_endian
= 1;
1215 set_target_endian
= 1;
1218 else if (strcmp (arg
, "solaris") == 0)
1221 ppc_comment_chars
= ppc_solaris_comment_chars
;
1224 else if (strcmp (arg
, "no-solaris") == 0)
1227 ppc_comment_chars
= ppc_eabi_comment_chars
;
1232 as_bad (_("invalid switch -m%s"), arg
);
1238 /* -V: SVR4 argument to print version ID. */
1240 print_version_id ();
1243 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1244 should be emitted or not. FIXME: Not implemented. */
1248 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1249 rather than .stabs.excl, which is ignored by the linker.
1250 FIXME: Not implemented. */
1261 nop_limit
= strtoul (optarg
, &end
, 0);
1263 as_bad (_("--nops needs a numeric argument"));
1275 md_show_usage (FILE *stream
)
1277 fprintf (stream
, _("\
1279 -a32 generate ELF32/XCOFF32\n\
1280 -a64 generate ELF64/XCOFF64\n\
1282 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1283 -mpwr generate code for POWER (RIOS1)\n\
1284 -m601 generate code for PowerPC 601\n\
1285 -mppc, -mppc32, -m603, -m604\n\
1286 generate code for PowerPC 603/604\n\
1287 -m403 generate code for PowerPC 403\n\
1288 -m405 generate code for PowerPC 405\n\
1289 -m440 generate code for PowerPC 440\n\
1290 -m464 generate code for PowerPC 464\n\
1291 -m476 generate code for PowerPC 476\n\
1292 -m7400, -m7410, -m7450, -m7455\n\
1293 generate code for PowerPC 7400/7410/7450/7455\n\
1294 -m750cl generate code for PowerPC 750cl\n"));
1295 fprintf (stream
, _("\
1296 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1297 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1298 -mbooke generate code for 32-bit PowerPC BookE\n\
1299 -ma2 generate code for A2 architecture\n\
1300 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1301 -mpower5, -mpwr5, -mpwr5x\n\
1302 generate code for Power5 architecture\n\
1303 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1304 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1305 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1306 -mcell generate code for Cell Broadband Engine architecture\n\
1307 -mcom generate code Power/PowerPC common instructions\n\
1308 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1309 fprintf (stream
, _("\
1310 -maltivec generate code for AltiVec\n\
1311 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1312 -mhtm generate code for Hardware Transactional Memory\n\
1313 -me300 generate code for PowerPC e300 family\n\
1314 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1315 -me500mc, generate code for Freescale e500mc core complex\n\
1316 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1317 -me5500, generate code for Freescale e5500 core complex\n\
1318 -me6500, generate code for Freescale e6500 core complex\n\
1319 -mspe generate code for Motorola SPE instructions\n\
1320 -mvle generate code for Freescale VLE instructions\n\
1321 -mtitan generate code for AppliedMicro Titan core complex\n\
1322 -mregnames Allow symbolic names for registers\n\
1323 -mno-regnames Do not allow symbolic names for registers\n"));
1325 fprintf (stream
, _("\
1326 -mrelocatable support for GCC's -mrelocatble option\n\
1327 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1328 -memb set PPC_EMB bit in ELF flags\n\
1329 -mlittle, -mlittle-endian, -le\n\
1330 generate code for a little endian machine\n\
1331 -mbig, -mbig-endian, -be\n\
1332 generate code for a big endian machine\n\
1333 -msolaris generate code for Solaris\n\
1334 -mno-solaris do not generate code for Solaris\n\
1335 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1336 -V print assembler version number\n\
1337 -Qy, -Qn ignored\n"));
1339 fprintf (stream
, _("\
1340 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1343 /* Set ppc_cpu if it is not already set. */
1348 const char *default_os
= TARGET_OS
;
1349 const char *default_cpu
= TARGET_CPU
;
1351 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1354 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1355 else if (strncmp (default_os
, "aix", 3) == 0
1356 && default_os
[3] >= '4' && default_os
[3] <= '9')
1357 ppc_cpu
|= PPC_OPCODE_COMMON
;
1358 else if (strncmp (default_os
, "aix3", 4) == 0)
1359 ppc_cpu
|= PPC_OPCODE_POWER
;
1360 else if (strcmp (default_cpu
, "rs6000") == 0)
1361 ppc_cpu
|= PPC_OPCODE_POWER
;
1362 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1363 ppc_cpu
|= PPC_OPCODE_PPC
;
1365 as_fatal (_("unknown default cpu = %s, os = %s"),
1366 default_cpu
, default_os
);
1370 /* Figure out the BFD architecture to use. This function and ppc_mach
1371 are called well before md_begin, when the output file is opened. */
1373 enum bfd_architecture
1376 const char *default_cpu
= TARGET_CPU
;
1379 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1380 return bfd_arch_powerpc
;
1381 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1382 return bfd_arch_powerpc
;
1383 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1384 return bfd_arch_rs6000
;
1385 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1387 if (strcmp (default_cpu
, "rs6000") == 0)
1388 return bfd_arch_rs6000
;
1389 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1390 return bfd_arch_powerpc
;
1393 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1394 return bfd_arch_unknown
;
1401 return bfd_mach_ppc64
;
1402 else if (ppc_arch () == bfd_arch_rs6000
)
1403 return bfd_mach_rs6k
;
1404 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1405 return bfd_mach_ppc_titan
;
1406 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1407 return bfd_mach_ppc_vle
;
1409 return bfd_mach_ppc
;
1413 ppc_target_format (void)
1417 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1419 return "xcoff-powermac";
1422 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1424 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1430 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1431 # elif defined (TE_VXWORKS)
1432 return "elf32-powerpc-vxworks";
1434 return (target_big_endian
1435 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1436 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1441 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1442 Return TRUE if there's a problem, otherwise FALSE. */
1445 insn_validate (const struct powerpc_opcode
*op
)
1447 const unsigned char *o
;
1448 unsigned long omask
= op
->mask
;
1450 /* The mask had better not trim off opcode bits. */
1451 if ((op
->opcode
& omask
) != op
->opcode
)
1453 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1457 /* The operands must not overlap the opcode or each other. */
1458 for (o
= op
->operands
; *o
; ++o
)
1460 if (*o
>= num_powerpc_operands
)
1462 as_bad (_("operand index error for %s"), op
->name
);
1467 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1468 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1472 if (operand
->shift
>= 0)
1473 mask
= operand
->bitm
<< operand
->shift
;
1475 mask
= operand
->bitm
>> -operand
->shift
;
1478 as_bad (_("operand %d overlap in %s"),
1479 (int) (o
- op
->operands
), op
->name
);
1489 /* Insert opcodes and macros into hash tables. Called at startup and
1490 for .machine pseudo. */
1493 ppc_setup_opcodes (void)
1495 const struct powerpc_opcode
*op
;
1496 const struct powerpc_opcode
*op_end
;
1497 const struct powerpc_macro
*macro
;
1498 const struct powerpc_macro
*macro_end
;
1499 bfd_boolean bad_insn
= FALSE
;
1501 if (ppc_hash
!= NULL
)
1502 hash_die (ppc_hash
);
1503 if (ppc_macro_hash
!= NULL
)
1504 hash_die (ppc_macro_hash
);
1506 /* Insert the opcodes into a hash table. */
1507 ppc_hash
= hash_new ();
1509 if (ENABLE_CHECKING
)
1513 /* An index into powerpc_operands is stored in struct fix
1514 fx_pcrel_adjust which is 8 bits wide. */
1515 gas_assert (num_powerpc_operands
< 256);
1517 /* Check operand masks. Code here and in the disassembler assumes
1518 all the 1's in the mask are contiguous. */
1519 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1521 unsigned long mask
= powerpc_operands
[i
].bitm
;
1522 unsigned long right_bit
;
1525 right_bit
= mask
& -mask
;
1527 right_bit
= mask
& -mask
;
1528 if (mask
!= right_bit
)
1530 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1533 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1534 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1535 sizeof (powerpc_operands
[0])) == 0)
1537 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1544 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1545 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1547 if (ENABLE_CHECKING
)
1549 if (op
!= powerpc_opcodes
)
1551 int old_opcode
= PPC_OP (op
[-1].opcode
);
1552 int new_opcode
= PPC_OP (op
[0].opcode
);
1554 #ifdef PRINT_OPCODE_TABLE
1555 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1556 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1557 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1558 (unsigned long long) op
->flags
);
1561 /* The major opcodes had better be sorted. Code in the
1562 disassembler assumes the insns are sorted according to
1564 if (new_opcode
< old_opcode
)
1566 as_bad (_("major opcode is not sorted for %s"),
1571 bad_insn
|= insn_validate (op
);
1574 if ((ppc_cpu
& op
->flags
) != 0
1575 && !(ppc_cpu
& op
->deprecated
))
1579 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1582 as_bad (_("duplicate instruction %s"),
1589 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1590 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1591 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1593 op_end
= vle_opcodes
+ vle_num_opcodes
;
1594 for (op
= vle_opcodes
; op
< op_end
; op
++)
1596 if (ENABLE_CHECKING
)
1598 if (op
!= vle_opcodes
)
1600 unsigned old_seg
, new_seg
;
1602 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1603 old_seg
= VLE_OP_TO_SEG (old_seg
);
1604 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1605 new_seg
= VLE_OP_TO_SEG (new_seg
);
1607 #ifdef PRINT_OPCODE_TABLE
1608 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1609 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1610 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1611 (unsigned long long) op
->flags
);
1613 /* The major opcodes had better be sorted. Code in the
1614 disassembler assumes the insns are sorted according to
1616 if (new_seg
< old_seg
)
1618 as_bad (_("major opcode is not sorted for %s"),
1624 bad_insn
|= insn_validate (op
);
1627 if ((ppc_cpu
& op
->flags
) != 0
1628 && !(ppc_cpu
& op
->deprecated
))
1632 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1635 as_bad (_("duplicate instruction %s"),
1642 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1643 for (op
= vle_opcodes
; op
< op_end
; op
++)
1644 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1646 /* Insert the macros into a hash table. */
1647 ppc_macro_hash
= hash_new ();
1649 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1650 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1652 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1656 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1657 if (retval
!= (const char *) NULL
)
1659 as_bad (_("duplicate macro %s"), macro
->name
);
1669 /* This function is called when the assembler starts up. It is called
1670 after the options have been parsed and the output file has been
1678 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1679 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1682 /* Set the ELF flags if desired. */
1683 if (ppc_flags
&& !msolaris
)
1684 bfd_set_private_flags (stdoutput
, ppc_flags
);
1687 ppc_setup_opcodes ();
1689 /* Tell the main code what the endianness is if it is not overridden
1691 if (!set_target_endian
)
1693 set_target_endian
= 1;
1694 target_big_endian
= PPC_BIG_ENDIAN
;
1698 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1700 /* Create dummy symbols to serve as initial csects. This forces the
1701 text csects to precede the data csects. These symbols will not
1703 ppc_text_csects
= symbol_make ("dummy\001");
1704 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1705 ppc_data_csects
= symbol_make ("dummy\001");
1706 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1711 ppc_current_section
= text_section
;
1712 ppc_previous_section
= 0;
1721 if (ppc_apuinfo_list
== NULL
)
1724 /* Ok, so write the section info out. We have this layout:
1728 0 8 length of "APUinfo\0"
1729 4 (n*4) number of APU's (4 bytes each)
1732 20 APU#1 first APU's info
1733 24 APU#2 second APU's info
1738 asection
*seg
= now_seg
;
1739 subsegT subseg
= now_subseg
;
1740 asection
*apuinfo_secp
= (asection
*) NULL
;
1743 /* Create the .PPC.EMB.apuinfo section. */
1744 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1745 bfd_set_section_flags (stdoutput
,
1747 SEC_HAS_CONTENTS
| SEC_READONLY
);
1750 md_number_to_chars (p
, (valueT
) 8, 4);
1753 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1756 md_number_to_chars (p
, (valueT
) 2, 4);
1759 strcpy (p
, "APUinfo");
1761 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1764 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1767 frag_align (2, 0, 0);
1769 /* We probably can't restore the current segment, for there likely
1772 subseg_set (seg
, subseg
);
1777 /* Insert an operand value into an instruction. */
1779 static unsigned long
1780 ppc_insert_operand (unsigned long insn
,
1781 const struct powerpc_operand
*operand
,
1787 long min
, max
, right
;
1789 max
= operand
->bitm
;
1793 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1795 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1796 max
= (max
>> 1) & -right
;
1797 min
= ~max
& -right
;
1800 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1803 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1812 /* Some people write constants with the sign extension done by
1813 hand but only up to 32 bits. This shouldn't really be valid,
1814 but, to permit this code to assemble on a 64-bit host, we
1815 sign extend the 32-bit value to 64 bits if so doing makes the
1818 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1819 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1820 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1821 val
= val
- 0x80000000 - 0x80000000;
1823 /* Similarly, people write expressions like ~(1<<15), and expect
1824 this to be OK for a 32-bit unsigned value. */
1826 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1827 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1828 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1829 val
= val
+ 0x80000000 + 0x80000000;
1833 || (val
& (right
- 1)) != 0)
1834 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1837 if (operand
->insert
)
1842 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1843 if (errmsg
!= (const char *) NULL
)
1844 as_bad_where (file
, line
, "%s", errmsg
);
1846 else if (operand
->shift
>= 0)
1847 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1849 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1856 /* Parse @got, etc. and return the desired relocation. */
1857 static bfd_reloc_code_real_type
1858 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1862 unsigned int length
: 8;
1863 unsigned int valid32
: 1;
1864 unsigned int valid64
: 1;
1873 const struct map_bfd
*ptr
;
1875 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1876 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1877 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1879 static const struct map_bfd mapping
[] = {
1880 MAP ("l", BFD_RELOC_LO16
),
1881 MAP ("h", BFD_RELOC_HI16
),
1882 MAP ("ha", BFD_RELOC_HI16_S
),
1883 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1884 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1885 MAP ("got", BFD_RELOC_16_GOTOFF
),
1886 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1887 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1888 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1889 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1890 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1891 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1892 MAP ("copy", BFD_RELOC_PPC_COPY
),
1893 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1894 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1895 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1896 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1897 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1898 MAP ("tls", BFD_RELOC_PPC_TLS
),
1899 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1900 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1901 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1902 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1903 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1904 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1905 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1906 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1907 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1908 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1909 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1910 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1911 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1912 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1913 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1914 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1915 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1916 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1917 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1918 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1919 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1920 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1921 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1922 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1923 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1924 MAP32 ("fixup", BFD_RELOC_CTOR
),
1925 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1926 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1927 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1928 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1929 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1930 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1931 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1932 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1933 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1934 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1935 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1936 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1937 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1938 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1939 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1940 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1941 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1942 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1943 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1944 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1945 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1946 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1947 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1948 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1949 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1950 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1951 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1952 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1953 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1954 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1955 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1956 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1957 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1958 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1959 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1960 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1961 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1962 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1963 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1964 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1965 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1966 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1967 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1968 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1969 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1973 return BFD_RELOC_UNUSED
;
1975 for (ch
= *str
, str2
= ident
;
1976 (str2
< ident
+ sizeof (ident
) - 1
1977 && (ISALNUM (ch
) || ch
== '@'));
1980 *str2
++ = TOLOWER (ch
);
1987 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1988 if (ch
== ptr
->string
[0]
1989 && len
== ptr
->length
1990 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1991 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1993 int reloc
= ptr
->reloc
;
1995 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1999 case BFD_RELOC_16_GOTOFF
:
2000 case BFD_RELOC_LO16_GOTOFF
:
2001 case BFD_RELOC_HI16_GOTOFF
:
2002 case BFD_RELOC_HI16_S_GOTOFF
:
2003 as_warn (_("identifier+constant@got means "
2004 "identifier@got+constant"));
2007 case BFD_RELOC_PPC_GOT_TLSGD16
:
2008 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2009 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2010 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2011 case BFD_RELOC_PPC_GOT_TLSLD16
:
2012 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2013 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2014 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2015 case BFD_RELOC_PPC_GOT_DTPREL16
:
2016 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2017 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2018 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2019 case BFD_RELOC_PPC_GOT_TPREL16
:
2020 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2021 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2022 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2023 as_bad (_("symbol+offset not supported for got tls"));
2028 /* Now check for identifier@suffix+constant. */
2029 if (*str
== '-' || *str
== '+')
2031 char *orig_line
= input_line_pointer
;
2032 expressionS new_exp
;
2034 input_line_pointer
= str
;
2035 expression (&new_exp
);
2036 if (new_exp
.X_op
== O_constant
)
2038 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2039 str
= input_line_pointer
;
2042 if (&input_line_pointer
!= str_p
)
2043 input_line_pointer
= orig_line
;
2047 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2048 && exp_p
->X_op
== O_symbol
2049 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2051 /* Change the symbol so that the dummy .TOC. symbol can be
2052 omitted from the object file. */
2053 exp_p
->X_add_symbol
= &abs_symbol
;
2056 return (bfd_reloc_code_real_type
) reloc
;
2059 return BFD_RELOC_UNUSED
;
2062 /* Like normal .long/.short/.word, except support @got, etc.
2063 Clobbers input_line_pointer, checks end-of-line. */
2065 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2068 bfd_reloc_code_real_type reloc
;
2070 if (is_it_end_of_statement ())
2072 demand_empty_rest_of_line ();
2079 if (exp
.X_op
== O_symbol
2080 && *input_line_pointer
== '@'
2081 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2082 &exp
)) != BFD_RELOC_UNUSED
)
2084 reloc_howto_type
*reloc_howto
;
2087 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2088 size
= bfd_get_reloc_size (reloc_howto
);
2092 as_bad (_("%s relocations do not fit in %d bytes\n"),
2093 reloc_howto
->name
, nbytes
);
2100 p
= frag_more (nbytes
);
2101 memset (p
, 0, nbytes
);
2103 if (target_big_endian
)
2104 offset
= nbytes
- size
;
2105 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2110 emit_expr (&exp
, (unsigned int) nbytes
);
2112 while (*input_line_pointer
++ == ',');
2114 /* Put terminator back into stream. */
2115 input_line_pointer
--;
2116 demand_empty_rest_of_line ();
2119 /* Solaris pseduo op to change to the .rodata section. */
2121 ppc_elf_rdata (int xxx
)
2123 char *save_line
= input_line_pointer
;
2124 static char section
[] = ".rodata\n";
2126 /* Just pretend this is .section .rodata */
2127 input_line_pointer
= section
;
2128 obj_elf_section (xxx
);
2130 input_line_pointer
= save_line
;
2133 /* Pseudo op to make file scope bss items. */
2135 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2148 name
= input_line_pointer
;
2149 c
= get_symbol_end ();
2151 /* just after name is now '\0'. */
2152 p
= input_line_pointer
;
2155 if (*input_line_pointer
!= ',')
2157 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2158 ignore_rest_of_line ();
2162 input_line_pointer
++; /* skip ',' */
2163 if ((size
= get_absolute_expression ()) < 0)
2165 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2166 ignore_rest_of_line ();
2170 /* The third argument to .lcomm is the alignment. */
2171 if (*input_line_pointer
!= ',')
2175 ++input_line_pointer
;
2176 align
= get_absolute_expression ();
2179 as_warn (_("ignoring bad alignment"));
2185 symbolP
= symbol_find_or_make (name
);
2188 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2190 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2191 S_GET_NAME (symbolP
));
2192 ignore_rest_of_line ();
2196 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2198 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2199 S_GET_NAME (symbolP
),
2200 (long) S_GET_VALUE (symbolP
),
2203 ignore_rest_of_line ();
2209 old_subsec
= now_subseg
;
2212 /* Convert to a power of 2 alignment. */
2213 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2216 as_bad (_("common alignment not a power of 2"));
2217 ignore_rest_of_line ();
2224 record_alignment (bss_section
, align2
);
2225 subseg_set (bss_section
, 0);
2227 frag_align (align2
, 0, 0);
2228 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2229 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2230 symbol_set_frag (symbolP
, frag_now
);
2231 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2234 S_SET_SIZE (symbolP
, size
);
2235 S_SET_SEGMENT (symbolP
, bss_section
);
2236 subseg_set (old_sec
, old_subsec
);
2237 demand_empty_rest_of_line ();
2240 /* Validate any relocations emitted for -mrelocatable, possibly adding
2241 fixups for word relocations in writable segments, so we can adjust
2244 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2246 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2255 case SHLIB_MRELOCATABLE
:
2256 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2257 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2258 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2259 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2260 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2261 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2262 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2263 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2264 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2265 && (seg
->flags
& SEC_LOAD
) != 0
2266 && strcmp (segment_name (seg
), ".got2") != 0
2267 && strcmp (segment_name (seg
), ".dtors") != 0
2268 && strcmp (segment_name (seg
), ".ctors") != 0
2269 && strcmp (segment_name (seg
), ".fixup") != 0
2270 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2271 && strcmp (segment_name (seg
), ".eh_frame") != 0
2272 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2274 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2275 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2277 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2278 _("relocation cannot be done when using -mrelocatable"));
2285 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2286 function descriptor sym if the corresponding code sym is used. */
2289 ppc_frob_file_before_adjust (void)
2297 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2304 name
= S_GET_NAME (symp
);
2308 if (! S_IS_WEAK (symp
)
2309 || S_IS_DEFINED (symp
))
2312 len
= strlen (name
) + 1;
2313 dotname
= xmalloc (len
+ 1);
2315 memcpy (dotname
+ 1, name
, len
);
2316 dotsym
= symbol_find_noref (dotname
, 1);
2318 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2319 || symbol_used_in_reloc_p (dotsym
)))
2320 symbol_mark_used (symp
);
2324 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2326 && toc_reloc_types
!= has_large_toc_reloc
2327 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2328 as_warn (_("TOC section size exceeds 64k"));
2331 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2332 emitted. Other uses of .TOC. will cause the symbol to be marked
2333 with BSF_KEEP in md_apply_fix. */
2336 ppc_elf_adjust_symtab (void)
2341 symp
= symbol_find (".TOC.");
2344 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2345 if ((bsym
->flags
& BSF_KEEP
) == 0)
2346 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2352 #endif /* OBJ_ELF */
2357 * Summary of parse_toc_entry.
2359 * in: Input_line_pointer points to the '[' in one of:
2361 * [toc] [tocv] [toc32] [toc64]
2363 * Anything else is an error of one kind or another.
2366 * return value: success or failure
2367 * toc_kind: kind of toc reference
2368 * input_line_pointer:
2369 * success: first char after the ']'
2370 * failure: unchanged
2374 * [toc] - rv == success, toc_kind = default_toc
2375 * [tocv] - rv == success, toc_kind = data_in_toc
2376 * [toc32] - rv == success, toc_kind = must_be_32
2377 * [toc64] - rv == success, toc_kind = must_be_64
2381 enum toc_size_qualifier
2383 default_toc
, /* The toc cell constructed should be the system default size */
2384 data_in_toc
, /* This is a direct reference to a toc cell */
2385 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2386 must_be_64
/* The toc cell constructed must be 64 bits wide */
2390 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2395 enum toc_size_qualifier t
;
2397 /* Save the input_line_pointer. */
2398 start
= input_line_pointer
;
2400 /* Skip over the '[' , and whitespace. */
2401 ++input_line_pointer
;
2404 /* Find the spelling of the operand. */
2405 toc_spec
= input_line_pointer
;
2406 c
= get_symbol_end ();
2408 if (strcmp (toc_spec
, "toc") == 0)
2412 else if (strcmp (toc_spec
, "tocv") == 0)
2416 else if (strcmp (toc_spec
, "toc32") == 0)
2420 else if (strcmp (toc_spec
, "toc64") == 0)
2426 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2427 *input_line_pointer
= c
;
2428 input_line_pointer
= start
;
2432 /* Now find the ']'. */
2433 *input_line_pointer
= c
;
2435 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2436 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2440 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2441 input_line_pointer
= start
;
2450 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2451 /* See whether a symbol is in the TOC section. */
2454 ppc_is_toc_sym (symbolS
*sym
)
2457 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
2460 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2462 return strcmp (sname
, ".toc") == 0;
2464 return strcmp (sname
, ".got") == 0;
2467 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2471 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2473 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2477 /* Check we don't already exist. */
2478 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2479 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2482 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2484 if (ppc_apuinfo_num_alloc
== 0)
2486 ppc_apuinfo_num_alloc
= 4;
2487 ppc_apuinfo_list
= (unsigned long *)
2488 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2492 ppc_apuinfo_num_alloc
+= 4;
2493 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2494 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2497 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2503 /* We need to keep a list of fixups. We can't simply generate them as
2504 we go, because that would require us to first create the frag, and
2505 that would screw up references to ``.''. */
2511 bfd_reloc_code_real_type reloc
;
2514 #define MAX_INSN_FIXUPS (5)
2517 #define E_OR2I_INSN 0x7000C000
2518 #define E_AND2I_DOT_INSN 0x7000C800
2519 #define E_OR2IS_INSN 0x7000D000
2520 #define E_LIS_INSN 0x7000E000
2521 #define E_AND2IS_DOT_INSN 0x7000E800
2524 #define E_ADD2I_DOT_INSN 0x70008800
2525 #define E_ADD2IS_INSN 0x70009000
2526 #define E_CMP16I_INSN 0x70009800
2527 #define E_MULL2I_INSN 0x7000A000
2528 #define E_CMPL16I_INSN 0x7000A800
2529 #define E_CMPH16I_INSN 0x7000B000
2530 #define E_CMPHL16I_INSN 0x7000B800
2532 /* This routine is called for each instruction to be assembled. */
2535 md_assemble (char *str
)
2538 const struct powerpc_opcode
*opcode
;
2540 const unsigned char *opindex_ptr
;
2544 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2549 unsigned int insn_length
;
2551 /* Get the opcode. */
2552 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2557 /* Look up the opcode in the hash table. */
2558 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2559 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2561 const struct powerpc_macro
*macro
;
2563 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2564 if (macro
== (const struct powerpc_macro
*) NULL
)
2565 as_bad (_("unrecognized opcode: `%s'"), str
);
2567 ppc_macro (s
, macro
);
2572 insn
= opcode
->opcode
;
2575 while (ISSPACE (*str
))
2578 /* PowerPC operands are just expressions. The only real issue is
2579 that a few operand types are optional. All cases which might use
2580 an optional operand separate the operands only with commas (in some
2581 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2582 have optional operands). Most instructions with optional operands
2583 have only one. Those that have more than one optional operand can
2584 take either all their operands or none. So, before we start seriously
2585 parsing the operands, we check to see if we have optional operands,
2586 and if we do, we count the number of commas to see which operands
2587 have been omitted. */
2589 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2591 const struct powerpc_operand
*operand
;
2593 operand
= &powerpc_operands
[*opindex_ptr
];
2594 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2596 unsigned int opcount
;
2597 unsigned int num_operands_expected
;
2599 /* There is an optional operand. Count the number of
2600 commas in the input line. */
2607 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2614 /* Compute the number of expected operands.
2615 Do not count fake operands. */
2616 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2617 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2618 ++ num_operands_expected
;
2620 /* If there are fewer operands in the line then are called
2621 for by the instruction, we want to skip the optional
2623 if (opcount
< num_operands_expected
)
2630 /* Gather the operands. */
2634 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2636 const struct powerpc_operand
*operand
;
2642 if (next_opindex
== 0)
2643 operand
= &powerpc_operands
[*opindex_ptr
];
2646 operand
= &powerpc_operands
[next_opindex
];
2651 /* If this is a fake operand, then we do not expect anything
2653 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2655 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2656 if (errmsg
!= (const char *) NULL
)
2657 as_bad ("%s", errmsg
);
2661 /* If this is an optional operand, and we are skipping it, just
2663 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2666 if (operand
->insert
)
2668 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2669 if (errmsg
!= (const char *) NULL
)
2670 as_bad ("%s", errmsg
);
2672 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2673 next_opindex
= *opindex_ptr
+ 1;
2677 /* Gather the operand. */
2678 hold
= input_line_pointer
;
2679 input_line_pointer
= str
;
2682 if (*input_line_pointer
== '[')
2684 /* We are expecting something like the second argument here:
2686 * lwz r4,[toc].GS.0.static_int(rtoc)
2687 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2688 * The argument following the `]' must be a symbol name, and the
2689 * register must be the toc register: 'rtoc' or '2'
2691 * The effect is to 0 as the displacement field
2692 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2693 * the appropriate variation) reloc against it based on the symbol.
2694 * The linker will build the toc, and insert the resolved toc offset.
2697 * o The size of the toc entry is currently assumed to be
2698 * 32 bits. This should not be assumed to be a hard coded
2700 * o In an effort to cope with a change from 32 to 64 bits,
2701 * there are also toc entries that are specified to be
2702 * either 32 or 64 bits:
2703 * lwz r4,[toc32].GS.0.static_int(rtoc)
2704 * lwz r4,[toc64].GS.0.static_int(rtoc)
2705 * These demand toc entries of the specified size, and the
2706 * instruction probably requires it.
2710 enum toc_size_qualifier toc_kind
;
2711 bfd_reloc_code_real_type toc_reloc
;
2713 /* Go parse off the [tocXX] part. */
2714 valid_toc
= parse_toc_entry (&toc_kind
);
2718 ignore_rest_of_line ();
2722 /* Now get the symbol following the ']'. */
2728 /* In this case, we may not have seen the symbol yet,
2729 since it is allowed to appear on a .extern or .globl
2730 or just be a label in the .data section. */
2731 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2734 /* 1. The symbol must be defined and either in the toc
2735 section, or a global.
2736 2. The reloc generated must have the TOCDEFN flag set
2737 in upper bit mess of the reloc type.
2738 FIXME: It's a little confusing what the tocv
2739 qualifier can be used for. At the very least, I've
2740 seen three uses, only one of which I'm sure I can
2742 if (ex
.X_op
== O_symbol
)
2744 gas_assert (ex
.X_add_symbol
!= NULL
);
2745 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2748 as_bad (_("[tocv] symbol is not a toc symbol"));
2752 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2755 /* FIXME: these next two specifically specify 32/64 bit
2756 toc entries. We don't support them today. Is this
2757 the right way to say that? */
2758 toc_reloc
= BFD_RELOC_UNUSED
;
2759 as_bad (_("unimplemented toc32 expression modifier"));
2762 /* FIXME: see above. */
2763 toc_reloc
= BFD_RELOC_UNUSED
;
2764 as_bad (_("unimplemented toc64 expression modifier"));
2768 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2774 /* We need to generate a fixup for this expression. */
2775 if (fc
>= MAX_INSN_FIXUPS
)
2776 as_fatal (_("too many fixups"));
2778 fixups
[fc
].reloc
= toc_reloc
;
2779 fixups
[fc
].exp
= ex
;
2780 fixups
[fc
].opindex
= *opindex_ptr
;
2783 /* Ok. We've set up the fixup for the instruction. Now make it
2784 look like the constant 0 was found here. */
2786 ex
.X_op
= O_constant
;
2787 ex
.X_add_number
= 0;
2788 ex
.X_add_symbol
= NULL
;
2789 ex
.X_op_symbol
= NULL
;
2796 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2797 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2798 || !register_name (&ex
))
2800 char save_lex
= lex_type
['%'];
2802 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2803 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2806 lex_type
['%'] |= LEX_BEGIN_NAME
;
2810 lex_type
['%'] = save_lex
;
2814 str
= input_line_pointer
;
2815 input_line_pointer
= hold
;
2817 if (ex
.X_op
== O_illegal
)
2818 as_bad (_("illegal operand"));
2819 else if (ex
.X_op
== O_absent
)
2820 as_bad (_("missing operand"));
2821 else if (ex
.X_op
== O_register
)
2823 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2824 ppc_cpu
, (char *) NULL
, 0);
2826 else if (ex
.X_op
== O_constant
)
2829 /* Allow @HA, @L, @H on constants. */
2830 bfd_reloc_code_real_type reloc
;
2831 char *orig_str
= str
;
2833 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2840 case BFD_RELOC_LO16
:
2841 /* X_unsigned is the default, so if the user has done
2842 something which cleared it, we always produce a
2844 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2845 ex
.X_add_number
&= 0xffff;
2847 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2850 case BFD_RELOC_HI16
:
2851 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2852 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2854 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2857 case BFD_RELOC_HI16_S
:
2858 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2859 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2861 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2864 case BFD_RELOC_PPC64_HIGHER
:
2865 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2866 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2868 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2871 case BFD_RELOC_PPC64_HIGHER_S
:
2872 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2873 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2875 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2878 case BFD_RELOC_PPC64_HIGHEST
:
2879 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2880 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2882 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2885 case BFD_RELOC_PPC64_HIGHEST_S
:
2886 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2887 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2889 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2892 #endif /* OBJ_ELF */
2893 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2894 ppc_cpu
, (char *) NULL
, 0);
2898 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
2900 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2902 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2903 if (sym_name
[0] == '.')
2906 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2908 expressionS tls_exp
;
2910 hold
= input_line_pointer
;
2911 input_line_pointer
= str
+ 1;
2912 expression (&tls_exp
);
2913 if (tls_exp
.X_op
== O_symbol
)
2915 reloc
= BFD_RELOC_UNUSED
;
2916 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2918 reloc
= BFD_RELOC_PPC_TLSGD
;
2919 input_line_pointer
+= 7;
2921 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2923 reloc
= BFD_RELOC_PPC_TLSLD
;
2924 input_line_pointer
+= 7;
2926 if (reloc
!= BFD_RELOC_UNUSED
)
2929 str
= input_line_pointer
;
2931 if (fc
>= MAX_INSN_FIXUPS
)
2932 as_fatal (_("too many fixups"));
2933 fixups
[fc
].exp
= tls_exp
;
2934 fixups
[fc
].opindex
= *opindex_ptr
;
2935 fixups
[fc
].reloc
= reloc
;
2939 input_line_pointer
= hold
;
2943 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2945 /* Some TLS tweaks. */
2951 case BFD_RELOC_PPC_TLS
:
2952 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2953 as_bad (_("@tls may not be used with \"%s\" operands"),
2955 else if (operand
->shift
!= 11)
2956 as_bad (_("@tls may only be used in last operand"));
2958 insn
= ppc_insert_operand (insn
, operand
,
2960 ppc_cpu
, (char *) NULL
, 0);
2963 /* We'll only use the 32 (or 64) bit form of these relocations
2964 in constants. Instructions get the 16 bit form. */
2965 case BFD_RELOC_PPC_DTPREL
:
2966 reloc
= BFD_RELOC_PPC_DTPREL16
;
2968 case BFD_RELOC_PPC_TPREL
:
2969 reloc
= BFD_RELOC_PPC_TPREL16
;
2973 /* If VLE-mode convert LO/HI/HA relocations. */
2974 if (opcode
->flags
& PPC_OPCODE_VLE
)
2976 int tmp_insn
= insn
& opcode
->mask
;
2978 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
2979 || tmp_insn
== E_AND2I_DOT_INSN
2980 || tmp_insn
== E_OR2IS_INSN
2981 || tmp_insn
== E_LIS_INSN
2982 || tmp_insn
== E_AND2IS_DOT_INSN
);
2985 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
2986 || tmp_insn
== E_ADD2IS_INSN
2987 || tmp_insn
== E_CMP16I_INSN
2988 || tmp_insn
== E_MULL2I_INSN
2989 || tmp_insn
== E_CMPL16I_INSN
2990 || tmp_insn
== E_CMPH16I_INSN
2991 || tmp_insn
== E_CMPHL16I_INSN
);
2998 case BFD_RELOC_PPC_EMB_SDA21
:
2999 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3002 case BFD_RELOC_LO16
:
3004 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3005 else if (use_a_reloc
)
3006 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3009 case BFD_RELOC_HI16
:
3011 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3012 else if (use_a_reloc
)
3013 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3016 case BFD_RELOC_HI16_S
:
3018 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3019 else if (use_a_reloc
)
3020 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3023 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3025 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3028 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3030 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3033 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3035 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3040 /* For the absolute forms of branches, convert the PC
3041 relative form back into the absolute. */
3042 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3046 case BFD_RELOC_PPC_B26
:
3047 reloc
= BFD_RELOC_PPC_BA26
;
3049 case BFD_RELOC_PPC_B16
:
3050 reloc
= BFD_RELOC_PPC_BA16
;
3052 case BFD_RELOC_PPC_B16_BRTAKEN
:
3053 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3055 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3056 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3065 case BFD_RELOC_PPC_TOC16
:
3066 toc_reloc_types
|= has_small_toc_reloc
;
3068 case BFD_RELOC_PPC64_TOC16_LO
:
3069 case BFD_RELOC_PPC64_TOC16_HI
:
3070 case BFD_RELOC_PPC64_TOC16_HA
:
3071 toc_reloc_types
|= has_large_toc_reloc
;
3077 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3082 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3084 case BFD_RELOC_LO16
:
3085 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3087 case BFD_RELOC_16_GOTOFF
:
3088 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3090 case BFD_RELOC_LO16_GOTOFF
:
3091 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3093 case BFD_RELOC_LO16_PLTOFF
:
3094 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3096 case BFD_RELOC_16_BASEREL
:
3097 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3099 case BFD_RELOC_LO16_BASEREL
:
3100 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3102 case BFD_RELOC_PPC_TOC16
:
3103 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3105 case BFD_RELOC_PPC64_TOC16_LO
:
3106 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3108 case BFD_RELOC_PPC64_PLTGOT16
:
3109 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3111 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3112 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3114 case BFD_RELOC_PPC_DTPREL16
:
3115 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3117 case BFD_RELOC_PPC_DTPREL16_LO
:
3118 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3120 case BFD_RELOC_PPC_TPREL16
:
3121 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3123 case BFD_RELOC_PPC_TPREL16_LO
:
3124 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3126 case BFD_RELOC_PPC_GOT_DTPREL16
:
3127 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3128 case BFD_RELOC_PPC_GOT_TPREL16
:
3129 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3132 as_bad (_("unsupported relocation for DS offset field"));
3137 #endif /* OBJ_ELF */
3139 if (reloc
!= BFD_RELOC_UNUSED
)
3141 /* Determine a BFD reloc value based on the operand information.
3142 We are only prepared to turn a few of the operands into
3144 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3145 && operand
->bitm
== 0x3fffffc
3146 && operand
->shift
== 0)
3147 reloc
= BFD_RELOC_PPC_B26
;
3148 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3149 && operand
->bitm
== 0xfffc
3150 && operand
->shift
== 0)
3151 reloc
= BFD_RELOC_PPC_B16
;
3152 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3153 && operand
->bitm
== 0x1fe
3154 && operand
->shift
== -1)
3155 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3156 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3157 && operand
->bitm
== 0xfffe
3158 && operand
->shift
== 0)
3159 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3160 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3161 && operand
->bitm
== 0x1fffffe
3162 && operand
->shift
== 0)
3163 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3164 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3165 && operand
->bitm
== 0x3fffffc
3166 && operand
->shift
== 0)
3167 reloc
= BFD_RELOC_PPC_BA26
;
3168 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3169 && operand
->bitm
== 0xfffc
3170 && operand
->shift
== 0)
3171 reloc
= BFD_RELOC_PPC_BA16
;
3172 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3173 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3174 && (operand
->bitm
& 0xfff0) == 0xfff0
3175 && operand
->shift
== 0)
3177 if (ppc_is_toc_sym (ex
.X_add_symbol
))
3179 reloc
= BFD_RELOC_PPC_TOC16
;
3182 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3183 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3188 reloc
= BFD_RELOC_16
;
3191 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3192 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3196 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3198 /* We need to generate a fixup for this expression. */
3199 if (fc
>= MAX_INSN_FIXUPS
)
3200 as_fatal (_("too many fixups"));
3201 fixups
[fc
].exp
= ex
;
3202 fixups
[fc
].opindex
= *opindex_ptr
;
3203 fixups
[fc
].reloc
= reloc
;
3211 /* If expecting more operands, then we want to see "),". */
3212 if (*str
== endc
&& opindex_ptr
[1] != 0)
3216 while (ISSPACE (*str
));
3220 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3228 /* The call to expression should have advanced str past any
3231 && (endc
!= ',' || *str
!= '\0'))
3234 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3236 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3244 while (ISSPACE (*str
))
3248 as_bad (_("junk at end of line: `%s'"), str
);
3251 /* Do we need/want an APUinfo section? */
3252 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0)
3254 /* These are all version "1". */
3255 if (opcode
->flags
& PPC_OPCODE_SPE
)
3256 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3257 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3258 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3259 if (opcode
->flags
& PPC_OPCODE_EFS
)
3260 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3261 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3262 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3263 if (opcode
->flags
& PPC_OPCODE_PMR
)
3264 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3265 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3266 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3267 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3268 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3269 if (opcode
->flags
& PPC_OPCODE_VLE
)
3270 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3274 /* Write out the instruction. */
3275 /* Differentiate between two and four byte insns. */
3276 if (ppc_mach () == bfd_mach_ppc_vle
)
3278 if (PPC_OP_SE_VLE (insn
))
3282 addr_mod
= frag_now_fix () & 1;
3287 addr_mod
= frag_now_fix () & 3;
3289 /* All instructions can start on a 2 byte boundary for VLE. */
3290 f
= frag_more (insn_length
);
3291 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3293 if (ppc_mach() == bfd_mach_ppc_vle
)
3294 as_bad (_("instruction address is not a multiple of 2"));
3296 as_bad (_("instruction address is not a multiple of 4"));
3298 frag_now
->insn_addr
= addr_mod
;
3299 frag_now
->has_code
= 1;
3300 md_number_to_chars (f
, insn
, insn_length
);
3303 dwarf2_emit_insn (insn_length
);
3306 /* Create any fixups. */
3307 for (i
= 0; i
< fc
; i
++)
3310 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3312 reloc_howto_type
*reloc_howto
;
3316 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3320 size
= bfd_get_reloc_size (reloc_howto
);
3321 offset
= target_big_endian
? (insn_length
- size
) : 0;
3323 if (size
< 1 || size
> 4)
3326 fixP
= fix_new_exp (frag_now
,
3327 f
- frag_now
->fr_literal
+ offset
,
3330 reloc_howto
->pc_relative
,
3335 const struct powerpc_operand
*operand
;
3337 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3338 fixP
= fix_new_exp (frag_now
,
3339 f
- frag_now
->fr_literal
,
3342 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3345 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3349 /* Handle a macro. Gather all the operands, transform them as
3350 described by the macro, and call md_assemble recursively. All the
3351 operands are separated by commas; we don't accept parentheses
3352 around operands here. */
3355 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3366 /* Gather the users operands into the operands array. */
3371 if (count
>= sizeof operands
/ sizeof operands
[0])
3373 operands
[count
++] = s
;
3374 s
= strchr (s
, ',');
3375 if (s
== (char *) NULL
)
3380 if (count
!= macro
->operands
)
3382 as_bad (_("wrong number of operands"));
3386 /* Work out how large the string must be (the size is unbounded
3387 because it includes user input). */
3389 format
= macro
->format
;
3390 while (*format
!= '\0')
3399 arg
= strtol (format
+ 1, &send
, 10);
3400 know (send
!= format
&& arg
< count
);
3401 len
+= strlen (operands
[arg
]);
3406 /* Put the string together. */
3407 complete
= s
= (char *) alloca (len
+ 1);
3408 format
= macro
->format
;
3409 while (*format
!= '\0')
3415 arg
= strtol (format
+ 1, &send
, 10);
3416 strcpy (s
, operands
[arg
]);
3423 /* Assemble the constructed instruction. */
3424 md_assemble (complete
);
3428 /* For ELF, add support for SHT_ORDERED. */
3431 ppc_section_type (char *str
, size_t len
)
3433 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3440 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3442 if (type
== SHT_ORDERED
)
3443 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3447 #endif /* OBJ_ELF */
3450 /* Pseudo-op handling. */
3452 /* The .byte pseudo-op. This is similar to the normal .byte
3453 pseudo-op, but it can also take a single ASCII string. */
3456 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3458 if (*input_line_pointer
!= '\"')
3464 /* Gather characters. A real double quote is doubled. Unusual
3465 characters are not permitted. */
3466 ++input_line_pointer
;
3471 c
= *input_line_pointer
++;
3475 if (*input_line_pointer
!= '\"')
3477 ++input_line_pointer
;
3480 FRAG_APPEND_1_CHAR (c
);
3483 demand_empty_rest_of_line ();
3488 /* XCOFF specific pseudo-op handling. */
3490 /* This is set if we are creating a .stabx symbol, since we don't want
3491 to handle symbol suffixes for such symbols. */
3492 static bfd_boolean ppc_stab_symbol
;
3494 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3495 symbols in the .bss segment as though they were local common
3496 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3497 aligns .comm and .lcomm to 4 bytes. */
3500 ppc_comm (int lcomm
)
3502 asection
*current_seg
= now_seg
;
3503 subsegT current_subseg
= now_subseg
;
3509 symbolS
*lcomm_sym
= NULL
;
3513 name
= input_line_pointer
;
3514 endc
= get_symbol_end ();
3515 end_name
= input_line_pointer
;
3518 if (*input_line_pointer
!= ',')
3520 as_bad (_("missing size"));
3521 ignore_rest_of_line ();
3524 ++input_line_pointer
;
3526 size
= get_absolute_expression ();
3529 as_bad (_("negative size"));
3530 ignore_rest_of_line ();
3536 /* The third argument to .comm is the alignment. */
3537 if (*input_line_pointer
!= ',')
3541 ++input_line_pointer
;
3542 align
= get_absolute_expression ();
3545 as_warn (_("ignoring bad alignment"));
3560 /* The third argument to .lcomm appears to be the real local
3561 common symbol to create. References to the symbol named in
3562 the first argument are turned into references to the third
3564 if (*input_line_pointer
!= ',')
3566 as_bad (_("missing real symbol name"));
3567 ignore_rest_of_line ();
3570 ++input_line_pointer
;
3572 lcomm_name
= input_line_pointer
;
3573 lcomm_endc
= get_symbol_end ();
3575 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3577 *input_line_pointer
= lcomm_endc
;
3581 sym
= symbol_find_or_make (name
);
3584 if (S_IS_DEFINED (sym
)
3585 || S_GET_VALUE (sym
) != 0)
3587 as_bad (_("attempt to redefine symbol"));
3588 ignore_rest_of_line ();
3592 record_alignment (bss_section
, align
);
3595 || ! S_IS_DEFINED (lcomm_sym
))
3604 S_SET_EXTERNAL (sym
);
3608 symbol_get_tc (lcomm_sym
)->output
= 1;
3609 def_sym
= lcomm_sym
;
3613 subseg_set (bss_section
, 1);
3614 frag_align (align
, 0, 0);
3616 symbol_set_frag (def_sym
, frag_now
);
3617 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3618 def_size
, (char *) NULL
);
3620 S_SET_SEGMENT (def_sym
, bss_section
);
3621 symbol_get_tc (def_sym
)->align
= align
;
3625 /* Align the size of lcomm_sym. */
3626 symbol_get_frag (lcomm_sym
)->fr_offset
=
3627 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3628 &~ ((1 << align
) - 1));
3629 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3630 symbol_get_tc (lcomm_sym
)->align
= align
;
3635 /* Make sym an offset from lcomm_sym. */
3636 S_SET_SEGMENT (sym
, bss_section
);
3637 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3638 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3639 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3642 subseg_set (current_seg
, current_subseg
);
3644 demand_empty_rest_of_line ();
3647 /* The .csect pseudo-op. This switches us into a different
3648 subsegment. The first argument is a symbol whose value is the
3649 start of the .csect. In COFF, csect symbols get special aux
3650 entries defined by the x_csect field of union internal_auxent. The
3651 optional second argument is the alignment (the default is 2). */
3654 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3661 name
= input_line_pointer
;
3662 endc
= get_symbol_end ();
3664 sym
= symbol_find_or_make (name
);
3666 *input_line_pointer
= endc
;
3668 if (S_GET_NAME (sym
)[0] == '\0')
3670 /* An unnamed csect is assumed to be [PR]. */
3671 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3675 if (*input_line_pointer
== ',')
3677 ++input_line_pointer
;
3678 align
= get_absolute_expression ();
3681 ppc_change_csect (sym
, align
);
3683 demand_empty_rest_of_line ();
3686 /* Change to a different csect. */
3689 ppc_change_csect (symbolS
*sym
, offsetT align
)
3691 if (S_IS_DEFINED (sym
))
3692 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3702 /* This is a new csect. We need to look at the symbol class to
3703 figure out whether it should go in the text section or the
3707 switch (symbol_get_tc (sym
)->symbol_class
)
3717 S_SET_SEGMENT (sym
, text_section
);
3718 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3719 ++ppc_text_subsegment
;
3720 list_ptr
= &ppc_text_csects
;
3730 if (ppc_toc_csect
!= NULL
3731 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3732 == ppc_data_subsegment
))
3734 S_SET_SEGMENT (sym
, data_section
);
3735 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3736 ++ppc_data_subsegment
;
3737 list_ptr
= &ppc_data_csects
;
3743 /* We set the obstack chunk size to a small value before
3744 changing subsegments, so that we don't use a lot of memory
3745 space for what may be a small section. */
3746 hold_chunksize
= chunksize
;
3749 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3750 symbol_get_tc (sym
)->subseg
);
3752 chunksize
= hold_chunksize
;
3755 ppc_after_toc_frag
= frag_now
;
3757 record_alignment (sec
, align
);
3759 frag_align_code (align
, 0);
3761 frag_align (align
, 0, 0);
3763 symbol_set_frag (sym
, frag_now
);
3764 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3766 symbol_get_tc (sym
)->align
= align
;
3767 symbol_get_tc (sym
)->output
= 1;
3768 symbol_get_tc (sym
)->within
= sym
;
3770 for (list
= *list_ptr
;
3771 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3772 list
= symbol_get_tc (list
)->next
)
3774 symbol_get_tc (list
)->next
= sym
;
3776 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3777 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3781 ppc_current_csect
= sym
;
3785 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3789 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3791 sec
= subseg_new (dw
->name
, subseg
);
3792 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3793 if (oldflags
== SEC_NO_FLAGS
)
3795 /* Just created section. */
3796 gas_assert (dw_sections
[idx
].sect
== NULL
);
3798 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3799 bfd_set_section_alignment (stdoutput
, sec
, 0);
3800 dw_sections
[idx
].sect
= sec
;
3803 /* Not anymore in a csect. */
3804 ppc_current_csect
= NULL
;
3807 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3808 .dwsect flag [, opt-label ]
3812 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3816 const struct xcoff_dwsect_name
*dw
;
3817 struct dw_subsection
*subseg
;
3818 struct dw_section
*dws
;
3822 flag
= get_absolute_expression ();
3824 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3825 if (xcoff_dwsect_names
[i
].flag
== flag
)
3827 dw
= &xcoff_dwsect_names
[i
];
3831 /* Parse opt-label. */
3832 if (*input_line_pointer
== ',')
3837 ++input_line_pointer
;
3839 label
= input_line_pointer
;
3840 c
= get_symbol_end ();
3841 opt_label
= symbol_find_or_make (label
);
3842 *input_line_pointer
= c
;
3847 demand_empty_rest_of_line ();
3849 /* Return now in case of unknown subsection. */
3852 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3857 /* Find the subsection. */
3858 dws
= &dw_sections
[i
];
3860 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3862 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3863 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3865 as_bad (_("label %s was not defined in this dwarf section"),
3866 S_GET_NAME (opt_label
));
3867 subseg
= dws
->anon_subseg
;
3871 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3876 /* Switch to the subsection. */
3877 ppc_change_debug_section (i
, subseg
->subseg
);
3881 /* Create a new dw subsection. */
3882 subseg
= (struct dw_subsection
*)
3883 xmalloc (sizeof (struct dw_subsection
));
3885 if (opt_label
== NULL
)
3887 /* The anonymous one. */
3889 subseg
->link
= NULL
;
3890 dws
->anon_subseg
= subseg
;
3895 if (dws
->list_subseg
!= NULL
)
3896 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3900 subseg
->link
= dws
->list_subseg
;
3901 dws
->list_subseg
= subseg
;
3902 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3905 ppc_change_debug_section (i
, subseg
->subseg
);
3909 /* Add the length field. */
3910 expressionS
*exp
= &subseg
->end_exp
;
3913 if (opt_label
!= NULL
)
3914 symbol_set_value_now (opt_label
);
3916 /* Add the length field. Note that according to the AIX assembler
3917 manual, the size of the length field is 4 for powerpc32 but
3918 12 for powerpc64. */
3921 /* Write the 64bit marker. */
3922 md_number_to_chars (frag_more (4), -1, 4);
3925 exp
->X_op
= O_subtract
;
3926 exp
->X_op_symbol
= symbol_temp_new_now ();
3927 exp
->X_add_symbol
= symbol_temp_make ();
3929 sz
= ppc_obj64
? 8 : 4;
3930 exp
->X_add_number
= -sz
;
3931 emit_expr (exp
, sz
);
3936 /* This function handles the .text and .data pseudo-ops. These
3937 pseudo-ops aren't really used by XCOFF; we implement them for the
3938 convenience of people who aren't used to XCOFF. */
3941 ppc_section (int type
)
3948 else if (type
== 'd')
3953 sym
= symbol_find_or_make (name
);
3955 ppc_change_csect (sym
, 2);
3957 demand_empty_rest_of_line ();
3960 /* This function handles the .section pseudo-op. This is mostly to
3961 give an error, since XCOFF only supports .text, .data and .bss, but
3962 we do permit the user to name the text or data section. */
3965 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3968 const char *real_name
;
3972 user_name
= input_line_pointer
;
3973 c
= get_symbol_end ();
3975 if (strcmp (user_name
, ".text") == 0)
3976 real_name
= ".text[PR]";
3977 else if (strcmp (user_name
, ".data") == 0)
3978 real_name
= ".data[RW]";
3981 as_bad (_("the XCOFF file format does not support arbitrary sections"));
3982 *input_line_pointer
= c
;
3983 ignore_rest_of_line ();
3987 *input_line_pointer
= c
;
3989 sym
= symbol_find_or_make (real_name
);
3991 ppc_change_csect (sym
, 2);
3993 demand_empty_rest_of_line ();
3996 /* The .extern pseudo-op. We create an undefined symbol. */
3999 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4004 name
= input_line_pointer
;
4005 endc
= get_symbol_end ();
4007 (void) symbol_find_or_make (name
);
4009 *input_line_pointer
= endc
;
4011 demand_empty_rest_of_line ();
4014 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4017 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4023 name
= input_line_pointer
;
4024 endc
= get_symbol_end ();
4026 sym
= symbol_find_or_make (name
);
4028 *input_line_pointer
= endc
;
4030 symbol_get_tc (sym
)->output
= 1;
4032 demand_empty_rest_of_line ();
4035 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4036 relocations at the beginning of the current csect.
4038 (In principle, there's no reason why the relocations _have_ to be at
4039 the beginning. Anywhere in the csect would do. However, inserting
4040 at the beginning is what the native assmebler does, and it helps to
4041 deal with cases where the .ref statements follow the section contents.)
4043 ??? .refs don't work for empty .csects. However, the native assembler
4044 doesn't report an error in this case, and neither yet do we. */
4047 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4052 if (ppc_current_csect
== NULL
)
4054 as_bad (_(".ref outside .csect"));
4055 ignore_rest_of_line ();
4061 name
= input_line_pointer
;
4062 c
= get_symbol_end ();
4064 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4065 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4067 *input_line_pointer
= c
;
4069 c
= *input_line_pointer
;
4072 input_line_pointer
++;
4074 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4076 as_bad (_("missing symbol name"));
4077 ignore_rest_of_line ();
4084 demand_empty_rest_of_line ();
4087 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4088 although I don't know why it bothers. */
4091 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4098 name
= input_line_pointer
;
4099 endc
= get_symbol_end ();
4101 sym
= symbol_find_or_make (name
);
4103 *input_line_pointer
= endc
;
4105 if (*input_line_pointer
!= ',')
4107 as_bad (_("missing rename string"));
4108 ignore_rest_of_line ();
4111 ++input_line_pointer
;
4113 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4115 demand_empty_rest_of_line ();
4118 /* The .stabx pseudo-op. This is similar to a normal .stabs
4119 pseudo-op, but slightly different. A sample is
4120 .stabx "main:F-1",.main,142,0
4121 The first argument is the symbol name to create. The second is the
4122 value, and the third is the storage class. The fourth seems to be
4123 always zero, and I am assuming it is the type. */
4126 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4133 name
= demand_copy_C_string (&len
);
4135 if (*input_line_pointer
!= ',')
4137 as_bad (_("missing value"));
4140 ++input_line_pointer
;
4142 ppc_stab_symbol
= TRUE
;
4143 sym
= symbol_make (name
);
4144 ppc_stab_symbol
= FALSE
;
4146 symbol_get_tc (sym
)->real_name
= name
;
4148 (void) expression (&exp
);
4155 as_bad (_("illegal .stabx expression; zero assumed"));
4156 exp
.X_add_number
= 0;
4159 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4160 symbol_set_frag (sym
, &zero_address_frag
);
4164 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4165 symbol_set_value_expression (sym
, &exp
);
4169 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4170 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4175 /* The value is some complex expression. This will probably
4176 fail at some later point, but this is probably the right
4177 thing to do here. */
4178 symbol_set_value_expression (sym
, &exp
);
4182 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4183 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4185 if (*input_line_pointer
!= ',')
4187 as_bad (_("missing class"));
4190 ++input_line_pointer
;
4192 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4194 if (*input_line_pointer
!= ',')
4196 as_bad (_("missing type"));
4199 ++input_line_pointer
;
4201 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4203 symbol_get_tc (sym
)->output
= 1;
4205 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4210 .stabx "z",arrays_,133,0
4213 .comm arrays_,13768,3
4215 resolve_symbol_value will copy the exp's "within" into sym's when the
4216 offset is 0. Since this seems to be corner case problem,
4217 only do the correction for storage class C_STSYM. A better solution
4218 would be to have the tc field updated in ppc_symbol_new_hook. */
4220 if (exp
.X_op
== O_symbol
)
4222 if (ppc_current_block
== NULL
)
4223 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4225 symbol_get_tc (sym
)->within
= ppc_current_block
;
4226 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4230 if (exp
.X_op
!= O_symbol
4231 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4232 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4233 ppc_frob_label (sym
);
4236 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4237 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4238 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4239 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4242 demand_empty_rest_of_line ();
4245 /* The .function pseudo-op. This takes several arguments. The first
4246 argument seems to be the external name of the symbol. The second
4247 argument seems to be the label for the start of the function. gcc
4248 uses the same name for both. I have no idea what the third and
4249 fourth arguments are meant to be. The optional fifth argument is
4250 an expression for the size of the function. In COFF this symbol
4251 gets an aux entry like that used for a csect. */
4254 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4262 name
= input_line_pointer
;
4263 endc
= get_symbol_end ();
4265 /* Ignore any [PR] suffix. */
4266 name
= ppc_canonicalize_symbol_name (name
);
4267 s
= strchr (name
, '[');
4268 if (s
!= (char *) NULL
4269 && strcmp (s
+ 1, "PR]") == 0)
4272 ext_sym
= symbol_find_or_make (name
);
4274 *input_line_pointer
= endc
;
4276 if (*input_line_pointer
!= ',')
4278 as_bad (_("missing symbol name"));
4279 ignore_rest_of_line ();
4282 ++input_line_pointer
;
4284 name
= input_line_pointer
;
4285 endc
= get_symbol_end ();
4287 lab_sym
= symbol_find_or_make (name
);
4289 *input_line_pointer
= endc
;
4291 if (ext_sym
!= lab_sym
)
4295 exp
.X_op
= O_symbol
;
4296 exp
.X_add_symbol
= lab_sym
;
4297 exp
.X_op_symbol
= NULL
;
4298 exp
.X_add_number
= 0;
4300 symbol_set_value_expression (ext_sym
, &exp
);
4303 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4304 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4305 symbol_get_tc (ext_sym
)->output
= 1;
4307 if (*input_line_pointer
== ',')
4311 /* Ignore the third argument. */
4312 ++input_line_pointer
;
4314 if (*input_line_pointer
== ',')
4316 /* Ignore the fourth argument. */
4317 ++input_line_pointer
;
4319 if (*input_line_pointer
== ',')
4321 /* The fifth argument is the function size. */
4322 ++input_line_pointer
;
4323 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4324 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4325 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4330 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4331 SF_SET_FUNCTION (ext_sym
);
4332 SF_SET_PROCESS (ext_sym
);
4333 coff_add_linesym (ext_sym
);
4335 demand_empty_rest_of_line ();
4338 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4339 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4340 with the correct line number */
4342 static symbolS
*saved_bi_sym
= 0;
4345 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4349 sym
= symbol_make (".bf");
4350 S_SET_SEGMENT (sym
, text_section
);
4351 symbol_set_frag (sym
, frag_now
);
4352 S_SET_VALUE (sym
, frag_now_fix ());
4353 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4355 coff_line_base
= get_absolute_expression ();
4357 S_SET_NUMBER_AUXILIARY (sym
, 1);
4358 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4360 /* Line number for bi. */
4363 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4368 symbol_get_tc (sym
)->output
= 1;
4370 ppc_frob_label (sym
);
4372 demand_empty_rest_of_line ();
4375 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4376 ".ef", except that the line number is absolute, not relative to the
4377 most recent ".bf" symbol. */
4380 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4384 sym
= symbol_make (".ef");
4385 S_SET_SEGMENT (sym
, text_section
);
4386 symbol_set_frag (sym
, frag_now
);
4387 S_SET_VALUE (sym
, frag_now_fix ());
4388 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4389 S_SET_NUMBER_AUXILIARY (sym
, 1);
4390 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4391 symbol_get_tc (sym
)->output
= 1;
4393 ppc_frob_label (sym
);
4395 demand_empty_rest_of_line ();
4398 /* The .bi and .ei pseudo-ops. These take a string argument and
4399 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4400 the symbol list. The value of .bi will be know when the next .bf
4406 static symbolS
*last_biei
;
4413 name
= demand_copy_C_string (&len
);
4415 /* The value of these symbols is actually file offset. Here we set
4416 the value to the index into the line number entries. In
4417 ppc_frob_symbols we set the fix_line field, which will cause BFD
4418 to do the right thing. */
4420 sym
= symbol_make (name
);
4421 /* obj-coff.c currently only handles line numbers correctly in the
4423 S_SET_SEGMENT (sym
, text_section
);
4424 S_SET_VALUE (sym
, coff_n_line_nos
);
4425 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4427 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4428 symbol_get_tc (sym
)->output
= 1;
4436 for (look
= last_biei
? last_biei
: symbol_rootP
;
4437 (look
!= (symbolS
*) NULL
4438 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4439 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4440 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4441 look
= symbol_next (look
))
4443 if (look
!= (symbolS
*) NULL
)
4445 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4446 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4450 demand_empty_rest_of_line ();
4453 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4454 There is one argument, which is a csect symbol. The value of the
4455 .bs symbol is the index of this csect symbol. */
4458 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4465 if (ppc_current_block
!= NULL
)
4466 as_bad (_("nested .bs blocks"));
4468 name
= input_line_pointer
;
4469 endc
= get_symbol_end ();
4471 csect
= symbol_find_or_make (name
);
4473 *input_line_pointer
= endc
;
4475 sym
= symbol_make (".bs");
4476 S_SET_SEGMENT (sym
, now_seg
);
4477 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4478 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4479 symbol_get_tc (sym
)->output
= 1;
4481 symbol_get_tc (sym
)->within
= csect
;
4483 ppc_frob_label (sym
);
4485 ppc_current_block
= sym
;
4487 demand_empty_rest_of_line ();
4490 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4493 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4497 if (ppc_current_block
== NULL
)
4498 as_bad (_(".es without preceding .bs"));
4500 sym
= symbol_make (".es");
4501 S_SET_SEGMENT (sym
, now_seg
);
4502 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4503 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4504 symbol_get_tc (sym
)->output
= 1;
4506 ppc_frob_label (sym
);
4508 ppc_current_block
= NULL
;
4510 demand_empty_rest_of_line ();
4513 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4517 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4521 sym
= symbol_make (".bb");
4522 S_SET_SEGMENT (sym
, text_section
);
4523 symbol_set_frag (sym
, frag_now
);
4524 S_SET_VALUE (sym
, frag_now_fix ());
4525 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4527 S_SET_NUMBER_AUXILIARY (sym
, 1);
4528 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4530 symbol_get_tc (sym
)->output
= 1;
4532 SF_SET_PROCESS (sym
);
4534 ppc_frob_label (sym
);
4536 demand_empty_rest_of_line ();
4539 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4543 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4547 sym
= symbol_make (".eb");
4548 S_SET_SEGMENT (sym
, text_section
);
4549 symbol_set_frag (sym
, frag_now
);
4550 S_SET_VALUE (sym
, frag_now_fix ());
4551 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4552 S_SET_NUMBER_AUXILIARY (sym
, 1);
4553 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4554 symbol_get_tc (sym
)->output
= 1;
4556 SF_SET_PROCESS (sym
);
4558 ppc_frob_label (sym
);
4560 demand_empty_rest_of_line ();
4563 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4567 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4573 name
= demand_copy_C_string (&len
);
4574 sym
= symbol_make (name
);
4575 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4576 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4577 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4578 S_SET_VALUE (sym
, 0);
4579 symbol_get_tc (sym
)->output
= 1;
4581 ppc_frob_label (sym
);
4583 demand_empty_rest_of_line ();
4586 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4589 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4593 sym
= symbol_make (".ec");
4594 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4595 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4596 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4597 S_SET_VALUE (sym
, 0);
4598 symbol_get_tc (sym
)->output
= 1;
4600 ppc_frob_label (sym
);
4602 demand_empty_rest_of_line ();
4605 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4608 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4610 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4611 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4618 subseg
= ppc_data_subsegment
;
4619 ++ppc_data_subsegment
;
4621 subseg_new (segment_name (data_section
), subseg
);
4622 ppc_toc_frag
= frag_now
;
4624 sym
= symbol_find_or_make ("TOC[TC0]");
4625 symbol_set_frag (sym
, frag_now
);
4626 S_SET_SEGMENT (sym
, data_section
);
4627 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4628 symbol_get_tc (sym
)->subseg
= subseg
;
4629 symbol_get_tc (sym
)->output
= 1;
4630 symbol_get_tc (sym
)->within
= sym
;
4632 ppc_toc_csect
= sym
;
4634 for (list
= ppc_data_csects
;
4635 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4636 list
= symbol_get_tc (list
)->next
)
4638 symbol_get_tc (list
)->next
= sym
;
4640 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4641 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4645 ppc_current_csect
= ppc_toc_csect
;
4647 demand_empty_rest_of_line ();
4650 /* The AIX assembler automatically aligns the operands of a .long or
4651 .short pseudo-op, and we want to be compatible. */
4654 ppc_xcoff_cons (int log_size
)
4656 frag_align (log_size
, 0, 0);
4657 record_alignment (now_seg
, log_size
);
4658 cons (1 << log_size
);
4662 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4667 (void) expression (&exp
);
4669 if (exp
.X_op
!= O_constant
)
4671 as_bad (_("non-constant byte count"));
4675 byte_count
= exp
.X_add_number
;
4677 if (*input_line_pointer
!= ',')
4679 as_bad (_("missing value"));
4683 ++input_line_pointer
;
4688 ppc_xcoff_end (void)
4692 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4694 struct dw_section
*dws
= &dw_sections
[i
];
4695 struct dw_subsection
*dwss
;
4697 if (dws
->anon_subseg
)
4699 dwss
= dws
->anon_subseg
;
4700 dwss
->link
= dws
->list_subseg
;
4703 dwss
= dws
->list_subseg
;
4705 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4706 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4708 subseg_set (dws
->sect
, dwss
->subseg
);
4709 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4714 #endif /* OBJ_XCOFF */
4715 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4717 /* The .tc pseudo-op. This is used when generating either XCOFF or
4718 ELF. This takes two or more arguments.
4720 When generating XCOFF output, the first argument is the name to
4721 give to this location in the toc; this will be a symbol with class
4722 TC. The rest of the arguments are N-byte values to actually put at
4723 this location in the TOC; often there is just one more argument, a
4724 relocatable symbol reference. The size of the value to store
4725 depends on target word size. A 32-bit target uses 4-byte values, a
4726 64-bit target uses 8-byte values.
4728 When not generating XCOFF output, the arguments are the same, but
4729 the first argument is simply ignored. */
4732 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4736 /* Define the TOC symbol name. */
4742 if (ppc_toc_csect
== (symbolS
*) NULL
4743 || ppc_toc_csect
!= ppc_current_csect
)
4745 as_bad (_(".tc not in .toc section"));
4746 ignore_rest_of_line ();
4750 name
= input_line_pointer
;
4751 endc
= get_symbol_end ();
4753 sym
= symbol_find_or_make (name
);
4755 *input_line_pointer
= endc
;
4757 if (S_IS_DEFINED (sym
))
4761 label
= symbol_get_tc (ppc_current_csect
)->within
;
4762 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4764 as_bad (_(".tc with no label"));
4765 ignore_rest_of_line ();
4769 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4770 symbol_set_frag (label
, symbol_get_frag (sym
));
4771 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4773 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4774 ++input_line_pointer
;
4779 S_SET_SEGMENT (sym
, now_seg
);
4780 symbol_set_frag (sym
, frag_now
);
4781 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4782 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4783 symbol_get_tc (sym
)->output
= 1;
4785 ppc_frob_label (sym
);
4788 #endif /* OBJ_XCOFF */
4792 /* Skip the TOC symbol name. */
4793 while (is_part_of_name (*input_line_pointer
)
4794 || *input_line_pointer
== ' '
4795 || *input_line_pointer
== '['
4796 || *input_line_pointer
== ']'
4797 || *input_line_pointer
== '{'
4798 || *input_line_pointer
== '}')
4799 ++input_line_pointer
;
4801 /* Align to a four/eight byte boundary. */
4802 align
= ppc_obj64
? 3 : 2;
4803 frag_align (align
, 0, 0);
4804 record_alignment (now_seg
, align
);
4805 #endif /* OBJ_ELF */
4807 if (*input_line_pointer
!= ',')
4808 demand_empty_rest_of_line ();
4811 ++input_line_pointer
;
4812 cons (ppc_obj64
? 8 : 4);
4816 /* Pseudo-op .machine. */
4819 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4822 #define MAX_HISTORY 100
4823 static ppc_cpu_t
*cpu_history
;
4824 static int curr_hist
;
4828 if (*input_line_pointer
== '"')
4831 cpu_string
= demand_copy_C_string (&len
);
4836 cpu_string
= input_line_pointer
;
4837 c
= get_symbol_end ();
4838 cpu_string
= xstrdup (cpu_string
);
4839 *input_line_pointer
= c
;
4842 if (cpu_string
!= NULL
)
4844 ppc_cpu_t old_cpu
= ppc_cpu
;
4848 for (p
= cpu_string
; *p
!= 0; p
++)
4851 if (strcmp (cpu_string
, "push") == 0)
4853 if (cpu_history
== NULL
)
4854 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4856 if (curr_hist
>= MAX_HISTORY
)
4857 as_bad (_(".machine stack overflow"));
4859 cpu_history
[curr_hist
++] = ppc_cpu
;
4861 else if (strcmp (cpu_string
, "pop") == 0)
4864 as_bad (_(".machine stack underflow"));
4866 ppc_cpu
= cpu_history
[--curr_hist
];
4868 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4871 as_bad (_("invalid machine `%s'"), cpu_string
);
4873 if (ppc_cpu
!= old_cpu
)
4874 ppc_setup_opcodes ();
4877 demand_empty_rest_of_line ();
4879 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4883 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4885 /* Set the current section. */
4887 ppc_set_current_section (segT
new)
4889 ppc_previous_section
= ppc_current_section
;
4890 ppc_current_section
= new;
4893 /* pseudo-op: .previous
4894 behaviour: toggles the current section with the previous section.
4896 warnings: "No previous section" */
4899 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4901 if (ppc_previous_section
== NULL
)
4903 as_warn (_("no previous section to return to, ignored."));
4907 subseg_set (ppc_previous_section
, 0);
4909 ppc_set_current_section (ppc_previous_section
);
4912 /* pseudo-op: .pdata
4913 behaviour: predefined read only data section
4917 initial: .section .pdata "adr3"
4918 a - don't know -- maybe a misprint
4919 d - initialized data
4921 3 - double word aligned (that would be 4 byte boundary)
4924 Tag index tables (also known as the function table) for exception
4925 handling, debugging, etc. */
4928 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4930 if (pdata_section
== 0)
4932 pdata_section
= subseg_new (".pdata", 0);
4934 bfd_set_section_flags (stdoutput
, pdata_section
,
4935 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4936 | SEC_READONLY
| SEC_DATA
));
4938 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4942 pdata_section
= subseg_new (".pdata", 0);
4944 ppc_set_current_section (pdata_section
);
4947 /* pseudo-op: .ydata
4948 behaviour: predefined read only data section
4952 initial: .section .ydata "drw3"
4953 a - don't know -- maybe a misprint
4954 d - initialized data
4956 3 - double word aligned (that would be 4 byte boundary)
4958 Tag tables (also known as the scope table) for exception handling,
4962 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4964 if (ydata_section
== 0)
4966 ydata_section
= subseg_new (".ydata", 0);
4967 bfd_set_section_flags (stdoutput
, ydata_section
,
4968 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4969 | SEC_READONLY
| SEC_DATA
));
4971 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4975 ydata_section
= subseg_new (".ydata", 0);
4977 ppc_set_current_section (ydata_section
);
4980 /* pseudo-op: .reldata
4981 behaviour: predefined read write data section
4982 double word aligned (4-byte)
4983 FIXME: relocation is applied to it
4984 FIXME: what's the difference between this and .data?
4987 initial: .section .reldata "drw3"
4988 d - initialized data
4991 3 - double word aligned (that would be 8 byte boundary)
4994 Like .data, but intended to hold data subject to relocation, such as
4995 function descriptors, etc. */
4998 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5000 if (reldata_section
== 0)
5002 reldata_section
= subseg_new (".reldata", 0);
5004 bfd_set_section_flags (stdoutput
, reldata_section
,
5005 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5008 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5012 reldata_section
= subseg_new (".reldata", 0);
5014 ppc_set_current_section (reldata_section
);
5017 /* pseudo-op: .rdata
5018 behaviour: predefined read only data section
5022 initial: .section .rdata "dr3"
5023 d - initialized data
5025 3 - double word aligned (that would be 4 byte boundary) */
5028 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5030 if (rdata_section
== 0)
5032 rdata_section
= subseg_new (".rdata", 0);
5033 bfd_set_section_flags (stdoutput
, rdata_section
,
5034 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5035 | SEC_READONLY
| SEC_DATA
));
5037 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5041 rdata_section
= subseg_new (".rdata", 0);
5043 ppc_set_current_section (rdata_section
);
5046 /* pseudo-op: .ualong
5047 behaviour: much like .int, with the exception that no alignment is
5049 FIXME: test the alignment statement
5054 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5060 /* pseudo-op: .znop <symbol name>
5061 behaviour: Issue a nop instruction
5062 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5063 the supplied symbol name.
5065 warnings: Missing symbol name */
5068 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5071 const struct powerpc_opcode
*opcode
;
5078 /* Strip out the symbol name. */
5079 symbol_name
= input_line_pointer
;
5080 c
= get_symbol_end ();
5082 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5083 strcpy (name
, symbol_name
);
5085 sym
= symbol_find_or_make (name
);
5087 *input_line_pointer
= c
;
5091 /* Look up the opcode in the hash table. */
5092 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5094 /* Stick in the nop. */
5095 insn
= opcode
->opcode
;
5097 /* Write out the instruction. */
5099 md_number_to_chars (f
, insn
, 4);
5101 f
- frag_now
->fr_literal
,
5106 BFD_RELOC_16_GOT_PCREL
);
5116 ppc_pe_comm (int lcomm
)
5125 name
= input_line_pointer
;
5126 c
= get_symbol_end ();
5128 /* just after name is now '\0'. */
5129 p
= input_line_pointer
;
5132 if (*input_line_pointer
!= ',')
5134 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5135 ignore_rest_of_line ();
5139 input_line_pointer
++; /* skip ',' */
5140 if ((temp
= get_absolute_expression ()) < 0)
5142 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5143 ignore_rest_of_line ();
5149 /* The third argument to .comm is the alignment. */
5150 if (*input_line_pointer
!= ',')
5154 ++input_line_pointer
;
5155 align
= get_absolute_expression ();
5158 as_warn (_("ignoring bad alignment"));
5165 symbolP
= symbol_find_or_make (name
);
5168 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5170 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5171 S_GET_NAME (symbolP
));
5172 ignore_rest_of_line ();
5176 if (S_GET_VALUE (symbolP
))
5178 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5179 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5180 S_GET_NAME (symbolP
),
5181 (long) S_GET_VALUE (symbolP
),
5186 S_SET_VALUE (symbolP
, (valueT
) temp
);
5187 S_SET_EXTERNAL (symbolP
);
5188 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5191 demand_empty_rest_of_line ();
5195 * implement the .section pseudo op:
5196 * .section name {, "flags"}
5198 * | +--- optional flags: 'b' for bss
5200 * +-- section name 'l' for lib
5204 * 'd' (apparently m88k for data)
5206 * But if the argument is not a quoted string, treat it as a
5207 * subsegment number.
5209 * FIXME: this is a copy of the section processing from obj-coff.c, with
5210 * additions/changes for the moto-pas assembler support. There are three
5213 * FIXME: I just noticed this. This doesn't work at all really. It it
5214 * setting bits that bfd probably neither understands or uses. The
5215 * correct approach (?) will have to incorporate extra fields attached
5216 * to the section to hold the system specific stuff. (krk)
5219 * 'a' - unknown - referred to in documentation, but no definition supplied
5220 * 'c' - section has code
5221 * 'd' - section has initialized data
5222 * 'u' - section has uninitialized data
5223 * 'i' - section contains directives (info)
5224 * 'n' - section can be discarded
5225 * 'R' - remove section at link time
5227 * Section Protection:
5228 * 'r' - section is readable
5229 * 'w' - section is writeable
5230 * 'x' - section is executable
5231 * 's' - section is sharable
5233 * Section Alignment:
5234 * '0' - align to byte boundary
5235 * '1' - align to halfword undary
5236 * '2' - align to word boundary
5237 * '3' - align to doubleword boundary
5238 * '4' - align to quadword boundary
5239 * '5' - align to 32 byte boundary
5240 * '6' - align to 64 byte boundary
5245 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5247 /* Strip out the section name. */
5256 section_name
= input_line_pointer
;
5257 c
= get_symbol_end ();
5259 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5260 strcpy (name
, section_name
);
5262 *input_line_pointer
= c
;
5267 flags
= SEC_NO_FLAGS
;
5269 if (strcmp (name
, ".idata$2") == 0)
5273 else if (strcmp (name
, ".idata$3") == 0)
5277 else if (strcmp (name
, ".idata$4") == 0)
5281 else if (strcmp (name
, ".idata$5") == 0)
5285 else if (strcmp (name
, ".idata$6") == 0)
5290 /* Default alignment to 16 byte boundary. */
5293 if (*input_line_pointer
== ',')
5295 ++input_line_pointer
;
5297 if (*input_line_pointer
!= '"')
5298 exp
= get_absolute_expression ();
5301 ++input_line_pointer
;
5302 while (*input_line_pointer
!= '"'
5303 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5305 switch (*input_line_pointer
)
5307 /* Section Contents */
5308 case 'a': /* unknown */
5309 as_bad (_("unsupported section attribute -- 'a'"));
5311 case 'c': /* code section */
5314 case 'd': /* section has initialized data */
5317 case 'u': /* section has uninitialized data */
5318 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5322 case 'i': /* section contains directives (info) */
5323 /* FIXME: This is IMAGE_SCN_LNK_INFO
5325 flags
|= SEC_HAS_CONTENTS
;
5327 case 'n': /* section can be discarded */
5330 case 'R': /* Remove section at link time */
5331 flags
|= SEC_NEVER_LOAD
;
5333 #if IFLICT_BRAIN_DAMAGE
5334 /* Section Protection */
5335 case 'r': /* section is readable */
5336 flags
|= IMAGE_SCN_MEM_READ
;
5338 case 'w': /* section is writeable */
5339 flags
|= IMAGE_SCN_MEM_WRITE
;
5341 case 'x': /* section is executable */
5342 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5344 case 's': /* section is sharable */
5345 flags
|= IMAGE_SCN_MEM_SHARED
;
5348 /* Section Alignment */
5349 case '0': /* align to byte boundary */
5350 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5353 case '1': /* align to halfword boundary */
5354 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5357 case '2': /* align to word boundary */
5358 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5361 case '3': /* align to doubleword boundary */
5362 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5365 case '4': /* align to quadword boundary */
5366 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5369 case '5': /* align to 32 byte boundary */
5370 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5373 case '6': /* align to 64 byte boundary */
5374 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5379 as_bad (_("unknown section attribute '%c'"),
5380 *input_line_pointer
);
5383 ++input_line_pointer
;
5385 if (*input_line_pointer
== '"')
5386 ++input_line_pointer
;
5390 sec
= subseg_new (name
, (subsegT
) exp
);
5392 ppc_set_current_section (sec
);
5394 if (flags
!= SEC_NO_FLAGS
)
5396 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5397 as_bad (_("error setting flags for \"%s\": %s"),
5398 bfd_section_name (stdoutput
, sec
),
5399 bfd_errmsg (bfd_get_error ()));
5402 bfd_set_section_alignment (stdoutput
, sec
, align
);
5406 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5412 name
= input_line_pointer
;
5413 endc
= get_symbol_end ();
5415 ext_sym
= symbol_find_or_make (name
);
5417 *input_line_pointer
= endc
;
5419 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5420 SF_SET_FUNCTION (ext_sym
);
5421 SF_SET_PROCESS (ext_sym
);
5422 coff_add_linesym (ext_sym
);
5424 demand_empty_rest_of_line ();
5428 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5430 if (tocdata_section
== 0)
5432 tocdata_section
= subseg_new (".tocd", 0);
5433 /* FIXME: section flags won't work. */
5434 bfd_set_section_flags (stdoutput
, tocdata_section
,
5435 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5436 | SEC_READONLY
| SEC_DATA
));
5438 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5442 rdata_section
= subseg_new (".tocd", 0);
5445 ppc_set_current_section (tocdata_section
);
5447 demand_empty_rest_of_line ();
5450 /* Don't adjust TOC relocs to use the section symbol. */
5453 ppc_pe_fix_adjustable (fixS
*fix
)
5455 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5462 /* XCOFF specific symbol and file handling. */
5464 /* Canonicalize the symbol name. We use the to force the suffix, if
5465 any, to use square brackets, and to be in upper case. */
5468 ppc_canonicalize_symbol_name (char *name
)
5472 if (ppc_stab_symbol
)
5475 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5489 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5492 if (*s
== '\0' || s
[1] != '\0')
5493 as_bad (_("bad symbol suffix"));
5501 /* Set the class of a symbol based on the suffix, if any. This is
5502 called whenever a new symbol is created. */
5505 ppc_symbol_new_hook (symbolS
*sym
)
5507 struct ppc_tc_sy
*tc
;
5510 tc
= symbol_get_tc (sym
);
5513 tc
->symbol_class
= -1;
5514 tc
->real_name
= NULL
;
5521 if (ppc_stab_symbol
)
5524 s
= strchr (S_GET_NAME (sym
), '[');
5525 if (s
== (const char *) NULL
)
5527 /* There is no suffix. */
5536 if (strcmp (s
, "BS]") == 0)
5537 tc
->symbol_class
= XMC_BS
;
5540 if (strcmp (s
, "DB]") == 0)
5541 tc
->symbol_class
= XMC_DB
;
5542 else if (strcmp (s
, "DS]") == 0)
5543 tc
->symbol_class
= XMC_DS
;
5546 if (strcmp (s
, "GL]") == 0)
5547 tc
->symbol_class
= XMC_GL
;
5550 if (strcmp (s
, "PR]") == 0)
5551 tc
->symbol_class
= XMC_PR
;
5554 if (strcmp (s
, "RO]") == 0)
5555 tc
->symbol_class
= XMC_RO
;
5556 else if (strcmp (s
, "RW]") == 0)
5557 tc
->symbol_class
= XMC_RW
;
5560 if (strcmp (s
, "SV]") == 0)
5561 tc
->symbol_class
= XMC_SV
;
5564 if (strcmp (s
, "TC]") == 0)
5565 tc
->symbol_class
= XMC_TC
;
5566 else if (strcmp (s
, "TI]") == 0)
5567 tc
->symbol_class
= XMC_TI
;
5568 else if (strcmp (s
, "TB]") == 0)
5569 tc
->symbol_class
= XMC_TB
;
5570 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5571 tc
->symbol_class
= XMC_TC0
;
5574 if (strcmp (s
, "UA]") == 0)
5575 tc
->symbol_class
= XMC_UA
;
5576 else if (strcmp (s
, "UC]") == 0)
5577 tc
->symbol_class
= XMC_UC
;
5580 if (strcmp (s
, "XO]") == 0)
5581 tc
->symbol_class
= XMC_XO
;
5585 if (tc
->symbol_class
== -1)
5586 as_bad (_("unrecognized symbol suffix"));
5589 /* Set the class of a label based on where it is defined. This
5590 handles symbols without suffixes. Also, move the symbol so that it
5591 follows the csect symbol. */
5594 ppc_frob_label (symbolS
*sym
)
5596 if (ppc_current_csect
!= (symbolS
*) NULL
)
5598 if (symbol_get_tc (sym
)->symbol_class
== -1)
5599 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5601 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5602 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5603 &symbol_rootP
, &symbol_lastP
);
5604 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5605 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5609 dwarf2_emit_label (sym
);
5613 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5614 seen. It tells ppc_adjust_symtab whether it needs to look through
5617 static bfd_boolean ppc_saw_abs
;
5619 /* Change the name of a symbol just before writing it out. Set the
5620 real name if the .rename pseudo-op was used. Otherwise, remove any
5621 class suffix. Return 1 if the symbol should not be included in the
5625 ppc_frob_symbol (symbolS
*sym
)
5627 static symbolS
*ppc_last_function
;
5628 static symbolS
*set_end
;
5630 /* Discard symbols that should not be included in the output symbol
5632 if (! symbol_used_in_reloc_p (sym
)
5633 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5634 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5635 && ! symbol_get_tc (sym
)->output
5636 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5639 /* This one will disappear anyway. Don't make a csect sym for it. */
5640 if (sym
== abs_section_sym
)
5643 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5644 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5650 name
= S_GET_NAME (sym
);
5651 s
= strchr (name
, '[');
5652 if (s
!= (char *) NULL
)
5658 snew
= xmalloc (len
+ 1);
5659 memcpy (snew
, name
, len
);
5662 S_SET_NAME (sym
, snew
);
5666 if (set_end
!= (symbolS
*) NULL
)
5668 SA_SET_SYM_ENDNDX (set_end
, sym
);
5672 if (SF_GET_FUNCTION (sym
))
5674 if (ppc_last_function
!= (symbolS
*) NULL
)
5675 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5676 ppc_last_function
= sym
;
5677 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5679 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5680 SA_SET_SYM_FSIZE (sym
,
5681 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5684 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5685 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5687 if (ppc_last_function
== (symbolS
*) NULL
)
5688 as_bad (_(".ef with no preceding .function"));
5691 set_end
= ppc_last_function
;
5692 ppc_last_function
= NULL
;
5694 /* We don't have a C_EFCN symbol, but we need to force the
5695 COFF backend to believe that it has seen one. */
5696 coff_last_function
= NULL
;
5700 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5701 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5702 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5703 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5704 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5705 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5706 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5707 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5708 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5709 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5710 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5712 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5713 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5714 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5717 union internal_auxent
*a
;
5719 /* Create a csect aux. */
5720 i
= S_GET_NUMBER_AUXILIARY (sym
);
5721 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5722 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5723 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5725 /* This is the TOC table. */
5726 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5727 a
->x_csect
.x_scnlen
.l
= 0;
5728 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5730 else if (symbol_get_tc (sym
)->subseg
!= 0)
5732 /* This is a csect symbol. x_scnlen is the size of the
5734 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5735 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5736 S_GET_SEGMENT (sym
))
5737 - S_GET_VALUE (sym
));
5740 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5741 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5742 - S_GET_VALUE (sym
));
5744 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5746 else if (S_GET_SEGMENT (sym
) == bss_section
)
5748 /* This is a common symbol. */
5749 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5750 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5751 if (S_IS_EXTERNAL (sym
))
5752 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5754 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5756 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5758 /* This is an absolute symbol. The csect will be created by
5759 ppc_adjust_symtab. */
5761 a
->x_csect
.x_smtyp
= XTY_LD
;
5762 if (symbol_get_tc (sym
)->symbol_class
== -1)
5763 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5765 else if (! S_IS_DEFINED (sym
))
5767 /* This is an external symbol. */
5768 a
->x_csect
.x_scnlen
.l
= 0;
5769 a
->x_csect
.x_smtyp
= XTY_ER
;
5771 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5775 /* This is a TOC definition. x_scnlen is the size of the
5777 next
= symbol_next (sym
);
5778 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5779 next
= symbol_next (next
);
5780 if (next
== (symbolS
*) NULL
5781 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5783 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5784 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5786 - S_GET_VALUE (sym
));
5788 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5789 - S_GET_VALUE (sym
));
5793 resolve_symbol_value (next
);
5794 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5795 - S_GET_VALUE (sym
));
5797 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5803 /* This is a normal symbol definition. x_scnlen is the
5804 symbol index of the containing csect. */
5805 if (S_GET_SEGMENT (sym
) == text_section
)
5806 csect
= ppc_text_csects
;
5807 else if (S_GET_SEGMENT (sym
) == data_section
)
5808 csect
= ppc_data_csects
;
5812 /* Skip the initial dummy symbol. */
5813 csect
= symbol_get_tc (csect
)->next
;
5815 if (csect
== (symbolS
*) NULL
)
5817 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5818 a
->x_csect
.x_scnlen
.l
= 0;
5822 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5824 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5825 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5826 > S_GET_VALUE (sym
))
5828 csect
= symbol_get_tc (csect
)->next
;
5831 a
->x_csect
.x_scnlen
.p
=
5832 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5833 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5836 a
->x_csect
.x_smtyp
= XTY_LD
;
5839 a
->x_csect
.x_parmhash
= 0;
5840 a
->x_csect
.x_snhash
= 0;
5841 if (symbol_get_tc (sym
)->symbol_class
== -1)
5842 a
->x_csect
.x_smclas
= XMC_PR
;
5844 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5845 a
->x_csect
.x_stab
= 0;
5846 a
->x_csect
.x_snstab
= 0;
5848 /* Don't let the COFF backend resort these symbols. */
5849 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5851 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5853 /* We want the value to be the symbol index of the referenced
5854 csect symbol. BFD will do that for us if we set the right
5856 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5857 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5859 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5860 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5862 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5867 block
= symbol_get_tc (sym
)->within
;
5870 /* The value is the offset from the enclosing csect. */
5873 csect
= symbol_get_tc (block
)->within
;
5874 resolve_symbol_value (csect
);
5875 base
= S_GET_VALUE (csect
);
5880 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5882 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5883 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5885 /* We want the value to be a file offset into the line numbers.
5886 BFD will do that for us if we set the right flags. We have
5887 already set the value correctly. */
5888 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5894 /* Adjust the symbol table. This creates csect symbols for all
5895 absolute symbols. */
5898 ppc_adjust_symtab (void)
5905 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5909 union internal_auxent
*a
;
5911 if (S_GET_SEGMENT (sym
) != absolute_section
)
5914 csect
= symbol_create (".abs[XO]", absolute_section
,
5915 S_GET_VALUE (sym
), &zero_address_frag
);
5916 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5917 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5918 i
= S_GET_NUMBER_AUXILIARY (csect
);
5919 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5920 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5921 a
->x_csect
.x_scnlen
.l
= 0;
5922 a
->x_csect
.x_smtyp
= XTY_SD
;
5923 a
->x_csect
.x_parmhash
= 0;
5924 a
->x_csect
.x_snhash
= 0;
5925 a
->x_csect
.x_smclas
= XMC_XO
;
5926 a
->x_csect
.x_stab
= 0;
5927 a
->x_csect
.x_snstab
= 0;
5929 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5931 i
= S_GET_NUMBER_AUXILIARY (sym
);
5932 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5933 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5934 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5937 ppc_saw_abs
= FALSE
;
5940 /* Set the VMA for a section. This is called on all the sections in
5944 ppc_frob_section (asection
*sec
)
5946 static bfd_vma vma
= 0;
5948 /* Dwarf sections start at 0. */
5949 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5952 vma
= md_section_align (sec
, vma
);
5953 bfd_set_section_vma (stdoutput
, sec
, vma
);
5954 vma
+= bfd_section_size (stdoutput
, sec
);
5957 #endif /* OBJ_XCOFF */
5960 md_atof (int type
, char *litp
, int *sizep
)
5962 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5965 /* Write a value out to the object file, using the appropriate
5969 md_number_to_chars (char *buf
, valueT val
, int n
)
5971 if (target_big_endian
)
5972 number_to_chars_bigendian (buf
, val
, n
);
5974 number_to_chars_littleendian (buf
, val
, n
);
5977 /* Align a section (I don't know why this is machine dependent). */
5980 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5985 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5987 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5991 /* We don't have any form of relaxing. */
5994 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5995 asection
*seg ATTRIBUTE_UNUSED
)
6001 /* Convert a machine dependent frag. We never generate these. */
6004 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6005 asection
*sec ATTRIBUTE_UNUSED
,
6006 fragS
*fragp ATTRIBUTE_UNUSED
)
6011 /* We have no need to default values of symbols. */
6014 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6019 /* Functions concerning relocs. */
6021 /* The location from which a PC relative jump should be calculated,
6022 given a PC relative reloc. */
6025 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6027 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6032 /* This is called to see whether a fixup should be adjusted to use a
6033 section symbol. We take the opportunity to change a fixup against
6034 a symbol in the TOC subsegment into a reloc against the
6035 corresponding .tc symbol. */
6038 ppc_fix_adjustable (fixS
*fix
)
6040 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6041 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6042 TC_SYMFIELD_TYPE
*tc
;
6044 if (symseg
== absolute_section
)
6047 /* Always adjust symbols in debugging sections. */
6048 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6051 if (ppc_toc_csect
!= (symbolS
*) NULL
6052 && fix
->fx_addsy
!= ppc_toc_csect
6053 && symseg
== data_section
6054 && val
>= ppc_toc_frag
->fr_address
6055 && (ppc_after_toc_frag
== (fragS
*) NULL
6056 || val
< ppc_after_toc_frag
->fr_address
))
6060 for (sy
= symbol_next (ppc_toc_csect
);
6061 sy
!= (symbolS
*) NULL
;
6062 sy
= symbol_next (sy
))
6064 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6066 if (sy_tc
->symbol_class
== XMC_TC0
)
6068 if (sy_tc
->symbol_class
!= XMC_TC
)
6070 if (val
== resolve_symbol_value (sy
))
6073 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6078 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6079 _("symbol in .toc does not match any .tc"));
6082 /* Possibly adjust the reloc to be against the csect. */
6083 tc
= symbol_get_tc (fix
->fx_addsy
);
6085 && tc
->symbol_class
!= XMC_TC0
6086 && tc
->symbol_class
!= XMC_TC
6087 && symseg
!= bss_section
6088 /* Don't adjust if this is a reloc in the toc section. */
6089 && (symseg
!= data_section
6090 || ppc_toc_csect
== NULL
6091 || val
< ppc_toc_frag
->fr_address
6092 || (ppc_after_toc_frag
!= NULL
6093 && val
>= ppc_after_toc_frag
->fr_address
)))
6095 symbolS
*csect
= tc
->within
;
6097 /* If the symbol was not declared by a label (eg: a section symbol),
6098 use the section instead of the csect. This doesn't happen in
6099 normal AIX assembly code. */
6101 csect
= seg_info (symseg
)->sym
;
6103 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6104 fix
->fx_addsy
= csect
;
6109 /* Adjust a reloc against a .lcomm symbol to be against the base
6111 if (symseg
== bss_section
6112 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6114 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6116 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6123 /* A reloc from one csect to another must be kept. The assembler
6124 will, of course, keep relocs between sections, and it will keep
6125 absolute relocs, but we need to force it to keep PC relative relocs
6126 between two csects in the same section. */
6129 ppc_force_relocation (fixS
*fix
)
6131 /* At this point fix->fx_addsy should already have been converted to
6132 a csect symbol. If the csect does not include the fragment, then
6133 we need to force the relocation. */
6135 && fix
->fx_addsy
!= NULL
6136 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6137 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6138 > fix
->fx_frag
->fr_address
)
6139 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6140 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6141 <= fix
->fx_frag
->fr_address
))))
6144 return generic_force_reloc (fix
);
6148 ppc_new_dot_label (symbolS
*sym
)
6150 /* Anchor this label to the current csect for relocations. */
6151 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6154 #endif /* OBJ_XCOFF */
6157 /* If this function returns non-zero, it guarantees that a relocation
6158 will be emitted for a fixup. */
6161 ppc_force_relocation (fixS
*fix
)
6163 /* Branch prediction relocations must force a relocation, as must
6164 the vtable description relocs. */
6165 switch (fix
->fx_r_type
)
6167 case BFD_RELOC_PPC_B16_BRTAKEN
:
6168 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6169 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6170 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6171 case BFD_RELOC_24_PLT_PCREL
:
6172 case BFD_RELOC_PPC64_TOC
:
6178 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6179 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6182 return generic_force_reloc (fix
);
6186 ppc_fix_adjustable (fixS
*fix
)
6188 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6189 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6190 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6191 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6192 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6193 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6194 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6195 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6196 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6197 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6198 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6203 ppc_frag_check (struct frag
*fragP
)
6205 if (!fragP
->has_code
)
6208 if (ppc_mach() == bfd_mach_ppc_vle
)
6210 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6211 as_bad (_("instruction address is not a multiple of 2"));
6215 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6216 as_bad (_("instruction address is not a multiple of 4"));
6220 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6221 rs_align_code frag. */
6224 ppc_handle_align (struct frag
*fragP
)
6226 valueT count
= (fragP
->fr_next
->fr_address
6227 - (fragP
->fr_address
+ fragP
->fr_fix
));
6229 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6231 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6234 md_number_to_chars (dest
, 0x4400, 2);
6236 else if (count
!= 0 && (count
& 3) == 0)
6238 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6242 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6246 /* Make a branch, then follow with nops. Insert another
6247 frag to handle the nops. */
6248 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6253 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6254 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6255 fragP
->fr_next
= rest
;
6257 rest
->fr_address
+= rest
->fr_fix
+ 4;
6259 /* If we leave the next frag as rs_align_code we'll come here
6260 again, resulting in a bunch of branches rather than a
6261 branch followed by nops. */
6262 rest
->fr_type
= rs_align
;
6263 dest
= rest
->fr_literal
;
6266 md_number_to_chars (dest
, 0x60000000, 4);
6268 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6269 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6270 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6272 /* For power6, power7 and power8, we want the last nop to be a group
6273 terminating one. Do this by inserting an rs_fill frag immediately
6274 after this one, with its address set to the last nop location.
6275 This will automatically reduce the number of nops in the current
6279 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6281 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6282 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6283 group_nop
->fr_fix
= 0;
6284 group_nop
->fr_offset
= 1;
6285 group_nop
->fr_type
= rs_fill
;
6286 fragP
->fr_next
= group_nop
;
6287 dest
= group_nop
->fr_literal
;
6290 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6291 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6293 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6294 /* e500mc group terminating nop: "ori 0,0,0". */
6295 md_number_to_chars (dest
, 0x60000000, 4);
6297 /* power7/power8 group terminating nop: "ori 2,2,0". */
6298 md_number_to_chars (dest
, 0x60420000, 4);
6301 /* power6 group terminating nop: "ori 1,1,0". */
6302 md_number_to_chars (dest
, 0x60210000, 4);
6307 /* Apply a fixup to the object code. This is called for all the
6308 fixups we generated by the calls to fix_new_exp, above. */
6311 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6313 valueT value
= * valP
;
6316 if (fixP
->fx_addsy
!= NULL
)
6318 /* Hack around bfd_install_relocation brain damage. */
6320 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6325 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6326 the symbol values. If we are doing this relocation the code in
6327 write.c is going to call bfd_install_relocation, which is also
6328 going to use the symbol value. That means that if the reloc is
6329 fully resolved we want to use *valP since bfd_install_relocation is
6331 However, if the reloc is not fully resolved we do not want to
6332 use *valP, and must use fx_offset instead. If the relocation
6333 is PC-relative, we then need to re-apply md_pcrel_from_section
6334 to this new relocation value. */
6335 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6340 value
= fixP
->fx_offset
;
6342 value
-= md_pcrel_from_section (fixP
, seg
);
6346 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6348 /* We can't actually support subtracting a symbol. */
6349 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6352 if (fixP
->fx_pcrel_adjust
!= 0)
6354 /* Handle relocs in an insn. */
6356 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6357 const struct powerpc_operand
*operand
= &powerpc_operands
[opindex
];
6363 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6364 does not generate a reloc. It uses the offset of `sym' within its
6365 csect. Other usages, such as `.long sym', generate relocs. This
6366 is the documented behaviour of non-TOC symbols. */
6367 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6368 && (operand
->bitm
& 0xfff0) == 0xfff0
6369 && operand
->shift
== 0
6370 && (operand
->insert
== NULL
|| ppc_obj64
)
6371 && fixP
->fx_addsy
!= NULL
6372 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6373 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6374 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6375 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6377 value
= fixP
->fx_offset
;
6382 switch (fixP
->fx_r_type
)
6385 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6390 case BFD_RELOC_LO16
:
6392 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6394 case BFD_RELOC_LO16_PCREL
:
6395 fieldval
= SEX16 (value
);
6398 case BFD_RELOC_HI16
:
6400 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6402 case BFD_RELOC_HI16_PCREL
:
6403 fieldval
= SEX16 (PPC_HI (value
));
6406 case BFD_RELOC_HI16_S
:
6408 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6410 case BFD_RELOC_HI16_S_PCREL
:
6411 fieldval
= SEX16 (PPC_HA (value
));
6415 case BFD_RELOC_PPC64_HIGHER
:
6418 fieldval
= SEX16 (PPC_HIGHER (value
));
6421 case BFD_RELOC_PPC64_HIGHER_S
:
6424 fieldval
= SEX16 (PPC_HIGHERA (value
));
6427 case BFD_RELOC_PPC64_HIGHEST
:
6430 fieldval
= SEX16 (PPC_HIGHEST (value
));
6433 case BFD_RELOC_PPC64_HIGHEST_S
:
6436 fieldval
= SEX16 (PPC_HIGHESTA (value
));
6439 /* The following relocs can't be calculated by the assembler.
6440 Leave the field zero. */
6441 case BFD_RELOC_PPC_TPREL16
:
6442 case BFD_RELOC_PPC_TPREL16_LO
:
6443 case BFD_RELOC_PPC_TPREL16_HI
:
6444 case BFD_RELOC_PPC_TPREL16_HA
:
6445 case BFD_RELOC_PPC_DTPREL16
:
6446 case BFD_RELOC_PPC_DTPREL16_LO
:
6447 case BFD_RELOC_PPC_DTPREL16_HI
:
6448 case BFD_RELOC_PPC_DTPREL16_HA
:
6449 case BFD_RELOC_PPC_GOT_TLSGD16
:
6450 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6451 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6452 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6453 case BFD_RELOC_PPC_GOT_TLSLD16
:
6454 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6455 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6456 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6457 case BFD_RELOC_PPC_GOT_TPREL16
:
6458 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6459 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6460 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6461 case BFD_RELOC_PPC_GOT_DTPREL16
:
6462 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6463 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6464 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6465 case BFD_RELOC_PPC64_TPREL16_DS
:
6466 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6467 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6468 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6469 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6470 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6471 case BFD_RELOC_PPC64_DTPREL16_DS
:
6472 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6473 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6474 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6475 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6476 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6477 gas_assert (fixP
->fx_addsy
!= NULL
);
6478 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6484 /* These also should leave the field zero for the same
6485 reason. Note that older versions of gas wrote values
6486 here. If we want to go back to the old behaviour, then
6487 all _LO and _LO_DS cases will need to be treated like
6488 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6489 case BFD_RELOC_16_GOTOFF
:
6490 case BFD_RELOC_LO16_GOTOFF
:
6491 case BFD_RELOC_HI16_GOTOFF
:
6492 case BFD_RELOC_HI16_S_GOTOFF
:
6493 case BFD_RELOC_LO16_PLTOFF
:
6494 case BFD_RELOC_HI16_PLTOFF
:
6495 case BFD_RELOC_HI16_S_PLTOFF
:
6496 case BFD_RELOC_GPREL16
:
6497 case BFD_RELOC_16_BASEREL
:
6498 case BFD_RELOC_LO16_BASEREL
:
6499 case BFD_RELOC_HI16_BASEREL
:
6500 case BFD_RELOC_HI16_S_BASEREL
:
6501 case BFD_RELOC_PPC_TOC16
:
6502 case BFD_RELOC_PPC64_TOC16_LO
:
6503 case BFD_RELOC_PPC64_TOC16_HI
:
6504 case BFD_RELOC_PPC64_TOC16_HA
:
6505 case BFD_RELOC_PPC64_PLTGOT16
:
6506 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6507 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6508 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6509 case BFD_RELOC_PPC64_GOT16_DS
:
6510 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6511 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6512 case BFD_RELOC_PPC64_SECTOFF_DS
:
6513 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6514 case BFD_RELOC_PPC64_TOC16_DS
:
6515 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6516 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6517 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6518 case BFD_RELOC_PPC_EMB_NADDR16
:
6519 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6520 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6521 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6522 case BFD_RELOC_PPC_EMB_SDAI16
:
6523 case BFD_RELOC_PPC_EMB_SDA2I16
:
6524 case BFD_RELOC_PPC_EMB_SDA2REL
:
6525 case BFD_RELOC_PPC_EMB_SDA21
:
6526 case BFD_RELOC_PPC_EMB_MRKREF
:
6527 case BFD_RELOC_PPC_EMB_RELSEC16
:
6528 case BFD_RELOC_PPC_EMB_RELST_LO
:
6529 case BFD_RELOC_PPC_EMB_RELST_HI
:
6530 case BFD_RELOC_PPC_EMB_RELST_HA
:
6531 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6532 case BFD_RELOC_PPC_EMB_RELSDA
:
6533 case BFD_RELOC_PPC_VLE_SDA21
:
6534 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6535 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6536 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6537 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6538 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6539 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6540 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6541 gas_assert (fixP
->fx_addsy
!= NULL
);
6544 case BFD_RELOC_PPC_TLS
:
6545 case BFD_RELOC_PPC_TLSGD
:
6546 case BFD_RELOC_PPC_TLSLD
:
6558 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6559 contents can stay at zero. */
6560 #define APPLY_RELOC fixP->fx_done
6562 #define APPLY_RELOC 1
6564 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6566 /* Fetch the instruction, insert the fully resolved operand
6567 value, and stuff the instruction back again. */
6568 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6569 if (target_big_endian
)
6571 if (fixP
->fx_size
== 4)
6572 insn
= bfd_getb32 ((unsigned char *) where
);
6574 insn
= bfd_getb16 ((unsigned char *) where
);
6578 if (fixP
->fx_size
== 4)
6579 insn
= bfd_getl32 ((unsigned char *) where
);
6581 insn
= bfd_getl16 ((unsigned char *) where
);
6583 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6584 fixP
->tc_fix_data
.ppc_cpu
,
6585 fixP
->fx_file
, fixP
->fx_line
);
6586 if (target_big_endian
)
6588 if (fixP
->fx_size
== 4)
6589 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6591 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6595 if (fixP
->fx_size
== 4)
6596 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6598 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6603 /* Nothing else to do here. */
6606 gas_assert (fixP
->fx_addsy
!= NULL
);
6607 if (fixP
->fx_r_type
== BFD_RELOC_UNUSED
)
6612 /* Use expr_symbol_where to see if this is an expression
6614 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6615 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6616 _("unresolved expression that must be resolved"));
6618 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6619 _("unsupported relocation against %s"),
6620 S_GET_NAME (fixP
->fx_addsy
));
6628 offsetT fieldval
= value
;
6630 /* Handle relocs in data. */
6631 switch (fixP
->fx_r_type
)
6633 case BFD_RELOC_CTOR
:
6640 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6643 case BFD_RELOC_32_PCREL
:
6651 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6654 case BFD_RELOC_64_PCREL
:
6660 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6663 case BFD_RELOC_16_PCREL
:
6678 /* Use expr_symbol_where to see if this is an
6679 expression symbol. */
6680 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6681 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6682 _("unresolved expression that must"
6685 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6686 _("cannot emit PC relative %s relocation"
6688 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6689 S_GET_NAME (fixP
->fx_addsy
));
6692 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6693 _("unable to resolve expression"));
6700 case BFD_RELOC_VTABLE_INHERIT
:
6702 && !S_IS_DEFINED (fixP
->fx_addsy
)
6703 && !S_IS_WEAK (fixP
->fx_addsy
))
6704 S_SET_WEAK (fixP
->fx_addsy
);
6707 case BFD_RELOC_VTABLE_ENTRY
:
6712 /* These can appear with @l etc. in data. */
6713 case BFD_RELOC_LO16
:
6715 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6716 case BFD_RELOC_LO16_PCREL
:
6720 case BFD_RELOC_HI16
:
6722 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6723 case BFD_RELOC_HI16_PCREL
:
6725 fieldval
= PPC_HI (value
);
6728 case BFD_RELOC_HI16_S
:
6730 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6731 case BFD_RELOC_HI16_S_PCREL
:
6733 fieldval
= PPC_HA (value
);
6736 case BFD_RELOC_PPC64_HIGHER
:
6740 fieldval
= PPC_HIGHER (value
);
6743 case BFD_RELOC_PPC64_HIGHER_S
:
6747 fieldval
= PPC_HIGHERA (value
);
6750 case BFD_RELOC_PPC64_HIGHEST
:
6754 fieldval
= PPC_HIGHEST (value
);
6757 case BFD_RELOC_PPC64_HIGHEST_S
:
6761 fieldval
= PPC_HIGHESTA (value
);
6764 case BFD_RELOC_PPC_DTPMOD
:
6765 case BFD_RELOC_PPC_TPREL
:
6766 case BFD_RELOC_PPC_DTPREL
:
6767 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6770 /* Just punt all of these to the linker. */
6771 case BFD_RELOC_PPC_B16_BRTAKEN
:
6772 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6773 case BFD_RELOC_16_GOTOFF
:
6774 case BFD_RELOC_LO16_GOTOFF
:
6775 case BFD_RELOC_HI16_GOTOFF
:
6776 case BFD_RELOC_HI16_S_GOTOFF
:
6777 case BFD_RELOC_LO16_PLTOFF
:
6778 case BFD_RELOC_HI16_PLTOFF
:
6779 case BFD_RELOC_HI16_S_PLTOFF
:
6780 case BFD_RELOC_PPC_COPY
:
6781 case BFD_RELOC_PPC_GLOB_DAT
:
6782 case BFD_RELOC_16_BASEREL
:
6783 case BFD_RELOC_LO16_BASEREL
:
6784 case BFD_RELOC_HI16_BASEREL
:
6785 case BFD_RELOC_HI16_S_BASEREL
:
6786 case BFD_RELOC_PPC_TLS
:
6787 case BFD_RELOC_PPC_DTPREL16_LO
:
6788 case BFD_RELOC_PPC_DTPREL16_HI
:
6789 case BFD_RELOC_PPC_DTPREL16_HA
:
6790 case BFD_RELOC_PPC_TPREL16_LO
:
6791 case BFD_RELOC_PPC_TPREL16_HI
:
6792 case BFD_RELOC_PPC_TPREL16_HA
:
6793 case BFD_RELOC_PPC_GOT_TLSGD16
:
6794 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6795 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6796 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6797 case BFD_RELOC_PPC_GOT_TLSLD16
:
6798 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6799 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6800 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6801 case BFD_RELOC_PPC_GOT_DTPREL16
:
6802 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6803 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6804 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6805 case BFD_RELOC_PPC_GOT_TPREL16
:
6806 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6807 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6808 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6809 case BFD_RELOC_24_PLT_PCREL
:
6810 case BFD_RELOC_PPC_LOCAL24PC
:
6811 case BFD_RELOC_32_PLT_PCREL
:
6812 case BFD_RELOC_GPREL16
:
6813 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6814 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6815 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6816 case BFD_RELOC_PPC_EMB_NADDR32
:
6817 case BFD_RELOC_PPC_EMB_NADDR16
:
6818 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6819 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6820 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6821 case BFD_RELOC_PPC_EMB_SDAI16
:
6822 case BFD_RELOC_PPC_EMB_SDA2REL
:
6823 case BFD_RELOC_PPC_EMB_SDA2I16
:
6824 case BFD_RELOC_PPC_EMB_SDA21
:
6825 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6826 case BFD_RELOC_PPC_EMB_MRKREF
:
6827 case BFD_RELOC_PPC_EMB_RELSEC16
:
6828 case BFD_RELOC_PPC_EMB_RELST_LO
:
6829 case BFD_RELOC_PPC_EMB_RELST_HI
:
6830 case BFD_RELOC_PPC_EMB_RELST_HA
:
6831 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6832 case BFD_RELOC_PPC_EMB_RELSDA
:
6833 case BFD_RELOC_PPC64_TOC
:
6834 case BFD_RELOC_PPC_TOC16
:
6835 case BFD_RELOC_PPC64_TOC16_LO
:
6836 case BFD_RELOC_PPC64_TOC16_HI
:
6837 case BFD_RELOC_PPC64_TOC16_HA
:
6838 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6839 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6840 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6841 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6842 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6843 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6844 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6845 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6851 case BFD_RELOC_NONE
:
6857 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6862 if (size
&& APPLY_RELOC
)
6863 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6868 ppc_elf_validate_fix (fixP
, seg
);
6869 fixP
->fx_addnumber
= value
;
6871 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6872 from the section contents. If we are going to be emitting a reloc
6873 then the section contents are immaterial, so don't warn if they
6874 happen to overflow. Leave such warnings to ld. */
6877 fixP
->fx_no_overflow
= 1;
6879 /* Arrange to emit .TOC. as a normal symbol if used in anything
6880 but .TOC.@tocbase. */
6882 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
6883 && fixP
->fx_addsy
!= NULL
6884 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
6885 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
6888 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6889 fixP
->fx_addnumber
= 0;
6893 fixP
->fx_addnumber
= 0;
6895 /* We want to use the offset within the toc, not the actual VMA
6897 fixP
->fx_addnumber
=
6898 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6899 - S_GET_VALUE (ppc_toc_csect
);
6905 /* Generate a reloc for a fixup. */
6908 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6912 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6914 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6915 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6916 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6917 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6918 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6920 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6921 _("reloc %d not supported by object file format"),
6922 (int) fixp
->fx_r_type
);
6925 reloc
->addend
= fixp
->fx_addnumber
;
6931 ppc_cfi_frame_initial_instructions (void)
6933 cfi_add_CFA_def_cfa (1, 0);
6937 tc_ppc_regname_to_dw2regnum (char *regname
)
6939 unsigned int regnum
= -1;
6943 static struct { char *name
; int dw2regnum
; } regnames
[] =
6945 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6946 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6947 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6948 { "spe_acc", 111 }, { "spefscr", 112 }
6951 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6952 if (strcmp (regnames
[i
].name
, regname
) == 0)
6953 return regnames
[i
].dw2regnum
;
6955 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6957 p
= regname
+ 1 + (regname
[1] == '.');
6958 regnum
= strtoul (p
, &q
, 10);
6959 if (p
== q
|| *q
|| regnum
>= 32)
6961 if (regname
[0] == 'f')
6963 else if (regname
[0] == 'v')
6966 else if (regname
[0] == 'c' && regname
[1] == 'r')
6968 p
= regname
+ 2 + (regname
[2] == '.');
6969 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6971 regnum
= p
[0] - '0' + 68;