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;
227 /* Flags set on encountering toc relocs. */
229 has_large_toc_reloc
= 1,
230 has_small_toc_reloc
= 2
233 /* The target specific pseudo-ops which we support. */
235 const pseudo_typeS md_pseudo_table
[] =
237 /* Pseudo-ops which must be overridden. */
238 { "byte", ppc_byte
, 0 },
241 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
242 legitimately belong in the obj-*.c file. However, XCOFF is based
243 on COFF, and is only implemented for the RS/6000. We just use
244 obj-coff.c, and add what we need here. */
245 { "comm", ppc_comm
, 0 },
246 { "lcomm", ppc_comm
, 1 },
250 { "bi", ppc_biei
, 0 },
252 { "csect", ppc_csect
, 0 },
253 { "dwsect", ppc_dwsect
, 0 },
254 { "data", ppc_section
, 'd' },
258 { "ei", ppc_biei
, 1 },
260 { "extern", ppc_extern
, 0 },
261 { "function", ppc_function
, 0 },
262 { "lglobl", ppc_lglobl
, 0 },
263 { "ref", ppc_ref
, 0 },
264 { "rename", ppc_rename
, 0 },
265 { "section", ppc_named_section
, 0 },
266 { "stabx", ppc_stabx
, 0 },
267 { "text", ppc_section
, 't' },
268 { "toc", ppc_toc
, 0 },
269 { "long", ppc_xcoff_cons
, 2 },
270 { "llong", ppc_xcoff_cons
, 3 },
271 { "word", ppc_xcoff_cons
, 1 },
272 { "short", ppc_xcoff_cons
, 1 },
273 { "vbyte", ppc_vbyte
, 0 },
277 { "llong", ppc_elf_cons
, 8 },
278 { "quad", ppc_elf_cons
, 8 },
279 { "long", ppc_elf_cons
, 4 },
280 { "word", ppc_elf_cons
, 2 },
281 { "short", ppc_elf_cons
, 2 },
282 { "rdata", ppc_elf_rdata
, 0 },
283 { "rodata", ppc_elf_rdata
, 0 },
284 { "lcomm", ppc_elf_lcomm
, 0 },
288 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
289 { "previous", ppc_previous
, 0 },
290 { "pdata", ppc_pdata
, 0 },
291 { "ydata", ppc_ydata
, 0 },
292 { "reldata", ppc_reldata
, 0 },
293 { "rdata", ppc_rdata
, 0 },
294 { "ualong", ppc_ualong
, 0 },
295 { "znop", ppc_znop
, 0 },
296 { "comm", ppc_pe_comm
, 0 },
297 { "lcomm", ppc_pe_comm
, 1 },
298 { "section", ppc_pe_section
, 0 },
299 { "function", ppc_pe_function
,0 },
300 { "tocd", ppc_pe_tocd
, 0 },
303 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
305 { "machine", ppc_machine
, 0 },
312 /* Predefined register names if -mregnames (or default for Windows NT).
313 In general, there are lots of them, in an attempt to be compatible
314 with a number of other Windows NT assemblers. */
316 /* Structure to hold information about predefined registers. */
323 /* List of registers that are pre-defined:
325 Each general register has predefined names of the form:
326 1. r<reg_num> which has the value <reg_num>.
327 2. r.<reg_num> which has the value <reg_num>.
329 Each floating point register has predefined names of the form:
330 1. f<reg_num> which has the value <reg_num>.
331 2. f.<reg_num> which has the value <reg_num>.
333 Each vector unit register has predefined names of the form:
334 1. v<reg_num> which has the value <reg_num>.
335 2. v.<reg_num> which has the value <reg_num>.
337 Each condition register has predefined names of the form:
338 1. cr<reg_num> which has the value <reg_num>.
339 2. cr.<reg_num> which has the value <reg_num>.
341 There are individual registers as well:
342 sp or r.sp has the value 1
343 rtoc or r.toc has the value 2
344 fpscr has the value 0
350 dsisr has the value 18
352 sdr1 has the value 25
353 srr0 has the value 26
354 srr1 has the value 27
356 The table is sorted. Suitable for searching by a binary search. */
358 static const struct pd_reg pre_defined_registers
[] =
360 { "cr.0", 0 }, /* Condition Registers */
380 { "dar", 19 }, /* Data Access Register */
381 { "dec", 22 }, /* Decrementer */
382 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
384 { "f.0", 0 }, /* Floating point registers */
411 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
477 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
518 /* Quantization registers used with pair single instructions. */
536 { "lr", 8 }, /* Link Register */
540 { "r.0", 0 }, /* General Purpose Registers */
573 { "r.sp", 1 }, /* Stack Pointer */
575 { "r.toc", 2 }, /* Pointer to the table of contents */
577 { "r0", 0 }, /* More general purpose registers */
610 { "rtoc", 2 }, /* Table of contents */
612 { "sdr1", 25 }, /* Storage Description Register 1 */
616 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
617 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
619 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
685 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
819 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
821 /* Given NAME, find the register number associated with that name, return
822 the integer value associated with the given name or -1 on failure. */
825 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
827 int middle
, low
, high
;
835 middle
= (low
+ high
) / 2;
836 cmp
= strcasecmp (name
, regs
[middle
].name
);
842 return regs
[middle
].value
;
850 * Summary of register_name.
852 * in: Input_line_pointer points to 1st char of operand.
854 * out: A expressionS.
855 * The operand may have been a register: in this case, X_op == O_register,
856 * X_add_number is set to the register number, and truth is returned.
857 * Input_line_pointer->(next non-blank) char after operand, or is in its
862 register_name (expressionS
*expressionP
)
869 /* Find the spelling of the operand. */
870 start
= name
= input_line_pointer
;
871 if (name
[0] == '%' && ISALPHA (name
[1]))
872 name
= ++input_line_pointer
;
874 else if (!reg_names_p
|| !ISALPHA (name
[0]))
877 c
= get_symbol_end ();
878 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
880 /* Put back the delimiting char. */
881 *input_line_pointer
= c
;
883 /* Look to see if it's in the register table. */
886 expressionP
->X_op
= O_register
;
887 expressionP
->X_add_number
= reg_number
;
889 /* Make the rest nice. */
890 expressionP
->X_add_symbol
= NULL
;
891 expressionP
->X_op_symbol
= NULL
;
895 /* Reset the line as if we had not done anything. */
896 input_line_pointer
= start
;
900 /* This function is called for each symbol seen in an expression. It
901 handles the special parsing which PowerPC assemblers are supposed
902 to use for condition codes. */
904 /* Whether to do the special parsing. */
905 static bfd_boolean cr_operand
;
907 /* Names to recognize in a condition code. This table is sorted. */
908 static const struct pd_reg cr_names
[] =
925 /* Parsing function. This returns non-zero if it recognized an
929 ppc_parse_name (const char *name
, expressionS
*exp
)
938 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
943 exp
->X_op
= O_constant
;
944 exp
->X_add_number
= val
;
949 /* Local variables. */
951 /* Whether to target xcoff64/elf64. */
952 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
954 /* Opcode hash table. */
955 static struct hash_control
*ppc_hash
;
957 /* Macro hash table. */
958 static struct hash_control
*ppc_macro_hash
;
961 /* What type of shared library support to use. */
962 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
964 /* Flags to set in the elf header. */
965 static flagword ppc_flags
= 0;
967 /* Whether this is Solaris or not. */
968 #ifdef TARGET_SOLARIS_COMMENT
969 #define SOLARIS_P TRUE
971 #define SOLARIS_P FALSE
974 static bfd_boolean msolaris
= SOLARIS_P
;
979 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
980 using a bunch of different sections. These assembler sections,
981 however, are all encompassed within the .text or .data sections of
982 the final output file. We handle this by using different
983 subsegments within these main segments. */
985 /* Next subsegment to allocate within the .text segment. */
986 static subsegT ppc_text_subsegment
= 2;
988 /* Linked list of csects in the text section. */
989 static symbolS
*ppc_text_csects
;
991 /* Next subsegment to allocate within the .data segment. */
992 static subsegT ppc_data_subsegment
= 2;
994 /* Linked list of csects in the data section. */
995 static symbolS
*ppc_data_csects
;
997 /* The current csect. */
998 static symbolS
*ppc_current_csect
;
1000 /* The RS/6000 assembler uses a TOC which holds addresses of functions
1001 and variables. Symbols are put in the TOC with the .tc pseudo-op.
1002 A special relocation is used when accessing TOC entries. We handle
1003 the TOC as a subsegment within the .data segment. We set it up if
1004 we see a .toc pseudo-op, and save the csect symbol here. */
1005 static symbolS
*ppc_toc_csect
;
1007 /* The first frag in the TOC subsegment. */
1008 static fragS
*ppc_toc_frag
;
1010 /* The first frag in the first subsegment after the TOC in the .data
1011 segment. NULL if there are no subsegments after the TOC. */
1012 static fragS
*ppc_after_toc_frag
;
1014 /* The current static block. */
1015 static symbolS
*ppc_current_block
;
1017 /* The COFF debugging section; set by md_begin. This is not the
1018 .debug section, but is instead the secret BFD section which will
1019 cause BFD to set the section number of a symbol to N_DEBUG. */
1020 static asection
*ppc_coff_debug_section
;
1022 /* Structure to set the length field of the dwarf sections. */
1023 struct dw_subsection
{
1024 /* Subsections are simply linked. */
1025 struct dw_subsection
*link
;
1027 /* The subsection number. */
1030 /* Expression to compute the length of the section. */
1031 expressionS end_exp
;
1034 static struct dw_section
{
1035 /* Corresponding section. */
1038 /* Simply linked list of subsections with a label. */
1039 struct dw_subsection
*list_subseg
;
1041 /* The anonymous subsection. */
1042 struct dw_subsection
*anon_subseg
;
1043 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1044 #endif /* OBJ_XCOFF */
1048 /* Various sections that we need for PE coff support. */
1049 static segT ydata_section
;
1050 static segT pdata_section
;
1051 static segT reldata_section
;
1052 static segT rdata_section
;
1053 static segT tocdata_section
;
1055 /* The current section and the previous section. See ppc_previous. */
1056 static segT ppc_previous_section
;
1057 static segT ppc_current_section
;
1062 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1063 #define PPC_APUINFO_ISEL 0x40
1064 #define PPC_APUINFO_PMR 0x41
1065 #define PPC_APUINFO_RFMCI 0x42
1066 #define PPC_APUINFO_CACHELCK 0x43
1067 #define PPC_APUINFO_SPE 0x100
1068 #define PPC_APUINFO_EFS 0x101
1069 #define PPC_APUINFO_BRLOCK 0x102
1070 #define PPC_APUINFO_VLE 0x104
1073 * We keep a list of APUinfo
1075 unsigned long *ppc_apuinfo_list
;
1076 unsigned int ppc_apuinfo_num
;
1077 unsigned int ppc_apuinfo_num_alloc
;
1078 #endif /* OBJ_ELF */
1081 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1083 const char *const md_shortopts
= "um:";
1085 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1086 const struct option md_longopts
[] = {
1087 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1088 {NULL
, no_argument
, NULL
, 0}
1090 const size_t md_longopts_size
= sizeof (md_longopts
);
1092 /* Convert the target integer stored in N bytes in BUF to a host
1093 integer, returning that value. */
1096 md_chars_to_number (char *buf
, int n
)
1099 unsigned char *p
= (unsigned char *) buf
;
1101 if (target_big_endian
)
1106 result
|= (*p
++ & 0xff);
1114 result
|= (p
[n
] & 0xff);
1122 md_parse_option (int c
, char *arg
)
1129 /* -u means that any undefined symbols should be treated as
1130 external, which is the default for gas anyhow. */
1135 /* Solaris as takes -le (presumably for little endian). For completeness
1136 sake, recognize -be also. */
1137 if (strcmp (arg
, "e") == 0)
1139 target_big_endian
= 0;
1140 set_target_endian
= 1;
1141 if (ppc_cpu
& PPC_OPCODE_VLE
)
1142 as_bad (_("the use of -mvle requires big endian."));
1150 if (strcmp (arg
, "e") == 0)
1152 target_big_endian
= 1;
1153 set_target_endian
= 1;
1161 /* Recognize -K PIC. */
1162 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1165 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1173 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1175 if (strcmp (arg
, "64") == 0)
1179 if (ppc_cpu
& PPC_OPCODE_VLE
)
1180 as_bad (_("the use of -mvle requires -a32."));
1182 as_fatal (_("%s unsupported"), "-a64");
1185 else if (strcmp (arg
, "32") == 0)
1192 new_cpu
= ppc_parse_cpu (ppc_cpu
, arg
);
1196 if (strcmp (arg
, "vle") == 0)
1198 if (set_target_endian
&& target_big_endian
== 0)
1199 as_bad (_("the use of -mvle requires big endian."));
1201 as_bad (_("the use of -mvle requires -a32."));
1205 else if (strcmp (arg
, "regnames") == 0)
1208 else if (strcmp (arg
, "no-regnames") == 0)
1209 reg_names_p
= FALSE
;
1212 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1213 that require relocation. */
1214 else if (strcmp (arg
, "relocatable") == 0)
1216 shlib
= SHLIB_MRELOCATABLE
;
1217 ppc_flags
|= EF_PPC_RELOCATABLE
;
1220 else if (strcmp (arg
, "relocatable-lib") == 0)
1222 shlib
= SHLIB_MRELOCATABLE
;
1223 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1226 /* -memb, set embedded bit. */
1227 else if (strcmp (arg
, "emb") == 0)
1228 ppc_flags
|= EF_PPC_EMB
;
1230 /* -mlittle/-mbig set the endianness. */
1231 else if (strcmp (arg
, "little") == 0
1232 || strcmp (arg
, "little-endian") == 0)
1234 target_big_endian
= 0;
1235 set_target_endian
= 1;
1236 if (ppc_cpu
& PPC_OPCODE_VLE
)
1237 as_bad (_("the use of -mvle requires big endian."));
1240 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1242 target_big_endian
= 1;
1243 set_target_endian
= 1;
1246 else if (strcmp (arg
, "solaris") == 0)
1249 ppc_comment_chars
= ppc_solaris_comment_chars
;
1252 else if (strcmp (arg
, "no-solaris") == 0)
1255 ppc_comment_chars
= ppc_eabi_comment_chars
;
1260 as_bad (_("invalid switch -m%s"), arg
);
1266 /* -V: SVR4 argument to print version ID. */
1268 print_version_id ();
1271 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1272 should be emitted or not. FIXME: Not implemented. */
1276 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1277 rather than .stabs.excl, which is ignored by the linker.
1278 FIXME: Not implemented. */
1289 nop_limit
= strtoul (optarg
, &end
, 0);
1291 as_bad (_("--nops needs a numeric argument"));
1303 md_show_usage (FILE *stream
)
1305 fprintf (stream
, _("\
1307 -a32 generate ELF32/XCOFF32\n\
1308 -a64 generate ELF64/XCOFF64\n\
1310 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1311 -mpwr generate code for POWER (RIOS1)\n\
1312 -m601 generate code for PowerPC 601\n\
1313 -mppc, -mppc32, -m603, -m604\n\
1314 generate code for PowerPC 603/604\n\
1315 -m403 generate code for PowerPC 403\n\
1316 -m405 generate code for PowerPC 405\n\
1317 -m440 generate code for PowerPC 440\n\
1318 -m464 generate code for PowerPC 464\n\
1319 -m476 generate code for PowerPC 476\n\
1320 -m7400, -m7410, -m7450, -m7455\n\
1321 generate code for PowerPC 7400/7410/7450/7455\n\
1322 -m750cl generate code for PowerPC 750cl\n"));
1323 fprintf (stream
, _("\
1324 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1325 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1326 -mbooke generate code for 32-bit PowerPC BookE\n\
1327 -ma2 generate code for A2 architecture\n\
1328 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1329 -mpower5, -mpwr5, -mpwr5x\n\
1330 generate code for Power5 architecture\n\
1331 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1332 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1333 -mcell generate code for Cell Broadband Engine architecture\n\
1334 -mcom generate code Power/PowerPC common instructions\n\
1335 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1336 fprintf (stream
, _("\
1337 -maltivec generate code for AltiVec\n\
1338 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1339 -me300 generate code for PowerPC e300 family\n\
1340 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1341 -me500mc, generate code for Freescale e500mc core complex\n\
1342 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1343 -me5500, generate code for Freescale e5500 core complex\n\
1344 -me6500, generate code for Freescale e6500 core complex\n\
1345 -mspe generate code for Motorola SPE instructions\n\
1346 -mvle generate code for Freescale VLE instructions\n\
1347 -mtitan generate code for AppliedMicro Titan core complex\n\
1348 -mregnames Allow symbolic names for registers\n\
1349 -mno-regnames Do not allow symbolic names for registers\n"));
1351 fprintf (stream
, _("\
1352 -mrelocatable support for GCC's -mrelocatble option\n\
1353 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1354 -memb set PPC_EMB bit in ELF flags\n\
1355 -mlittle, -mlittle-endian, -le\n\
1356 generate code for a little endian machine\n\
1357 -mbig, -mbig-endian, -be\n\
1358 generate code for a big endian machine\n\
1359 -msolaris generate code for Solaris\n\
1360 -mno-solaris do not generate code for Solaris\n\
1361 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1362 -V print assembler version number\n\
1363 -Qy, -Qn ignored\n"));
1365 fprintf (stream
, _("\
1366 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1369 /* Set ppc_cpu if it is not already set. */
1374 const char *default_os
= TARGET_OS
;
1375 const char *default_cpu
= TARGET_CPU
;
1377 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1380 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1381 else if (strncmp (default_os
, "aix", 3) == 0
1382 && default_os
[3] >= '4' && default_os
[3] <= '9')
1383 ppc_cpu
|= PPC_OPCODE_COMMON
;
1384 else if (strncmp (default_os
, "aix3", 4) == 0)
1385 ppc_cpu
|= PPC_OPCODE_POWER
;
1386 else if (strcmp (default_cpu
, "rs6000") == 0)
1387 ppc_cpu
|= PPC_OPCODE_POWER
;
1388 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1389 ppc_cpu
|= PPC_OPCODE_PPC
;
1391 as_fatal (_("unknown default cpu = %s, os = %s"),
1392 default_cpu
, default_os
);
1396 /* Figure out the BFD architecture to use. This function and ppc_mach
1397 are called well before md_begin, when the output file is opened. */
1399 enum bfd_architecture
1402 const char *default_cpu
= TARGET_CPU
;
1405 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1406 return bfd_arch_powerpc
;
1407 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1408 return bfd_arch_powerpc
;
1409 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1410 return bfd_arch_rs6000
;
1411 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1413 if (strcmp (default_cpu
, "rs6000") == 0)
1414 return bfd_arch_rs6000
;
1415 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1416 return bfd_arch_powerpc
;
1419 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1420 return bfd_arch_unknown
;
1427 return bfd_mach_ppc64
;
1428 else if (ppc_arch () == bfd_arch_rs6000
)
1429 return bfd_mach_rs6k
;
1430 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1431 return bfd_mach_ppc_titan
;
1432 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1433 return bfd_mach_ppc_vle
;
1435 return bfd_mach_ppc
;
1439 ppc_target_format (void)
1443 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1445 return "xcoff-powermac";
1448 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1450 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1456 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1457 # elif defined (TE_VXWORKS)
1458 return "elf32-powerpc-vxworks";
1460 return (target_big_endian
1461 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1462 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1467 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1468 Return TRUE if there's a problem, otherwise FALSE. */
1471 insn_validate (const struct powerpc_opcode
*op
)
1473 const unsigned char *o
;
1474 unsigned long omask
= op
->mask
;
1476 /* The mask had better not trim off opcode bits. */
1477 if ((op
->opcode
& omask
) != op
->opcode
)
1479 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1483 /* The operands must not overlap the opcode or each other. */
1484 for (o
= op
->operands
; *o
; ++o
)
1486 if (*o
>= num_powerpc_operands
)
1488 as_bad (_("operand index error for %s"), op
->name
);
1493 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1494 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1498 if (operand
->shift
>= 0)
1499 mask
= operand
->bitm
<< operand
->shift
;
1501 mask
= operand
->bitm
>> -operand
->shift
;
1504 as_bad (_("operand %d overlap in %s"),
1505 (int) (o
- op
->operands
), op
->name
);
1515 /* Insert opcodes and macros into hash tables. Called at startup and
1516 for .machine pseudo. */
1519 ppc_setup_opcodes (void)
1521 const struct powerpc_opcode
*op
;
1522 const struct powerpc_opcode
*op_end
;
1523 const struct powerpc_macro
*macro
;
1524 const struct powerpc_macro
*macro_end
;
1525 bfd_boolean bad_insn
= FALSE
;
1527 if (ppc_hash
!= NULL
)
1528 hash_die (ppc_hash
);
1529 if (ppc_macro_hash
!= NULL
)
1530 hash_die (ppc_macro_hash
);
1532 /* Insert the opcodes into a hash table. */
1533 ppc_hash
= hash_new ();
1535 if (ENABLE_CHECKING
)
1539 /* Check operand masks. Code here and in the disassembler assumes
1540 all the 1's in the mask are contiguous. */
1541 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1543 unsigned long mask
= powerpc_operands
[i
].bitm
;
1544 unsigned long right_bit
;
1547 right_bit
= mask
& -mask
;
1549 right_bit
= mask
& -mask
;
1550 if (mask
!= right_bit
)
1552 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1555 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1556 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1557 sizeof (powerpc_operands
[0])) == 0)
1559 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1566 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1567 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1569 if (ENABLE_CHECKING
)
1571 if (op
!= powerpc_opcodes
)
1573 int old_opcode
= PPC_OP (op
[-1].opcode
);
1574 int new_opcode
= PPC_OP (op
[0].opcode
);
1576 #ifdef PRINT_OPCODE_TABLE
1577 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1578 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1579 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1580 (unsigned long long) op
->flags
);
1583 /* The major opcodes had better be sorted. Code in the
1584 disassembler assumes the insns are sorted according to
1586 if (new_opcode
< old_opcode
)
1588 as_bad (_("major opcode is not sorted for %s"),
1593 bad_insn
|= insn_validate (op
);
1596 if ((ppc_cpu
& op
->flags
) != 0
1597 && !(ppc_cpu
& op
->deprecated
))
1601 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1604 as_bad (_("duplicate instruction %s"),
1611 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1612 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1613 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1615 op_end
= vle_opcodes
+ vle_num_opcodes
;
1616 for (op
= vle_opcodes
; op
< op_end
; op
++)
1618 if (ENABLE_CHECKING
)
1620 if (op
!= vle_opcodes
)
1622 unsigned old_seg
, new_seg
;
1624 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1625 old_seg
= VLE_OP_TO_SEG (old_seg
);
1626 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1627 new_seg
= VLE_OP_TO_SEG (new_seg
);
1629 #ifdef PRINT_OPCODE_TABLE
1630 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1631 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1632 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1633 (unsigned long long) op
->flags
);
1635 /* The major opcodes had better be sorted. Code in the
1636 disassembler assumes the insns are sorted according to
1638 if (new_seg
< old_seg
)
1640 as_bad (_("major opcode is not sorted for %s"),
1646 bad_insn
|= insn_validate (op
);
1649 if ((ppc_cpu
& op
->flags
) != 0
1650 && !(ppc_cpu
& op
->deprecated
))
1654 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1657 as_bad (_("duplicate instruction %s"),
1664 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1665 for (op
= vle_opcodes
; op
< op_end
; op
++)
1666 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1668 /* Insert the macros into a hash table. */
1669 ppc_macro_hash
= hash_new ();
1671 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1672 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1674 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1678 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1679 if (retval
!= (const char *) NULL
)
1681 as_bad (_("duplicate macro %s"), macro
->name
);
1691 /* This function is called when the assembler starts up. It is called
1692 after the options have been parsed and the output file has been
1700 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1701 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1704 /* Set the ELF flags if desired. */
1705 if (ppc_flags
&& !msolaris
)
1706 bfd_set_private_flags (stdoutput
, ppc_flags
);
1709 ppc_setup_opcodes ();
1711 /* Tell the main code what the endianness is if it is not overridden
1713 if (!set_target_endian
)
1715 set_target_endian
= 1;
1716 target_big_endian
= PPC_BIG_ENDIAN
;
1720 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1722 /* Create dummy symbols to serve as initial csects. This forces the
1723 text csects to precede the data csects. These symbols will not
1725 ppc_text_csects
= symbol_make ("dummy\001");
1726 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1727 ppc_data_csects
= symbol_make ("dummy\001");
1728 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1733 ppc_current_section
= text_section
;
1734 ppc_previous_section
= 0;
1743 if (ppc_apuinfo_list
== NULL
)
1746 /* Ok, so write the section info out. We have this layout:
1750 0 8 length of "APUinfo\0"
1751 4 (n*4) number of APU's (4 bytes each)
1754 20 APU#1 first APU's info
1755 24 APU#2 second APU's info
1760 asection
*seg
= now_seg
;
1761 subsegT subseg
= now_subseg
;
1762 asection
*apuinfo_secp
= (asection
*) NULL
;
1765 /* Create the .PPC.EMB.apuinfo section. */
1766 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1767 bfd_set_section_flags (stdoutput
,
1769 SEC_HAS_CONTENTS
| SEC_READONLY
);
1772 md_number_to_chars (p
, (valueT
) 8, 4);
1775 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1778 md_number_to_chars (p
, (valueT
) 2, 4);
1781 strcpy (p
, "APUinfo");
1783 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1786 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1789 frag_align (2, 0, 0);
1791 /* We probably can't restore the current segment, for there likely
1794 subseg_set (seg
, subseg
);
1799 /* Insert an operand value into an instruction. */
1801 static unsigned long
1802 ppc_insert_operand (unsigned long insn
,
1803 const struct powerpc_operand
*operand
,
1809 long min
, max
, right
;
1811 max
= operand
->bitm
;
1815 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1817 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1818 max
= (max
>> 1) & -right
;
1819 min
= ~max
& -right
;
1822 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1825 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1834 /* Some people write constants with the sign extension done by
1835 hand but only up to 32 bits. This shouldn't really be valid,
1836 but, to permit this code to assemble on a 64-bit host, we
1837 sign extend the 32-bit value to 64 bits if so doing makes the
1840 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1841 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1842 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1843 val
= val
- 0x80000000 - 0x80000000;
1845 /* Similarly, people write expressions like ~(1<<15), and expect
1846 this to be OK for a 32-bit unsigned value. */
1848 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1849 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1850 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1851 val
= val
+ 0x80000000 + 0x80000000;
1855 || (val
& (right
- 1)) != 0)
1856 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1859 if (operand
->insert
)
1864 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1865 if (errmsg
!= (const char *) NULL
)
1866 as_bad_where (file
, line
, "%s", errmsg
);
1868 else if (operand
->shift
>= 0)
1869 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1871 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1878 /* Parse @got, etc. and return the desired relocation. */
1879 static bfd_reloc_code_real_type
1880 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1884 unsigned int length
: 8;
1885 unsigned int valid32
: 1;
1886 unsigned int valid64
: 1;
1895 const struct map_bfd
*ptr
;
1897 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1898 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1899 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1901 static const struct map_bfd mapping
[] = {
1902 MAP ("l", BFD_RELOC_LO16
),
1903 MAP ("h", BFD_RELOC_HI16
),
1904 MAP ("ha", BFD_RELOC_HI16_S
),
1905 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1906 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1907 MAP ("got", BFD_RELOC_16_GOTOFF
),
1908 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1909 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1910 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1911 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1912 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1913 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1914 MAP ("copy", BFD_RELOC_PPC_COPY
),
1915 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1916 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1917 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1918 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1919 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1920 MAP ("tls", BFD_RELOC_PPC_TLS
),
1921 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1922 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1923 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1924 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1925 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1926 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1927 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1928 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1929 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1930 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1931 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1932 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1933 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1934 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1935 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1936 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1937 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1938 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1939 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1940 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1941 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1942 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1943 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1944 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1945 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1946 MAP32 ("fixup", BFD_RELOC_CTOR
),
1947 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1948 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1949 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1950 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1951 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1952 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1953 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1954 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1955 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1956 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1957 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1958 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1959 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1960 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1961 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1962 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1963 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1964 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1965 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1966 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1967 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1968 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1969 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1970 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1971 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1972 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1973 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1974 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1975 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1976 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1977 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1978 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1979 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1980 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1981 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1982 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1983 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1984 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1985 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1986 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1987 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1988 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1989 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1990 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1991 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1995 return BFD_RELOC_UNUSED
;
1997 for (ch
= *str
, str2
= ident
;
1998 (str2
< ident
+ sizeof (ident
) - 1
1999 && (ISALNUM (ch
) || ch
== '@'));
2002 *str2
++ = TOLOWER (ch
);
2009 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
2010 if (ch
== ptr
->string
[0]
2011 && len
== ptr
->length
2012 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
2013 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
2015 int reloc
= ptr
->reloc
;
2017 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
2021 case BFD_RELOC_16_GOTOFF
:
2022 case BFD_RELOC_LO16_GOTOFF
:
2023 case BFD_RELOC_HI16_GOTOFF
:
2024 case BFD_RELOC_HI16_S_GOTOFF
:
2025 as_warn (_("identifier+constant@got means "
2026 "identifier@got+constant"));
2029 case BFD_RELOC_PPC_GOT_TLSGD16
:
2030 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2031 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2032 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2033 case BFD_RELOC_PPC_GOT_TLSLD16
:
2034 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2035 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2036 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2037 case BFD_RELOC_PPC_GOT_DTPREL16
:
2038 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2039 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2040 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2041 case BFD_RELOC_PPC_GOT_TPREL16
:
2042 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2043 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2044 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2045 as_bad (_("symbol+offset not supported for got tls"));
2050 /* Now check for identifier@suffix+constant. */
2051 if (*str
== '-' || *str
== '+')
2053 char *orig_line
= input_line_pointer
;
2054 expressionS new_exp
;
2056 input_line_pointer
= str
;
2057 expression (&new_exp
);
2058 if (new_exp
.X_op
== O_constant
)
2060 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2061 str
= input_line_pointer
;
2064 if (&input_line_pointer
!= str_p
)
2065 input_line_pointer
= orig_line
;
2069 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2070 && exp_p
->X_op
== O_symbol
2071 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2073 /* Change the symbol so that the dummy .TOC. symbol can be
2074 omitted from the object file. */
2075 exp_p
->X_add_symbol
= &abs_symbol
;
2078 return (bfd_reloc_code_real_type
) reloc
;
2081 return BFD_RELOC_UNUSED
;
2084 /* Like normal .long/.short/.word, except support @got, etc.
2085 Clobbers input_line_pointer, checks end-of-line. */
2087 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2090 bfd_reloc_code_real_type reloc
;
2092 if (is_it_end_of_statement ())
2094 demand_empty_rest_of_line ();
2101 if (exp
.X_op
== O_symbol
2102 && *input_line_pointer
== '@'
2103 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2104 &exp
)) != BFD_RELOC_UNUSED
)
2106 reloc_howto_type
*reloc_howto
;
2109 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2110 size
= bfd_get_reloc_size (reloc_howto
);
2114 as_bad (_("%s relocations do not fit in %d bytes\n"),
2115 reloc_howto
->name
, nbytes
);
2122 p
= frag_more (nbytes
);
2123 memset (p
, 0, nbytes
);
2125 if (target_big_endian
)
2126 offset
= nbytes
- size
;
2127 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2132 emit_expr (&exp
, (unsigned int) nbytes
);
2134 while (*input_line_pointer
++ == ',');
2136 /* Put terminator back into stream. */
2137 input_line_pointer
--;
2138 demand_empty_rest_of_line ();
2141 /* Solaris pseduo op to change to the .rodata section. */
2143 ppc_elf_rdata (int xxx
)
2145 char *save_line
= input_line_pointer
;
2146 static char section
[] = ".rodata\n";
2148 /* Just pretend this is .section .rodata */
2149 input_line_pointer
= section
;
2150 obj_elf_section (xxx
);
2152 input_line_pointer
= save_line
;
2155 /* Pseudo op to make file scope bss items. */
2157 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2170 name
= input_line_pointer
;
2171 c
= get_symbol_end ();
2173 /* just after name is now '\0'. */
2174 p
= input_line_pointer
;
2177 if (*input_line_pointer
!= ',')
2179 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2180 ignore_rest_of_line ();
2184 input_line_pointer
++; /* skip ',' */
2185 if ((size
= get_absolute_expression ()) < 0)
2187 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2188 ignore_rest_of_line ();
2192 /* The third argument to .lcomm is the alignment. */
2193 if (*input_line_pointer
!= ',')
2197 ++input_line_pointer
;
2198 align
= get_absolute_expression ();
2201 as_warn (_("ignoring bad alignment"));
2207 symbolP
= symbol_find_or_make (name
);
2210 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2212 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2213 S_GET_NAME (symbolP
));
2214 ignore_rest_of_line ();
2218 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2220 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2221 S_GET_NAME (symbolP
),
2222 (long) S_GET_VALUE (symbolP
),
2225 ignore_rest_of_line ();
2231 old_subsec
= now_subseg
;
2234 /* Convert to a power of 2 alignment. */
2235 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2238 as_bad (_("common alignment not a power of 2"));
2239 ignore_rest_of_line ();
2246 record_alignment (bss_section
, align2
);
2247 subseg_set (bss_section
, 0);
2249 frag_align (align2
, 0, 0);
2250 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2251 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2252 symbol_set_frag (symbolP
, frag_now
);
2253 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2256 S_SET_SIZE (symbolP
, size
);
2257 S_SET_SEGMENT (symbolP
, bss_section
);
2258 subseg_set (old_sec
, old_subsec
);
2259 demand_empty_rest_of_line ();
2262 /* Validate any relocations emitted for -mrelocatable, possibly adding
2263 fixups for word relocations in writable segments, so we can adjust
2266 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2268 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2277 case SHLIB_MRELOCATABLE
:
2278 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2279 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2280 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2281 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2282 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2283 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2284 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2285 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2286 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2287 && (seg
->flags
& SEC_LOAD
) != 0
2288 && strcmp (segment_name (seg
), ".got2") != 0
2289 && strcmp (segment_name (seg
), ".dtors") != 0
2290 && strcmp (segment_name (seg
), ".ctors") != 0
2291 && strcmp (segment_name (seg
), ".fixup") != 0
2292 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2293 && strcmp (segment_name (seg
), ".eh_frame") != 0
2294 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2296 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2297 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2299 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2300 _("relocation cannot be done when using -mrelocatable"));
2307 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2308 function descriptor sym if the corresponding code sym is used. */
2311 ppc_frob_file_before_adjust (void)
2319 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2326 name
= S_GET_NAME (symp
);
2330 if (! S_IS_WEAK (symp
)
2331 || S_IS_DEFINED (symp
))
2334 len
= strlen (name
) + 1;
2335 dotname
= xmalloc (len
+ 1);
2337 memcpy (dotname
+ 1, name
, len
);
2338 dotsym
= symbol_find_noref (dotname
, 1);
2340 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2341 || symbol_used_in_reloc_p (dotsym
)))
2342 symbol_mark_used (symp
);
2346 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2348 && toc_reloc_types
!= has_large_toc_reloc
2349 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2350 as_warn (_("TOC section size exceeds 64k"));
2352 /* Don't emit .TOC. symbol. */
2353 symp
= symbol_find (".TOC.");
2355 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2357 #endif /* OBJ_ELF */
2362 * Summary of parse_toc_entry.
2364 * in: Input_line_pointer points to the '[' in one of:
2366 * [toc] [tocv] [toc32] [toc64]
2368 * Anything else is an error of one kind or another.
2371 * return value: success or failure
2372 * toc_kind: kind of toc reference
2373 * input_line_pointer:
2374 * success: first char after the ']'
2375 * failure: unchanged
2379 * [toc] - rv == success, toc_kind = default_toc
2380 * [tocv] - rv == success, toc_kind = data_in_toc
2381 * [toc32] - rv == success, toc_kind = must_be_32
2382 * [toc64] - rv == success, toc_kind = must_be_64
2386 enum toc_size_qualifier
2388 default_toc
, /* The toc cell constructed should be the system default size */
2389 data_in_toc
, /* This is a direct reference to a toc cell */
2390 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2391 must_be_64
/* The toc cell constructed must be 64 bits wide */
2395 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2400 enum toc_size_qualifier t
;
2402 /* Save the input_line_pointer. */
2403 start
= input_line_pointer
;
2405 /* Skip over the '[' , and whitespace. */
2406 ++input_line_pointer
;
2409 /* Find the spelling of the operand. */
2410 toc_spec
= input_line_pointer
;
2411 c
= get_symbol_end ();
2413 if (strcmp (toc_spec
, "toc") == 0)
2417 else if (strcmp (toc_spec
, "tocv") == 0)
2421 else if (strcmp (toc_spec
, "toc32") == 0)
2425 else if (strcmp (toc_spec
, "toc64") == 0)
2431 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2432 *input_line_pointer
= c
;
2433 input_line_pointer
= start
;
2437 /* Now find the ']'. */
2438 *input_line_pointer
= c
;
2440 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2441 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2445 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2446 input_line_pointer
= start
;
2457 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2459 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2463 /* Check we don't already exist. */
2464 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2465 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2468 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2470 if (ppc_apuinfo_num_alloc
== 0)
2472 ppc_apuinfo_num_alloc
= 4;
2473 ppc_apuinfo_list
= (unsigned long *)
2474 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2478 ppc_apuinfo_num_alloc
+= 4;
2479 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2480 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2483 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2489 /* We need to keep a list of fixups. We can't simply generate them as
2490 we go, because that would require us to first create the frag, and
2491 that would screw up references to ``.''. */
2497 bfd_reloc_code_real_type reloc
;
2500 #define MAX_INSN_FIXUPS (5)
2503 #define E_OR2I_INSN 0x7000C000
2504 #define E_AND2I_DOT_INSN 0x7000C800
2505 #define E_OR2IS_INSN 0x7000D000
2506 #define E_LIS_INSN 0x7000E000
2507 #define E_AND2IS_DOT_INSN 0x7000E800
2510 #define E_ADD2I_DOT_INSN 0x70008800
2511 #define E_ADD2IS_INSN 0x70009000
2512 #define E_CMP16I_INSN 0x70009800
2513 #define E_MULL2I_INSN 0x7000A000
2514 #define E_CMPL16I_INSN 0x7000A800
2515 #define E_CMPH16I_INSN 0x7000B000
2516 #define E_CMPHL16I_INSN 0x7000B800
2518 /* This routine is called for each instruction to be assembled. */
2521 md_assemble (char *str
)
2524 const struct powerpc_opcode
*opcode
;
2526 const unsigned char *opindex_ptr
;
2530 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2535 unsigned int insn_length
;
2537 bfd_reloc_code_real_type reloc
;
2540 /* Get the opcode. */
2541 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2546 /* Look up the opcode in the hash table. */
2547 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2548 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2550 const struct powerpc_macro
*macro
;
2552 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2553 if (macro
== (const struct powerpc_macro
*) NULL
)
2554 as_bad (_("unrecognized opcode: `%s'"), str
);
2556 ppc_macro (s
, macro
);
2561 insn
= opcode
->opcode
;
2564 while (ISSPACE (*str
))
2567 /* PowerPC operands are just expressions. The only real issue is
2568 that a few operand types are optional. All cases which might use
2569 an optional operand separate the operands only with commas (in some
2570 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2571 have optional operands). Most instructions with optional operands
2572 have only one. Those that have more than one optional operand can
2573 take either all their operands or none. So, before we start seriously
2574 parsing the operands, we check to see if we have optional operands,
2575 and if we do, we count the number of commas to see which operands
2576 have been omitted. */
2578 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2580 const struct powerpc_operand
*operand
;
2582 operand
= &powerpc_operands
[*opindex_ptr
];
2583 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2585 unsigned int opcount
;
2586 unsigned int num_operands_expected
;
2588 /* There is an optional operand. Count the number of
2589 commas in the input line. */
2596 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2603 /* Compute the number of expected operands.
2604 Do not count fake operands. */
2605 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2606 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2607 ++ num_operands_expected
;
2609 /* If there are fewer operands in the line then are called
2610 for by the instruction, we want to skip the optional
2612 if (opcount
< num_operands_expected
)
2619 /* Gather the operands. */
2623 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2625 const struct powerpc_operand
*operand
;
2631 if (next_opindex
== 0)
2632 operand
= &powerpc_operands
[*opindex_ptr
];
2635 operand
= &powerpc_operands
[next_opindex
];
2640 /* If this is a fake operand, then we do not expect anything
2642 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2644 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2645 if (errmsg
!= (const char *) NULL
)
2646 as_bad ("%s", errmsg
);
2650 /* If this is an optional operand, and we are skipping it, just
2652 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2655 if (operand
->insert
)
2657 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2658 if (errmsg
!= (const char *) NULL
)
2659 as_bad ("%s", errmsg
);
2661 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2662 next_opindex
= *opindex_ptr
+ 1;
2666 /* Gather the operand. */
2667 hold
= input_line_pointer
;
2668 input_line_pointer
= str
;
2671 if (*input_line_pointer
== '[')
2673 /* We are expecting something like the second argument here:
2675 * lwz r4,[toc].GS.0.static_int(rtoc)
2676 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2677 * The argument following the `]' must be a symbol name, and the
2678 * register must be the toc register: 'rtoc' or '2'
2680 * The effect is to 0 as the displacement field
2681 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2682 * the appropriate variation) reloc against it based on the symbol.
2683 * The linker will build the toc, and insert the resolved toc offset.
2686 * o The size of the toc entry is currently assumed to be
2687 * 32 bits. This should not be assumed to be a hard coded
2689 * o In an effort to cope with a change from 32 to 64 bits,
2690 * there are also toc entries that are specified to be
2691 * either 32 or 64 bits:
2692 * lwz r4,[toc32].GS.0.static_int(rtoc)
2693 * lwz r4,[toc64].GS.0.static_int(rtoc)
2694 * These demand toc entries of the specified size, and the
2695 * instruction probably requires it.
2699 enum toc_size_qualifier toc_kind
;
2700 bfd_reloc_code_real_type toc_reloc
;
2702 /* Go parse off the [tocXX] part. */
2703 valid_toc
= parse_toc_entry (&toc_kind
);
2707 /* Note: message has already been issued.
2708 FIXME: what sort of recovery should we do?
2709 demand_rest_of_line (); return; ? */
2712 /* Now get the symbol following the ']'. */
2718 /* In this case, we may not have seen the symbol yet,
2719 since it is allowed to appear on a .extern or .globl
2720 or just be a label in the .data section. */
2721 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2724 /* 1. The symbol must be defined and either in the toc
2725 section, or a global.
2726 2. The reloc generated must have the TOCDEFN flag set
2727 in upper bit mess of the reloc type.
2728 FIXME: It's a little confusing what the tocv
2729 qualifier can be used for. At the very least, I've
2730 seen three uses, only one of which I'm sure I can
2732 if (ex
.X_op
== O_symbol
)
2734 gas_assert (ex
.X_add_symbol
!= NULL
);
2735 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2738 as_bad (_("[tocv] symbol is not a toc symbol"));
2742 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2745 /* FIXME: these next two specifically specify 32/64 bit
2746 toc entries. We don't support them today. Is this
2747 the right way to say that? */
2748 toc_reloc
= BFD_RELOC_UNUSED
;
2749 as_bad (_("unimplemented toc32 expression modifier"));
2752 /* FIXME: see above. */
2753 toc_reloc
= BFD_RELOC_UNUSED
;
2754 as_bad (_("unimplemented toc64 expression modifier"));
2758 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2764 /* We need to generate a fixup for this expression. */
2765 if (fc
>= MAX_INSN_FIXUPS
)
2766 as_fatal (_("too many fixups"));
2768 fixups
[fc
].reloc
= toc_reloc
;
2769 fixups
[fc
].exp
= ex
;
2770 fixups
[fc
].opindex
= *opindex_ptr
;
2773 /* Ok. We've set up the fixup for the instruction. Now make it
2774 look like the constant 0 was found here. */
2776 ex
.X_op
= O_constant
;
2777 ex
.X_add_number
= 0;
2778 ex
.X_add_symbol
= NULL
;
2779 ex
.X_op_symbol
= NULL
;
2786 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2787 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2788 || !register_name (&ex
))
2790 char save_lex
= lex_type
['%'];
2792 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2793 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2796 lex_type
['%'] |= LEX_BEGIN_NAME
;
2800 lex_type
['%'] = save_lex
;
2804 str
= input_line_pointer
;
2805 input_line_pointer
= hold
;
2807 if (ex
.X_op
== O_illegal
)
2808 as_bad (_("illegal operand"));
2809 else if (ex
.X_op
== O_absent
)
2810 as_bad (_("missing operand"));
2811 else if (ex
.X_op
== O_register
)
2813 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2814 ppc_cpu
, (char *) NULL
, 0);
2816 else if (ex
.X_op
== O_constant
)
2819 /* Allow @HA, @L, @H on constants. */
2820 char *orig_str
= str
;
2822 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2829 case BFD_RELOC_LO16
:
2830 /* X_unsigned is the default, so if the user has done
2831 something which cleared it, we always produce a
2833 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2834 ex
.X_add_number
&= 0xffff;
2836 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2839 case BFD_RELOC_HI16
:
2840 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2841 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2843 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2846 case BFD_RELOC_HI16_S
:
2847 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2848 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2850 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2853 case BFD_RELOC_PPC64_HIGHER
:
2854 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2855 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2857 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2860 case BFD_RELOC_PPC64_HIGHER_S
:
2861 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2862 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2864 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2867 case BFD_RELOC_PPC64_HIGHEST
:
2868 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2869 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2871 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2874 case BFD_RELOC_PPC64_HIGHEST_S
:
2875 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2876 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2878 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2881 #endif /* OBJ_ELF */
2882 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2883 ppc_cpu
, (char *) NULL
, 0);
2888 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2890 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2891 if (sym_name
[0] == '.')
2894 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2896 expressionS tls_exp
;
2898 hold
= input_line_pointer
;
2899 input_line_pointer
= str
+ 1;
2900 expression (&tls_exp
);
2901 if (tls_exp
.X_op
== O_symbol
)
2903 reloc
= BFD_RELOC_UNUSED
;
2904 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2906 reloc
= BFD_RELOC_PPC_TLSGD
;
2907 input_line_pointer
+= 7;
2909 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2911 reloc
= BFD_RELOC_PPC_TLSLD
;
2912 input_line_pointer
+= 7;
2914 if (reloc
!= BFD_RELOC_UNUSED
)
2917 str
= input_line_pointer
;
2919 if (fc
>= MAX_INSN_FIXUPS
)
2920 as_fatal (_("too many fixups"));
2921 fixups
[fc
].exp
= tls_exp
;
2922 fixups
[fc
].opindex
= *opindex_ptr
;
2923 fixups
[fc
].reloc
= reloc
;
2927 input_line_pointer
= hold
;
2931 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2933 /* Some TLS tweaks. */
2939 case BFD_RELOC_PPC_TLS
:
2940 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2941 as_bad (_("@tls may not be used with \"%s\" operands"),
2943 else if (operand
->shift
!= 11)
2944 as_bad (_("@tls may only be used in last operand"));
2946 insn
= ppc_insert_operand (insn
, operand
,
2948 ppc_cpu
, (char *) NULL
, 0);
2951 /* We'll only use the 32 (or 64) bit form of these relocations
2952 in constants. Instructions get the 16 bit form. */
2953 case BFD_RELOC_PPC_DTPREL
:
2954 reloc
= BFD_RELOC_PPC_DTPREL16
;
2956 case BFD_RELOC_PPC_TPREL
:
2957 reloc
= BFD_RELOC_PPC_TPREL16
;
2961 /* If VLE-mode convert LO/HI/HA relocations. */
2962 if (opcode
->flags
& PPC_OPCODE_VLE
)
2964 int tmp_insn
= insn
& opcode
->mask
;
2966 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
2967 || tmp_insn
== E_AND2I_DOT_INSN
2968 || tmp_insn
== E_OR2IS_INSN
2969 || tmp_insn
== E_LIS_INSN
2970 || tmp_insn
== E_AND2IS_DOT_INSN
);
2973 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
2974 || tmp_insn
== E_ADD2IS_INSN
2975 || tmp_insn
== E_CMP16I_INSN
2976 || tmp_insn
== E_MULL2I_INSN
2977 || tmp_insn
== E_CMPL16I_INSN
2978 || tmp_insn
== E_CMPH16I_INSN
2979 || tmp_insn
== E_CMPHL16I_INSN
);
2986 case BFD_RELOC_PPC_EMB_SDA21
:
2987 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
2990 case BFD_RELOC_LO16
:
2992 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
2993 else if (use_a_reloc
)
2994 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
2997 case BFD_RELOC_HI16
:
2999 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3000 else if (use_a_reloc
)
3001 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3004 case BFD_RELOC_HI16_S
:
3006 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3007 else if (use_a_reloc
)
3008 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3011 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3013 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3016 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3018 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3021 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3023 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3028 /* For the absolute forms of branches, convert the PC
3029 relative form back into the absolute. */
3030 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3034 case BFD_RELOC_PPC_B26
:
3035 reloc
= BFD_RELOC_PPC_BA26
;
3037 case BFD_RELOC_PPC_B16
:
3038 reloc
= BFD_RELOC_PPC_BA16
;
3040 case BFD_RELOC_PPC_B16_BRTAKEN
:
3041 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3043 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3044 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3053 case BFD_RELOC_PPC_TOC16
:
3054 toc_reloc_types
|= has_small_toc_reloc
;
3056 case BFD_RELOC_PPC64_TOC16_LO
:
3057 case BFD_RELOC_PPC64_TOC16_HI
:
3058 case BFD_RELOC_PPC64_TOC16_HA
:
3059 toc_reloc_types
|= has_large_toc_reloc
;
3065 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3070 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3072 case BFD_RELOC_LO16
:
3073 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3075 case BFD_RELOC_16_GOTOFF
:
3076 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3078 case BFD_RELOC_LO16_GOTOFF
:
3079 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3081 case BFD_RELOC_LO16_PLTOFF
:
3082 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3084 case BFD_RELOC_16_BASEREL
:
3085 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3087 case BFD_RELOC_LO16_BASEREL
:
3088 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3090 case BFD_RELOC_PPC_TOC16
:
3091 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3093 case BFD_RELOC_PPC64_TOC16_LO
:
3094 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3096 case BFD_RELOC_PPC64_PLTGOT16
:
3097 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3099 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3100 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3102 case BFD_RELOC_PPC_DTPREL16
:
3103 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3105 case BFD_RELOC_PPC_DTPREL16_LO
:
3106 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3108 case BFD_RELOC_PPC_TPREL16
:
3109 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3111 case BFD_RELOC_PPC_TPREL16_LO
:
3112 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3114 case BFD_RELOC_PPC_GOT_DTPREL16
:
3115 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3116 case BFD_RELOC_PPC_GOT_TPREL16
:
3117 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3120 as_bad (_("unsupported relocation for DS offset field"));
3126 /* We need to generate a fixup for this expression. */
3127 if (fc
>= MAX_INSN_FIXUPS
)
3128 as_fatal (_("too many fixups"));
3129 fixups
[fc
].exp
= ex
;
3130 fixups
[fc
].opindex
= *opindex_ptr
;
3131 fixups
[fc
].reloc
= reloc
;
3137 /* We need to generate a fixup for this expression. */
3138 if (fc
>= MAX_INSN_FIXUPS
)
3139 as_fatal (_("too many fixups"));
3140 fixups
[fc
].exp
= ex
;
3141 fixups
[fc
].opindex
= *opindex_ptr
;
3142 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
3145 #endif /* OBJ_ELF */
3151 /* If expecting more operands, then we want to see "),". */
3152 if (*str
== endc
&& opindex_ptr
[1] != 0)
3156 while (ISSPACE (*str
));
3160 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3168 /* The call to expression should have advanced str past any
3171 && (endc
!= ',' || *str
!= '\0'))
3174 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3176 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3184 while (ISSPACE (*str
))
3188 as_bad (_("junk at end of line: `%s'"), str
);
3191 /* Do we need/want an APUinfo section? */
3192 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0)
3194 /* These are all version "1". */
3195 if (opcode
->flags
& PPC_OPCODE_SPE
)
3196 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3197 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3198 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3199 if (opcode
->flags
& PPC_OPCODE_EFS
)
3200 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3201 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3202 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3203 if (opcode
->flags
& PPC_OPCODE_PMR
)
3204 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3205 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3206 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3207 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3208 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3209 if (opcode
->flags
& PPC_OPCODE_VLE
)
3210 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3214 /* Write out the instruction. */
3215 /* Differentiate between two and four byte insns. */
3216 if (ppc_mach () == bfd_mach_ppc_vle
)
3218 if (PPC_OP_SE_VLE (insn
))
3222 addr_mod
= frag_now_fix () & 1;
3227 addr_mod
= frag_now_fix () & 3;
3229 /* All instructions can start on a 2 byte boundary for VLE. */
3230 f
= frag_more (insn_length
);
3231 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3233 if (ppc_mach() == bfd_mach_ppc_vle
)
3234 as_bad (_("instruction address is not a multiple of 2"));
3236 as_bad (_("instruction address is not a multiple of 4"));
3238 frag_now
->insn_addr
= addr_mod
;
3239 frag_now
->has_code
= 1;
3240 md_number_to_chars (f
, insn
, insn_length
);
3243 dwarf2_emit_insn (insn_length
);
3246 /* Create any fixups. At this point we do not use a
3247 bfd_reloc_code_real_type, but instead just use the
3248 BFD_RELOC_UNUSED plus the operand index. This lets us easily
3249 handle fixups for any operand type, although that is admittedly
3250 not a very exciting feature. We pick a BFD reloc type in
3252 for (i
= 0; i
< fc
; i
++)
3254 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3256 reloc_howto_type
*reloc_howto
;
3261 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3265 size
= bfd_get_reloc_size (reloc_howto
);
3266 offset
= target_big_endian
? (4 - size
) : 0;
3268 if (size
< 1 || size
> 4)
3271 fixP
= fix_new_exp (frag_now
,
3272 f
- frag_now
->fr_literal
+ offset
,
3275 reloc_howto
->pc_relative
,
3278 /* Turn off complaints that the addend is too large for things like
3280 switch (fixups
[i
].reloc
)
3282 case BFD_RELOC_16_GOTOFF
:
3283 case BFD_RELOC_PPC_TOC16
:
3284 case BFD_RELOC_LO16
:
3285 case BFD_RELOC_HI16
:
3286 case BFD_RELOC_HI16_S
:
3287 case BFD_RELOC_PPC_VLE_LO16A
:
3288 case BFD_RELOC_PPC_VLE_LO16D
:
3289 case BFD_RELOC_PPC_VLE_HI16A
:
3290 case BFD_RELOC_PPC_VLE_HI16D
:
3291 case BFD_RELOC_PPC_VLE_HA16A
:
3292 case BFD_RELOC_PPC_VLE_HA16D
:
3294 case BFD_RELOC_PPC64_HIGHER
:
3295 case BFD_RELOC_PPC64_HIGHER_S
:
3296 case BFD_RELOC_PPC64_HIGHEST
:
3297 case BFD_RELOC_PPC64_HIGHEST_S
:
3299 fixP
->fx_no_overflow
= 1;
3307 const struct powerpc_operand
*operand
;
3309 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3310 fix_new_exp (frag_now
,
3311 f
- frag_now
->fr_literal
,
3314 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3315 ((bfd_reloc_code_real_type
)
3316 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
3321 /* Handle a macro. Gather all the operands, transform them as
3322 described by the macro, and call md_assemble recursively. All the
3323 operands are separated by commas; we don't accept parentheses
3324 around operands here. */
3327 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3338 /* Gather the users operands into the operands array. */
3343 if (count
>= sizeof operands
/ sizeof operands
[0])
3345 operands
[count
++] = s
;
3346 s
= strchr (s
, ',');
3347 if (s
== (char *) NULL
)
3352 if (count
!= macro
->operands
)
3354 as_bad (_("wrong number of operands"));
3358 /* Work out how large the string must be (the size is unbounded
3359 because it includes user input). */
3361 format
= macro
->format
;
3362 while (*format
!= '\0')
3371 arg
= strtol (format
+ 1, &send
, 10);
3372 know (send
!= format
&& arg
< count
);
3373 len
+= strlen (operands
[arg
]);
3378 /* Put the string together. */
3379 complete
= s
= (char *) alloca (len
+ 1);
3380 format
= macro
->format
;
3381 while (*format
!= '\0')
3387 arg
= strtol (format
+ 1, &send
, 10);
3388 strcpy (s
, operands
[arg
]);
3395 /* Assemble the constructed instruction. */
3396 md_assemble (complete
);
3400 /* For ELF, add support for SHT_ORDERED. */
3403 ppc_section_type (char *str
, size_t len
)
3405 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3412 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3414 if (type
== SHT_ORDERED
)
3415 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3419 #endif /* OBJ_ELF */
3422 /* Pseudo-op handling. */
3424 /* The .byte pseudo-op. This is similar to the normal .byte
3425 pseudo-op, but it can also take a single ASCII string. */
3428 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3430 if (*input_line_pointer
!= '\"')
3436 /* Gather characters. A real double quote is doubled. Unusual
3437 characters are not permitted. */
3438 ++input_line_pointer
;
3443 c
= *input_line_pointer
++;
3447 if (*input_line_pointer
!= '\"')
3449 ++input_line_pointer
;
3452 FRAG_APPEND_1_CHAR (c
);
3455 demand_empty_rest_of_line ();
3460 /* XCOFF specific pseudo-op handling. */
3462 /* This is set if we are creating a .stabx symbol, since we don't want
3463 to handle symbol suffixes for such symbols. */
3464 static bfd_boolean ppc_stab_symbol
;
3466 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3467 symbols in the .bss segment as though they were local common
3468 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3469 aligns .comm and .lcomm to 4 bytes. */
3472 ppc_comm (int lcomm
)
3474 asection
*current_seg
= now_seg
;
3475 subsegT current_subseg
= now_subseg
;
3481 symbolS
*lcomm_sym
= NULL
;
3485 name
= input_line_pointer
;
3486 endc
= get_symbol_end ();
3487 end_name
= input_line_pointer
;
3490 if (*input_line_pointer
!= ',')
3492 as_bad (_("missing size"));
3493 ignore_rest_of_line ();
3496 ++input_line_pointer
;
3498 size
= get_absolute_expression ();
3501 as_bad (_("negative size"));
3502 ignore_rest_of_line ();
3508 /* The third argument to .comm is the alignment. */
3509 if (*input_line_pointer
!= ',')
3513 ++input_line_pointer
;
3514 align
= get_absolute_expression ();
3517 as_warn (_("ignoring bad alignment"));
3532 /* The third argument to .lcomm appears to be the real local
3533 common symbol to create. References to the symbol named in
3534 the first argument are turned into references to the third
3536 if (*input_line_pointer
!= ',')
3538 as_bad (_("missing real symbol name"));
3539 ignore_rest_of_line ();
3542 ++input_line_pointer
;
3544 lcomm_name
= input_line_pointer
;
3545 lcomm_endc
= get_symbol_end ();
3547 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3549 *input_line_pointer
= lcomm_endc
;
3553 sym
= symbol_find_or_make (name
);
3556 if (S_IS_DEFINED (sym
)
3557 || S_GET_VALUE (sym
) != 0)
3559 as_bad (_("attempt to redefine symbol"));
3560 ignore_rest_of_line ();
3564 record_alignment (bss_section
, align
);
3567 || ! S_IS_DEFINED (lcomm_sym
))
3576 S_SET_EXTERNAL (sym
);
3580 symbol_get_tc (lcomm_sym
)->output
= 1;
3581 def_sym
= lcomm_sym
;
3585 subseg_set (bss_section
, 1);
3586 frag_align (align
, 0, 0);
3588 symbol_set_frag (def_sym
, frag_now
);
3589 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3590 def_size
, (char *) NULL
);
3592 S_SET_SEGMENT (def_sym
, bss_section
);
3593 symbol_get_tc (def_sym
)->align
= align
;
3597 /* Align the size of lcomm_sym. */
3598 symbol_get_frag (lcomm_sym
)->fr_offset
=
3599 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3600 &~ ((1 << align
) - 1));
3601 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3602 symbol_get_tc (lcomm_sym
)->align
= align
;
3607 /* Make sym an offset from lcomm_sym. */
3608 S_SET_SEGMENT (sym
, bss_section
);
3609 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3610 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3611 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3614 subseg_set (current_seg
, current_subseg
);
3616 demand_empty_rest_of_line ();
3619 /* The .csect pseudo-op. This switches us into a different
3620 subsegment. The first argument is a symbol whose value is the
3621 start of the .csect. In COFF, csect symbols get special aux
3622 entries defined by the x_csect field of union internal_auxent. The
3623 optional second argument is the alignment (the default is 2). */
3626 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3633 name
= input_line_pointer
;
3634 endc
= get_symbol_end ();
3636 sym
= symbol_find_or_make (name
);
3638 *input_line_pointer
= endc
;
3640 if (S_GET_NAME (sym
)[0] == '\0')
3642 /* An unnamed csect is assumed to be [PR]. */
3643 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3647 if (*input_line_pointer
== ',')
3649 ++input_line_pointer
;
3650 align
= get_absolute_expression ();
3653 ppc_change_csect (sym
, align
);
3655 demand_empty_rest_of_line ();
3658 /* Change to a different csect. */
3661 ppc_change_csect (symbolS
*sym
, offsetT align
)
3663 if (S_IS_DEFINED (sym
))
3664 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3674 /* This is a new csect. We need to look at the symbol class to
3675 figure out whether it should go in the text section or the
3679 switch (symbol_get_tc (sym
)->symbol_class
)
3689 S_SET_SEGMENT (sym
, text_section
);
3690 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3691 ++ppc_text_subsegment
;
3692 list_ptr
= &ppc_text_csects
;
3702 if (ppc_toc_csect
!= NULL
3703 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3704 == ppc_data_subsegment
))
3706 S_SET_SEGMENT (sym
, data_section
);
3707 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3708 ++ppc_data_subsegment
;
3709 list_ptr
= &ppc_data_csects
;
3715 /* We set the obstack chunk size to a small value before
3716 changing subsegments, so that we don't use a lot of memory
3717 space for what may be a small section. */
3718 hold_chunksize
= chunksize
;
3721 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3722 symbol_get_tc (sym
)->subseg
);
3724 chunksize
= hold_chunksize
;
3727 ppc_after_toc_frag
= frag_now
;
3729 record_alignment (sec
, align
);
3731 frag_align_code (align
, 0);
3733 frag_align (align
, 0, 0);
3735 symbol_set_frag (sym
, frag_now
);
3736 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3738 symbol_get_tc (sym
)->align
= align
;
3739 symbol_get_tc (sym
)->output
= 1;
3740 symbol_get_tc (sym
)->within
= sym
;
3742 for (list
= *list_ptr
;
3743 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3744 list
= symbol_get_tc (list
)->next
)
3746 symbol_get_tc (list
)->next
= sym
;
3748 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3749 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3753 ppc_current_csect
= sym
;
3757 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3761 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3763 sec
= subseg_new (dw
->name
, subseg
);
3764 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3765 if (oldflags
== SEC_NO_FLAGS
)
3767 /* Just created section. */
3768 gas_assert (dw_sections
[idx
].sect
== NULL
);
3770 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3771 bfd_set_section_alignment (stdoutput
, sec
, 0);
3772 dw_sections
[idx
].sect
= sec
;
3775 /* Not anymore in a csect. */
3776 ppc_current_csect
= NULL
;
3779 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3780 .dwsect flag [, opt-label ]
3784 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3788 const struct xcoff_dwsect_name
*dw
;
3789 struct dw_subsection
*subseg
;
3790 struct dw_section
*dws
;
3794 flag
= get_absolute_expression ();
3796 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3797 if (xcoff_dwsect_names
[i
].flag
== flag
)
3799 dw
= &xcoff_dwsect_names
[i
];
3803 /* Parse opt-label. */
3804 if (*input_line_pointer
== ',')
3809 ++input_line_pointer
;
3811 label
= input_line_pointer
;
3812 c
= get_symbol_end ();
3813 opt_label
= symbol_find_or_make (label
);
3814 *input_line_pointer
= c
;
3819 demand_empty_rest_of_line ();
3821 /* Return now in case of unknown subsection. */
3824 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3829 /* Find the subsection. */
3830 dws
= &dw_sections
[i
];
3832 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3834 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3835 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3837 as_bad (_("label %s was not defined in this dwarf section"),
3838 S_GET_NAME (opt_label
));
3839 subseg
= dws
->anon_subseg
;
3843 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3848 /* Switch to the subsection. */
3849 ppc_change_debug_section (i
, subseg
->subseg
);
3853 /* Create a new dw subsection. */
3854 subseg
= (struct dw_subsection
*)
3855 xmalloc (sizeof (struct dw_subsection
));
3857 if (opt_label
== NULL
)
3859 /* The anonymous one. */
3861 subseg
->link
= NULL
;
3862 dws
->anon_subseg
= subseg
;
3867 if (dws
->list_subseg
!= NULL
)
3868 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3872 subseg
->link
= dws
->list_subseg
;
3873 dws
->list_subseg
= subseg
;
3874 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3877 ppc_change_debug_section (i
, subseg
->subseg
);
3881 /* Add the length field. */
3882 expressionS
*exp
= &subseg
->end_exp
;
3885 if (opt_label
!= NULL
)
3886 symbol_set_value_now (opt_label
);
3888 /* Add the length field. Note that according to the AIX assembler
3889 manual, the size of the length field is 4 for powerpc32 but
3890 12 for powerpc64. */
3893 /* Write the 64bit marker. */
3894 md_number_to_chars (frag_more (4), -1, 4);
3897 exp
->X_op
= O_subtract
;
3898 exp
->X_op_symbol
= symbol_temp_new_now ();
3899 exp
->X_add_symbol
= symbol_temp_make ();
3901 sz
= ppc_obj64
? 8 : 4;
3902 exp
->X_add_number
= -sz
;
3903 emit_expr (exp
, sz
);
3908 /* This function handles the .text and .data pseudo-ops. These
3909 pseudo-ops aren't really used by XCOFF; we implement them for the
3910 convenience of people who aren't used to XCOFF. */
3913 ppc_section (int type
)
3920 else if (type
== 'd')
3925 sym
= symbol_find_or_make (name
);
3927 ppc_change_csect (sym
, 2);
3929 demand_empty_rest_of_line ();
3932 /* This function handles the .section pseudo-op. This is mostly to
3933 give an error, since XCOFF only supports .text, .data and .bss, but
3934 we do permit the user to name the text or data section. */
3937 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3940 const char *real_name
;
3944 user_name
= input_line_pointer
;
3945 c
= get_symbol_end ();
3947 if (strcmp (user_name
, ".text") == 0)
3948 real_name
= ".text[PR]";
3949 else if (strcmp (user_name
, ".data") == 0)
3950 real_name
= ".data[RW]";
3953 as_bad (_("the XCOFF file format does not support arbitrary sections"));
3954 *input_line_pointer
= c
;
3955 ignore_rest_of_line ();
3959 *input_line_pointer
= c
;
3961 sym
= symbol_find_or_make (real_name
);
3963 ppc_change_csect (sym
, 2);
3965 demand_empty_rest_of_line ();
3968 /* The .extern pseudo-op. We create an undefined symbol. */
3971 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
3976 name
= input_line_pointer
;
3977 endc
= get_symbol_end ();
3979 (void) symbol_find_or_make (name
);
3981 *input_line_pointer
= endc
;
3983 demand_empty_rest_of_line ();
3986 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3989 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
3995 name
= input_line_pointer
;
3996 endc
= get_symbol_end ();
3998 sym
= symbol_find_or_make (name
);
4000 *input_line_pointer
= endc
;
4002 symbol_get_tc (sym
)->output
= 1;
4004 demand_empty_rest_of_line ();
4007 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4008 relocations at the beginning of the current csect.
4010 (In principle, there's no reason why the relocations _have_ to be at
4011 the beginning. Anywhere in the csect would do. However, inserting
4012 at the beginning is what the native assmebler does, and it helps to
4013 deal with cases where the .ref statements follow the section contents.)
4015 ??? .refs don't work for empty .csects. However, the native assembler
4016 doesn't report an error in this case, and neither yet do we. */
4019 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4024 if (ppc_current_csect
== NULL
)
4026 as_bad (_(".ref outside .csect"));
4027 ignore_rest_of_line ();
4033 name
= input_line_pointer
;
4034 c
= get_symbol_end ();
4036 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4037 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4039 *input_line_pointer
= c
;
4041 c
= *input_line_pointer
;
4044 input_line_pointer
++;
4046 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4048 as_bad (_("missing symbol name"));
4049 ignore_rest_of_line ();
4056 demand_empty_rest_of_line ();
4059 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4060 although I don't know why it bothers. */
4063 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4070 name
= input_line_pointer
;
4071 endc
= get_symbol_end ();
4073 sym
= symbol_find_or_make (name
);
4075 *input_line_pointer
= endc
;
4077 if (*input_line_pointer
!= ',')
4079 as_bad (_("missing rename string"));
4080 ignore_rest_of_line ();
4083 ++input_line_pointer
;
4085 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4087 demand_empty_rest_of_line ();
4090 /* The .stabx pseudo-op. This is similar to a normal .stabs
4091 pseudo-op, but slightly different. A sample is
4092 .stabx "main:F-1",.main,142,0
4093 The first argument is the symbol name to create. The second is the
4094 value, and the third is the storage class. The fourth seems to be
4095 always zero, and I am assuming it is the type. */
4098 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4105 name
= demand_copy_C_string (&len
);
4107 if (*input_line_pointer
!= ',')
4109 as_bad (_("missing value"));
4112 ++input_line_pointer
;
4114 ppc_stab_symbol
= TRUE
;
4115 sym
= symbol_make (name
);
4116 ppc_stab_symbol
= FALSE
;
4118 symbol_get_tc (sym
)->real_name
= name
;
4120 (void) expression (&exp
);
4127 as_bad (_("illegal .stabx expression; zero assumed"));
4128 exp
.X_add_number
= 0;
4131 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4132 symbol_set_frag (sym
, &zero_address_frag
);
4136 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4137 symbol_set_value_expression (sym
, &exp
);
4141 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4142 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4147 /* The value is some complex expression. This will probably
4148 fail at some later point, but this is probably the right
4149 thing to do here. */
4150 symbol_set_value_expression (sym
, &exp
);
4154 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4155 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4157 if (*input_line_pointer
!= ',')
4159 as_bad (_("missing class"));
4162 ++input_line_pointer
;
4164 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4166 if (*input_line_pointer
!= ',')
4168 as_bad (_("missing type"));
4171 ++input_line_pointer
;
4173 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4175 symbol_get_tc (sym
)->output
= 1;
4177 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4182 .stabx "z",arrays_,133,0
4185 .comm arrays_,13768,3
4187 resolve_symbol_value will copy the exp's "within" into sym's when the
4188 offset is 0. Since this seems to be corner case problem,
4189 only do the correction for storage class C_STSYM. A better solution
4190 would be to have the tc field updated in ppc_symbol_new_hook. */
4192 if (exp
.X_op
== O_symbol
)
4194 if (ppc_current_block
== NULL
)
4195 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4197 symbol_get_tc (sym
)->within
= ppc_current_block
;
4198 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4202 if (exp
.X_op
!= O_symbol
4203 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4204 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4205 ppc_frob_label (sym
);
4208 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4209 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4210 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4211 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4214 demand_empty_rest_of_line ();
4217 /* The .function pseudo-op. This takes several arguments. The first
4218 argument seems to be the external name of the symbol. The second
4219 argument seems to be the label for the start of the function. gcc
4220 uses the same name for both. I have no idea what the third and
4221 fourth arguments are meant to be. The optional fifth argument is
4222 an expression for the size of the function. In COFF this symbol
4223 gets an aux entry like that used for a csect. */
4226 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4234 name
= input_line_pointer
;
4235 endc
= get_symbol_end ();
4237 /* Ignore any [PR] suffix. */
4238 name
= ppc_canonicalize_symbol_name (name
);
4239 s
= strchr (name
, '[');
4240 if (s
!= (char *) NULL
4241 && strcmp (s
+ 1, "PR]") == 0)
4244 ext_sym
= symbol_find_or_make (name
);
4246 *input_line_pointer
= endc
;
4248 if (*input_line_pointer
!= ',')
4250 as_bad (_("missing symbol name"));
4251 ignore_rest_of_line ();
4254 ++input_line_pointer
;
4256 name
= input_line_pointer
;
4257 endc
= get_symbol_end ();
4259 lab_sym
= symbol_find_or_make (name
);
4261 *input_line_pointer
= endc
;
4263 if (ext_sym
!= lab_sym
)
4267 exp
.X_op
= O_symbol
;
4268 exp
.X_add_symbol
= lab_sym
;
4269 exp
.X_op_symbol
= NULL
;
4270 exp
.X_add_number
= 0;
4272 symbol_set_value_expression (ext_sym
, &exp
);
4275 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4276 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4277 symbol_get_tc (ext_sym
)->output
= 1;
4279 if (*input_line_pointer
== ',')
4283 /* Ignore the third argument. */
4284 ++input_line_pointer
;
4286 if (*input_line_pointer
== ',')
4288 /* Ignore the fourth argument. */
4289 ++input_line_pointer
;
4291 if (*input_line_pointer
== ',')
4293 /* The fifth argument is the function size. */
4294 ++input_line_pointer
;
4295 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4296 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4297 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4302 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4303 SF_SET_FUNCTION (ext_sym
);
4304 SF_SET_PROCESS (ext_sym
);
4305 coff_add_linesym (ext_sym
);
4307 demand_empty_rest_of_line ();
4310 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4311 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4312 with the correct line number */
4314 static symbolS
*saved_bi_sym
= 0;
4317 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4321 sym
= symbol_make (".bf");
4322 S_SET_SEGMENT (sym
, text_section
);
4323 symbol_set_frag (sym
, frag_now
);
4324 S_SET_VALUE (sym
, frag_now_fix ());
4325 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4327 coff_line_base
= get_absolute_expression ();
4329 S_SET_NUMBER_AUXILIARY (sym
, 1);
4330 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4332 /* Line number for bi. */
4335 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4340 symbol_get_tc (sym
)->output
= 1;
4342 ppc_frob_label (sym
);
4344 demand_empty_rest_of_line ();
4347 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4348 ".ef", except that the line number is absolute, not relative to the
4349 most recent ".bf" symbol. */
4352 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4356 sym
= symbol_make (".ef");
4357 S_SET_SEGMENT (sym
, text_section
);
4358 symbol_set_frag (sym
, frag_now
);
4359 S_SET_VALUE (sym
, frag_now_fix ());
4360 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4361 S_SET_NUMBER_AUXILIARY (sym
, 1);
4362 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4363 symbol_get_tc (sym
)->output
= 1;
4365 ppc_frob_label (sym
);
4367 demand_empty_rest_of_line ();
4370 /* The .bi and .ei pseudo-ops. These take a string argument and
4371 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4372 the symbol list. The value of .bi will be know when the next .bf
4378 static symbolS
*last_biei
;
4385 name
= demand_copy_C_string (&len
);
4387 /* The value of these symbols is actually file offset. Here we set
4388 the value to the index into the line number entries. In
4389 ppc_frob_symbols we set the fix_line field, which will cause BFD
4390 to do the right thing. */
4392 sym
= symbol_make (name
);
4393 /* obj-coff.c currently only handles line numbers correctly in the
4395 S_SET_SEGMENT (sym
, text_section
);
4396 S_SET_VALUE (sym
, coff_n_line_nos
);
4397 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4399 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4400 symbol_get_tc (sym
)->output
= 1;
4408 for (look
= last_biei
? last_biei
: symbol_rootP
;
4409 (look
!= (symbolS
*) NULL
4410 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4411 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4412 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4413 look
= symbol_next (look
))
4415 if (look
!= (symbolS
*) NULL
)
4417 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4418 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4422 demand_empty_rest_of_line ();
4425 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4426 There is one argument, which is a csect symbol. The value of the
4427 .bs symbol is the index of this csect symbol. */
4430 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4437 if (ppc_current_block
!= NULL
)
4438 as_bad (_("nested .bs blocks"));
4440 name
= input_line_pointer
;
4441 endc
= get_symbol_end ();
4443 csect
= symbol_find_or_make (name
);
4445 *input_line_pointer
= endc
;
4447 sym
= symbol_make (".bs");
4448 S_SET_SEGMENT (sym
, now_seg
);
4449 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4450 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4451 symbol_get_tc (sym
)->output
= 1;
4453 symbol_get_tc (sym
)->within
= csect
;
4455 ppc_frob_label (sym
);
4457 ppc_current_block
= sym
;
4459 demand_empty_rest_of_line ();
4462 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4465 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4469 if (ppc_current_block
== NULL
)
4470 as_bad (_(".es without preceding .bs"));
4472 sym
= symbol_make (".es");
4473 S_SET_SEGMENT (sym
, now_seg
);
4474 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4475 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4476 symbol_get_tc (sym
)->output
= 1;
4478 ppc_frob_label (sym
);
4480 ppc_current_block
= NULL
;
4482 demand_empty_rest_of_line ();
4485 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4489 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4493 sym
= symbol_make (".bb");
4494 S_SET_SEGMENT (sym
, text_section
);
4495 symbol_set_frag (sym
, frag_now
);
4496 S_SET_VALUE (sym
, frag_now_fix ());
4497 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4499 S_SET_NUMBER_AUXILIARY (sym
, 1);
4500 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4502 symbol_get_tc (sym
)->output
= 1;
4504 SF_SET_PROCESS (sym
);
4506 ppc_frob_label (sym
);
4508 demand_empty_rest_of_line ();
4511 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4515 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4519 sym
= symbol_make (".eb");
4520 S_SET_SEGMENT (sym
, text_section
);
4521 symbol_set_frag (sym
, frag_now
);
4522 S_SET_VALUE (sym
, frag_now_fix ());
4523 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4524 S_SET_NUMBER_AUXILIARY (sym
, 1);
4525 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4526 symbol_get_tc (sym
)->output
= 1;
4528 SF_SET_PROCESS (sym
);
4530 ppc_frob_label (sym
);
4532 demand_empty_rest_of_line ();
4535 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4539 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4545 name
= demand_copy_C_string (&len
);
4546 sym
= symbol_make (name
);
4547 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4548 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4549 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4550 S_SET_VALUE (sym
, 0);
4551 symbol_get_tc (sym
)->output
= 1;
4553 ppc_frob_label (sym
);
4555 demand_empty_rest_of_line ();
4558 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4561 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4565 sym
= symbol_make (".ec");
4566 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4567 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4568 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4569 S_SET_VALUE (sym
, 0);
4570 symbol_get_tc (sym
)->output
= 1;
4572 ppc_frob_label (sym
);
4574 demand_empty_rest_of_line ();
4577 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4580 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4582 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4583 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4590 subseg
= ppc_data_subsegment
;
4591 ++ppc_data_subsegment
;
4593 subseg_new (segment_name (data_section
), subseg
);
4594 ppc_toc_frag
= frag_now
;
4596 sym
= symbol_find_or_make ("TOC[TC0]");
4597 symbol_set_frag (sym
, frag_now
);
4598 S_SET_SEGMENT (sym
, data_section
);
4599 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4600 symbol_get_tc (sym
)->subseg
= subseg
;
4601 symbol_get_tc (sym
)->output
= 1;
4602 symbol_get_tc (sym
)->within
= sym
;
4604 ppc_toc_csect
= sym
;
4606 for (list
= ppc_data_csects
;
4607 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4608 list
= symbol_get_tc (list
)->next
)
4610 symbol_get_tc (list
)->next
= sym
;
4612 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4613 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4617 ppc_current_csect
= ppc_toc_csect
;
4619 demand_empty_rest_of_line ();
4622 /* The AIX assembler automatically aligns the operands of a .long or
4623 .short pseudo-op, and we want to be compatible. */
4626 ppc_xcoff_cons (int log_size
)
4628 frag_align (log_size
, 0, 0);
4629 record_alignment (now_seg
, log_size
);
4630 cons (1 << log_size
);
4634 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4639 (void) expression (&exp
);
4641 if (exp
.X_op
!= O_constant
)
4643 as_bad (_("non-constant byte count"));
4647 byte_count
= exp
.X_add_number
;
4649 if (*input_line_pointer
!= ',')
4651 as_bad (_("missing value"));
4655 ++input_line_pointer
;
4660 ppc_xcoff_end (void)
4664 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4666 struct dw_section
*dws
= &dw_sections
[i
];
4667 struct dw_subsection
*dwss
;
4669 if (dws
->anon_subseg
)
4671 dwss
= dws
->anon_subseg
;
4672 dwss
->link
= dws
->list_subseg
;
4675 dwss
= dws
->list_subseg
;
4677 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4678 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4680 subseg_set (dws
->sect
, dwss
->subseg
);
4681 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4686 #endif /* OBJ_XCOFF */
4687 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4689 /* The .tc pseudo-op. This is used when generating either XCOFF or
4690 ELF. This takes two or more arguments.
4692 When generating XCOFF output, the first argument is the name to
4693 give to this location in the toc; this will be a symbol with class
4694 TC. The rest of the arguments are N-byte values to actually put at
4695 this location in the TOC; often there is just one more argument, a
4696 relocatable symbol reference. The size of the value to store
4697 depends on target word size. A 32-bit target uses 4-byte values, a
4698 64-bit target uses 8-byte values.
4700 When not generating XCOFF output, the arguments are the same, but
4701 the first argument is simply ignored. */
4704 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4708 /* Define the TOC symbol name. */
4714 if (ppc_toc_csect
== (symbolS
*) NULL
4715 || ppc_toc_csect
!= ppc_current_csect
)
4717 as_bad (_(".tc not in .toc section"));
4718 ignore_rest_of_line ();
4722 name
= input_line_pointer
;
4723 endc
= get_symbol_end ();
4725 sym
= symbol_find_or_make (name
);
4727 *input_line_pointer
= endc
;
4729 if (S_IS_DEFINED (sym
))
4733 label
= symbol_get_tc (ppc_current_csect
)->within
;
4734 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4736 as_bad (_(".tc with no label"));
4737 ignore_rest_of_line ();
4741 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4742 symbol_set_frag (label
, symbol_get_frag (sym
));
4743 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4745 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4746 ++input_line_pointer
;
4751 S_SET_SEGMENT (sym
, now_seg
);
4752 symbol_set_frag (sym
, frag_now
);
4753 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4754 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4755 symbol_get_tc (sym
)->output
= 1;
4757 ppc_frob_label (sym
);
4760 #endif /* OBJ_XCOFF */
4764 /* Skip the TOC symbol name. */
4765 while (is_part_of_name (*input_line_pointer
)
4766 || *input_line_pointer
== ' '
4767 || *input_line_pointer
== '['
4768 || *input_line_pointer
== ']'
4769 || *input_line_pointer
== '{'
4770 || *input_line_pointer
== '}')
4771 ++input_line_pointer
;
4773 /* Align to a four/eight byte boundary. */
4774 align
= ppc_obj64
? 3 : 2;
4775 frag_align (align
, 0, 0);
4776 record_alignment (now_seg
, align
);
4777 #endif /* OBJ_ELF */
4779 if (*input_line_pointer
!= ',')
4780 demand_empty_rest_of_line ();
4783 ++input_line_pointer
;
4784 cons (ppc_obj64
? 8 : 4);
4788 /* Pseudo-op .machine. */
4791 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4794 #define MAX_HISTORY 100
4795 static ppc_cpu_t
*cpu_history
;
4796 static int curr_hist
;
4800 if (*input_line_pointer
== '"')
4803 cpu_string
= demand_copy_C_string (&len
);
4808 cpu_string
= input_line_pointer
;
4809 c
= get_symbol_end ();
4810 cpu_string
= xstrdup (cpu_string
);
4811 *input_line_pointer
= c
;
4814 if (cpu_string
!= NULL
)
4816 ppc_cpu_t old_cpu
= ppc_cpu
;
4820 for (p
= cpu_string
; *p
!= 0; p
++)
4823 if (strcmp (cpu_string
, "push") == 0)
4825 if (cpu_history
== NULL
)
4826 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4828 if (curr_hist
>= MAX_HISTORY
)
4829 as_bad (_(".machine stack overflow"));
4831 cpu_history
[curr_hist
++] = ppc_cpu
;
4833 else if (strcmp (cpu_string
, "pop") == 0)
4836 as_bad (_(".machine stack underflow"));
4838 ppc_cpu
= cpu_history
[--curr_hist
];
4840 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, cpu_string
)) != 0)
4843 as_bad (_("invalid machine `%s'"), cpu_string
);
4845 if (ppc_cpu
!= old_cpu
)
4846 ppc_setup_opcodes ();
4849 demand_empty_rest_of_line ();
4852 /* See whether a symbol is in the TOC section. */
4855 ppc_is_toc_sym (symbolS
*sym
)
4858 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
4861 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4863 return strcmp (sname
, ".toc") == 0;
4865 return strcmp (sname
, ".got") == 0;
4868 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4872 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4874 /* Set the current section. */
4876 ppc_set_current_section (segT
new)
4878 ppc_previous_section
= ppc_current_section
;
4879 ppc_current_section
= new;
4882 /* pseudo-op: .previous
4883 behaviour: toggles the current section with the previous section.
4885 warnings: "No previous section" */
4888 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4892 if (ppc_previous_section
== NULL
)
4894 as_warn (_("no previous section to return to, ignored."));
4898 subseg_set (ppc_previous_section
, 0);
4900 ppc_set_current_section (ppc_previous_section
);
4903 /* pseudo-op: .pdata
4904 behaviour: predefined read only data section
4908 initial: .section .pdata "adr3"
4909 a - don't know -- maybe a misprint
4910 d - initialized data
4912 3 - double word aligned (that would be 4 byte boundary)
4915 Tag index tables (also known as the function table) for exception
4916 handling, debugging, etc. */
4919 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4921 if (pdata_section
== 0)
4923 pdata_section
= subseg_new (".pdata", 0);
4925 bfd_set_section_flags (stdoutput
, pdata_section
,
4926 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4927 | SEC_READONLY
| SEC_DATA
));
4929 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4933 pdata_section
= subseg_new (".pdata", 0);
4935 ppc_set_current_section (pdata_section
);
4938 /* pseudo-op: .ydata
4939 behaviour: predefined read only data section
4943 initial: .section .ydata "drw3"
4944 a - don't know -- maybe a misprint
4945 d - initialized data
4947 3 - double word aligned (that would be 4 byte boundary)
4949 Tag tables (also known as the scope table) for exception handling,
4953 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4955 if (ydata_section
== 0)
4957 ydata_section
= subseg_new (".ydata", 0);
4958 bfd_set_section_flags (stdoutput
, ydata_section
,
4959 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4960 | SEC_READONLY
| SEC_DATA
));
4962 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4966 ydata_section
= subseg_new (".ydata", 0);
4968 ppc_set_current_section (ydata_section
);
4971 /* pseudo-op: .reldata
4972 behaviour: predefined read write data section
4973 double word aligned (4-byte)
4974 FIXME: relocation is applied to it
4975 FIXME: what's the difference between this and .data?
4978 initial: .section .reldata "drw3"
4979 d - initialized data
4982 3 - double word aligned (that would be 8 byte boundary)
4985 Like .data, but intended to hold data subject to relocation, such as
4986 function descriptors, etc. */
4989 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
4991 if (reldata_section
== 0)
4993 reldata_section
= subseg_new (".reldata", 0);
4995 bfd_set_section_flags (stdoutput
, reldata_section
,
4996 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4999 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5003 reldata_section
= subseg_new (".reldata", 0);
5005 ppc_set_current_section (reldata_section
);
5008 /* pseudo-op: .rdata
5009 behaviour: predefined read only data section
5013 initial: .section .rdata "dr3"
5014 d - initialized data
5016 3 - double word aligned (that would be 4 byte boundary) */
5019 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5021 if (rdata_section
== 0)
5023 rdata_section
= subseg_new (".rdata", 0);
5024 bfd_set_section_flags (stdoutput
, rdata_section
,
5025 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5026 | SEC_READONLY
| SEC_DATA
));
5028 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5032 rdata_section
= subseg_new (".rdata", 0);
5034 ppc_set_current_section (rdata_section
);
5037 /* pseudo-op: .ualong
5038 behaviour: much like .int, with the exception that no alignment is
5040 FIXME: test the alignment statement
5045 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5051 /* pseudo-op: .znop <symbol name>
5052 behaviour: Issue a nop instruction
5053 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5054 the supplied symbol name.
5056 warnings: Missing symbol name */
5059 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5062 const struct powerpc_opcode
*opcode
;
5073 /* Strip out the symbol name. */
5074 symbol_name
= input_line_pointer
;
5075 c
= get_symbol_end ();
5077 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5078 strcpy (name
, symbol_name
);
5080 sym
= symbol_find_or_make (name
);
5082 *input_line_pointer
= c
;
5086 /* Look up the opcode in the hash table. */
5087 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5089 /* Stick in the nop. */
5090 insn
= opcode
->opcode
;
5092 /* Write out the instruction. */
5094 md_number_to_chars (f
, insn
, 4);
5096 f
- frag_now
->fr_literal
,
5101 BFD_RELOC_16_GOT_PCREL
);
5111 ppc_pe_comm (int lcomm
)
5120 name
= input_line_pointer
;
5121 c
= get_symbol_end ();
5123 /* just after name is now '\0'. */
5124 p
= input_line_pointer
;
5127 if (*input_line_pointer
!= ',')
5129 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5130 ignore_rest_of_line ();
5134 input_line_pointer
++; /* skip ',' */
5135 if ((temp
= get_absolute_expression ()) < 0)
5137 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5138 ignore_rest_of_line ();
5144 /* The third argument to .comm is the alignment. */
5145 if (*input_line_pointer
!= ',')
5149 ++input_line_pointer
;
5150 align
= get_absolute_expression ();
5153 as_warn (_("ignoring bad alignment"));
5160 symbolP
= symbol_find_or_make (name
);
5163 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5165 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5166 S_GET_NAME (symbolP
));
5167 ignore_rest_of_line ();
5171 if (S_GET_VALUE (symbolP
))
5173 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5174 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5175 S_GET_NAME (symbolP
),
5176 (long) S_GET_VALUE (symbolP
),
5181 S_SET_VALUE (symbolP
, (valueT
) temp
);
5182 S_SET_EXTERNAL (symbolP
);
5183 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5186 demand_empty_rest_of_line ();
5190 * implement the .section pseudo op:
5191 * .section name {, "flags"}
5193 * | +--- optional flags: 'b' for bss
5195 * +-- section name 'l' for lib
5199 * 'd' (apparently m88k for data)
5201 * But if the argument is not a quoted string, treat it as a
5202 * subsegment number.
5204 * FIXME: this is a copy of the section processing from obj-coff.c, with
5205 * additions/changes for the moto-pas assembler support. There are three
5208 * FIXME: I just noticed this. This doesn't work at all really. It it
5209 * setting bits that bfd probably neither understands or uses. The
5210 * correct approach (?) will have to incorporate extra fields attached
5211 * to the section to hold the system specific stuff. (krk)
5214 * 'a' - unknown - referred to in documentation, but no definition supplied
5215 * 'c' - section has code
5216 * 'd' - section has initialized data
5217 * 'u' - section has uninitialized data
5218 * 'i' - section contains directives (info)
5219 * 'n' - section can be discarded
5220 * 'R' - remove section at link time
5222 * Section Protection:
5223 * 'r' - section is readable
5224 * 'w' - section is writeable
5225 * 'x' - section is executable
5226 * 's' - section is sharable
5228 * Section Alignment:
5229 * '0' - align to byte boundary
5230 * '1' - align to halfword undary
5231 * '2' - align to word boundary
5232 * '3' - align to doubleword boundary
5233 * '4' - align to quadword boundary
5234 * '5' - align to 32 byte boundary
5235 * '6' - align to 64 byte boundary
5240 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5242 /* Strip out the section name. */
5251 section_name
= input_line_pointer
;
5252 c
= get_symbol_end ();
5254 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5255 strcpy (name
, section_name
);
5257 *input_line_pointer
= c
;
5262 flags
= SEC_NO_FLAGS
;
5264 if (strcmp (name
, ".idata$2") == 0)
5268 else if (strcmp (name
, ".idata$3") == 0)
5272 else if (strcmp (name
, ".idata$4") == 0)
5276 else if (strcmp (name
, ".idata$5") == 0)
5280 else if (strcmp (name
, ".idata$6") == 0)
5285 /* Default alignment to 16 byte boundary. */
5288 if (*input_line_pointer
== ',')
5290 ++input_line_pointer
;
5292 if (*input_line_pointer
!= '"')
5293 exp
= get_absolute_expression ();
5296 ++input_line_pointer
;
5297 while (*input_line_pointer
!= '"'
5298 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5300 switch (*input_line_pointer
)
5302 /* Section Contents */
5303 case 'a': /* unknown */
5304 as_bad (_("unsupported section attribute -- 'a'"));
5306 case 'c': /* code section */
5309 case 'd': /* section has initialized data */
5312 case 'u': /* section has uninitialized data */
5313 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5317 case 'i': /* section contains directives (info) */
5318 /* FIXME: This is IMAGE_SCN_LNK_INFO
5320 flags
|= SEC_HAS_CONTENTS
;
5322 case 'n': /* section can be discarded */
5325 case 'R': /* Remove section at link time */
5326 flags
|= SEC_NEVER_LOAD
;
5328 #if IFLICT_BRAIN_DAMAGE
5329 /* Section Protection */
5330 case 'r': /* section is readable */
5331 flags
|= IMAGE_SCN_MEM_READ
;
5333 case 'w': /* section is writeable */
5334 flags
|= IMAGE_SCN_MEM_WRITE
;
5336 case 'x': /* section is executable */
5337 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5339 case 's': /* section is sharable */
5340 flags
|= IMAGE_SCN_MEM_SHARED
;
5343 /* Section Alignment */
5344 case '0': /* align to byte boundary */
5345 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5348 case '1': /* align to halfword boundary */
5349 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5352 case '2': /* align to word boundary */
5353 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5356 case '3': /* align to doubleword boundary */
5357 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5360 case '4': /* align to quadword boundary */
5361 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5364 case '5': /* align to 32 byte boundary */
5365 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5368 case '6': /* align to 64 byte boundary */
5369 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5374 as_bad (_("unknown section attribute '%c'"),
5375 *input_line_pointer
);
5378 ++input_line_pointer
;
5380 if (*input_line_pointer
== '"')
5381 ++input_line_pointer
;
5385 sec
= subseg_new (name
, (subsegT
) exp
);
5387 ppc_set_current_section (sec
);
5389 if (flags
!= SEC_NO_FLAGS
)
5391 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5392 as_bad (_("error setting flags for \"%s\": %s"),
5393 bfd_section_name (stdoutput
, sec
),
5394 bfd_errmsg (bfd_get_error ()));
5397 bfd_set_section_alignment (stdoutput
, sec
, align
);
5401 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5407 name
= input_line_pointer
;
5408 endc
= get_symbol_end ();
5410 ext_sym
= symbol_find_or_make (name
);
5412 *input_line_pointer
= endc
;
5414 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5415 SF_SET_FUNCTION (ext_sym
);
5416 SF_SET_PROCESS (ext_sym
);
5417 coff_add_linesym (ext_sym
);
5419 demand_empty_rest_of_line ();
5423 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5425 if (tocdata_section
== 0)
5427 tocdata_section
= subseg_new (".tocd", 0);
5428 /* FIXME: section flags won't work. */
5429 bfd_set_section_flags (stdoutput
, tocdata_section
,
5430 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5431 | SEC_READONLY
| SEC_DATA
));
5433 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5437 rdata_section
= subseg_new (".tocd", 0);
5440 ppc_set_current_section (tocdata_section
);
5442 demand_empty_rest_of_line ();
5445 /* Don't adjust TOC relocs to use the section symbol. */
5448 ppc_pe_fix_adjustable (fixS
*fix
)
5450 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5457 /* XCOFF specific symbol and file handling. */
5459 /* Canonicalize the symbol name. We use the to force the suffix, if
5460 any, to use square brackets, and to be in upper case. */
5463 ppc_canonicalize_symbol_name (char *name
)
5467 if (ppc_stab_symbol
)
5470 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5484 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5487 if (*s
== '\0' || s
[1] != '\0')
5488 as_bad (_("bad symbol suffix"));
5496 /* Set the class of a symbol based on the suffix, if any. This is
5497 called whenever a new symbol is created. */
5500 ppc_symbol_new_hook (symbolS
*sym
)
5502 struct ppc_tc_sy
*tc
;
5505 tc
= symbol_get_tc (sym
);
5508 tc
->symbol_class
= -1;
5509 tc
->real_name
= NULL
;
5516 if (ppc_stab_symbol
)
5519 s
= strchr (S_GET_NAME (sym
), '[');
5520 if (s
== (const char *) NULL
)
5522 /* There is no suffix. */
5531 if (strcmp (s
, "BS]") == 0)
5532 tc
->symbol_class
= XMC_BS
;
5535 if (strcmp (s
, "DB]") == 0)
5536 tc
->symbol_class
= XMC_DB
;
5537 else if (strcmp (s
, "DS]") == 0)
5538 tc
->symbol_class
= XMC_DS
;
5541 if (strcmp (s
, "GL]") == 0)
5542 tc
->symbol_class
= XMC_GL
;
5545 if (strcmp (s
, "PR]") == 0)
5546 tc
->symbol_class
= XMC_PR
;
5549 if (strcmp (s
, "RO]") == 0)
5550 tc
->symbol_class
= XMC_RO
;
5551 else if (strcmp (s
, "RW]") == 0)
5552 tc
->symbol_class
= XMC_RW
;
5555 if (strcmp (s
, "SV]") == 0)
5556 tc
->symbol_class
= XMC_SV
;
5559 if (strcmp (s
, "TC]") == 0)
5560 tc
->symbol_class
= XMC_TC
;
5561 else if (strcmp (s
, "TI]") == 0)
5562 tc
->symbol_class
= XMC_TI
;
5563 else if (strcmp (s
, "TB]") == 0)
5564 tc
->symbol_class
= XMC_TB
;
5565 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5566 tc
->symbol_class
= XMC_TC0
;
5569 if (strcmp (s
, "UA]") == 0)
5570 tc
->symbol_class
= XMC_UA
;
5571 else if (strcmp (s
, "UC]") == 0)
5572 tc
->symbol_class
= XMC_UC
;
5575 if (strcmp (s
, "XO]") == 0)
5576 tc
->symbol_class
= XMC_XO
;
5580 if (tc
->symbol_class
== -1)
5581 as_bad (_("unrecognized symbol suffix"));
5584 /* Set the class of a label based on where it is defined. This
5585 handles symbols without suffixes. Also, move the symbol so that it
5586 follows the csect symbol. */
5589 ppc_frob_label (symbolS
*sym
)
5591 if (ppc_current_csect
!= (symbolS
*) NULL
)
5593 if (symbol_get_tc (sym
)->symbol_class
== -1)
5594 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5596 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5597 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5598 &symbol_rootP
, &symbol_lastP
);
5599 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5600 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5604 dwarf2_emit_label (sym
);
5608 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5609 seen. It tells ppc_adjust_symtab whether it needs to look through
5612 static bfd_boolean ppc_saw_abs
;
5614 /* Change the name of a symbol just before writing it out. Set the
5615 real name if the .rename pseudo-op was used. Otherwise, remove any
5616 class suffix. Return 1 if the symbol should not be included in the
5620 ppc_frob_symbol (symbolS
*sym
)
5622 static symbolS
*ppc_last_function
;
5623 static symbolS
*set_end
;
5625 /* Discard symbols that should not be included in the output symbol
5627 if (! symbol_used_in_reloc_p (sym
)
5628 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5629 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5630 && ! symbol_get_tc (sym
)->output
5631 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5634 /* This one will disappear anyway. Don't make a csect sym for it. */
5635 if (sym
== abs_section_sym
)
5638 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5639 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5645 name
= S_GET_NAME (sym
);
5646 s
= strchr (name
, '[');
5647 if (s
!= (char *) NULL
)
5653 snew
= xmalloc (len
+ 1);
5654 memcpy (snew
, name
, len
);
5657 S_SET_NAME (sym
, snew
);
5661 if (set_end
!= (symbolS
*) NULL
)
5663 SA_SET_SYM_ENDNDX (set_end
, sym
);
5667 if (SF_GET_FUNCTION (sym
))
5669 if (ppc_last_function
!= (symbolS
*) NULL
)
5670 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5671 ppc_last_function
= sym
;
5672 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5674 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5675 SA_SET_SYM_FSIZE (sym
,
5676 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5679 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5680 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5682 if (ppc_last_function
== (symbolS
*) NULL
)
5683 as_bad (_(".ef with no preceding .function"));
5686 set_end
= ppc_last_function
;
5687 ppc_last_function
= NULL
;
5689 /* We don't have a C_EFCN symbol, but we need to force the
5690 COFF backend to believe that it has seen one. */
5691 coff_last_function
= NULL
;
5695 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5696 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5697 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5698 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5699 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5700 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5701 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5702 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5703 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5704 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5705 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5707 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5708 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5709 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5712 union internal_auxent
*a
;
5714 /* Create a csect aux. */
5715 i
= S_GET_NUMBER_AUXILIARY (sym
);
5716 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5717 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5718 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5720 /* This is the TOC table. */
5721 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5722 a
->x_csect
.x_scnlen
.l
= 0;
5723 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5725 else if (symbol_get_tc (sym
)->subseg
!= 0)
5727 /* This is a csect symbol. x_scnlen is the size of the
5729 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5730 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5731 S_GET_SEGMENT (sym
))
5732 - S_GET_VALUE (sym
));
5735 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5736 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5737 - S_GET_VALUE (sym
));
5739 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5741 else if (S_GET_SEGMENT (sym
) == bss_section
)
5743 /* This is a common symbol. */
5744 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5745 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5746 if (S_IS_EXTERNAL (sym
))
5747 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5749 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5751 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5753 /* This is an absolute symbol. The csect will be created by
5754 ppc_adjust_symtab. */
5756 a
->x_csect
.x_smtyp
= XTY_LD
;
5757 if (symbol_get_tc (sym
)->symbol_class
== -1)
5758 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5760 else if (! S_IS_DEFINED (sym
))
5762 /* This is an external symbol. */
5763 a
->x_csect
.x_scnlen
.l
= 0;
5764 a
->x_csect
.x_smtyp
= XTY_ER
;
5766 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5770 /* This is a TOC definition. x_scnlen is the size of the
5772 next
= symbol_next (sym
);
5773 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5774 next
= symbol_next (next
);
5775 if (next
== (symbolS
*) NULL
5776 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5778 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5779 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5781 - S_GET_VALUE (sym
));
5783 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5784 - S_GET_VALUE (sym
));
5788 resolve_symbol_value (next
);
5789 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5790 - S_GET_VALUE (sym
));
5792 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5798 /* This is a normal symbol definition. x_scnlen is the
5799 symbol index of the containing csect. */
5800 if (S_GET_SEGMENT (sym
) == text_section
)
5801 csect
= ppc_text_csects
;
5802 else if (S_GET_SEGMENT (sym
) == data_section
)
5803 csect
= ppc_data_csects
;
5807 /* Skip the initial dummy symbol. */
5808 csect
= symbol_get_tc (csect
)->next
;
5810 if (csect
== (symbolS
*) NULL
)
5812 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5813 a
->x_csect
.x_scnlen
.l
= 0;
5817 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5819 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5820 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5821 > S_GET_VALUE (sym
))
5823 csect
= symbol_get_tc (csect
)->next
;
5826 a
->x_csect
.x_scnlen
.p
=
5827 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5828 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5831 a
->x_csect
.x_smtyp
= XTY_LD
;
5834 a
->x_csect
.x_parmhash
= 0;
5835 a
->x_csect
.x_snhash
= 0;
5836 if (symbol_get_tc (sym
)->symbol_class
== -1)
5837 a
->x_csect
.x_smclas
= XMC_PR
;
5839 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5840 a
->x_csect
.x_stab
= 0;
5841 a
->x_csect
.x_snstab
= 0;
5843 /* Don't let the COFF backend resort these symbols. */
5844 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5846 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5848 /* We want the value to be the symbol index of the referenced
5849 csect symbol. BFD will do that for us if we set the right
5851 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5852 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5854 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5855 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5857 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5862 block
= symbol_get_tc (sym
)->within
;
5865 /* The value is the offset from the enclosing csect. */
5868 csect
= symbol_get_tc (block
)->within
;
5869 resolve_symbol_value (csect
);
5870 base
= S_GET_VALUE (csect
);
5875 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5877 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5878 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5880 /* We want the value to be a file offset into the line numbers.
5881 BFD will do that for us if we set the right flags. We have
5882 already set the value correctly. */
5883 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5889 /* Adjust the symbol table. This creates csect symbols for all
5890 absolute symbols. */
5893 ppc_adjust_symtab (void)
5900 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5904 union internal_auxent
*a
;
5906 if (S_GET_SEGMENT (sym
) != absolute_section
)
5909 csect
= symbol_create (".abs[XO]", absolute_section
,
5910 S_GET_VALUE (sym
), &zero_address_frag
);
5911 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5912 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5913 i
= S_GET_NUMBER_AUXILIARY (csect
);
5914 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5915 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5916 a
->x_csect
.x_scnlen
.l
= 0;
5917 a
->x_csect
.x_smtyp
= XTY_SD
;
5918 a
->x_csect
.x_parmhash
= 0;
5919 a
->x_csect
.x_snhash
= 0;
5920 a
->x_csect
.x_smclas
= XMC_XO
;
5921 a
->x_csect
.x_stab
= 0;
5922 a
->x_csect
.x_snstab
= 0;
5924 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5926 i
= S_GET_NUMBER_AUXILIARY (sym
);
5927 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5928 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5929 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5932 ppc_saw_abs
= FALSE
;
5935 /* Set the VMA for a section. This is called on all the sections in
5939 ppc_frob_section (asection
*sec
)
5941 static bfd_vma vma
= 0;
5943 /* Dwarf sections start at 0. */
5944 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5947 vma
= md_section_align (sec
, vma
);
5948 bfd_set_section_vma (stdoutput
, sec
, vma
);
5949 vma
+= bfd_section_size (stdoutput
, sec
);
5952 #endif /* OBJ_XCOFF */
5955 md_atof (int type
, char *litp
, int *sizep
)
5957 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5960 /* Write a value out to the object file, using the appropriate
5964 md_number_to_chars (char *buf
, valueT val
, int n
)
5966 if (target_big_endian
)
5967 number_to_chars_bigendian (buf
, val
, n
);
5969 number_to_chars_littleendian (buf
, val
, n
);
5972 /* Align a section (I don't know why this is machine dependent). */
5975 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5980 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5982 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5986 /* We don't have any form of relaxing. */
5989 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5990 asection
*seg ATTRIBUTE_UNUSED
)
5996 /* Convert a machine dependent frag. We never generate these. */
5999 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6000 asection
*sec ATTRIBUTE_UNUSED
,
6001 fragS
*fragp ATTRIBUTE_UNUSED
)
6006 /* We have no need to default values of symbols. */
6009 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6014 /* Functions concerning relocs. */
6016 /* The location from which a PC relative jump should be calculated,
6017 given a PC relative reloc. */
6020 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6022 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6027 /* This is called to see whether a fixup should be adjusted to use a
6028 section symbol. We take the opportunity to change a fixup against
6029 a symbol in the TOC subsegment into a reloc against the
6030 corresponding .tc symbol. */
6033 ppc_fix_adjustable (fixS
*fix
)
6035 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6036 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6037 TC_SYMFIELD_TYPE
*tc
;
6039 if (symseg
== absolute_section
)
6042 /* Always adjust symbols in debugging sections. */
6043 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6046 if (ppc_toc_csect
!= (symbolS
*) NULL
6047 && fix
->fx_addsy
!= ppc_toc_csect
6048 && symseg
== data_section
6049 && val
>= ppc_toc_frag
->fr_address
6050 && (ppc_after_toc_frag
== (fragS
*) NULL
6051 || val
< ppc_after_toc_frag
->fr_address
))
6055 for (sy
= symbol_next (ppc_toc_csect
);
6056 sy
!= (symbolS
*) NULL
;
6057 sy
= symbol_next (sy
))
6059 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6061 if (sy_tc
->symbol_class
== XMC_TC0
)
6063 if (sy_tc
->symbol_class
!= XMC_TC
)
6065 if (val
== resolve_symbol_value (sy
))
6068 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6073 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6074 _("symbol in .toc does not match any .tc"));
6077 /* Possibly adjust the reloc to be against the csect. */
6078 tc
= symbol_get_tc (fix
->fx_addsy
);
6080 && tc
->symbol_class
!= XMC_TC0
6081 && tc
->symbol_class
!= XMC_TC
6082 && symseg
!= bss_section
6083 /* Don't adjust if this is a reloc in the toc section. */
6084 && (symseg
!= data_section
6085 || ppc_toc_csect
== NULL
6086 || val
< ppc_toc_frag
->fr_address
6087 || (ppc_after_toc_frag
!= NULL
6088 && val
>= ppc_after_toc_frag
->fr_address
)))
6090 symbolS
*csect
= tc
->within
;
6092 /* If the symbol was not declared by a label (eg: a section symbol),
6093 use the section instead of the csect. This doesn't happen in
6094 normal AIX assembly code. */
6096 csect
= seg_info (symseg
)->sym
;
6098 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6099 fix
->fx_addsy
= csect
;
6104 /* Adjust a reloc against a .lcomm symbol to be against the base
6106 if (symseg
== bss_section
6107 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6109 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6111 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6118 /* A reloc from one csect to another must be kept. The assembler
6119 will, of course, keep relocs between sections, and it will keep
6120 absolute relocs, but we need to force it to keep PC relative relocs
6121 between two csects in the same section. */
6124 ppc_force_relocation (fixS
*fix
)
6126 /* At this point fix->fx_addsy should already have been converted to
6127 a csect symbol. If the csect does not include the fragment, then
6128 we need to force the relocation. */
6130 && fix
->fx_addsy
!= NULL
6131 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6132 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6133 > fix
->fx_frag
->fr_address
)
6134 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6135 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6136 <= fix
->fx_frag
->fr_address
))))
6139 return generic_force_reloc (fix
);
6143 ppc_new_dot_label (symbolS
*sym
)
6145 /* Anchor this label to the current csect for relocations. */
6146 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6149 #endif /* OBJ_XCOFF */
6152 /* If this function returns non-zero, it guarantees that a relocation
6153 will be emitted for a fixup. */
6156 ppc_force_relocation (fixS
*fix
)
6158 /* Branch prediction relocations must force a relocation, as must
6159 the vtable description relocs. */
6160 switch (fix
->fx_r_type
)
6162 case BFD_RELOC_PPC_B16_BRTAKEN
:
6163 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6164 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6165 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6166 case BFD_RELOC_24_PLT_PCREL
:
6167 case BFD_RELOC_PPC64_TOC
:
6173 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6174 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6177 return generic_force_reloc (fix
);
6181 ppc_fix_adjustable (fixS
*fix
)
6183 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6184 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6185 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6186 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6187 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6188 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6189 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6190 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6191 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6192 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6193 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6198 ppc_frag_check (struct frag
*fragP
)
6200 if (!fragP
->has_code
)
6203 if (ppc_mach() == bfd_mach_ppc_vle
)
6205 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6206 as_bad (_("instruction address is not a multiple of 2"));
6210 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6211 as_bad (_("instruction address is not a multiple of 4"));
6215 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6216 rs_align_code frag. */
6219 ppc_handle_align (struct frag
*fragP
)
6221 valueT count
= (fragP
->fr_next
->fr_address
6222 - (fragP
->fr_address
+ fragP
->fr_fix
));
6224 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6226 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6229 md_number_to_chars (dest
, 0x4400, 2);
6231 else if (count
!= 0 && (count
& 3) == 0)
6233 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6237 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6241 /* Make a branch, then follow with nops. Insert another
6242 frag to handle the nops. */
6243 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6248 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6249 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6250 fragP
->fr_next
= rest
;
6252 rest
->fr_address
+= rest
->fr_fix
+ 4;
6254 /* If we leave the next frag as rs_align_code we'll come here
6255 again, resulting in a bunch of branches rather than a
6256 branch followed by nops. */
6257 rest
->fr_type
= rs_align
;
6258 dest
= rest
->fr_literal
;
6261 md_number_to_chars (dest
, 0x60000000, 4);
6263 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6264 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6266 /* For power6 and power7, we want the last nop to be a group
6267 terminating one. Do this by inserting an rs_fill frag immediately
6268 after this one, with its address set to the last nop location.
6269 This will automatically reduce the number of nops in the current
6273 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6275 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6276 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6277 group_nop
->fr_fix
= 0;
6278 group_nop
->fr_offset
= 1;
6279 group_nop
->fr_type
= rs_fill
;
6280 fragP
->fr_next
= group_nop
;
6281 dest
= group_nop
->fr_literal
;
6284 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6286 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6287 /* e500mc group terminating nop: "ori 0,0,0". */
6288 md_number_to_chars (dest
, 0x60000000, 4);
6290 /* power7 group terminating nop: "ori 2,2,0". */
6291 md_number_to_chars (dest
, 0x60420000, 4);
6294 /* power6 group terminating nop: "ori 1,1,0". */
6295 md_number_to_chars (dest
, 0x60210000, 4);
6300 /* Apply a fixup to the object code. This is called for all the
6301 fixups we generated by the call to fix_new_exp, above. In the call
6302 above we used a reloc code which was the largest legal reloc code
6303 plus the operand index. Here we undo that to recover the operand
6304 index. At this point all symbol values should be fully resolved,
6305 and we attempt to completely resolve the reloc. If we can not do
6306 that, we determine the correct reloc code and put it back in the
6310 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6312 valueT value
= * valP
;
6315 if (fixP
->fx_addsy
!= NULL
)
6317 /* Hack around bfd_install_relocation brain damage. */
6319 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6324 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6325 the symbol values. If we are doing this relocation the code in
6326 write.c is going to call bfd_install_relocation, which is also
6327 going to use the symbol value. That means that if the reloc is
6328 fully resolved we want to use *valP since bfd_install_relocation is
6330 However, if the reloc is not fully resolved we do not want to
6331 use *valP, and must use fx_offset instead. If the relocation
6332 is PC-relative, we then need to re-apply md_pcrel_from_section
6333 to this new relocation value. */
6334 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6339 value
= fixP
->fx_offset
;
6341 value
-= md_pcrel_from_section (fixP
, seg
);
6345 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6347 /* We can't actually support subtracting a symbol. */
6348 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6351 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
6354 const struct powerpc_operand
*operand
;
6358 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
6360 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 /* Fetch the instruction, insert the fully resolved operand
6383 value, and stuff the instruction back again. */
6384 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6385 if (target_big_endian
)
6387 if (fixP
->fx_size
== 4)
6388 insn
= bfd_getb32 ((unsigned char *) where
);
6390 insn
= bfd_getb16 ((unsigned char *) where
);
6394 if (fixP
->fx_size
== 4)
6395 insn
= bfd_getl32 ((unsigned char *) where
);
6397 insn
= bfd_getl16 ((unsigned char *) where
);
6399 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
6400 fixP
->tc_fix_data
.ppc_cpu
,
6401 fixP
->fx_file
, fixP
->fx_line
);
6402 if (target_big_endian
)
6404 if (fixP
->fx_size
== 4)
6405 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6407 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6411 if (fixP
->fx_size
== 4)
6412 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6414 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6418 /* Nothing else to do here. */
6421 gas_assert (fixP
->fx_addsy
!= NULL
);
6423 /* Determine a BFD reloc value based on the operand information.
6424 We are only prepared to turn a few of the operands into
6426 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6427 && operand
->bitm
== 0x3fffffc
6428 && operand
->shift
== 0)
6429 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
6430 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6431 && operand
->bitm
== 0xfffc
6432 && operand
->shift
== 0)
6434 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
6437 if (target_big_endian
)
6438 fixP
->fx_where
+= 2;
6441 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6442 && operand
->bitm
== 0x1fe
6443 && operand
->shift
== -1)
6444 fixP
->fx_r_type
= BFD_RELOC_PPC_VLE_REL8
;
6445 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6446 && operand
->bitm
== 0xfffe
6447 && operand
->shift
== 0)
6448 fixP
->fx_r_type
= BFD_RELOC_PPC_VLE_REL15
;
6449 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6450 && operand
->bitm
== 0x1fffffe
6451 && operand
->shift
== 0)
6452 fixP
->fx_r_type
= BFD_RELOC_PPC_VLE_REL24
;
6453 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6454 && operand
->bitm
== 0x3fffffc
6455 && operand
->shift
== 0)
6456 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
6457 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6458 && operand
->bitm
== 0xfffc
6459 && operand
->shift
== 0)
6461 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
6464 if (target_big_endian
)
6465 fixP
->fx_where
+= 2;
6468 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
6469 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6470 && (operand
->bitm
& 0xfff0) == 0xfff0
6471 && operand
->shift
== 0)
6473 if (ppc_is_toc_sym (fixP
->fx_addsy
))
6475 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6478 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6479 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
6484 fixP
->fx_r_type
= BFD_RELOC_16
;
6487 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6488 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
6492 if (target_big_endian
)
6493 fixP
->fx_where
+= 2;
6495 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
6501 /* Use expr_symbol_where to see if this is an expression
6503 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6504 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6505 _("unresolved expression that must be resolved"));
6507 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6508 _("unsupported relocation against %s"),
6509 S_GET_NAME (fixP
->fx_addsy
));
6517 ppc_elf_validate_fix (fixP
, seg
);
6519 switch (fixP
->fx_r_type
)
6521 case BFD_RELOC_CTOR
:
6528 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6532 case BFD_RELOC_32_PCREL
:
6533 case BFD_RELOC_PPC_EMB_NADDR32
:
6534 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6541 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6544 case BFD_RELOC_64_PCREL
:
6545 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6549 case BFD_RELOC_GPREL16
:
6550 case BFD_RELOC_16_GOT_PCREL
:
6551 case BFD_RELOC_16_GOTOFF
:
6552 case BFD_RELOC_LO16_GOTOFF
:
6553 case BFD_RELOC_HI16_GOTOFF
:
6554 case BFD_RELOC_HI16_S_GOTOFF
:
6555 case BFD_RELOC_16_BASEREL
:
6556 case BFD_RELOC_LO16_BASEREL
:
6557 case BFD_RELOC_HI16_BASEREL
:
6558 case BFD_RELOC_HI16_S_BASEREL
:
6559 case BFD_RELOC_PPC_EMB_NADDR16
:
6560 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6561 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6562 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6563 case BFD_RELOC_PPC_EMB_SDAI16
:
6564 case BFD_RELOC_PPC_EMB_SDA2REL
:
6565 case BFD_RELOC_PPC_EMB_SDA2I16
:
6566 case BFD_RELOC_PPC_EMB_RELSEC16
:
6567 case BFD_RELOC_PPC_EMB_RELST_LO
:
6568 case BFD_RELOC_PPC_EMB_RELST_HI
:
6569 case BFD_RELOC_PPC_EMB_RELST_HA
:
6570 case BFD_RELOC_PPC_EMB_RELSDA
:
6571 case BFD_RELOC_PPC_TOC16
:
6573 case BFD_RELOC_PPC64_TOC16_LO
:
6574 case BFD_RELOC_PPC64_TOC16_HI
:
6575 case BFD_RELOC_PPC64_TOC16_HA
:
6579 if (fixP
->fx_addsy
!= NULL
)
6580 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6581 _("cannot emit PC relative %s relocation against %s"),
6582 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6583 S_GET_NAME (fixP
->fx_addsy
));
6585 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6586 _("cannot emit PC relative %s relocation"),
6587 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6590 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6596 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6599 case BFD_RELOC_16_PCREL
:
6600 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6604 case BFD_RELOC_LO16
:
6606 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6609 case BFD_RELOC_LO16_PCREL
:
6610 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6614 /* This case happens when you write, for example,
6616 where L1 and L2 are defined later. */
6617 case BFD_RELOC_HI16
:
6619 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6622 case BFD_RELOC_HI16_PCREL
:
6623 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6627 case BFD_RELOC_HI16_S
:
6629 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6632 case BFD_RELOC_HI16_S_PCREL
:
6633 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6637 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6638 case BFD_RELOC_PPC_VLE_LO16A
:
6640 int tval
= PPC_VLE_LO16A (value
);
6641 valueT oldval
= md_chars_to_number (
6642 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6643 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6644 (oldval
| tval
), 4);
6648 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6649 case BFD_RELOC_PPC_VLE_LO16D
:
6651 int tval
= PPC_VLE_LO16D (value
);
6652 valueT oldval
= md_chars_to_number (
6653 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6654 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6655 (oldval
| tval
), 4);
6659 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6660 case BFD_RELOC_PPC_VLE_HI16A
:
6662 int tval
= PPC_VLE_HI16A (value
);
6663 valueT oldval
= md_chars_to_number (
6664 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6665 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6666 (oldval
| tval
), 4);
6670 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6671 case BFD_RELOC_PPC_VLE_HI16D
:
6673 int tval
= PPC_VLE_HI16D (value
);
6674 valueT oldval
= md_chars_to_number (
6675 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6676 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6677 (oldval
| tval
), 4);
6681 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6682 case BFD_RELOC_PPC_VLE_HA16A
:
6684 int tval
= PPC_VLE_HA16A (value
);
6685 valueT oldval
= md_chars_to_number (
6686 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6687 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6688 (oldval
| tval
), 4);
6692 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6693 case BFD_RELOC_PPC_VLE_HA16D
:
6695 int tval
= PPC_VLE_HA16D (value
);
6696 valueT oldval
= md_chars_to_number (
6697 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6698 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6699 (oldval
| tval
), 4);
6703 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6705 int tval
= PPC_LO (value
);
6706 valueT oldval
= md_chars_to_number (
6707 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6708 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6709 (oldval
| tval
), 4);
6713 case BFD_RELOC_PPC_VLE_SDA21
:
6715 valueT oldval
= md_chars_to_number (
6716 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6717 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6718 (oldval
| value
), 4);
6723 case BFD_RELOC_NONE
:
6728 case BFD_RELOC_PPC64_HIGHER
:
6731 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6732 PPC_HIGHER (value
), 2);
6735 case BFD_RELOC_PPC64_HIGHER_S
:
6738 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6739 PPC_HIGHERA (value
), 2);
6742 case BFD_RELOC_PPC64_HIGHEST
:
6745 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6746 PPC_HIGHEST (value
), 2);
6749 case BFD_RELOC_PPC64_HIGHEST_S
:
6752 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6753 PPC_HIGHESTA (value
), 2);
6756 case BFD_RELOC_PPC64_ADDR16_DS
:
6757 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6758 case BFD_RELOC_PPC64_GOT16_DS
:
6759 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6760 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6761 case BFD_RELOC_PPC64_SECTOFF_DS
:
6762 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6763 case BFD_RELOC_PPC64_TOC16_DS
:
6764 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6765 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6766 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6770 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6771 unsigned long val
, mask
;
6773 if (target_big_endian
)
6774 val
= bfd_getb32 (where
- 2);
6776 val
= bfd_getl32 (where
);
6778 /* lq insns reserve the four lsbs. */
6779 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
6780 && (val
& (0x3f << 26)) == (56u << 26))
6782 val
|= value
& mask
;
6783 if (target_big_endian
)
6784 bfd_putb16 ((bfd_vma
) val
, where
);
6786 bfd_putl16 ((bfd_vma
) val
, where
);
6790 case BFD_RELOC_PPC_B16_BRTAKEN
:
6791 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6792 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6793 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6796 case BFD_RELOC_PPC_TLS
:
6797 case BFD_RELOC_PPC_TLSGD
:
6798 case BFD_RELOC_PPC_TLSLD
:
6801 case BFD_RELOC_PPC_DTPMOD
:
6802 case BFD_RELOC_PPC_TPREL16
:
6803 case BFD_RELOC_PPC_TPREL16_LO
:
6804 case BFD_RELOC_PPC_TPREL16_HI
:
6805 case BFD_RELOC_PPC_TPREL16_HA
:
6806 case BFD_RELOC_PPC_TPREL
:
6807 case BFD_RELOC_PPC_DTPREL16
:
6808 case BFD_RELOC_PPC_DTPREL16_LO
:
6809 case BFD_RELOC_PPC_DTPREL16_HI
:
6810 case BFD_RELOC_PPC_DTPREL16_HA
:
6811 case BFD_RELOC_PPC_DTPREL
:
6812 case BFD_RELOC_PPC_GOT_TLSGD16
:
6813 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6814 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6815 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6816 case BFD_RELOC_PPC_GOT_TLSLD16
:
6817 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6818 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6819 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6820 case BFD_RELOC_PPC_GOT_TPREL16
:
6821 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6822 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6823 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6824 case BFD_RELOC_PPC_GOT_DTPREL16
:
6825 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6826 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6827 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6828 case BFD_RELOC_PPC64_TPREL16_DS
:
6829 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6830 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6831 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6832 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6833 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6834 case BFD_RELOC_PPC64_DTPREL16_DS
:
6835 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6836 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6837 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6838 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6839 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6840 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6843 /* Because SDA21 modifies the register field, the size is set to 4
6844 bytes, rather than 2, so offset it here appropriately. */
6845 case BFD_RELOC_PPC_EMB_SDA21
:
6849 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
6850 + ((target_big_endian
) ? 2 : 0),
6857 /* This can occur if there is a bug in the input assembler, eg:
6858 ".byte <undefined_symbol> - ." */
6860 as_bad (_("unable to handle reference to symbol %s"),
6861 S_GET_NAME (fixP
->fx_addsy
));
6863 as_bad (_("unable to resolve expression"));
6867 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6871 case BFD_RELOC_24_PLT_PCREL
:
6872 case BFD_RELOC_PPC_LOCAL24PC
:
6873 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
6881 /* Fetch the instruction, insert the fully resolved operand
6882 value, and stuff the instruction back again. */
6883 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6884 if (target_big_endian
)
6885 insn
= bfd_getb32 ((unsigned char *) where
);
6887 insn
= bfd_getl32 ((unsigned char *) where
);
6888 if (ppc_mach() == bfd_mach_ppc_vle
)
6890 if ((value
& 1) != 0)
6891 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6892 _("branch address must be a multiple of 2"));
6896 if ((value
& 3) != 0)
6897 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6898 _("branch address must be a multiple of 4"));
6900 if ((offsetT
) value
< -0x40000000
6901 || (offsetT
) value
>= 0x40000000)
6902 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6903 _("@local or @plt branch destination is too far away, %ld bytes"),
6905 insn
= insn
| (value
& 0x03fffffc);
6906 if (target_big_endian
)
6907 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6909 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6913 case BFD_RELOC_VTABLE_INHERIT
:
6916 && !S_IS_DEFINED (fixP
->fx_addsy
)
6917 && !S_IS_WEAK (fixP
->fx_addsy
))
6918 S_SET_WEAK (fixP
->fx_addsy
);
6921 case BFD_RELOC_VTABLE_ENTRY
:
6926 /* Generated by reference to `sym@tocbase'. The sym is
6927 ignored by the linker. */
6928 case BFD_RELOC_PPC64_TOC
:
6934 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6941 fixP
->fx_addnumber
= value
;
6943 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6944 from the section contents. If we are going to be emitting a reloc
6945 then the section contents are immaterial, so don't warn if they
6946 happen to overflow. Leave such warnings to ld. */
6948 fixP
->fx_no_overflow
= 1;
6950 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6951 fixP
->fx_addnumber
= 0;
6955 fixP
->fx_addnumber
= 0;
6957 /* We want to use the offset within the toc, not the actual VMA
6959 fixP
->fx_addnumber
=
6960 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6961 - S_GET_VALUE (ppc_toc_csect
);
6967 /* Generate a reloc for a fixup. */
6970 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6974 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6976 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6977 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6978 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6979 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6980 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6982 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6983 _("reloc %d not supported by object file format"),
6984 (int) fixp
->fx_r_type
);
6987 reloc
->addend
= fixp
->fx_addnumber
;
6993 ppc_cfi_frame_initial_instructions (void)
6995 cfi_add_CFA_def_cfa (1, 0);
6999 tc_ppc_regname_to_dw2regnum (char *regname
)
7001 unsigned int regnum
= -1;
7005 static struct { char *name
; int dw2regnum
; } regnames
[] =
7007 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7008 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7009 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7010 { "spe_acc", 111 }, { "spefscr", 112 }
7013 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7014 if (strcmp (regnames
[i
].name
, regname
) == 0)
7015 return regnames
[i
].dw2regnum
;
7017 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7019 p
= regname
+ 1 + (regname
[1] == '.');
7020 regnum
= strtoul (p
, &q
, 10);
7021 if (p
== q
|| *q
|| regnum
>= 32)
7023 if (regname
[0] == 'f')
7025 else if (regname
[0] == 'v')
7028 else if (regname
[0] == 'c' && regname
[1] == 'r')
7030 p
= regname
+ 2 + (regname
[2] == '.');
7031 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7033 regnum
= p
[0] - '0' + 68;