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 /* More than this number of nops in an alignment op gets a branch
218 unsigned long nop_limit
= 4;
220 /* The type of processor we are assembling for. This is one or more
221 of the PPC_OPCODE flags defined in opcode/ppc.h. */
222 ppc_cpu_t ppc_cpu
= 0;
224 /* Flags set on encountering toc relocs. */
226 has_large_toc_reloc
= 1,
227 has_small_toc_reloc
= 2
230 /* The target specific pseudo-ops which we support. */
232 const pseudo_typeS md_pseudo_table
[] =
234 /* Pseudo-ops which must be overridden. */
235 { "byte", ppc_byte
, 0 },
238 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
239 legitimately belong in the obj-*.c file. However, XCOFF is based
240 on COFF, and is only implemented for the RS/6000. We just use
241 obj-coff.c, and add what we need here. */
242 { "comm", ppc_comm
, 0 },
243 { "lcomm", ppc_comm
, 1 },
247 { "bi", ppc_biei
, 0 },
249 { "csect", ppc_csect
, 0 },
250 { "dwsect", ppc_dwsect
, 0 },
251 { "data", ppc_section
, 'd' },
255 { "ei", ppc_biei
, 1 },
257 { "extern", ppc_extern
, 0 },
258 { "function", ppc_function
, 0 },
259 { "lglobl", ppc_lglobl
, 0 },
260 { "ref", ppc_ref
, 0 },
261 { "rename", ppc_rename
, 0 },
262 { "section", ppc_named_section
, 0 },
263 { "stabx", ppc_stabx
, 0 },
264 { "text", ppc_section
, 't' },
265 { "toc", ppc_toc
, 0 },
266 { "long", ppc_xcoff_cons
, 2 },
267 { "llong", ppc_xcoff_cons
, 3 },
268 { "word", ppc_xcoff_cons
, 1 },
269 { "short", ppc_xcoff_cons
, 1 },
270 { "vbyte", ppc_vbyte
, 0 },
274 { "llong", ppc_elf_cons
, 8 },
275 { "quad", ppc_elf_cons
, 8 },
276 { "long", ppc_elf_cons
, 4 },
277 { "word", ppc_elf_cons
, 2 },
278 { "short", ppc_elf_cons
, 2 },
279 { "rdata", ppc_elf_rdata
, 0 },
280 { "rodata", ppc_elf_rdata
, 0 },
281 { "lcomm", ppc_elf_lcomm
, 0 },
285 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
286 { "previous", ppc_previous
, 0 },
287 { "pdata", ppc_pdata
, 0 },
288 { "ydata", ppc_ydata
, 0 },
289 { "reldata", ppc_reldata
, 0 },
290 { "rdata", ppc_rdata
, 0 },
291 { "ualong", ppc_ualong
, 0 },
292 { "znop", ppc_znop
, 0 },
293 { "comm", ppc_pe_comm
, 0 },
294 { "lcomm", ppc_pe_comm
, 1 },
295 { "section", ppc_pe_section
, 0 },
296 { "function", ppc_pe_function
,0 },
297 { "tocd", ppc_pe_tocd
, 0 },
300 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
302 { "machine", ppc_machine
, 0 },
309 /* Predefined register names if -mregnames (or default for Windows NT).
310 In general, there are lots of them, in an attempt to be compatible
311 with a number of other Windows NT assemblers. */
313 /* Structure to hold information about predefined registers. */
320 /* List of registers that are pre-defined:
322 Each general register has predefined names of the form:
323 1. r<reg_num> which has the value <reg_num>.
324 2. r.<reg_num> which has the value <reg_num>.
326 Each floating point register has predefined names of the form:
327 1. f<reg_num> which has the value <reg_num>.
328 2. f.<reg_num> which has the value <reg_num>.
330 Each vector unit register has predefined names of the form:
331 1. v<reg_num> which has the value <reg_num>.
332 2. v.<reg_num> which has the value <reg_num>.
334 Each condition register has predefined names of the form:
335 1. cr<reg_num> which has the value <reg_num>.
336 2. cr.<reg_num> which has the value <reg_num>.
338 There are individual registers as well:
339 sp or r.sp has the value 1
340 rtoc or r.toc has the value 2
341 fpscr has the value 0
347 dsisr has the value 18
349 sdr1 has the value 25
350 srr0 has the value 26
351 srr1 has the value 27
353 The table is sorted. Suitable for searching by a binary search. */
355 static const struct pd_reg pre_defined_registers
[] =
357 { "cr.0", 0 }, /* Condition Registers */
377 { "dar", 19 }, /* Data Access Register */
378 { "dec", 22 }, /* Decrementer */
379 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
381 { "f.0", 0 }, /* Floating point registers */
408 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
474 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
515 /* Quantization registers used with pair single instructions. */
533 { "lr", 8 }, /* Link Register */
537 { "r.0", 0 }, /* General Purpose Registers */
570 { "r.sp", 1 }, /* Stack Pointer */
572 { "r.toc", 2 }, /* Pointer to the table of contents */
574 { "r0", 0 }, /* More general purpose registers */
607 { "rtoc", 2 }, /* Table of contents */
609 { "sdr1", 25 }, /* Storage Description Register 1 */
613 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
614 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
616 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
682 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
816 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
818 /* Given NAME, find the register number associated with that name, return
819 the integer value associated with the given name or -1 on failure. */
822 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
824 int middle
, low
, high
;
832 middle
= (low
+ high
) / 2;
833 cmp
= strcasecmp (name
, regs
[middle
].name
);
839 return regs
[middle
].value
;
847 * Summary of register_name.
849 * in: Input_line_pointer points to 1st char of operand.
851 * out: A expressionS.
852 * The operand may have been a register: in this case, X_op == O_register,
853 * X_add_number is set to the register number, and truth is returned.
854 * Input_line_pointer->(next non-blank) char after operand, or is in its
859 register_name (expressionS
*expressionP
)
866 /* Find the spelling of the operand. */
867 start
= name
= input_line_pointer
;
868 if (name
[0] == '%' && ISALPHA (name
[1]))
869 name
= ++input_line_pointer
;
871 else if (!reg_names_p
|| !ISALPHA (name
[0]))
874 c
= get_symbol_end ();
875 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
877 /* Put back the delimiting char. */
878 *input_line_pointer
= c
;
880 /* Look to see if it's in the register table. */
883 expressionP
->X_op
= O_register
;
884 expressionP
->X_add_number
= reg_number
;
886 /* Make the rest nice. */
887 expressionP
->X_add_symbol
= NULL
;
888 expressionP
->X_op_symbol
= NULL
;
892 /* Reset the line as if we had not done anything. */
893 input_line_pointer
= start
;
897 /* This function is called for each symbol seen in an expression. It
898 handles the special parsing which PowerPC assemblers are supposed
899 to use for condition codes. */
901 /* Whether to do the special parsing. */
902 static bfd_boolean cr_operand
;
904 /* Names to recognize in a condition code. This table is sorted. */
905 static const struct pd_reg cr_names
[] =
922 /* Parsing function. This returns non-zero if it recognized an
926 ppc_parse_name (const char *name
, expressionS
*exp
)
935 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
940 exp
->X_op
= O_constant
;
941 exp
->X_add_number
= val
;
946 /* Local variables. */
948 /* Whether to target xcoff64/elf64. */
949 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
951 /* Opcode hash table. */
952 static struct hash_control
*ppc_hash
;
954 /* Macro hash table. */
955 static struct hash_control
*ppc_macro_hash
;
958 /* What type of shared library support to use. */
959 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
961 /* Flags to set in the elf header. */
962 static flagword ppc_flags
= 0;
964 /* Whether this is Solaris or not. */
965 #ifdef TARGET_SOLARIS_COMMENT
966 #define SOLARIS_P TRUE
968 #define SOLARIS_P FALSE
971 static bfd_boolean msolaris
= SOLARIS_P
;
976 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
977 using a bunch of different sections. These assembler sections,
978 however, are all encompassed within the .text or .data sections of
979 the final output file. We handle this by using different
980 subsegments within these main segments. */
982 /* Next subsegment to allocate within the .text segment. */
983 static subsegT ppc_text_subsegment
= 2;
985 /* Linked list of csects in the text section. */
986 static symbolS
*ppc_text_csects
;
988 /* Next subsegment to allocate within the .data segment. */
989 static subsegT ppc_data_subsegment
= 2;
991 /* Linked list of csects in the data section. */
992 static symbolS
*ppc_data_csects
;
994 /* The current csect. */
995 static symbolS
*ppc_current_csect
;
997 /* The RS/6000 assembler uses a TOC which holds addresses of functions
998 and variables. Symbols are put in the TOC with the .tc pseudo-op.
999 A special relocation is used when accessing TOC entries. We handle
1000 the TOC as a subsegment within the .data segment. We set it up if
1001 we see a .toc pseudo-op, and save the csect symbol here. */
1002 static symbolS
*ppc_toc_csect
;
1004 /* The first frag in the TOC subsegment. */
1005 static fragS
*ppc_toc_frag
;
1007 /* The first frag in the first subsegment after the TOC in the .data
1008 segment. NULL if there are no subsegments after the TOC. */
1009 static fragS
*ppc_after_toc_frag
;
1011 /* The current static block. */
1012 static symbolS
*ppc_current_block
;
1014 /* The COFF debugging section; set by md_begin. This is not the
1015 .debug section, but is instead the secret BFD section which will
1016 cause BFD to set the section number of a symbol to N_DEBUG. */
1017 static asection
*ppc_coff_debug_section
;
1019 /* Structure to set the length field of the dwarf sections. */
1020 struct dw_subsection
{
1021 /* Subsections are simply linked. */
1022 struct dw_subsection
*link
;
1024 /* The subsection number. */
1027 /* Expression to compute the length of the section. */
1028 expressionS end_exp
;
1031 static struct dw_section
{
1032 /* Corresponding section. */
1035 /* Simply linked list of subsections with a label. */
1036 struct dw_subsection
*list_subseg
;
1038 /* The anonymous subsection. */
1039 struct dw_subsection
*anon_subseg
;
1040 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1041 #endif /* OBJ_XCOFF */
1045 /* Various sections that we need for PE coff support. */
1046 static segT ydata_section
;
1047 static segT pdata_section
;
1048 static segT reldata_section
;
1049 static segT rdata_section
;
1050 static segT tocdata_section
;
1052 /* The current section and the previous section. See ppc_previous. */
1053 static segT ppc_previous_section
;
1054 static segT ppc_current_section
;
1059 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1060 #define PPC_APUINFO_ISEL 0x40
1061 #define PPC_APUINFO_PMR 0x41
1062 #define PPC_APUINFO_RFMCI 0x42
1063 #define PPC_APUINFO_CACHELCK 0x43
1064 #define PPC_APUINFO_SPE 0x100
1065 #define PPC_APUINFO_EFS 0x101
1066 #define PPC_APUINFO_BRLOCK 0x102
1067 #define PPC_APUINFO_VLE 0x104
1070 * We keep a list of APUinfo
1072 unsigned long *ppc_apuinfo_list
;
1073 unsigned int ppc_apuinfo_num
;
1074 unsigned int ppc_apuinfo_num_alloc
;
1075 #endif /* OBJ_ELF */
1078 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1080 const char *const md_shortopts
= "um:";
1082 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1083 const struct option md_longopts
[] = {
1084 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1085 {NULL
, no_argument
, NULL
, 0}
1087 const size_t md_longopts_size
= sizeof (md_longopts
);
1089 /* Convert the target integer stored in N bytes in BUF to a host
1090 integer, returning that value. */
1093 md_chars_to_number (char *buf
, int n
)
1096 unsigned char *p
= (unsigned char *) buf
;
1098 if (target_big_endian
)
1103 result
|= (*p
++ & 0xff);
1111 result
|= (p
[n
] & 0xff);
1119 md_parse_option (int c
, char *arg
)
1126 /* -u means that any undefined symbols should be treated as
1127 external, which is the default for gas anyhow. */
1132 /* Solaris as takes -le (presumably for little endian). For completeness
1133 sake, recognize -be also. */
1134 if (strcmp (arg
, "e") == 0)
1136 target_big_endian
= 0;
1137 set_target_endian
= 1;
1138 if (ppc_cpu
& PPC_OPCODE_VLE
)
1139 as_bad (_("The use of -mvle requires big endian."));
1147 if (strcmp (arg
, "e") == 0)
1149 target_big_endian
= 1;
1150 set_target_endian
= 1;
1158 /* Recognize -K PIC. */
1159 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1162 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1170 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1172 if (strcmp (arg
, "64") == 0)
1177 as_fatal (_("%s unsupported"), "-a64");
1180 else if (strcmp (arg
, "32") == 0)
1187 new_cpu
= ppc_parse_cpu (ppc_cpu
, arg
);
1191 if (set_target_endian
&& target_big_endian
== 0)
1192 as_bad (_("The use of -mvle requires big endian."));
1195 else if (strcmp (arg
, "regnames") == 0)
1198 else if (strcmp (arg
, "no-regnames") == 0)
1199 reg_names_p
= FALSE
;
1202 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1203 that require relocation. */
1204 else if (strcmp (arg
, "relocatable") == 0)
1206 shlib
= SHLIB_MRELOCATABLE
;
1207 ppc_flags
|= EF_PPC_RELOCATABLE
;
1210 else if (strcmp (arg
, "relocatable-lib") == 0)
1212 shlib
= SHLIB_MRELOCATABLE
;
1213 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1216 /* -memb, set embedded bit. */
1217 else if (strcmp (arg
, "emb") == 0)
1218 ppc_flags
|= EF_PPC_EMB
;
1220 /* -mlittle/-mbig set the endianness. */
1221 else if (strcmp (arg
, "little") == 0
1222 || strcmp (arg
, "little-endian") == 0)
1224 target_big_endian
= 0;
1225 set_target_endian
= 1;
1226 if (ppc_cpu
& PPC_OPCODE_VLE
)
1227 as_bad (_("The use of -mvle requires big endian."));
1230 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1232 target_big_endian
= 1;
1233 set_target_endian
= 1;
1236 else if (strcmp (arg
, "solaris") == 0)
1239 ppc_comment_chars
= ppc_solaris_comment_chars
;
1242 else if (strcmp (arg
, "no-solaris") == 0)
1245 ppc_comment_chars
= ppc_eabi_comment_chars
;
1250 as_bad (_("invalid switch -m%s"), arg
);
1256 /* -V: SVR4 argument to print version ID. */
1258 print_version_id ();
1261 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1262 should be emitted or not. FIXME: Not implemented. */
1266 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1267 rather than .stabs.excl, which is ignored by the linker.
1268 FIXME: Not implemented. */
1279 nop_limit
= strtoul (optarg
, &end
, 0);
1281 as_bad (_("--nops needs a numeric argument"));
1293 md_show_usage (FILE *stream
)
1295 fprintf (stream
, _("\
1297 -a32 generate ELF32/XCOFF32\n\
1298 -a64 generate ELF64/XCOFF64\n\
1300 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1301 -mpwr generate code for POWER (RIOS1)\n\
1302 -m601 generate code for PowerPC 601\n\
1303 -mppc, -mppc32, -m603, -m604\n\
1304 generate code for PowerPC 603/604\n\
1305 -m403 generate code for PowerPC 403\n\
1306 -m405 generate code for PowerPC 405\n\
1307 -m440 generate code for PowerPC 440\n\
1308 -m464 generate code for PowerPC 464\n\
1309 -m476 generate code for PowerPC 476\n\
1310 -m7400, -m7410, -m7450, -m7455\n\
1311 generate code for PowerPC 7400/7410/7450/7455\n\
1312 -m750cl generate code for PowerPC 750cl\n"));
1313 fprintf (stream
, _("\
1314 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1315 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1316 -mbooke generate code for 32-bit PowerPC BookE\n\
1317 -ma2 generate code for A2 architecture\n\
1318 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1319 -mpower5, -mpwr5, -mpwr5x\n\
1320 generate code for Power5 architecture\n\
1321 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1322 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1323 -mcell generate code for Cell Broadband Engine architecture\n\
1324 -mcom generate code Power/PowerPC common instructions\n\
1325 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1326 fprintf (stream
, _("\
1327 -maltivec generate code for AltiVec\n\
1328 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1329 -me300 generate code for PowerPC e300 family\n\
1330 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1331 -me500mc, generate code for Freescale e500mc core complex\n\
1332 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1333 -me5500, generate code for Freescale e5500 core complex\n\
1334 -me6500, generate code for Freescale e6500 core complex\n\
1335 -mspe generate code for Motorola SPE instructions\n\
1336 -mvle generate code for Freescale VLE instructions\n\
1337 -mtitan generate code for AppliedMicro Titan core complex\n\
1338 -mregnames Allow symbolic names for registers\n\
1339 -mno-regnames Do not allow symbolic names for registers\n"));
1341 fprintf (stream
, _("\
1342 -mrelocatable support for GCC's -mrelocatble option\n\
1343 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1344 -memb set PPC_EMB bit in ELF flags\n\
1345 -mlittle, -mlittle-endian, -le\n\
1346 generate code for a little endian machine\n\
1347 -mbig, -mbig-endian, -be\n\
1348 generate code for a big endian machine\n\
1349 -msolaris generate code for Solaris\n\
1350 -mno-solaris do not generate code for Solaris\n\
1351 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1352 -V print assembler version number\n\
1353 -Qy, -Qn ignored\n"));
1355 fprintf (stream
, _("\
1356 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1359 /* Set ppc_cpu if it is not already set. */
1364 const char *default_os
= TARGET_OS
;
1365 const char *default_cpu
= TARGET_CPU
;
1367 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1370 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1371 else if (strncmp (default_os
, "aix", 3) == 0
1372 && default_os
[3] >= '4' && default_os
[3] <= '9')
1373 ppc_cpu
|= PPC_OPCODE_COMMON
;
1374 else if (strncmp (default_os
, "aix3", 4) == 0)
1375 ppc_cpu
|= PPC_OPCODE_POWER
;
1376 else if (strcmp (default_cpu
, "rs6000") == 0)
1377 ppc_cpu
|= PPC_OPCODE_POWER
;
1378 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1379 ppc_cpu
|= PPC_OPCODE_PPC
;
1381 as_fatal (_("Unknown default cpu = %s, os = %s"),
1382 default_cpu
, default_os
);
1386 /* Figure out the BFD architecture to use. This function and ppc_mach
1387 are called well before md_begin, when the output file is opened. */
1389 enum bfd_architecture
1392 const char *default_cpu
= TARGET_CPU
;
1395 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1396 return bfd_arch_powerpc
;
1397 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1398 return bfd_arch_powerpc
;
1399 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1400 return bfd_arch_rs6000
;
1401 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1403 if (strcmp (default_cpu
, "rs6000") == 0)
1404 return bfd_arch_rs6000
;
1405 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1406 return bfd_arch_powerpc
;
1409 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1410 return bfd_arch_unknown
;
1417 return bfd_mach_ppc64
;
1418 else if (ppc_arch () == bfd_arch_rs6000
)
1419 return bfd_mach_rs6k
;
1420 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1421 return bfd_mach_ppc_titan
;
1422 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1423 return bfd_mach_ppc_vle
;
1425 return bfd_mach_ppc
;
1429 ppc_target_format (void)
1433 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1435 return "xcoff-powermac";
1438 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1440 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1446 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1447 # elif defined (TE_VXWORKS)
1448 return "elf32-powerpc-vxworks";
1450 return (target_big_endian
1451 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1452 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1457 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1458 Return TRUE if there's a problem, otherwise FALSE. */
1461 insn_validate (const struct powerpc_opcode
*op
)
1463 const unsigned char *o
;
1464 unsigned long omask
= op
->mask
;
1466 /* The mask had better not trim off opcode bits. */
1467 if ((op
->opcode
& omask
) != op
->opcode
)
1469 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1473 /* The operands must not overlap the opcode or each other. */
1474 for (o
= op
->operands
; *o
; ++o
)
1476 if (*o
>= num_powerpc_operands
)
1478 as_bad (_("operand index error for %s"), op
->name
);
1483 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1484 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1488 if (operand
->shift
>= 0)
1489 mask
= operand
->bitm
<< operand
->shift
;
1491 mask
= operand
->bitm
>> -operand
->shift
;
1494 as_bad (_("operand %d overlap in %s"),
1495 (int) (o
- op
->operands
), op
->name
);
1505 /* Insert opcodes and macros into hash tables. Called at startup and
1509 ppc_setup_opcodes (void)
1511 const struct powerpc_opcode
*op
;
1512 const struct powerpc_opcode
*op_end
;
1513 const struct powerpc_macro
*macro
;
1514 const struct powerpc_macro
*macro_end
;
1515 bfd_boolean bad_insn
= FALSE
;
1517 if (ppc_hash
!= NULL
)
1518 hash_die (ppc_hash
);
1519 if (ppc_macro_hash
!= NULL
)
1520 hash_die (ppc_macro_hash
);
1522 /* Insert the opcodes into a hash table. */
1523 ppc_hash
= hash_new ();
1525 if (ENABLE_CHECKING
)
1529 /* Check operand masks. Code here and in the disassembler assumes
1530 all the 1's in the mask are contiguous. */
1531 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1533 unsigned long mask
= powerpc_operands
[i
].bitm
;
1534 unsigned long right_bit
;
1537 right_bit
= mask
& -mask
;
1539 right_bit
= mask
& -mask
;
1540 if (mask
!= right_bit
)
1542 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1545 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1546 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1547 sizeof (powerpc_operands
[0])) == 0)
1549 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1556 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1557 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1559 if (ENABLE_CHECKING
)
1561 if (op
!= powerpc_opcodes
)
1563 int old_opcode
= PPC_OP (op
[-1].opcode
);
1564 int new_opcode
= PPC_OP (op
[0].opcode
);
1566 #ifdef PRINT_OPCODE_TABLE
1567 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1568 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1569 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1570 (unsigned long long) op
->flags
);
1573 /* The major opcodes had better be sorted. Code in the
1574 disassembler assumes the insns are sorted according to
1576 if (new_opcode
< old_opcode
)
1578 as_bad (_("major opcode is not sorted for %s"),
1583 bad_insn
|= insn_validate (op
);
1586 if ((ppc_cpu
& op
->flags
) != 0
1587 && !(ppc_cpu
& op
->deprecated
))
1591 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1594 as_bad (_("duplicate instruction %s"),
1601 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1602 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1603 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1605 op_end
= vle_opcodes
+ vle_num_opcodes
;
1606 for (op
= vle_opcodes
; op
< op_end
; op
++)
1608 if (ENABLE_CHECKING
)
1610 if (op
!= vle_opcodes
)
1612 unsigned old_seg
, new_seg
;
1614 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1615 old_seg
= VLE_OP_TO_SEG (old_seg
);
1616 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1617 new_seg
= VLE_OP_TO_SEG (new_seg
);
1619 #ifdef PRINT_OPCODE_TABLE
1620 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1621 op
->name
, op
- powerpc_opcodes
, (unsigned int) new_opcode
,
1622 (unsigned int) op
->opcode
, (unsigned int) op
->mask
,
1623 (unsigned long long) op
->flags
);
1625 /* The major opcodes had better be sorted. Code in the
1626 disassembler assumes the insns are sorted according to
1628 if (new_seg
< old_seg
)
1630 as_bad (_("major opcode is not sorted for %s"),
1636 bad_insn
|= insn_validate (op
);
1639 if ((ppc_cpu
& op
->flags
) != 0
1640 && !(ppc_cpu
& op
->deprecated
))
1644 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1647 as_bad (_("duplicate instruction %s"),
1654 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1655 for (op
= vle_opcodes
; op
< op_end
; op
++)
1656 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1658 /* Insert the macros into a hash table. */
1659 ppc_macro_hash
= hash_new ();
1661 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1662 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1664 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1668 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1669 if (retval
!= (const char *) NULL
)
1671 as_bad (_("duplicate macro %s"), macro
->name
);
1681 /* This function is called when the assembler starts up. It is called
1682 after the options have been parsed and the output file has been
1690 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1693 /* Set the ELF flags if desired. */
1694 if (ppc_flags
&& !msolaris
)
1695 bfd_set_private_flags (stdoutput
, ppc_flags
);
1698 ppc_setup_opcodes ();
1700 /* Tell the main code what the endianness is if it is not overridden
1702 if (!set_target_endian
)
1704 set_target_endian
= 1;
1705 target_big_endian
= PPC_BIG_ENDIAN
;
1709 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1711 /* Create dummy symbols to serve as initial csects. This forces the
1712 text csects to precede the data csects. These symbols will not
1714 ppc_text_csects
= symbol_make ("dummy\001");
1715 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1716 ppc_data_csects
= symbol_make ("dummy\001");
1717 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1722 ppc_current_section
= text_section
;
1723 ppc_previous_section
= 0;
1732 if (ppc_apuinfo_list
== NULL
)
1735 /* Ok, so write the section info out. We have this layout:
1739 0 8 length of "APUinfo\0"
1740 4 (n*4) number of APU's (4 bytes each)
1743 20 APU#1 first APU's info
1744 24 APU#2 second APU's info
1749 asection
*seg
= now_seg
;
1750 subsegT subseg
= now_subseg
;
1751 asection
*apuinfo_secp
= (asection
*) NULL
;
1754 /* Create the .PPC.EMB.apuinfo section. */
1755 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1756 bfd_set_section_flags (stdoutput
,
1758 SEC_HAS_CONTENTS
| SEC_READONLY
);
1761 md_number_to_chars (p
, (valueT
) 8, 4);
1764 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1767 md_number_to_chars (p
, (valueT
) 2, 4);
1770 strcpy (p
, "APUinfo");
1772 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1775 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1778 frag_align (2, 0, 0);
1780 /* We probably can't restore the current segment, for there likely
1783 subseg_set (seg
, subseg
);
1788 /* Insert an operand value into an instruction. */
1790 static unsigned long
1791 ppc_insert_operand (unsigned long insn
,
1792 const struct powerpc_operand
*operand
,
1798 long min
, max
, right
;
1800 max
= operand
->bitm
;
1804 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1806 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1807 max
= (max
>> 1) & -right
;
1808 min
= ~max
& -right
;
1811 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1814 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1823 /* Some people write constants with the sign extension done by
1824 hand but only up to 32 bits. This shouldn't really be valid,
1825 but, to permit this code to assemble on a 64-bit host, we
1826 sign extend the 32-bit value to 64 bits if so doing makes the
1829 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1830 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1831 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1832 val
= val
- 0x80000000 - 0x80000000;
1834 /* Similarly, people write expressions like ~(1<<15), and expect
1835 this to be OK for a 32-bit unsigned value. */
1837 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1838 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1839 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1840 val
= val
+ 0x80000000 + 0x80000000;
1844 || (val
& (right
- 1)) != 0)
1845 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1848 if (operand
->insert
)
1853 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1854 if (errmsg
!= (const char *) NULL
)
1855 as_bad_where (file
, line
, "%s", errmsg
);
1857 else if (operand
->shift
>= 0)
1858 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1860 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1867 /* Parse @got, etc. and return the desired relocation. */
1868 static bfd_reloc_code_real_type
1869 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1873 unsigned int length
: 8;
1874 unsigned int valid32
: 1;
1875 unsigned int valid64
: 1;
1884 const struct map_bfd
*ptr
;
1886 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1887 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1888 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1890 static const struct map_bfd mapping
[] = {
1891 MAP ("l", BFD_RELOC_LO16
),
1892 MAP ("h", BFD_RELOC_HI16
),
1893 MAP ("ha", BFD_RELOC_HI16_S
),
1894 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1895 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1896 MAP ("got", BFD_RELOC_16_GOTOFF
),
1897 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1898 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1899 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1900 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1901 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1902 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1903 MAP ("copy", BFD_RELOC_PPC_COPY
),
1904 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1905 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1906 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1907 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1908 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1909 MAP ("tls", BFD_RELOC_PPC_TLS
),
1910 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1911 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1912 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1913 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1914 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1915 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1916 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1917 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1918 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1919 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1920 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1921 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1922 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1923 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1924 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1925 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1926 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1927 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1928 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1929 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1930 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1931 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1932 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1933 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1934 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1935 MAP32 ("fixup", BFD_RELOC_CTOR
),
1936 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1937 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1938 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1939 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1940 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1941 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1942 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1943 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1944 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1945 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1946 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1947 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1948 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1949 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1950 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1951 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1952 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1953 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1954 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1955 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1956 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1957 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1958 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1959 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1960 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1961 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1962 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1963 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1964 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1965 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1966 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1967 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1968 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1969 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1970 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1971 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1972 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1973 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1974 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1975 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1976 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1977 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1978 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1979 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1980 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1984 return BFD_RELOC_UNUSED
;
1986 for (ch
= *str
, str2
= ident
;
1987 (str2
< ident
+ sizeof (ident
) - 1
1988 && (ISALNUM (ch
) || ch
== '@'));
1991 *str2
++ = TOLOWER (ch
);
1998 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1999 if (ch
== ptr
->string
[0]
2000 && len
== ptr
->length
2001 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
2002 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
2004 int reloc
= ptr
->reloc
;
2006 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
2010 case BFD_RELOC_16_GOTOFF
:
2011 case BFD_RELOC_LO16_GOTOFF
:
2012 case BFD_RELOC_HI16_GOTOFF
:
2013 case BFD_RELOC_HI16_S_GOTOFF
:
2014 as_warn (_("identifier+constant@got means "
2015 "identifier@got+constant"));
2018 case BFD_RELOC_PPC_GOT_TLSGD16
:
2019 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2020 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2021 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2022 case BFD_RELOC_PPC_GOT_TLSLD16
:
2023 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2024 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2025 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2026 case BFD_RELOC_PPC_GOT_DTPREL16
:
2027 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2028 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2029 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2030 case BFD_RELOC_PPC_GOT_TPREL16
:
2031 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2032 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2033 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2034 as_bad (_("symbol+offset not supported for got tls"));
2039 /* Now check for identifier@suffix+constant. */
2040 if (*str
== '-' || *str
== '+')
2042 char *orig_line
= input_line_pointer
;
2043 expressionS new_exp
;
2045 input_line_pointer
= str
;
2046 expression (&new_exp
);
2047 if (new_exp
.X_op
== O_constant
)
2049 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2050 str
= input_line_pointer
;
2053 if (&input_line_pointer
!= str_p
)
2054 input_line_pointer
= orig_line
;
2058 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2059 && exp_p
->X_op
== O_symbol
2060 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2062 /* Change the symbol so that the dummy .TOC. symbol can be
2063 omitted from the object file. */
2064 exp_p
->X_add_symbol
= &abs_symbol
;
2067 return (bfd_reloc_code_real_type
) reloc
;
2070 return BFD_RELOC_UNUSED
;
2073 /* Like normal .long/.short/.word, except support @got, etc.
2074 Clobbers input_line_pointer, checks end-of-line. */
2076 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2079 bfd_reloc_code_real_type reloc
;
2081 if (is_it_end_of_statement ())
2083 demand_empty_rest_of_line ();
2090 if (exp
.X_op
== O_symbol
2091 && *input_line_pointer
== '@'
2092 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2093 &exp
)) != BFD_RELOC_UNUSED
)
2095 reloc_howto_type
*reloc_howto
;
2098 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2099 size
= bfd_get_reloc_size (reloc_howto
);
2103 as_bad (_("%s relocations do not fit in %d bytes\n"),
2104 reloc_howto
->name
, nbytes
);
2111 p
= frag_more (nbytes
);
2112 memset (p
, 0, nbytes
);
2114 if (target_big_endian
)
2115 offset
= nbytes
- size
;
2116 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2121 emit_expr (&exp
, (unsigned int) nbytes
);
2123 while (*input_line_pointer
++ == ',');
2125 /* Put terminator back into stream. */
2126 input_line_pointer
--;
2127 demand_empty_rest_of_line ();
2130 /* Solaris pseduo op to change to the .rodata section. */
2132 ppc_elf_rdata (int xxx
)
2134 char *save_line
= input_line_pointer
;
2135 static char section
[] = ".rodata\n";
2137 /* Just pretend this is .section .rodata */
2138 input_line_pointer
= section
;
2139 obj_elf_section (xxx
);
2141 input_line_pointer
= save_line
;
2144 /* Pseudo op to make file scope bss items. */
2146 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2159 name
= input_line_pointer
;
2160 c
= get_symbol_end ();
2162 /* just after name is now '\0'. */
2163 p
= input_line_pointer
;
2166 if (*input_line_pointer
!= ',')
2168 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
2169 ignore_rest_of_line ();
2173 input_line_pointer
++; /* skip ',' */
2174 if ((size
= get_absolute_expression ()) < 0)
2176 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2177 ignore_rest_of_line ();
2181 /* The third argument to .lcomm is the alignment. */
2182 if (*input_line_pointer
!= ',')
2186 ++input_line_pointer
;
2187 align
= get_absolute_expression ();
2190 as_warn (_("ignoring bad alignment"));
2196 symbolP
= symbol_find_or_make (name
);
2199 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2201 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2202 S_GET_NAME (symbolP
));
2203 ignore_rest_of_line ();
2207 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2209 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2210 S_GET_NAME (symbolP
),
2211 (long) S_GET_VALUE (symbolP
),
2214 ignore_rest_of_line ();
2220 old_subsec
= now_subseg
;
2223 /* Convert to a power of 2 alignment. */
2224 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2227 as_bad (_("Common alignment not a power of 2"));
2228 ignore_rest_of_line ();
2235 record_alignment (bss_section
, align2
);
2236 subseg_set (bss_section
, 0);
2238 frag_align (align2
, 0, 0);
2239 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2240 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2241 symbol_set_frag (symbolP
, frag_now
);
2242 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2245 S_SET_SIZE (symbolP
, size
);
2246 S_SET_SEGMENT (symbolP
, bss_section
);
2247 subseg_set (old_sec
, old_subsec
);
2248 demand_empty_rest_of_line ();
2251 /* Validate any relocations emitted for -mrelocatable, possibly adding
2252 fixups for word relocations in writable segments, so we can adjust
2255 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2257 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2266 case SHLIB_MRELOCATABLE
:
2267 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2268 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2269 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2270 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2271 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2272 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2273 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2274 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2275 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2276 && (seg
->flags
& SEC_LOAD
) != 0
2277 && strcmp (segment_name (seg
), ".got2") != 0
2278 && strcmp (segment_name (seg
), ".dtors") != 0
2279 && strcmp (segment_name (seg
), ".ctors") != 0
2280 && strcmp (segment_name (seg
), ".fixup") != 0
2281 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2282 && strcmp (segment_name (seg
), ".eh_frame") != 0
2283 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2285 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2286 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2288 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2289 _("Relocation cannot be done when using -mrelocatable"));
2296 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2297 function descriptor sym if the corresponding code sym is used. */
2300 ppc_frob_file_before_adjust (void)
2308 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2315 name
= S_GET_NAME (symp
);
2319 if (! S_IS_WEAK (symp
)
2320 || S_IS_DEFINED (symp
))
2323 len
= strlen (name
) + 1;
2324 dotname
= xmalloc (len
+ 1);
2326 memcpy (dotname
+ 1, name
, len
);
2327 dotsym
= symbol_find_noref (dotname
, 1);
2329 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2330 || symbol_used_in_reloc_p (dotsym
)))
2331 symbol_mark_used (symp
);
2335 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2337 && toc_reloc_types
!= has_large_toc_reloc
2338 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2339 as_warn (_("TOC section size exceeds 64k"));
2341 /* Don't emit .TOC. symbol. */
2342 symp
= symbol_find (".TOC.");
2344 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2346 #endif /* OBJ_ELF */
2351 * Summary of parse_toc_entry.
2353 * in: Input_line_pointer points to the '[' in one of:
2355 * [toc] [tocv] [toc32] [toc64]
2357 * Anything else is an error of one kind or another.
2360 * return value: success or failure
2361 * toc_kind: kind of toc reference
2362 * input_line_pointer:
2363 * success: first char after the ']'
2364 * failure: unchanged
2368 * [toc] - rv == success, toc_kind = default_toc
2369 * [tocv] - rv == success, toc_kind = data_in_toc
2370 * [toc32] - rv == success, toc_kind = must_be_32
2371 * [toc64] - rv == success, toc_kind = must_be_64
2375 enum toc_size_qualifier
2377 default_toc
, /* The toc cell constructed should be the system default size */
2378 data_in_toc
, /* This is a direct reference to a toc cell */
2379 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2380 must_be_64
/* The toc cell constructed must be 64 bits wide */
2384 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2389 enum toc_size_qualifier t
;
2391 /* Save the input_line_pointer. */
2392 start
= input_line_pointer
;
2394 /* Skip over the '[' , and whitespace. */
2395 ++input_line_pointer
;
2398 /* Find the spelling of the operand. */
2399 toc_spec
= input_line_pointer
;
2400 c
= get_symbol_end ();
2402 if (strcmp (toc_spec
, "toc") == 0)
2406 else if (strcmp (toc_spec
, "tocv") == 0)
2410 else if (strcmp (toc_spec
, "toc32") == 0)
2414 else if (strcmp (toc_spec
, "toc64") == 0)
2420 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2421 *input_line_pointer
= c
;
2422 input_line_pointer
= start
;
2426 /* Now find the ']'. */
2427 *input_line_pointer
= c
;
2429 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2430 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2434 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2435 input_line_pointer
= start
;
2446 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2448 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2452 /* Check we don't already exist. */
2453 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2454 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2457 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2459 if (ppc_apuinfo_num_alloc
== 0)
2461 ppc_apuinfo_num_alloc
= 4;
2462 ppc_apuinfo_list
= (unsigned long *)
2463 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2467 ppc_apuinfo_num_alloc
+= 4;
2468 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2469 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2472 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2478 /* We need to keep a list of fixups. We can't simply generate them as
2479 we go, because that would require us to first create the frag, and
2480 that would screw up references to ``.''. */
2486 bfd_reloc_code_real_type reloc
;
2489 #define MAX_INSN_FIXUPS (5)
2492 #define E_OR2I_INSN 0x7000C000
2493 #define E_AND2I_DOT_INSN 0x7000C800
2494 #define E_OR2IS_INSN 0x7000D000
2495 #define E_LIS_INSN 0x7000E000
2496 #define E_AND2IS_DOT_INSN 0x7000E800
2499 #define E_ADD2I_DOT_INSN 0x70008800
2500 #define E_ADD2IS_INSN 0x70009000
2501 #define E_CMP16I_INSN 0x70009800
2502 #define E_MULL2I_INSN 0x7000A000
2503 #define E_CMPL16I_INSN 0x7000A800
2504 #define E_CMPH16I_INSN 0x7000B000
2505 #define E_CMPHL16I_INSN 0x7000B800
2507 /* This routine is called for each instruction to be assembled. */
2510 md_assemble (char *str
)
2513 const struct powerpc_opcode
*opcode
;
2515 const unsigned char *opindex_ptr
;
2519 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2524 unsigned int insn_length
;
2526 bfd_reloc_code_real_type reloc
;
2529 /* Get the opcode. */
2530 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2535 /* Look up the opcode in the hash table. */
2536 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2537 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2539 const struct powerpc_macro
*macro
;
2541 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2542 if (macro
== (const struct powerpc_macro
*) NULL
)
2543 as_bad (_("Unrecognized opcode: `%s'"), str
);
2545 ppc_macro (s
, macro
);
2550 insn
= opcode
->opcode
;
2553 while (ISSPACE (*str
))
2556 /* PowerPC operands are just expressions. The only real issue is
2557 that a few operand types are optional. All cases which might use
2558 an optional operand separate the operands only with commas (in some
2559 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2560 have optional operands). Most instructions with optional operands
2561 have only one. Those that have more than one optional operand can
2562 take either all their operands or none. So, before we start seriously
2563 parsing the operands, we check to see if we have optional operands,
2564 and if we do, we count the number of commas to see which operands
2565 have been omitted. */
2567 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2569 const struct powerpc_operand
*operand
;
2571 operand
= &powerpc_operands
[*opindex_ptr
];
2572 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2574 unsigned int opcount
;
2575 unsigned int num_operands_expected
;
2577 /* There is an optional operand. Count the number of
2578 commas in the input line. */
2585 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2592 /* Compute the number of expected operands.
2593 Do not count fake operands. */
2594 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2595 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2596 ++ num_operands_expected
;
2598 /* If there are fewer operands in the line then are called
2599 for by the instruction, we want to skip the optional
2601 if (opcount
< num_operands_expected
)
2608 /* Gather the operands. */
2612 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2614 const struct powerpc_operand
*operand
;
2620 if (next_opindex
== 0)
2621 operand
= &powerpc_operands
[*opindex_ptr
];
2624 operand
= &powerpc_operands
[next_opindex
];
2629 /* If this is a fake operand, then we do not expect anything
2631 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2633 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2634 if (errmsg
!= (const char *) NULL
)
2635 as_bad ("%s", errmsg
);
2639 /* If this is an optional operand, and we are skipping it, just
2641 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2644 if (operand
->insert
)
2646 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2647 if (errmsg
!= (const char *) NULL
)
2648 as_bad ("%s", errmsg
);
2650 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2651 next_opindex
= *opindex_ptr
+ 1;
2655 /* Gather the operand. */
2656 hold
= input_line_pointer
;
2657 input_line_pointer
= str
;
2660 if (*input_line_pointer
== '[')
2662 /* We are expecting something like the second argument here:
2664 * lwz r4,[toc].GS.0.static_int(rtoc)
2665 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2666 * The argument following the `]' must be a symbol name, and the
2667 * register must be the toc register: 'rtoc' or '2'
2669 * The effect is to 0 as the displacement field
2670 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2671 * the appropriate variation) reloc against it based on the symbol.
2672 * The linker will build the toc, and insert the resolved toc offset.
2675 * o The size of the toc entry is currently assumed to be
2676 * 32 bits. This should not be assumed to be a hard coded
2678 * o In an effort to cope with a change from 32 to 64 bits,
2679 * there are also toc entries that are specified to be
2680 * either 32 or 64 bits:
2681 * lwz r4,[toc32].GS.0.static_int(rtoc)
2682 * lwz r4,[toc64].GS.0.static_int(rtoc)
2683 * These demand toc entries of the specified size, and the
2684 * instruction probably requires it.
2688 enum toc_size_qualifier toc_kind
;
2689 bfd_reloc_code_real_type toc_reloc
;
2691 /* Go parse off the [tocXX] part. */
2692 valid_toc
= parse_toc_entry (&toc_kind
);
2696 /* Note: message has already been issued.
2697 FIXME: what sort of recovery should we do?
2698 demand_rest_of_line (); return; ? */
2701 /* Now get the symbol following the ']'. */
2707 /* In this case, we may not have seen the symbol yet,
2708 since it is allowed to appear on a .extern or .globl
2709 or just be a label in the .data section. */
2710 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2713 /* 1. The symbol must be defined and either in the toc
2714 section, or a global.
2715 2. The reloc generated must have the TOCDEFN flag set
2716 in upper bit mess of the reloc type.
2717 FIXME: It's a little confusing what the tocv
2718 qualifier can be used for. At the very least, I've
2719 seen three uses, only one of which I'm sure I can
2721 if (ex
.X_op
== O_symbol
)
2723 gas_assert (ex
.X_add_symbol
!= NULL
);
2724 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2727 as_bad (_("[tocv] symbol is not a toc symbol"));
2731 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2734 /* FIXME: these next two specifically specify 32/64 bit
2735 toc entries. We don't support them today. Is this
2736 the right way to say that? */
2737 toc_reloc
= BFD_RELOC_UNUSED
;
2738 as_bad (_("Unimplemented toc32 expression modifier"));
2741 /* FIXME: see above. */
2742 toc_reloc
= BFD_RELOC_UNUSED
;
2743 as_bad (_("Unimplemented toc64 expression modifier"));
2747 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2753 /* We need to generate a fixup for this expression. */
2754 if (fc
>= MAX_INSN_FIXUPS
)
2755 as_fatal (_("too many fixups"));
2757 fixups
[fc
].reloc
= toc_reloc
;
2758 fixups
[fc
].exp
= ex
;
2759 fixups
[fc
].opindex
= *opindex_ptr
;
2762 /* Ok. We've set up the fixup for the instruction. Now make it
2763 look like the constant 0 was found here. */
2765 ex
.X_op
= O_constant
;
2766 ex
.X_add_number
= 0;
2767 ex
.X_add_symbol
= NULL
;
2768 ex
.X_op_symbol
= NULL
;
2775 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2776 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2777 || !register_name (&ex
))
2779 char save_lex
= lex_type
['%'];
2781 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2782 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2785 lex_type
['%'] |= LEX_BEGIN_NAME
;
2789 lex_type
['%'] = save_lex
;
2793 str
= input_line_pointer
;
2794 input_line_pointer
= hold
;
2796 if (ex
.X_op
== O_illegal
)
2797 as_bad (_("illegal operand"));
2798 else if (ex
.X_op
== O_absent
)
2799 as_bad (_("missing operand"));
2800 else if (ex
.X_op
== O_register
)
2802 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2803 ppc_cpu
, (char *) NULL
, 0);
2805 else if (ex
.X_op
== O_constant
)
2808 /* Allow @HA, @L, @H on constants. */
2809 char *orig_str
= str
;
2811 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2818 case BFD_RELOC_LO16
:
2819 /* X_unsigned is the default, so if the user has done
2820 something which cleared it, we always produce a
2822 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2823 ex
.X_add_number
&= 0xffff;
2825 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2828 case BFD_RELOC_HI16
:
2829 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2830 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2832 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2835 case BFD_RELOC_HI16_S
:
2836 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2837 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2839 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2842 case BFD_RELOC_PPC64_HIGHER
:
2843 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2844 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2846 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2849 case BFD_RELOC_PPC64_HIGHER_S
:
2850 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2851 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2853 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2856 case BFD_RELOC_PPC64_HIGHEST
:
2857 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2858 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2860 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2863 case BFD_RELOC_PPC64_HIGHEST_S
:
2864 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2865 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2867 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2870 #endif /* OBJ_ELF */
2871 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2872 ppc_cpu
, (char *) NULL
, 0);
2877 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2879 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2880 if (sym_name
[0] == '.')
2883 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2885 expressionS tls_exp
;
2887 hold
= input_line_pointer
;
2888 input_line_pointer
= str
+ 1;
2889 expression (&tls_exp
);
2890 if (tls_exp
.X_op
== O_symbol
)
2892 reloc
= BFD_RELOC_UNUSED
;
2893 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2895 reloc
= BFD_RELOC_PPC_TLSGD
;
2896 input_line_pointer
+= 7;
2898 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2900 reloc
= BFD_RELOC_PPC_TLSLD
;
2901 input_line_pointer
+= 7;
2903 if (reloc
!= BFD_RELOC_UNUSED
)
2906 str
= input_line_pointer
;
2908 if (fc
>= MAX_INSN_FIXUPS
)
2909 as_fatal (_("too many fixups"));
2910 fixups
[fc
].exp
= tls_exp
;
2911 fixups
[fc
].opindex
= *opindex_ptr
;
2912 fixups
[fc
].reloc
= reloc
;
2916 input_line_pointer
= hold
;
2920 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2922 /* Some TLS tweaks. */
2928 case BFD_RELOC_PPC_TLS
:
2929 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2930 as_bad (_("@tls may not be used with \"%s\" operands"),
2932 else if (operand
->shift
!= 11)
2933 as_bad (_("@tls may only be used in last operand"));
2935 insn
= ppc_insert_operand (insn
, operand
,
2937 ppc_cpu
, (char *) NULL
, 0);
2940 /* We'll only use the 32 (or 64) bit form of these relocations
2941 in constants. Instructions get the 16 bit form. */
2942 case BFD_RELOC_PPC_DTPREL
:
2943 reloc
= BFD_RELOC_PPC_DTPREL16
;
2945 case BFD_RELOC_PPC_TPREL
:
2946 reloc
= BFD_RELOC_PPC_TPREL16
;
2950 /* If VLE-mode convert LO/HI/HA relocations. */
2951 if (opcode
->flags
& PPC_OPCODE_VLE
)
2953 int tmp_insn
= insn
& opcode
->mask
;
2955 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
2956 || tmp_insn
== E_AND2I_DOT_INSN
2957 || tmp_insn
== E_OR2IS_INSN
2958 || tmp_insn
== E_LIS_INSN
2959 || tmp_insn
== E_AND2IS_DOT_INSN
);
2962 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
2963 || tmp_insn
== E_ADD2IS_INSN
2964 || tmp_insn
== E_CMP16I_INSN
2965 || tmp_insn
== E_MULL2I_INSN
2966 || tmp_insn
== E_CMPL16I_INSN
2967 || tmp_insn
== E_CMPH16I_INSN
2968 || tmp_insn
== E_CMPHL16I_INSN
);
2975 case BFD_RELOC_PPC_EMB_SDA21
:
2976 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
2979 case BFD_RELOC_LO16
:
2981 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
2982 else if (use_a_reloc
)
2983 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
2986 case BFD_RELOC_HI16
:
2988 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
2989 else if (use_a_reloc
)
2990 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
2993 case BFD_RELOC_HI16_S
:
2995 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
2996 else if (use_a_reloc
)
2997 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3000 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3002 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3005 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3007 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3010 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3012 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3017 /* For the absolute forms of branches, convert the PC
3018 relative form back into the absolute. */
3019 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3023 case BFD_RELOC_PPC_B26
:
3024 reloc
= BFD_RELOC_PPC_BA26
;
3026 case BFD_RELOC_PPC_B16
:
3027 reloc
= BFD_RELOC_PPC_BA16
;
3029 case BFD_RELOC_PPC_B16_BRTAKEN
:
3030 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3032 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3033 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3042 case BFD_RELOC_PPC_TOC16
:
3043 toc_reloc_types
|= has_small_toc_reloc
;
3045 case BFD_RELOC_PPC64_TOC16_LO
:
3046 case BFD_RELOC_PPC64_TOC16_HI
:
3047 case BFD_RELOC_PPC64_TOC16_HA
:
3048 toc_reloc_types
|= has_large_toc_reloc
;
3055 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3060 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3062 case BFD_RELOC_LO16
:
3063 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3065 case BFD_RELOC_16_GOTOFF
:
3066 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3068 case BFD_RELOC_LO16_GOTOFF
:
3069 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3071 case BFD_RELOC_LO16_PLTOFF
:
3072 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3074 case BFD_RELOC_16_BASEREL
:
3075 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3077 case BFD_RELOC_LO16_BASEREL
:
3078 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3080 case BFD_RELOC_PPC_TOC16
:
3081 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3083 case BFD_RELOC_PPC64_TOC16_LO
:
3084 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3086 case BFD_RELOC_PPC64_PLTGOT16
:
3087 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3089 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3090 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3092 case BFD_RELOC_PPC_DTPREL16
:
3093 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3095 case BFD_RELOC_PPC_DTPREL16_LO
:
3096 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3098 case BFD_RELOC_PPC_TPREL16
:
3099 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3101 case BFD_RELOC_PPC_TPREL16_LO
:
3102 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3104 case BFD_RELOC_PPC_GOT_DTPREL16
:
3105 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3106 case BFD_RELOC_PPC_GOT_TPREL16
:
3107 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3110 as_bad (_("unsupported relocation for DS offset field"));
3116 /* We need to generate a fixup for this expression. */
3117 if (fc
>= MAX_INSN_FIXUPS
)
3118 as_fatal (_("too many fixups"));
3119 fixups
[fc
].exp
= ex
;
3120 fixups
[fc
].opindex
= *opindex_ptr
;
3121 fixups
[fc
].reloc
= reloc
;
3127 /* We need to generate a fixup for this expression. */
3128 if (fc
>= MAX_INSN_FIXUPS
)
3129 as_fatal (_("too many fixups"));
3130 fixups
[fc
].exp
= ex
;
3131 fixups
[fc
].opindex
= *opindex_ptr
;
3132 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
3135 #endif /* OBJ_ELF */
3141 /* If expecting more operands, then we want to see "),". */
3142 if (*str
== endc
&& opindex_ptr
[1] != 0)
3146 while (ISSPACE (*str
));
3150 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3158 /* The call to expression should have advanced str past any
3161 && (endc
!= ',' || *str
!= '\0'))
3164 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3166 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3174 while (ISSPACE (*str
))
3178 as_bad (_("junk at end of line: `%s'"), str
);
3181 /* Do we need/want an APUinfo section? */
3182 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0)
3184 /* These are all version "1". */
3185 if (opcode
->flags
& PPC_OPCODE_SPE
)
3186 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3187 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3188 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3189 if (opcode
->flags
& PPC_OPCODE_EFS
)
3190 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3191 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3192 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3193 if (opcode
->flags
& PPC_OPCODE_PMR
)
3194 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3195 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3196 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3197 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3198 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3199 if (opcode
->flags
& PPC_OPCODE_VLE
)
3200 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3204 /* Write out the instruction. */
3205 /* Differentiate between two and four byte insns. */
3206 if (ppc_mach () == bfd_mach_ppc_vle
)
3208 if (PPC_OP_SE_VLE (insn
))
3212 addr_mod
= frag_now_fix () & 1;
3217 addr_mod
= frag_now_fix () & 3;
3219 /* All instructions can start on a 2 byte boundary for VLE. */
3220 f
= frag_more (insn_length
);
3221 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3223 if (ppc_mach() == bfd_mach_ppc_vle
)
3224 as_bad (_("instruction address is not a multiple of 2"));
3226 as_bad (_("instruction address is not a multiple of 4"));
3228 frag_now
->insn_addr
= addr_mod
;
3229 frag_now
->has_code
= 1;
3230 md_number_to_chars (f
, insn
, insn_length
);
3233 dwarf2_emit_insn (insn_length
);
3236 /* Create any fixups. At this point we do not use a
3237 bfd_reloc_code_real_type, but instead just use the
3238 BFD_RELOC_UNUSED plus the operand index. This lets us easily
3239 handle fixups for any operand type, although that is admittedly
3240 not a very exciting feature. We pick a BFD reloc type in
3242 for (i
= 0; i
< fc
; i
++)
3244 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3246 reloc_howto_type
*reloc_howto
;
3251 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3255 size
= bfd_get_reloc_size (reloc_howto
);
3256 offset
= target_big_endian
? (4 - size
) : 0;
3258 if (size
< 1 || size
> 4)
3261 fixP
= fix_new_exp (frag_now
,
3262 f
- frag_now
->fr_literal
+ offset
,
3265 reloc_howto
->pc_relative
,
3268 /* Turn off complaints that the addend is too large for things like
3270 switch (fixups
[i
].reloc
)
3272 case BFD_RELOC_16_GOTOFF
:
3273 case BFD_RELOC_PPC_TOC16
:
3274 case BFD_RELOC_LO16
:
3275 case BFD_RELOC_HI16
:
3276 case BFD_RELOC_HI16_S
:
3277 case BFD_RELOC_PPC_VLE_LO16A
:
3278 case BFD_RELOC_PPC_VLE_LO16D
:
3279 case BFD_RELOC_PPC_VLE_HI16A
:
3280 case BFD_RELOC_PPC_VLE_HI16D
:
3281 case BFD_RELOC_PPC_VLE_HA16A
:
3282 case BFD_RELOC_PPC_VLE_HA16D
:
3284 case BFD_RELOC_PPC64_HIGHER
:
3285 case BFD_RELOC_PPC64_HIGHER_S
:
3286 case BFD_RELOC_PPC64_HIGHEST
:
3287 case BFD_RELOC_PPC64_HIGHEST_S
:
3289 fixP
->fx_no_overflow
= 1;
3297 const struct powerpc_operand
*operand
;
3299 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3300 fix_new_exp (frag_now
,
3301 f
- frag_now
->fr_literal
,
3304 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3305 ((bfd_reloc_code_real_type
)
3306 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
3311 /* Handle a macro. Gather all the operands, transform them as
3312 described by the macro, and call md_assemble recursively. All the
3313 operands are separated by commas; we don't accept parentheses
3314 around operands here. */
3317 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3328 /* Gather the users operands into the operands array. */
3333 if (count
>= sizeof operands
/ sizeof operands
[0])
3335 operands
[count
++] = s
;
3336 s
= strchr (s
, ',');
3337 if (s
== (char *) NULL
)
3342 if (count
!= macro
->operands
)
3344 as_bad (_("wrong number of operands"));
3348 /* Work out how large the string must be (the size is unbounded
3349 because it includes user input). */
3351 format
= macro
->format
;
3352 while (*format
!= '\0')
3361 arg
= strtol (format
+ 1, &send
, 10);
3362 know (send
!= format
&& arg
< count
);
3363 len
+= strlen (operands
[arg
]);
3368 /* Put the string together. */
3369 complete
= s
= (char *) alloca (len
+ 1);
3370 format
= macro
->format
;
3371 while (*format
!= '\0')
3377 arg
= strtol (format
+ 1, &send
, 10);
3378 strcpy (s
, operands
[arg
]);
3385 /* Assemble the constructed instruction. */
3386 md_assemble (complete
);
3390 /* For ELF, add support for SHT_ORDERED. */
3393 ppc_section_type (char *str
, size_t len
)
3395 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3402 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3404 if (type
== SHT_ORDERED
)
3405 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3409 #endif /* OBJ_ELF */
3412 /* Pseudo-op handling. */
3414 /* The .byte pseudo-op. This is similar to the normal .byte
3415 pseudo-op, but it can also take a single ASCII string. */
3418 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3420 if (*input_line_pointer
!= '\"')
3426 /* Gather characters. A real double quote is doubled. Unusual
3427 characters are not permitted. */
3428 ++input_line_pointer
;
3433 c
= *input_line_pointer
++;
3437 if (*input_line_pointer
!= '\"')
3439 ++input_line_pointer
;
3442 FRAG_APPEND_1_CHAR (c
);
3445 demand_empty_rest_of_line ();
3450 /* XCOFF specific pseudo-op handling. */
3452 /* This is set if we are creating a .stabx symbol, since we don't want
3453 to handle symbol suffixes for such symbols. */
3454 static bfd_boolean ppc_stab_symbol
;
3456 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3457 symbols in the .bss segment as though they were local common
3458 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3459 aligns .comm and .lcomm to 4 bytes. */
3462 ppc_comm (int lcomm
)
3464 asection
*current_seg
= now_seg
;
3465 subsegT current_subseg
= now_subseg
;
3471 symbolS
*lcomm_sym
= NULL
;
3475 name
= input_line_pointer
;
3476 endc
= get_symbol_end ();
3477 end_name
= input_line_pointer
;
3480 if (*input_line_pointer
!= ',')
3482 as_bad (_("missing size"));
3483 ignore_rest_of_line ();
3486 ++input_line_pointer
;
3488 size
= get_absolute_expression ();
3491 as_bad (_("negative size"));
3492 ignore_rest_of_line ();
3498 /* The third argument to .comm is the alignment. */
3499 if (*input_line_pointer
!= ',')
3503 ++input_line_pointer
;
3504 align
= get_absolute_expression ();
3507 as_warn (_("ignoring bad alignment"));
3522 /* The third argument to .lcomm appears to be the real local
3523 common symbol to create. References to the symbol named in
3524 the first argument are turned into references to the third
3526 if (*input_line_pointer
!= ',')
3528 as_bad (_("missing real symbol name"));
3529 ignore_rest_of_line ();
3532 ++input_line_pointer
;
3534 lcomm_name
= input_line_pointer
;
3535 lcomm_endc
= get_symbol_end ();
3537 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3539 *input_line_pointer
= lcomm_endc
;
3543 sym
= symbol_find_or_make (name
);
3546 if (S_IS_DEFINED (sym
)
3547 || S_GET_VALUE (sym
) != 0)
3549 as_bad (_("attempt to redefine symbol"));
3550 ignore_rest_of_line ();
3554 record_alignment (bss_section
, align
);
3557 || ! S_IS_DEFINED (lcomm_sym
))
3566 S_SET_EXTERNAL (sym
);
3570 symbol_get_tc (lcomm_sym
)->output
= 1;
3571 def_sym
= lcomm_sym
;
3575 subseg_set (bss_section
, 1);
3576 frag_align (align
, 0, 0);
3578 symbol_set_frag (def_sym
, frag_now
);
3579 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3580 def_size
, (char *) NULL
);
3582 S_SET_SEGMENT (def_sym
, bss_section
);
3583 symbol_get_tc (def_sym
)->align
= align
;
3587 /* Align the size of lcomm_sym. */
3588 symbol_get_frag (lcomm_sym
)->fr_offset
=
3589 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3590 &~ ((1 << align
) - 1));
3591 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3592 symbol_get_tc (lcomm_sym
)->align
= align
;
3597 /* Make sym an offset from lcomm_sym. */
3598 S_SET_SEGMENT (sym
, bss_section
);
3599 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3600 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3601 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3604 subseg_set (current_seg
, current_subseg
);
3606 demand_empty_rest_of_line ();
3609 /* The .csect pseudo-op. This switches us into a different
3610 subsegment. The first argument is a symbol whose value is the
3611 start of the .csect. In COFF, csect symbols get special aux
3612 entries defined by the x_csect field of union internal_auxent. The
3613 optional second argument is the alignment (the default is 2). */
3616 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3623 name
= input_line_pointer
;
3624 endc
= get_symbol_end ();
3626 sym
= symbol_find_or_make (name
);
3628 *input_line_pointer
= endc
;
3630 if (S_GET_NAME (sym
)[0] == '\0')
3632 /* An unnamed csect is assumed to be [PR]. */
3633 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3637 if (*input_line_pointer
== ',')
3639 ++input_line_pointer
;
3640 align
= get_absolute_expression ();
3643 ppc_change_csect (sym
, align
);
3645 demand_empty_rest_of_line ();
3648 /* Change to a different csect. */
3651 ppc_change_csect (symbolS
*sym
, offsetT align
)
3653 if (S_IS_DEFINED (sym
))
3654 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3664 /* This is a new csect. We need to look at the symbol class to
3665 figure out whether it should go in the text section or the
3669 switch (symbol_get_tc (sym
)->symbol_class
)
3679 S_SET_SEGMENT (sym
, text_section
);
3680 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3681 ++ppc_text_subsegment
;
3682 list_ptr
= &ppc_text_csects
;
3692 if (ppc_toc_csect
!= NULL
3693 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3694 == ppc_data_subsegment
))
3696 S_SET_SEGMENT (sym
, data_section
);
3697 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3698 ++ppc_data_subsegment
;
3699 list_ptr
= &ppc_data_csects
;
3705 /* We set the obstack chunk size to a small value before
3706 changing subsegments, so that we don't use a lot of memory
3707 space for what may be a small section. */
3708 hold_chunksize
= chunksize
;
3711 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3712 symbol_get_tc (sym
)->subseg
);
3714 chunksize
= hold_chunksize
;
3717 ppc_after_toc_frag
= frag_now
;
3719 record_alignment (sec
, align
);
3721 frag_align_code (align
, 0);
3723 frag_align (align
, 0, 0);
3725 symbol_set_frag (sym
, frag_now
);
3726 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3728 symbol_get_tc (sym
)->align
= align
;
3729 symbol_get_tc (sym
)->output
= 1;
3730 symbol_get_tc (sym
)->within
= sym
;
3732 for (list
= *list_ptr
;
3733 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3734 list
= symbol_get_tc (list
)->next
)
3736 symbol_get_tc (list
)->next
= sym
;
3738 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3739 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3743 ppc_current_csect
= sym
;
3747 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3751 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3753 sec
= subseg_new (dw
->name
, subseg
);
3754 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3755 if (oldflags
== SEC_NO_FLAGS
)
3757 /* Just created section. */
3758 gas_assert (dw_sections
[idx
].sect
== NULL
);
3760 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3761 bfd_set_section_alignment (stdoutput
, sec
, 0);
3762 dw_sections
[idx
].sect
= sec
;
3765 /* Not anymore in a csect. */
3766 ppc_current_csect
= NULL
;
3769 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3770 .dwsect flag [, opt-label ]
3774 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3778 const struct xcoff_dwsect_name
*dw
;
3779 struct dw_subsection
*subseg
;
3780 struct dw_section
*dws
;
3784 flag
= get_absolute_expression ();
3786 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3787 if (xcoff_dwsect_names
[i
].flag
== flag
)
3789 dw
= &xcoff_dwsect_names
[i
];
3793 /* Parse opt-label. */
3794 if (*input_line_pointer
== ',')
3799 ++input_line_pointer
;
3801 label
= input_line_pointer
;
3802 c
= get_symbol_end ();
3803 opt_label
= symbol_find_or_make (label
);
3804 *input_line_pointer
= c
;
3809 demand_empty_rest_of_line ();
3811 /* Return now in case of unknown subsection. */
3814 as_bad (_("No known dwarf XCOFF section for flag 0x%08x\n"),
3819 /* Find the subsection. */
3820 dws
= &dw_sections
[i
];
3822 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3824 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3825 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3827 as_bad (_("label %s was not defined in this dwarf section"),
3828 S_GET_NAME (opt_label
));
3829 subseg
= dws
->anon_subseg
;
3833 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3838 /* Switch to the subsection. */
3839 ppc_change_debug_section (i
, subseg
->subseg
);
3843 /* Create a new dw subsection. */
3844 subseg
= (struct dw_subsection
*)
3845 xmalloc (sizeof (struct dw_subsection
));
3847 if (opt_label
== NULL
)
3849 /* The anonymous one. */
3851 subseg
->link
= NULL
;
3852 dws
->anon_subseg
= subseg
;
3857 if (dws
->list_subseg
!= NULL
)
3858 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3862 subseg
->link
= dws
->list_subseg
;
3863 dws
->list_subseg
= subseg
;
3864 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3867 ppc_change_debug_section (i
, subseg
->subseg
);
3871 /* Add the length field. */
3872 expressionS
*exp
= &subseg
->end_exp
;
3875 if (opt_label
!= NULL
)
3876 symbol_set_value_now (opt_label
);
3878 /* Add the length field. Note that according to the AIX assembler
3879 manual, the size of the length field is 4 for powerpc32 but
3880 12 for powerpc64. */
3883 /* Write the 64bit marker. */
3884 md_number_to_chars (frag_more (4), -1, 4);
3887 exp
->X_op
= O_subtract
;
3888 exp
->X_op_symbol
= symbol_temp_new_now ();
3889 exp
->X_add_symbol
= symbol_temp_make ();
3891 sz
= ppc_obj64
? 8 : 4;
3892 exp
->X_add_number
= -sz
;
3893 emit_expr (exp
, sz
);
3898 /* This function handles the .text and .data pseudo-ops. These
3899 pseudo-ops aren't really used by XCOFF; we implement them for the
3900 convenience of people who aren't used to XCOFF. */
3903 ppc_section (int type
)
3910 else if (type
== 'd')
3915 sym
= symbol_find_or_make (name
);
3917 ppc_change_csect (sym
, 2);
3919 demand_empty_rest_of_line ();
3922 /* This function handles the .section pseudo-op. This is mostly to
3923 give an error, since XCOFF only supports .text, .data and .bss, but
3924 we do permit the user to name the text or data section. */
3927 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3930 const char *real_name
;
3934 user_name
= input_line_pointer
;
3935 c
= get_symbol_end ();
3937 if (strcmp (user_name
, ".text") == 0)
3938 real_name
= ".text[PR]";
3939 else if (strcmp (user_name
, ".data") == 0)
3940 real_name
= ".data[RW]";
3943 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3944 *input_line_pointer
= c
;
3945 ignore_rest_of_line ();
3949 *input_line_pointer
= c
;
3951 sym
= symbol_find_or_make (real_name
);
3953 ppc_change_csect (sym
, 2);
3955 demand_empty_rest_of_line ();
3958 /* The .extern pseudo-op. We create an undefined symbol. */
3961 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
3966 name
= input_line_pointer
;
3967 endc
= get_symbol_end ();
3969 (void) symbol_find_or_make (name
);
3971 *input_line_pointer
= endc
;
3973 demand_empty_rest_of_line ();
3976 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3979 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
3985 name
= input_line_pointer
;
3986 endc
= get_symbol_end ();
3988 sym
= symbol_find_or_make (name
);
3990 *input_line_pointer
= endc
;
3992 symbol_get_tc (sym
)->output
= 1;
3994 demand_empty_rest_of_line ();
3997 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
3998 relocations at the beginning of the current csect.
4000 (In principle, there's no reason why the relocations _have_ to be at
4001 the beginning. Anywhere in the csect would do. However, inserting
4002 at the beginning is what the native assmebler does, and it helps to
4003 deal with cases where the .ref statements follow the section contents.)
4005 ??? .refs don't work for empty .csects. However, the native assembler
4006 doesn't report an error in this case, and neither yet do we. */
4009 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4014 if (ppc_current_csect
== NULL
)
4016 as_bad (_(".ref outside .csect"));
4017 ignore_rest_of_line ();
4023 name
= input_line_pointer
;
4024 c
= get_symbol_end ();
4026 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4027 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4029 *input_line_pointer
= c
;
4031 c
= *input_line_pointer
;
4034 input_line_pointer
++;
4036 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4038 as_bad (_("missing symbol name"));
4039 ignore_rest_of_line ();
4046 demand_empty_rest_of_line ();
4049 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4050 although I don't know why it bothers. */
4053 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4060 name
= input_line_pointer
;
4061 endc
= get_symbol_end ();
4063 sym
= symbol_find_or_make (name
);
4065 *input_line_pointer
= endc
;
4067 if (*input_line_pointer
!= ',')
4069 as_bad (_("missing rename string"));
4070 ignore_rest_of_line ();
4073 ++input_line_pointer
;
4075 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4077 demand_empty_rest_of_line ();
4080 /* The .stabx pseudo-op. This is similar to a normal .stabs
4081 pseudo-op, but slightly different. A sample is
4082 .stabx "main:F-1",.main,142,0
4083 The first argument is the symbol name to create. The second is the
4084 value, and the third is the storage class. The fourth seems to be
4085 always zero, and I am assuming it is the type. */
4088 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4095 name
= demand_copy_C_string (&len
);
4097 if (*input_line_pointer
!= ',')
4099 as_bad (_("missing value"));
4102 ++input_line_pointer
;
4104 ppc_stab_symbol
= TRUE
;
4105 sym
= symbol_make (name
);
4106 ppc_stab_symbol
= FALSE
;
4108 symbol_get_tc (sym
)->real_name
= name
;
4110 (void) expression (&exp
);
4117 as_bad (_("illegal .stabx expression; zero assumed"));
4118 exp
.X_add_number
= 0;
4121 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4122 symbol_set_frag (sym
, &zero_address_frag
);
4126 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4127 symbol_set_value_expression (sym
, &exp
);
4131 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4132 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4137 /* The value is some complex expression. This will probably
4138 fail at some later point, but this is probably the right
4139 thing to do here. */
4140 symbol_set_value_expression (sym
, &exp
);
4144 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4145 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4147 if (*input_line_pointer
!= ',')
4149 as_bad (_("missing class"));
4152 ++input_line_pointer
;
4154 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4156 if (*input_line_pointer
!= ',')
4158 as_bad (_("missing type"));
4161 ++input_line_pointer
;
4163 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4165 symbol_get_tc (sym
)->output
= 1;
4167 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4172 .stabx "z",arrays_,133,0
4175 .comm arrays_,13768,3
4177 resolve_symbol_value will copy the exp's "within" into sym's when the
4178 offset is 0. Since this seems to be corner case problem,
4179 only do the correction for storage class C_STSYM. A better solution
4180 would be to have the tc field updated in ppc_symbol_new_hook. */
4182 if (exp
.X_op
== O_symbol
)
4184 if (ppc_current_block
== NULL
)
4185 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4187 symbol_get_tc (sym
)->within
= ppc_current_block
;
4188 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4192 if (exp
.X_op
!= O_symbol
4193 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4194 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4195 ppc_frob_label (sym
);
4198 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4199 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4200 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4201 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4204 demand_empty_rest_of_line ();
4207 /* The .function pseudo-op. This takes several arguments. The first
4208 argument seems to be the external name of the symbol. The second
4209 argument seems to be the label for the start of the function. gcc
4210 uses the same name for both. I have no idea what the third and
4211 fourth arguments are meant to be. The optional fifth argument is
4212 an expression for the size of the function. In COFF this symbol
4213 gets an aux entry like that used for a csect. */
4216 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4224 name
= input_line_pointer
;
4225 endc
= get_symbol_end ();
4227 /* Ignore any [PR] suffix. */
4228 name
= ppc_canonicalize_symbol_name (name
);
4229 s
= strchr (name
, '[');
4230 if (s
!= (char *) NULL
4231 && strcmp (s
+ 1, "PR]") == 0)
4234 ext_sym
= symbol_find_or_make (name
);
4236 *input_line_pointer
= endc
;
4238 if (*input_line_pointer
!= ',')
4240 as_bad (_("missing symbol name"));
4241 ignore_rest_of_line ();
4244 ++input_line_pointer
;
4246 name
= input_line_pointer
;
4247 endc
= get_symbol_end ();
4249 lab_sym
= symbol_find_or_make (name
);
4251 *input_line_pointer
= endc
;
4253 if (ext_sym
!= lab_sym
)
4257 exp
.X_op
= O_symbol
;
4258 exp
.X_add_symbol
= lab_sym
;
4259 exp
.X_op_symbol
= NULL
;
4260 exp
.X_add_number
= 0;
4262 symbol_set_value_expression (ext_sym
, &exp
);
4265 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4266 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4267 symbol_get_tc (ext_sym
)->output
= 1;
4269 if (*input_line_pointer
== ',')
4273 /* Ignore the third argument. */
4274 ++input_line_pointer
;
4276 if (*input_line_pointer
== ',')
4278 /* Ignore the fourth argument. */
4279 ++input_line_pointer
;
4281 if (*input_line_pointer
== ',')
4283 /* The fifth argument is the function size. */
4284 ++input_line_pointer
;
4285 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4286 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4287 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4292 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4293 SF_SET_FUNCTION (ext_sym
);
4294 SF_SET_PROCESS (ext_sym
);
4295 coff_add_linesym (ext_sym
);
4297 demand_empty_rest_of_line ();
4300 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4301 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4302 with the correct line number */
4304 static symbolS
*saved_bi_sym
= 0;
4307 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4311 sym
= symbol_make (".bf");
4312 S_SET_SEGMENT (sym
, text_section
);
4313 symbol_set_frag (sym
, frag_now
);
4314 S_SET_VALUE (sym
, frag_now_fix ());
4315 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4317 coff_line_base
= get_absolute_expression ();
4319 S_SET_NUMBER_AUXILIARY (sym
, 1);
4320 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4322 /* Line number for bi. */
4325 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4330 symbol_get_tc (sym
)->output
= 1;
4332 ppc_frob_label (sym
);
4334 demand_empty_rest_of_line ();
4337 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4338 ".ef", except that the line number is absolute, not relative to the
4339 most recent ".bf" symbol. */
4342 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4346 sym
= symbol_make (".ef");
4347 S_SET_SEGMENT (sym
, text_section
);
4348 symbol_set_frag (sym
, frag_now
);
4349 S_SET_VALUE (sym
, frag_now_fix ());
4350 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4351 S_SET_NUMBER_AUXILIARY (sym
, 1);
4352 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4353 symbol_get_tc (sym
)->output
= 1;
4355 ppc_frob_label (sym
);
4357 demand_empty_rest_of_line ();
4360 /* The .bi and .ei pseudo-ops. These take a string argument and
4361 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4362 the symbol list. The value of .bi will be know when the next .bf
4368 static symbolS
*last_biei
;
4375 name
= demand_copy_C_string (&len
);
4377 /* The value of these symbols is actually file offset. Here we set
4378 the value to the index into the line number entries. In
4379 ppc_frob_symbols we set the fix_line field, which will cause BFD
4380 to do the right thing. */
4382 sym
= symbol_make (name
);
4383 /* obj-coff.c currently only handles line numbers correctly in the
4385 S_SET_SEGMENT (sym
, text_section
);
4386 S_SET_VALUE (sym
, coff_n_line_nos
);
4387 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4389 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4390 symbol_get_tc (sym
)->output
= 1;
4398 for (look
= last_biei
? last_biei
: symbol_rootP
;
4399 (look
!= (symbolS
*) NULL
4400 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4401 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4402 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4403 look
= symbol_next (look
))
4405 if (look
!= (symbolS
*) NULL
)
4407 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4408 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4412 demand_empty_rest_of_line ();
4415 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4416 There is one argument, which is a csect symbol. The value of the
4417 .bs symbol is the index of this csect symbol. */
4420 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4427 if (ppc_current_block
!= NULL
)
4428 as_bad (_("nested .bs blocks"));
4430 name
= input_line_pointer
;
4431 endc
= get_symbol_end ();
4433 csect
= symbol_find_or_make (name
);
4435 *input_line_pointer
= endc
;
4437 sym
= symbol_make (".bs");
4438 S_SET_SEGMENT (sym
, now_seg
);
4439 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4440 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4441 symbol_get_tc (sym
)->output
= 1;
4443 symbol_get_tc (sym
)->within
= csect
;
4445 ppc_frob_label (sym
);
4447 ppc_current_block
= sym
;
4449 demand_empty_rest_of_line ();
4452 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4455 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4459 if (ppc_current_block
== NULL
)
4460 as_bad (_(".es without preceding .bs"));
4462 sym
= symbol_make (".es");
4463 S_SET_SEGMENT (sym
, now_seg
);
4464 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4465 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4466 symbol_get_tc (sym
)->output
= 1;
4468 ppc_frob_label (sym
);
4470 ppc_current_block
= NULL
;
4472 demand_empty_rest_of_line ();
4475 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4479 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4483 sym
= symbol_make (".bb");
4484 S_SET_SEGMENT (sym
, text_section
);
4485 symbol_set_frag (sym
, frag_now
);
4486 S_SET_VALUE (sym
, frag_now_fix ());
4487 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4489 S_SET_NUMBER_AUXILIARY (sym
, 1);
4490 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4492 symbol_get_tc (sym
)->output
= 1;
4494 SF_SET_PROCESS (sym
);
4496 ppc_frob_label (sym
);
4498 demand_empty_rest_of_line ();
4501 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4505 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4509 sym
= symbol_make (".eb");
4510 S_SET_SEGMENT (sym
, text_section
);
4511 symbol_set_frag (sym
, frag_now
);
4512 S_SET_VALUE (sym
, frag_now_fix ());
4513 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4514 S_SET_NUMBER_AUXILIARY (sym
, 1);
4515 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4516 symbol_get_tc (sym
)->output
= 1;
4518 SF_SET_PROCESS (sym
);
4520 ppc_frob_label (sym
);
4522 demand_empty_rest_of_line ();
4525 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4529 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4535 name
= demand_copy_C_string (&len
);
4536 sym
= symbol_make (name
);
4537 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4538 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4539 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4540 S_SET_VALUE (sym
, 0);
4541 symbol_get_tc (sym
)->output
= 1;
4543 ppc_frob_label (sym
);
4545 demand_empty_rest_of_line ();
4548 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4551 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4555 sym
= symbol_make (".ec");
4556 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4557 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4558 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4559 S_SET_VALUE (sym
, 0);
4560 symbol_get_tc (sym
)->output
= 1;
4562 ppc_frob_label (sym
);
4564 demand_empty_rest_of_line ();
4567 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4570 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4572 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4573 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4580 subseg
= ppc_data_subsegment
;
4581 ++ppc_data_subsegment
;
4583 subseg_new (segment_name (data_section
), subseg
);
4584 ppc_toc_frag
= frag_now
;
4586 sym
= symbol_find_or_make ("TOC[TC0]");
4587 symbol_set_frag (sym
, frag_now
);
4588 S_SET_SEGMENT (sym
, data_section
);
4589 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4590 symbol_get_tc (sym
)->subseg
= subseg
;
4591 symbol_get_tc (sym
)->output
= 1;
4592 symbol_get_tc (sym
)->within
= sym
;
4594 ppc_toc_csect
= sym
;
4596 for (list
= ppc_data_csects
;
4597 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4598 list
= symbol_get_tc (list
)->next
)
4600 symbol_get_tc (list
)->next
= sym
;
4602 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4603 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4607 ppc_current_csect
= ppc_toc_csect
;
4609 demand_empty_rest_of_line ();
4612 /* The AIX assembler automatically aligns the operands of a .long or
4613 .short pseudo-op, and we want to be compatible. */
4616 ppc_xcoff_cons (int log_size
)
4618 frag_align (log_size
, 0, 0);
4619 record_alignment (now_seg
, log_size
);
4620 cons (1 << log_size
);
4624 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4629 (void) expression (&exp
);
4631 if (exp
.X_op
!= O_constant
)
4633 as_bad (_("non-constant byte count"));
4637 byte_count
= exp
.X_add_number
;
4639 if (*input_line_pointer
!= ',')
4641 as_bad (_("missing value"));
4645 ++input_line_pointer
;
4650 ppc_xcoff_end (void)
4654 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4656 struct dw_section
*dws
= &dw_sections
[i
];
4657 struct dw_subsection
*dwss
;
4659 if (dws
->anon_subseg
)
4661 dwss
= dws
->anon_subseg
;
4662 dwss
->link
= dws
->list_subseg
;
4665 dwss
= dws
->list_subseg
;
4667 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4668 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4670 subseg_set (dws
->sect
, dwss
->subseg
);
4671 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4676 #endif /* OBJ_XCOFF */
4677 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4679 /* The .tc pseudo-op. This is used when generating either XCOFF or
4680 ELF. This takes two or more arguments.
4682 When generating XCOFF output, the first argument is the name to
4683 give to this location in the toc; this will be a symbol with class
4684 TC. The rest of the arguments are N-byte values to actually put at
4685 this location in the TOC; often there is just one more argument, a
4686 relocatable symbol reference. The size of the value to store
4687 depends on target word size. A 32-bit target uses 4-byte values, a
4688 64-bit target uses 8-byte values.
4690 When not generating XCOFF output, the arguments are the same, but
4691 the first argument is simply ignored. */
4694 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4698 /* Define the TOC symbol name. */
4704 if (ppc_toc_csect
== (symbolS
*) NULL
4705 || ppc_toc_csect
!= ppc_current_csect
)
4707 as_bad (_(".tc not in .toc section"));
4708 ignore_rest_of_line ();
4712 name
= input_line_pointer
;
4713 endc
= get_symbol_end ();
4715 sym
= symbol_find_or_make (name
);
4717 *input_line_pointer
= endc
;
4719 if (S_IS_DEFINED (sym
))
4723 label
= symbol_get_tc (ppc_current_csect
)->within
;
4724 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4726 as_bad (_(".tc with no label"));
4727 ignore_rest_of_line ();
4731 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4732 symbol_set_frag (label
, symbol_get_frag (sym
));
4733 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4735 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4736 ++input_line_pointer
;
4741 S_SET_SEGMENT (sym
, now_seg
);
4742 symbol_set_frag (sym
, frag_now
);
4743 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4744 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4745 symbol_get_tc (sym
)->output
= 1;
4747 ppc_frob_label (sym
);
4750 #endif /* OBJ_XCOFF */
4754 /* Skip the TOC symbol name. */
4755 while (is_part_of_name (*input_line_pointer
)
4756 || *input_line_pointer
== ' '
4757 || *input_line_pointer
== '['
4758 || *input_line_pointer
== ']'
4759 || *input_line_pointer
== '{'
4760 || *input_line_pointer
== '}')
4761 ++input_line_pointer
;
4763 /* Align to a four/eight byte boundary. */
4764 align
= ppc_obj64
? 3 : 2;
4765 frag_align (align
, 0, 0);
4766 record_alignment (now_seg
, align
);
4767 #endif /* OBJ_ELF */
4769 if (*input_line_pointer
!= ',')
4770 demand_empty_rest_of_line ();
4773 ++input_line_pointer
;
4774 cons (ppc_obj64
? 8 : 4);
4778 /* Pseudo-op .machine. */
4781 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4784 #define MAX_HISTORY 100
4785 static ppc_cpu_t
*cpu_history
;
4786 static int curr_hist
;
4790 if (*input_line_pointer
== '"')
4793 cpu_string
= demand_copy_C_string (&len
);
4798 cpu_string
= input_line_pointer
;
4799 c
= get_symbol_end ();
4800 cpu_string
= xstrdup (cpu_string
);
4801 *input_line_pointer
= c
;
4804 if (cpu_string
!= NULL
)
4806 ppc_cpu_t old_cpu
= ppc_cpu
;
4810 for (p
= cpu_string
; *p
!= 0; p
++)
4813 if (strcmp (cpu_string
, "push") == 0)
4815 if (cpu_history
== NULL
)
4816 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4818 if (curr_hist
>= MAX_HISTORY
)
4819 as_bad (_(".machine stack overflow"));
4821 cpu_history
[curr_hist
++] = ppc_cpu
;
4823 else if (strcmp (cpu_string
, "pop") == 0)
4826 as_bad (_(".machine stack underflow"));
4828 ppc_cpu
= cpu_history
[--curr_hist
];
4830 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, cpu_string
)) != 0)
4833 as_bad (_("invalid machine `%s'"), cpu_string
);
4835 if (ppc_cpu
!= old_cpu
)
4836 ppc_setup_opcodes ();
4839 demand_empty_rest_of_line ();
4842 /* See whether a symbol is in the TOC section. */
4845 ppc_is_toc_sym (symbolS
*sym
)
4848 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
4851 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4853 return strcmp (sname
, ".toc") == 0;
4855 return strcmp (sname
, ".got") == 0;
4858 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4862 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4864 /* Set the current section. */
4866 ppc_set_current_section (segT
new)
4868 ppc_previous_section
= ppc_current_section
;
4869 ppc_current_section
= new;
4872 /* pseudo-op: .previous
4873 behaviour: toggles the current section with the previous section.
4875 warnings: "No previous section" */
4878 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4882 if (ppc_previous_section
== NULL
)
4884 as_warn (_("No previous section to return to. Directive ignored."));
4888 subseg_set (ppc_previous_section
, 0);
4890 ppc_set_current_section (ppc_previous_section
);
4893 /* pseudo-op: .pdata
4894 behaviour: predefined read only data section
4898 initial: .section .pdata "adr3"
4899 a - don't know -- maybe a misprint
4900 d - initialized data
4902 3 - double word aligned (that would be 4 byte boundary)
4905 Tag index tables (also known as the function table) for exception
4906 handling, debugging, etc. */
4909 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4911 if (pdata_section
== 0)
4913 pdata_section
= subseg_new (".pdata", 0);
4915 bfd_set_section_flags (stdoutput
, pdata_section
,
4916 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4917 | SEC_READONLY
| SEC_DATA
));
4919 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4923 pdata_section
= subseg_new (".pdata", 0);
4925 ppc_set_current_section (pdata_section
);
4928 /* pseudo-op: .ydata
4929 behaviour: predefined read only data section
4933 initial: .section .ydata "drw3"
4934 a - don't know -- maybe a misprint
4935 d - initialized data
4937 3 - double word aligned (that would be 4 byte boundary)
4939 Tag tables (also known as the scope table) for exception handling,
4943 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4945 if (ydata_section
== 0)
4947 ydata_section
= subseg_new (".ydata", 0);
4948 bfd_set_section_flags (stdoutput
, ydata_section
,
4949 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4950 | SEC_READONLY
| SEC_DATA
));
4952 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4956 ydata_section
= subseg_new (".ydata", 0);
4958 ppc_set_current_section (ydata_section
);
4961 /* pseudo-op: .reldata
4962 behaviour: predefined read write data section
4963 double word aligned (4-byte)
4964 FIXME: relocation is applied to it
4965 FIXME: what's the difference between this and .data?
4968 initial: .section .reldata "drw3"
4969 d - initialized data
4972 3 - double word aligned (that would be 8 byte boundary)
4975 Like .data, but intended to hold data subject to relocation, such as
4976 function descriptors, etc. */
4979 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
4981 if (reldata_section
== 0)
4983 reldata_section
= subseg_new (".reldata", 0);
4985 bfd_set_section_flags (stdoutput
, reldata_section
,
4986 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4989 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4993 reldata_section
= subseg_new (".reldata", 0);
4995 ppc_set_current_section (reldata_section
);
4998 /* pseudo-op: .rdata
4999 behaviour: predefined read only data section
5003 initial: .section .rdata "dr3"
5004 d - initialized data
5006 3 - double word aligned (that would be 4 byte boundary) */
5009 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5011 if (rdata_section
== 0)
5013 rdata_section
= subseg_new (".rdata", 0);
5014 bfd_set_section_flags (stdoutput
, rdata_section
,
5015 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5016 | SEC_READONLY
| SEC_DATA
));
5018 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5022 rdata_section
= subseg_new (".rdata", 0);
5024 ppc_set_current_section (rdata_section
);
5027 /* pseudo-op: .ualong
5028 behaviour: much like .int, with the exception that no alignment is
5030 FIXME: test the alignment statement
5035 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5041 /* pseudo-op: .znop <symbol name>
5042 behaviour: Issue a nop instruction
5043 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5044 the supplied symbol name.
5046 warnings: Missing symbol name */
5049 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5052 const struct powerpc_opcode
*opcode
;
5063 /* Strip out the symbol name. */
5064 symbol_name
= input_line_pointer
;
5065 c
= get_symbol_end ();
5067 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5068 strcpy (name
, symbol_name
);
5070 sym
= symbol_find_or_make (name
);
5072 *input_line_pointer
= c
;
5076 /* Look up the opcode in the hash table. */
5077 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5079 /* Stick in the nop. */
5080 insn
= opcode
->opcode
;
5082 /* Write out the instruction. */
5084 md_number_to_chars (f
, insn
, 4);
5086 f
- frag_now
->fr_literal
,
5091 BFD_RELOC_16_GOT_PCREL
);
5101 ppc_pe_comm (int lcomm
)
5110 name
= input_line_pointer
;
5111 c
= get_symbol_end ();
5113 /* just after name is now '\0'. */
5114 p
= input_line_pointer
;
5117 if (*input_line_pointer
!= ',')
5119 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
5120 ignore_rest_of_line ();
5124 input_line_pointer
++; /* skip ',' */
5125 if ((temp
= get_absolute_expression ()) < 0)
5127 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5128 ignore_rest_of_line ();
5134 /* The third argument to .comm is the alignment. */
5135 if (*input_line_pointer
!= ',')
5139 ++input_line_pointer
;
5140 align
= get_absolute_expression ();
5143 as_warn (_("ignoring bad alignment"));
5150 symbolP
= symbol_find_or_make (name
);
5153 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5155 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
5156 S_GET_NAME (symbolP
));
5157 ignore_rest_of_line ();
5161 if (S_GET_VALUE (symbolP
))
5163 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5164 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
5165 S_GET_NAME (symbolP
),
5166 (long) S_GET_VALUE (symbolP
),
5171 S_SET_VALUE (symbolP
, (valueT
) temp
);
5172 S_SET_EXTERNAL (symbolP
);
5173 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5176 demand_empty_rest_of_line ();
5180 * implement the .section pseudo op:
5181 * .section name {, "flags"}
5183 * | +--- optional flags: 'b' for bss
5185 * +-- section name 'l' for lib
5189 * 'd' (apparently m88k for data)
5191 * But if the argument is not a quoted string, treat it as a
5192 * subsegment number.
5194 * FIXME: this is a copy of the section processing from obj-coff.c, with
5195 * additions/changes for the moto-pas assembler support. There are three
5198 * FIXME: I just noticed this. This doesn't work at all really. It it
5199 * setting bits that bfd probably neither understands or uses. The
5200 * correct approach (?) will have to incorporate extra fields attached
5201 * to the section to hold the system specific stuff. (krk)
5204 * 'a' - unknown - referred to in documentation, but no definition supplied
5205 * 'c' - section has code
5206 * 'd' - section has initialized data
5207 * 'u' - section has uninitialized data
5208 * 'i' - section contains directives (info)
5209 * 'n' - section can be discarded
5210 * 'R' - remove section at link time
5212 * Section Protection:
5213 * 'r' - section is readable
5214 * 'w' - section is writeable
5215 * 'x' - section is executable
5216 * 's' - section is sharable
5218 * Section Alignment:
5219 * '0' - align to byte boundary
5220 * '1' - align to halfword undary
5221 * '2' - align to word boundary
5222 * '3' - align to doubleword boundary
5223 * '4' - align to quadword boundary
5224 * '5' - align to 32 byte boundary
5225 * '6' - align to 64 byte boundary
5230 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5232 /* Strip out the section name. */
5241 section_name
= input_line_pointer
;
5242 c
= get_symbol_end ();
5244 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5245 strcpy (name
, section_name
);
5247 *input_line_pointer
= c
;
5252 flags
= SEC_NO_FLAGS
;
5254 if (strcmp (name
, ".idata$2") == 0)
5258 else if (strcmp (name
, ".idata$3") == 0)
5262 else if (strcmp (name
, ".idata$4") == 0)
5266 else if (strcmp (name
, ".idata$5") == 0)
5270 else if (strcmp (name
, ".idata$6") == 0)
5275 /* Default alignment to 16 byte boundary. */
5278 if (*input_line_pointer
== ',')
5280 ++input_line_pointer
;
5282 if (*input_line_pointer
!= '"')
5283 exp
= get_absolute_expression ();
5286 ++input_line_pointer
;
5287 while (*input_line_pointer
!= '"'
5288 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5290 switch (*input_line_pointer
)
5292 /* Section Contents */
5293 case 'a': /* unknown */
5294 as_bad (_("Unsupported section attribute -- 'a'"));
5296 case 'c': /* code section */
5299 case 'd': /* section has initialized data */
5302 case 'u': /* section has uninitialized data */
5303 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5307 case 'i': /* section contains directives (info) */
5308 /* FIXME: This is IMAGE_SCN_LNK_INFO
5310 flags
|= SEC_HAS_CONTENTS
;
5312 case 'n': /* section can be discarded */
5315 case 'R': /* Remove section at link time */
5316 flags
|= SEC_NEVER_LOAD
;
5318 #if IFLICT_BRAIN_DAMAGE
5319 /* Section Protection */
5320 case 'r': /* section is readable */
5321 flags
|= IMAGE_SCN_MEM_READ
;
5323 case 'w': /* section is writeable */
5324 flags
|= IMAGE_SCN_MEM_WRITE
;
5326 case 'x': /* section is executable */
5327 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5329 case 's': /* section is sharable */
5330 flags
|= IMAGE_SCN_MEM_SHARED
;
5333 /* Section Alignment */
5334 case '0': /* align to byte boundary */
5335 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5338 case '1': /* align to halfword boundary */
5339 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5342 case '2': /* align to word boundary */
5343 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5346 case '3': /* align to doubleword boundary */
5347 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5350 case '4': /* align to quadword boundary */
5351 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5354 case '5': /* align to 32 byte boundary */
5355 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5358 case '6': /* align to 64 byte boundary */
5359 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5364 as_bad (_("unknown section attribute '%c'"),
5365 *input_line_pointer
);
5368 ++input_line_pointer
;
5370 if (*input_line_pointer
== '"')
5371 ++input_line_pointer
;
5375 sec
= subseg_new (name
, (subsegT
) exp
);
5377 ppc_set_current_section (sec
);
5379 if (flags
!= SEC_NO_FLAGS
)
5381 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5382 as_bad (_("error setting flags for \"%s\": %s"),
5383 bfd_section_name (stdoutput
, sec
),
5384 bfd_errmsg (bfd_get_error ()));
5387 bfd_set_section_alignment (stdoutput
, sec
, align
);
5391 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5397 name
= input_line_pointer
;
5398 endc
= get_symbol_end ();
5400 ext_sym
= symbol_find_or_make (name
);
5402 *input_line_pointer
= endc
;
5404 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5405 SF_SET_FUNCTION (ext_sym
);
5406 SF_SET_PROCESS (ext_sym
);
5407 coff_add_linesym (ext_sym
);
5409 demand_empty_rest_of_line ();
5413 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5415 if (tocdata_section
== 0)
5417 tocdata_section
= subseg_new (".tocd", 0);
5418 /* FIXME: section flags won't work. */
5419 bfd_set_section_flags (stdoutput
, tocdata_section
,
5420 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5421 | SEC_READONLY
| SEC_DATA
));
5423 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5427 rdata_section
= subseg_new (".tocd", 0);
5430 ppc_set_current_section (tocdata_section
);
5432 demand_empty_rest_of_line ();
5435 /* Don't adjust TOC relocs to use the section symbol. */
5438 ppc_pe_fix_adjustable (fixS
*fix
)
5440 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5447 /* XCOFF specific symbol and file handling. */
5449 /* Canonicalize the symbol name. We use the to force the suffix, if
5450 any, to use square brackets, and to be in upper case. */
5453 ppc_canonicalize_symbol_name (char *name
)
5457 if (ppc_stab_symbol
)
5460 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5474 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5477 if (*s
== '\0' || s
[1] != '\0')
5478 as_bad (_("bad symbol suffix"));
5486 /* Set the class of a symbol based on the suffix, if any. This is
5487 called whenever a new symbol is created. */
5490 ppc_symbol_new_hook (symbolS
*sym
)
5492 struct ppc_tc_sy
*tc
;
5495 tc
= symbol_get_tc (sym
);
5498 tc
->symbol_class
= -1;
5499 tc
->real_name
= NULL
;
5506 if (ppc_stab_symbol
)
5509 s
= strchr (S_GET_NAME (sym
), '[');
5510 if (s
== (const char *) NULL
)
5512 /* There is no suffix. */
5521 if (strcmp (s
, "BS]") == 0)
5522 tc
->symbol_class
= XMC_BS
;
5525 if (strcmp (s
, "DB]") == 0)
5526 tc
->symbol_class
= XMC_DB
;
5527 else if (strcmp (s
, "DS]") == 0)
5528 tc
->symbol_class
= XMC_DS
;
5531 if (strcmp (s
, "GL]") == 0)
5532 tc
->symbol_class
= XMC_GL
;
5535 if (strcmp (s
, "PR]") == 0)
5536 tc
->symbol_class
= XMC_PR
;
5539 if (strcmp (s
, "RO]") == 0)
5540 tc
->symbol_class
= XMC_RO
;
5541 else if (strcmp (s
, "RW]") == 0)
5542 tc
->symbol_class
= XMC_RW
;
5545 if (strcmp (s
, "SV]") == 0)
5546 tc
->symbol_class
= XMC_SV
;
5549 if (strcmp (s
, "TC]") == 0)
5550 tc
->symbol_class
= XMC_TC
;
5551 else if (strcmp (s
, "TI]") == 0)
5552 tc
->symbol_class
= XMC_TI
;
5553 else if (strcmp (s
, "TB]") == 0)
5554 tc
->symbol_class
= XMC_TB
;
5555 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5556 tc
->symbol_class
= XMC_TC0
;
5559 if (strcmp (s
, "UA]") == 0)
5560 tc
->symbol_class
= XMC_UA
;
5561 else if (strcmp (s
, "UC]") == 0)
5562 tc
->symbol_class
= XMC_UC
;
5565 if (strcmp (s
, "XO]") == 0)
5566 tc
->symbol_class
= XMC_XO
;
5570 if (tc
->symbol_class
== -1)
5571 as_bad (_("Unrecognized symbol suffix"));
5574 /* Set the class of a label based on where it is defined. This
5575 handles symbols without suffixes. Also, move the symbol so that it
5576 follows the csect symbol. */
5579 ppc_frob_label (symbolS
*sym
)
5581 if (ppc_current_csect
!= (symbolS
*) NULL
)
5583 if (symbol_get_tc (sym
)->symbol_class
== -1)
5584 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5586 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5587 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5588 &symbol_rootP
, &symbol_lastP
);
5589 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5590 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5594 dwarf2_emit_label (sym
);
5598 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5599 seen. It tells ppc_adjust_symtab whether it needs to look through
5602 static bfd_boolean ppc_saw_abs
;
5604 /* Change the name of a symbol just before writing it out. Set the
5605 real name if the .rename pseudo-op was used. Otherwise, remove any
5606 class suffix. Return 1 if the symbol should not be included in the
5610 ppc_frob_symbol (symbolS
*sym
)
5612 static symbolS
*ppc_last_function
;
5613 static symbolS
*set_end
;
5615 /* Discard symbols that should not be included in the output symbol
5617 if (! symbol_used_in_reloc_p (sym
)
5618 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5619 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5620 && ! symbol_get_tc (sym
)->output
5621 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5624 /* This one will disappear anyway. Don't make a csect sym for it. */
5625 if (sym
== abs_section_sym
)
5628 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5629 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5635 name
= S_GET_NAME (sym
);
5636 s
= strchr (name
, '[');
5637 if (s
!= (char *) NULL
)
5643 snew
= xmalloc (len
+ 1);
5644 memcpy (snew
, name
, len
);
5647 S_SET_NAME (sym
, snew
);
5651 if (set_end
!= (symbolS
*) NULL
)
5653 SA_SET_SYM_ENDNDX (set_end
, sym
);
5657 if (SF_GET_FUNCTION (sym
))
5659 if (ppc_last_function
!= (symbolS
*) NULL
)
5660 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5661 ppc_last_function
= sym
;
5662 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5664 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5665 SA_SET_SYM_FSIZE (sym
,
5666 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5669 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5670 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5672 if (ppc_last_function
== (symbolS
*) NULL
)
5673 as_bad (_(".ef with no preceding .function"));
5676 set_end
= ppc_last_function
;
5677 ppc_last_function
= NULL
;
5679 /* We don't have a C_EFCN symbol, but we need to force the
5680 COFF backend to believe that it has seen one. */
5681 coff_last_function
= NULL
;
5685 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5686 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5687 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5688 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5689 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5690 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5691 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5692 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5693 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5694 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5695 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5697 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5698 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5699 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5702 union internal_auxent
*a
;
5704 /* Create a csect aux. */
5705 i
= S_GET_NUMBER_AUXILIARY (sym
);
5706 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5707 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5708 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5710 /* This is the TOC table. */
5711 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5712 a
->x_csect
.x_scnlen
.l
= 0;
5713 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5715 else if (symbol_get_tc (sym
)->subseg
!= 0)
5717 /* This is a csect symbol. x_scnlen is the size of the
5719 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5720 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5721 S_GET_SEGMENT (sym
))
5722 - S_GET_VALUE (sym
));
5725 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5726 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5727 - S_GET_VALUE (sym
));
5729 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5731 else if (S_GET_SEGMENT (sym
) == bss_section
)
5733 /* This is a common symbol. */
5734 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5735 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5736 if (S_IS_EXTERNAL (sym
))
5737 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5739 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5741 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5743 /* This is an absolute symbol. The csect will be created by
5744 ppc_adjust_symtab. */
5746 a
->x_csect
.x_smtyp
= XTY_LD
;
5747 if (symbol_get_tc (sym
)->symbol_class
== -1)
5748 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5750 else if (! S_IS_DEFINED (sym
))
5752 /* This is an external symbol. */
5753 a
->x_csect
.x_scnlen
.l
= 0;
5754 a
->x_csect
.x_smtyp
= XTY_ER
;
5756 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5760 /* This is a TOC definition. x_scnlen is the size of the
5762 next
= symbol_next (sym
);
5763 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5764 next
= symbol_next (next
);
5765 if (next
== (symbolS
*) NULL
5766 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5768 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5769 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5771 - S_GET_VALUE (sym
));
5773 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5774 - S_GET_VALUE (sym
));
5778 resolve_symbol_value (next
);
5779 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5780 - S_GET_VALUE (sym
));
5782 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5788 /* This is a normal symbol definition. x_scnlen is the
5789 symbol index of the containing csect. */
5790 if (S_GET_SEGMENT (sym
) == text_section
)
5791 csect
= ppc_text_csects
;
5792 else if (S_GET_SEGMENT (sym
) == data_section
)
5793 csect
= ppc_data_csects
;
5797 /* Skip the initial dummy symbol. */
5798 csect
= symbol_get_tc (csect
)->next
;
5800 if (csect
== (symbolS
*) NULL
)
5802 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5803 a
->x_csect
.x_scnlen
.l
= 0;
5807 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5809 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5810 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5811 > S_GET_VALUE (sym
))
5813 csect
= symbol_get_tc (csect
)->next
;
5816 a
->x_csect
.x_scnlen
.p
=
5817 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5818 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5821 a
->x_csect
.x_smtyp
= XTY_LD
;
5824 a
->x_csect
.x_parmhash
= 0;
5825 a
->x_csect
.x_snhash
= 0;
5826 if (symbol_get_tc (sym
)->symbol_class
== -1)
5827 a
->x_csect
.x_smclas
= XMC_PR
;
5829 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5830 a
->x_csect
.x_stab
= 0;
5831 a
->x_csect
.x_snstab
= 0;
5833 /* Don't let the COFF backend resort these symbols. */
5834 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5836 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5838 /* We want the value to be the symbol index of the referenced
5839 csect symbol. BFD will do that for us if we set the right
5841 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5842 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5844 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5845 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5847 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5852 block
= symbol_get_tc (sym
)->within
;
5855 /* The value is the offset from the enclosing csect. */
5858 csect
= symbol_get_tc (block
)->within
;
5859 resolve_symbol_value (csect
);
5860 base
= S_GET_VALUE (csect
);
5865 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5867 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5868 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5870 /* We want the value to be a file offset into the line numbers.
5871 BFD will do that for us if we set the right flags. We have
5872 already set the value correctly. */
5873 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5879 /* Adjust the symbol table. This creates csect symbols for all
5880 absolute symbols. */
5883 ppc_adjust_symtab (void)
5890 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5894 union internal_auxent
*a
;
5896 if (S_GET_SEGMENT (sym
) != absolute_section
)
5899 csect
= symbol_create (".abs[XO]", absolute_section
,
5900 S_GET_VALUE (sym
), &zero_address_frag
);
5901 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5902 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5903 i
= S_GET_NUMBER_AUXILIARY (csect
);
5904 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5905 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5906 a
->x_csect
.x_scnlen
.l
= 0;
5907 a
->x_csect
.x_smtyp
= XTY_SD
;
5908 a
->x_csect
.x_parmhash
= 0;
5909 a
->x_csect
.x_snhash
= 0;
5910 a
->x_csect
.x_smclas
= XMC_XO
;
5911 a
->x_csect
.x_stab
= 0;
5912 a
->x_csect
.x_snstab
= 0;
5914 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5916 i
= S_GET_NUMBER_AUXILIARY (sym
);
5917 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5918 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5919 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5922 ppc_saw_abs
= FALSE
;
5925 /* Set the VMA for a section. This is called on all the sections in
5929 ppc_frob_section (asection
*sec
)
5931 static bfd_vma vma
= 0;
5933 /* Dwarf sections start at 0. */
5934 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5937 vma
= md_section_align (sec
, vma
);
5938 bfd_set_section_vma (stdoutput
, sec
, vma
);
5939 vma
+= bfd_section_size (stdoutput
, sec
);
5942 #endif /* OBJ_XCOFF */
5945 md_atof (int type
, char *litp
, int *sizep
)
5947 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5950 /* Write a value out to the object file, using the appropriate
5954 md_number_to_chars (char *buf
, valueT val
, int n
)
5956 if (target_big_endian
)
5957 number_to_chars_bigendian (buf
, val
, n
);
5959 number_to_chars_littleendian (buf
, val
, n
);
5962 /* Align a section (I don't know why this is machine dependent). */
5965 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5970 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5972 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5976 /* We don't have any form of relaxing. */
5979 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5980 asection
*seg ATTRIBUTE_UNUSED
)
5986 /* Convert a machine dependent frag. We never generate these. */
5989 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5990 asection
*sec ATTRIBUTE_UNUSED
,
5991 fragS
*fragp ATTRIBUTE_UNUSED
)
5996 /* We have no need to default values of symbols. */
5999 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6004 /* Functions concerning relocs. */
6006 /* The location from which a PC relative jump should be calculated,
6007 given a PC relative reloc. */
6010 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6012 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6017 /* This is called to see whether a fixup should be adjusted to use a
6018 section symbol. We take the opportunity to change a fixup against
6019 a symbol in the TOC subsegment into a reloc against the
6020 corresponding .tc symbol. */
6023 ppc_fix_adjustable (fixS
*fix
)
6025 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6026 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6027 TC_SYMFIELD_TYPE
*tc
;
6029 if (symseg
== absolute_section
)
6032 /* Always adjust symbols in debugging sections. */
6033 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6036 if (ppc_toc_csect
!= (symbolS
*) NULL
6037 && fix
->fx_addsy
!= ppc_toc_csect
6038 && symseg
== data_section
6039 && val
>= ppc_toc_frag
->fr_address
6040 && (ppc_after_toc_frag
== (fragS
*) NULL
6041 || val
< ppc_after_toc_frag
->fr_address
))
6045 for (sy
= symbol_next (ppc_toc_csect
);
6046 sy
!= (symbolS
*) NULL
;
6047 sy
= symbol_next (sy
))
6049 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6051 if (sy_tc
->symbol_class
== XMC_TC0
)
6053 if (sy_tc
->symbol_class
!= XMC_TC
)
6055 if (val
== resolve_symbol_value (sy
))
6058 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6063 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6064 _("symbol in .toc does not match any .tc"));
6067 /* Possibly adjust the reloc to be against the csect. */
6068 tc
= symbol_get_tc (fix
->fx_addsy
);
6070 && tc
->symbol_class
!= XMC_TC0
6071 && tc
->symbol_class
!= XMC_TC
6072 && symseg
!= bss_section
6073 /* Don't adjust if this is a reloc in the toc section. */
6074 && (symseg
!= data_section
6075 || ppc_toc_csect
== NULL
6076 || val
< ppc_toc_frag
->fr_address
6077 || (ppc_after_toc_frag
!= NULL
6078 && val
>= ppc_after_toc_frag
->fr_address
)))
6080 symbolS
*csect
= tc
->within
;
6082 /* If the symbol was not declared by a label (eg: a section symbol),
6083 use the section instead of the csect. This doesn't happen in
6084 normal AIX assembly code. */
6086 csect
= seg_info (symseg
)->sym
;
6088 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6089 fix
->fx_addsy
= csect
;
6094 /* Adjust a reloc against a .lcomm symbol to be against the base
6096 if (symseg
== bss_section
6097 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6099 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6101 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6108 /* A reloc from one csect to another must be kept. The assembler
6109 will, of course, keep relocs between sections, and it will keep
6110 absolute relocs, but we need to force it to keep PC relative relocs
6111 between two csects in the same section. */
6114 ppc_force_relocation (fixS
*fix
)
6116 /* At this point fix->fx_addsy should already have been converted to
6117 a csect symbol. If the csect does not include the fragment, then
6118 we need to force the relocation. */
6120 && fix
->fx_addsy
!= NULL
6121 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6122 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6123 > fix
->fx_frag
->fr_address
)
6124 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6125 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6126 <= fix
->fx_frag
->fr_address
))))
6129 return generic_force_reloc (fix
);
6133 ppc_new_dot_label (symbolS
*sym
)
6135 /* Anchor this label to the current csect for relocations. */
6136 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6139 #endif /* OBJ_XCOFF */
6142 /* If this function returns non-zero, it guarantees that a relocation
6143 will be emitted for a fixup. */
6146 ppc_force_relocation (fixS
*fix
)
6148 /* Branch prediction relocations must force a relocation, as must
6149 the vtable description relocs. */
6150 switch (fix
->fx_r_type
)
6152 case BFD_RELOC_PPC_B16_BRTAKEN
:
6153 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6154 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6155 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6156 case BFD_RELOC_24_PLT_PCREL
:
6157 case BFD_RELOC_PPC64_TOC
:
6163 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6164 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6167 return generic_force_reloc (fix
);
6171 ppc_fix_adjustable (fixS
*fix
)
6173 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6174 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6175 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6176 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6177 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6178 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6179 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6180 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6181 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6182 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6183 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6188 ppc_frag_check (struct frag
*fragP
)
6190 if (!fragP
->has_code
)
6193 if (ppc_mach() == bfd_mach_ppc_vle
)
6195 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6196 as_bad (_("instruction address is not a multiple of 2"));
6200 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6201 as_bad (_("instruction address is not a multiple of 4"));
6205 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6206 rs_align_code frag. */
6209 ppc_handle_align (struct frag
*fragP
)
6211 valueT count
= (fragP
->fr_next
->fr_address
6212 - (fragP
->fr_address
+ fragP
->fr_fix
));
6214 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6216 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6219 md_number_to_chars (dest
, 0x4400, 2);
6221 else if (count
!= 0 && (count
& 3) == 0)
6223 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6227 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6231 /* Make a branch, then follow with nops. Insert another
6232 frag to handle the nops. */
6233 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6238 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6239 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6240 fragP
->fr_next
= rest
;
6242 rest
->fr_address
+= rest
->fr_fix
+ 4;
6244 /* If we leave the next frag as rs_align_code we'll come here
6245 again, resulting in a bunch of branches rather than a
6246 branch followed by nops. */
6247 rest
->fr_type
= rs_align
;
6248 dest
= rest
->fr_literal
;
6251 md_number_to_chars (dest
, 0x60000000, 4);
6253 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6254 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6256 /* For power6 and power7, we want the last nop to be a group
6257 terminating one. Do this by inserting an rs_fill frag immediately
6258 after this one, with its address set to the last nop location.
6259 This will automatically reduce the number of nops in the current
6263 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6265 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6266 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6267 group_nop
->fr_fix
= 0;
6268 group_nop
->fr_offset
= 1;
6269 group_nop
->fr_type
= rs_fill
;
6270 fragP
->fr_next
= group_nop
;
6271 dest
= group_nop
->fr_literal
;
6274 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6276 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6277 /* e500mc group terminating nop: "ori 0,0,0". */
6278 md_number_to_chars (dest
, 0x60000000, 4);
6280 /* power7 group terminating nop: "ori 2,2,0". */
6281 md_number_to_chars (dest
, 0x60420000, 4);
6284 /* power6 group terminating nop: "ori 1,1,0". */
6285 md_number_to_chars (dest
, 0x60210000, 4);
6290 /* Apply a fixup to the object code. This is called for all the
6291 fixups we generated by the call to fix_new_exp, above. In the call
6292 above we used a reloc code which was the largest legal reloc code
6293 plus the operand index. Here we undo that to recover the operand
6294 index. At this point all symbol values should be fully resolved,
6295 and we attempt to completely resolve the reloc. If we can not do
6296 that, we determine the correct reloc code and put it back in the
6300 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6302 valueT value
= * valP
;
6305 if (fixP
->fx_addsy
!= NULL
)
6307 /* Hack around bfd_install_relocation brain damage. */
6309 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6314 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6315 the symbol values. If we are doing this relocation the code in
6316 write.c is going to call bfd_install_relocation, which is also
6317 going to use the symbol value. That means that if the reloc is
6318 fully resolved we want to use *valP since bfd_install_relocation is
6320 However, if the reloc is not fully resolved we do not want to
6321 use *valP, and must use fx_offset instead. If the relocation
6322 is PC-relative, we then need to re-apply md_pcrel_from_section
6323 to this new relocation value. */
6324 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6329 value
= fixP
->fx_offset
;
6331 value
-= md_pcrel_from_section (fixP
, seg
);
6335 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6337 /* We can't actually support subtracting a symbol. */
6338 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6341 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
6344 const struct powerpc_operand
*operand
;
6348 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
6350 operand
= &powerpc_operands
[opindex
];
6353 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6354 does not generate a reloc. It uses the offset of `sym' within its
6355 csect. Other usages, such as `.long sym', generate relocs. This
6356 is the documented behaviour of non-TOC symbols. */
6357 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6358 && (operand
->bitm
& 0xfff0) == 0xfff0
6359 && operand
->shift
== 0
6360 && (operand
->insert
== NULL
|| ppc_obj64
)
6361 && fixP
->fx_addsy
!= NULL
6362 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6363 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6364 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6365 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6367 value
= fixP
->fx_offset
;
6372 /* Fetch the instruction, insert the fully resolved operand
6373 value, and stuff the instruction back again. */
6374 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6375 if (target_big_endian
)
6377 if (fixP
->fx_size
== 4)
6378 insn
= bfd_getb32 ((unsigned char *) where
);
6380 insn
= bfd_getb16 ((unsigned char *) where
);
6384 if (fixP
->fx_size
== 4)
6385 insn
= bfd_getl32 ((unsigned char *) where
);
6387 insn
= bfd_getl16 ((unsigned char *) where
);
6389 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
6390 fixP
->tc_fix_data
.ppc_cpu
,
6391 fixP
->fx_file
, fixP
->fx_line
);
6392 if (target_big_endian
)
6394 if (fixP
->fx_size
== 4)
6395 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6397 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6401 if (fixP
->fx_size
== 4)
6402 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6404 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6408 /* Nothing else to do here. */
6411 gas_assert (fixP
->fx_addsy
!= NULL
);
6413 /* Determine a BFD reloc value based on the operand information.
6414 We are only prepared to turn a few of the operands into
6416 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6417 && operand
->bitm
== 0x3fffffc
6418 && operand
->shift
== 0)
6419 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
6420 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6421 && operand
->bitm
== 0xfffc
6422 && operand
->shift
== 0)
6424 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
6427 if (target_big_endian
)
6428 fixP
->fx_where
+= 2;
6431 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6432 && operand
->bitm
== 0x1fe
6433 && operand
->shift
== -1)
6434 fixP
->fx_r_type
= BFD_RELOC_PPC_VLE_REL8
;
6435 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6436 && operand
->bitm
== 0xfffe
6437 && operand
->shift
== 0)
6438 fixP
->fx_r_type
= BFD_RELOC_PPC_VLE_REL15
;
6439 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6440 && operand
->bitm
== 0x1fffffe
6441 && operand
->shift
== 0)
6442 fixP
->fx_r_type
= BFD_RELOC_PPC_VLE_REL24
;
6443 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6444 && operand
->bitm
== 0x3fffffc
6445 && operand
->shift
== 0)
6446 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
6447 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6448 && operand
->bitm
== 0xfffc
6449 && operand
->shift
== 0)
6451 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
6454 if (target_big_endian
)
6455 fixP
->fx_where
+= 2;
6458 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
6459 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6460 && (operand
->bitm
& 0xfff0) == 0xfff0
6461 && operand
->shift
== 0)
6463 if (ppc_is_toc_sym (fixP
->fx_addsy
))
6465 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6468 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6469 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
6474 fixP
->fx_r_type
= BFD_RELOC_16
;
6477 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6478 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
6482 if (target_big_endian
)
6483 fixP
->fx_where
+= 2;
6485 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
6491 /* Use expr_symbol_where to see if this is an expression
6493 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6494 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6495 _("unresolved expression that must be resolved"));
6497 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6498 _("unsupported relocation against %s"),
6499 S_GET_NAME (fixP
->fx_addsy
));
6507 ppc_elf_validate_fix (fixP
, seg
);
6509 switch (fixP
->fx_r_type
)
6511 case BFD_RELOC_CTOR
:
6518 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6522 case BFD_RELOC_32_PCREL
:
6523 case BFD_RELOC_PPC_EMB_NADDR32
:
6524 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6531 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6534 case BFD_RELOC_64_PCREL
:
6535 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6539 case BFD_RELOC_GPREL16
:
6540 case BFD_RELOC_16_GOT_PCREL
:
6541 case BFD_RELOC_16_GOTOFF
:
6542 case BFD_RELOC_LO16_GOTOFF
:
6543 case BFD_RELOC_HI16_GOTOFF
:
6544 case BFD_RELOC_HI16_S_GOTOFF
:
6545 case BFD_RELOC_16_BASEREL
:
6546 case BFD_RELOC_LO16_BASEREL
:
6547 case BFD_RELOC_HI16_BASEREL
:
6548 case BFD_RELOC_HI16_S_BASEREL
:
6549 case BFD_RELOC_PPC_EMB_NADDR16
:
6550 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6551 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6552 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6553 case BFD_RELOC_PPC_EMB_SDAI16
:
6554 case BFD_RELOC_PPC_EMB_SDA2REL
:
6555 case BFD_RELOC_PPC_EMB_SDA2I16
:
6556 case BFD_RELOC_PPC_EMB_RELSEC16
:
6557 case BFD_RELOC_PPC_EMB_RELST_LO
:
6558 case BFD_RELOC_PPC_EMB_RELST_HI
:
6559 case BFD_RELOC_PPC_EMB_RELST_HA
:
6560 case BFD_RELOC_PPC_EMB_RELSDA
:
6561 case BFD_RELOC_PPC_TOC16
:
6563 case BFD_RELOC_PPC64_TOC16_LO
:
6564 case BFD_RELOC_PPC64_TOC16_HI
:
6565 case BFD_RELOC_PPC64_TOC16_HA
:
6569 if (fixP
->fx_addsy
!= NULL
)
6570 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6571 _("cannot emit PC relative %s relocation against %s"),
6572 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6573 S_GET_NAME (fixP
->fx_addsy
));
6575 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6576 _("cannot emit PC relative %s relocation"),
6577 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6580 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6586 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6589 case BFD_RELOC_16_PCREL
:
6590 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6594 case BFD_RELOC_LO16
:
6596 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6599 case BFD_RELOC_LO16_PCREL
:
6600 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6604 /* This case happens when you write, for example,
6606 where L1 and L2 are defined later. */
6607 case BFD_RELOC_HI16
:
6609 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6612 case BFD_RELOC_HI16_PCREL
:
6613 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6617 case BFD_RELOC_HI16_S
:
6619 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6622 case BFD_RELOC_HI16_S_PCREL
:
6623 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6627 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6628 case BFD_RELOC_PPC_VLE_LO16A
:
6630 int tval
= PPC_VLE_LO16A (value
);
6631 valueT oldval
= md_chars_to_number (
6632 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6633 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6634 (oldval
| tval
), 4);
6638 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6639 case BFD_RELOC_PPC_VLE_LO16D
:
6641 int tval
= PPC_VLE_LO16D (value
);
6642 valueT oldval
= md_chars_to_number (
6643 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6644 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6645 (oldval
| tval
), 4);
6649 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6650 case BFD_RELOC_PPC_VLE_HI16A
:
6652 int tval
= PPC_VLE_HI16A (value
);
6653 valueT oldval
= md_chars_to_number (
6654 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6655 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6656 (oldval
| tval
), 4);
6660 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6661 case BFD_RELOC_PPC_VLE_HI16D
:
6663 int tval
= PPC_VLE_HI16D (value
);
6664 valueT oldval
= md_chars_to_number (
6665 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6666 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6667 (oldval
| tval
), 4);
6671 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6672 case BFD_RELOC_PPC_VLE_HA16A
:
6674 int tval
= PPC_VLE_HA16A (value
);
6675 valueT oldval
= md_chars_to_number (
6676 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6677 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6678 (oldval
| tval
), 4);
6682 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6683 case BFD_RELOC_PPC_VLE_HA16D
:
6685 int tval
= PPC_VLE_HA16D (value
);
6686 valueT oldval
= md_chars_to_number (
6687 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6688 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6689 (oldval
| tval
), 4);
6693 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6695 int tval
= PPC_LO (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
:
6705 valueT oldval
= md_chars_to_number (
6706 fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
, 4);
6707 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6708 (oldval
| value
), 4);
6713 case BFD_RELOC_NONE
:
6718 case BFD_RELOC_PPC64_HIGHER
:
6721 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6722 PPC_HIGHER (value
), 2);
6725 case BFD_RELOC_PPC64_HIGHER_S
:
6728 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6729 PPC_HIGHERA (value
), 2);
6732 case BFD_RELOC_PPC64_HIGHEST
:
6735 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6736 PPC_HIGHEST (value
), 2);
6739 case BFD_RELOC_PPC64_HIGHEST_S
:
6742 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6743 PPC_HIGHESTA (value
), 2);
6746 case BFD_RELOC_PPC64_ADDR16_DS
:
6747 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6748 case BFD_RELOC_PPC64_GOT16_DS
:
6749 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6750 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6751 case BFD_RELOC_PPC64_SECTOFF_DS
:
6752 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6753 case BFD_RELOC_PPC64_TOC16_DS
:
6754 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6755 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6756 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6760 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6761 unsigned long val
, mask
;
6763 if (target_big_endian
)
6764 val
= bfd_getb32 (where
- 2);
6766 val
= bfd_getl32 (where
);
6768 /* lq insns reserve the four lsbs. */
6769 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
6770 && (val
& (0x3f << 26)) == (56u << 26))
6772 val
|= value
& mask
;
6773 if (target_big_endian
)
6774 bfd_putb16 ((bfd_vma
) val
, where
);
6776 bfd_putl16 ((bfd_vma
) val
, where
);
6780 case BFD_RELOC_PPC_B16_BRTAKEN
:
6781 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6782 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6783 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6786 case BFD_RELOC_PPC_TLS
:
6787 case BFD_RELOC_PPC_TLSGD
:
6788 case BFD_RELOC_PPC_TLSLD
:
6791 case BFD_RELOC_PPC_DTPMOD
:
6792 case BFD_RELOC_PPC_TPREL16
:
6793 case BFD_RELOC_PPC_TPREL16_LO
:
6794 case BFD_RELOC_PPC_TPREL16_HI
:
6795 case BFD_RELOC_PPC_TPREL16_HA
:
6796 case BFD_RELOC_PPC_TPREL
:
6797 case BFD_RELOC_PPC_DTPREL16
:
6798 case BFD_RELOC_PPC_DTPREL16_LO
:
6799 case BFD_RELOC_PPC_DTPREL16_HI
:
6800 case BFD_RELOC_PPC_DTPREL16_HA
:
6801 case BFD_RELOC_PPC_DTPREL
:
6802 case BFD_RELOC_PPC_GOT_TLSGD16
:
6803 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6804 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6805 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6806 case BFD_RELOC_PPC_GOT_TLSLD16
:
6807 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6808 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6809 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6810 case BFD_RELOC_PPC_GOT_TPREL16
:
6811 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6812 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6813 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6814 case BFD_RELOC_PPC_GOT_DTPREL16
:
6815 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6816 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6817 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6818 case BFD_RELOC_PPC64_TPREL16_DS
:
6819 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6820 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6821 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6822 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6823 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6824 case BFD_RELOC_PPC64_DTPREL16_DS
:
6825 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6826 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6827 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6828 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6829 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6830 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6833 /* Because SDA21 modifies the register field, the size is set to 4
6834 bytes, rather than 2, so offset it here appropriately. */
6835 case BFD_RELOC_PPC_EMB_SDA21
:
6839 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
6840 + ((target_big_endian
) ? 2 : 0),
6847 /* This can occur if there is a bug in the input assembler, eg:
6848 ".byte <undefined_symbol> - ." */
6850 as_bad (_("Unable to handle reference to symbol %s"),
6851 S_GET_NAME (fixP
->fx_addsy
));
6853 as_bad (_("Unable to resolve expression"));
6857 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6861 case BFD_RELOC_24_PLT_PCREL
:
6862 case BFD_RELOC_PPC_LOCAL24PC
:
6863 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
6871 /* Fetch the instruction, insert the fully resolved operand
6872 value, and stuff the instruction back again. */
6873 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6874 if (target_big_endian
)
6875 insn
= bfd_getb32 ((unsigned char *) where
);
6877 insn
= bfd_getl32 ((unsigned char *) where
);
6878 if ((value
& 3) != 0)
6879 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6880 _("must branch to an address a multiple of 4"));
6881 if ((offsetT
) value
< -0x40000000
6882 || (offsetT
) value
>= 0x40000000)
6883 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6884 _("@local or @plt branch destination is too far away, %ld bytes"),
6886 insn
= insn
| (value
& 0x03fffffc);
6887 if (target_big_endian
)
6888 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6890 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6894 case BFD_RELOC_VTABLE_INHERIT
:
6897 && !S_IS_DEFINED (fixP
->fx_addsy
)
6898 && !S_IS_WEAK (fixP
->fx_addsy
))
6899 S_SET_WEAK (fixP
->fx_addsy
);
6902 case BFD_RELOC_VTABLE_ENTRY
:
6907 /* Generated by reference to `sym@tocbase'. The sym is
6908 ignored by the linker. */
6909 case BFD_RELOC_PPC64_TOC
:
6915 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6922 fixP
->fx_addnumber
= value
;
6924 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6925 from the section contents. If we are going to be emitting a reloc
6926 then the section contents are immaterial, so don't warn if they
6927 happen to overflow. Leave such warnings to ld. */
6929 fixP
->fx_no_overflow
= 1;
6931 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6932 fixP
->fx_addnumber
= 0;
6936 fixP
->fx_addnumber
= 0;
6938 /* We want to use the offset within the toc, not the actual VMA
6940 fixP
->fx_addnumber
=
6941 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6942 - S_GET_VALUE (ppc_toc_csect
);
6948 /* Generate a reloc for a fixup. */
6951 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6955 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6957 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6958 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6959 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6960 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6961 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6963 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6964 _("reloc %d not supported by object file format"),
6965 (int) fixp
->fx_r_type
);
6968 reloc
->addend
= fixp
->fx_addnumber
;
6974 ppc_cfi_frame_initial_instructions (void)
6976 cfi_add_CFA_def_cfa (1, 0);
6980 tc_ppc_regname_to_dw2regnum (char *regname
)
6982 unsigned int regnum
= -1;
6986 static struct { char *name
; int dw2regnum
; } regnames
[] =
6988 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6989 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6990 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6991 { "spe_acc", 111 }, { "spefscr", 112 }
6994 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6995 if (strcmp (regnames
[i
].name
, regname
) == 0)
6996 return regnames
[i
].dw2regnum
;
6998 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7000 p
= regname
+ 1 + (regname
[1] == '.');
7001 regnum
= strtoul (p
, &q
, 10);
7002 if (p
== q
|| *q
|| regnum
>= 32)
7004 if (regname
[0] == 'f')
7006 else if (regname
[0] == 'v')
7009 else if (regname
[0] == 'c' && regname
[1] == 'r')
7011 p
= regname
+ 2 + (regname
[2] == '.');
7012 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7014 regnum
= p
[0] - '0' + 68;