1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994-2014 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "safe-ctype.h"
25 #include "dw2gencfi.h"
26 #include "opcode/ppc.h"
30 #include "elf/ppc64.h"
31 #include "dwarf2dbg.h"
39 #include "coff/xcoff.h"
43 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
45 /* Tell the main code what the endianness is. */
46 extern int target_big_endian
;
48 /* Whether or not, we've set target_big_endian. */
49 static int set_target_endian
= 0;
51 /* Whether to use user friendly register names. */
52 #ifndef TARGET_REG_NAMES_P
54 #define TARGET_REG_NAMES_P TRUE
56 #define TARGET_REG_NAMES_P FALSE
60 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
63 /* #lo(value) denotes the least significant 16 bits of the indicated. */
64 #define PPC_LO(v) ((v) & 0xffff)
66 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
67 #define PPC_HI(v) (((v) >> 16) & 0xffff)
69 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
70 the indicated value, compensating for #lo() being treated as a
72 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
74 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
75 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
77 /* #highera(value) denotes bits 32 through 47 of the indicated value,
78 compensating for #lo() being treated as a signed number. */
79 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
81 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
82 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
84 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
85 compensating for #lo being treated as a signed number. */
86 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
88 #define SEX16(val) (((val) ^ 0x8000) - 0x8000)
90 /* For the time being on ppc64, don't report overflow on @h and @ha
91 applied to constants. */
92 #define REPORT_OVERFLOW_HI 0
94 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
96 static void ppc_macro (char *, const struct powerpc_macro
*);
97 static void ppc_byte (int);
99 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
100 static void ppc_tc (int);
101 static void ppc_machine (int);
105 static void ppc_comm (int);
106 static void ppc_bb (int);
107 static void ppc_bc (int);
108 static void ppc_bf (int);
109 static void ppc_biei (int);
110 static void ppc_bs (int);
111 static void ppc_eb (int);
112 static void ppc_ec (int);
113 static void ppc_ef (int);
114 static void ppc_es (int);
115 static void ppc_csect (int);
116 static void ppc_dwsect (int);
117 static void ppc_change_csect (symbolS
*, offsetT
);
118 static void ppc_function (int);
119 static void ppc_extern (int);
120 static void ppc_lglobl (int);
121 static void ppc_ref (int);
122 static void ppc_section (int);
123 static void ppc_named_section (int);
124 static void ppc_stabx (int);
125 static void ppc_rename (int);
126 static void ppc_toc (int);
127 static void ppc_xcoff_cons (int);
128 static void ppc_vbyte (int);
132 static void ppc_elf_rdata (int);
133 static void ppc_elf_lcomm (int);
134 static void ppc_elf_localentry (int);
135 static void ppc_elf_abiversion (int);
139 static void ppc_previous (int);
140 static void ppc_pdata (int);
141 static void ppc_ydata (int);
142 static void ppc_reldata (int);
143 static void ppc_rdata (int);
144 static void ppc_ualong (int);
145 static void ppc_znop (int);
146 static void ppc_pe_comm (int);
147 static void ppc_pe_section (int);
148 static void ppc_pe_function (int);
149 static void ppc_pe_tocd (int);
152 /* Generic assembler global variables which must be defined by all
156 /* This string holds the chars that always start a comment. If the
157 pre-processor is disabled, these aren't very useful. The macro
158 tc_comment_chars points to this. We use this, rather than the
159 usual comment_chars, so that we can switch for Solaris conventions. */
160 static const char ppc_solaris_comment_chars
[] = "#!";
161 static const char ppc_eabi_comment_chars
[] = "#";
163 #ifdef TARGET_SOLARIS_COMMENT
164 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
166 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
169 const char comment_chars
[] = "#";
172 /* Characters which start a comment at the beginning of a line. */
173 const char line_comment_chars
[] = "#";
175 /* Characters which may be used to separate multiple commands on a
177 const char line_separator_chars
[] = ";";
179 /* Characters which are used to indicate an exponent in a floating
181 const char EXP_CHARS
[] = "eE";
183 /* Characters which mean that a number is a floating point constant,
185 const char FLT_CHARS
[] = "dD";
187 /* Anything that can start an operand needs to be mentioned here,
188 to stop the input scrubber eating whitespace. */
189 const char ppc_symbol_chars
[] = "%[";
191 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
192 int ppc_cie_data_alignment
;
194 /* The dwarf2 minimum instruction length. */
195 int ppc_dwarf2_line_min_insn_length
;
197 /* More than this number of nops in an alignment op gets a branch
199 unsigned long nop_limit
= 4;
201 /* The type of processor we are assembling for. This is one or more
202 of the PPC_OPCODE flags defined in opcode/ppc.h. */
203 ppc_cpu_t ppc_cpu
= 0;
204 ppc_cpu_t sticky
= 0;
206 /* Value for ELF e_flags EF_PPC64_ABI. */
207 unsigned int ppc_abiversion
= 0;
209 /* Flags set on encountering toc relocs. */
211 has_large_toc_reloc
= 1,
212 has_small_toc_reloc
= 2
215 /* Warn on emitting data to code sections. */
217 unsigned long last_insn
;
221 /* The target specific pseudo-ops which we support. */
223 const pseudo_typeS md_pseudo_table
[] =
225 /* Pseudo-ops which must be overridden. */
226 { "byte", ppc_byte
, 0 },
229 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
230 legitimately belong in the obj-*.c file. However, XCOFF is based
231 on COFF, and is only implemented for the RS/6000. We just use
232 obj-coff.c, and add what we need here. */
233 { "comm", ppc_comm
, 0 },
234 { "lcomm", ppc_comm
, 1 },
238 { "bi", ppc_biei
, 0 },
240 { "csect", ppc_csect
, 0 },
241 { "dwsect", ppc_dwsect
, 0 },
242 { "data", ppc_section
, 'd' },
246 { "ei", ppc_biei
, 1 },
248 { "extern", ppc_extern
, 0 },
249 { "function", ppc_function
, 0 },
250 { "lglobl", ppc_lglobl
, 0 },
251 { "ref", ppc_ref
, 0 },
252 { "rename", ppc_rename
, 0 },
253 { "section", ppc_named_section
, 0 },
254 { "stabx", ppc_stabx
, 0 },
255 { "text", ppc_section
, 't' },
256 { "toc", ppc_toc
, 0 },
257 { "long", ppc_xcoff_cons
, 2 },
258 { "llong", ppc_xcoff_cons
, 3 },
259 { "word", ppc_xcoff_cons
, 1 },
260 { "short", ppc_xcoff_cons
, 1 },
261 { "vbyte", ppc_vbyte
, 0 },
265 { "llong", cons
, 8 },
266 { "rdata", ppc_elf_rdata
, 0 },
267 { "rodata", ppc_elf_rdata
, 0 },
268 { "lcomm", ppc_elf_lcomm
, 0 },
269 { "localentry", ppc_elf_localentry
, 0 },
270 { "abiversion", ppc_elf_abiversion
, 0 },
274 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
275 { "previous", ppc_previous
, 0 },
276 { "pdata", ppc_pdata
, 0 },
277 { "ydata", ppc_ydata
, 0 },
278 { "reldata", ppc_reldata
, 0 },
279 { "rdata", ppc_rdata
, 0 },
280 { "ualong", ppc_ualong
, 0 },
281 { "znop", ppc_znop
, 0 },
282 { "comm", ppc_pe_comm
, 0 },
283 { "lcomm", ppc_pe_comm
, 1 },
284 { "section", ppc_pe_section
, 0 },
285 { "function", ppc_pe_function
,0 },
286 { "tocd", ppc_pe_tocd
, 0 },
289 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
291 { "machine", ppc_machine
, 0 },
298 /* Predefined register names if -mregnames (or default for Windows NT).
299 In general, there are lots of them, in an attempt to be compatible
300 with a number of other Windows NT assemblers. */
302 /* Structure to hold information about predefined registers. */
309 /* List of registers that are pre-defined:
311 Each general register has predefined names of the form:
312 1. r<reg_num> which has the value <reg_num>.
313 2. r.<reg_num> which has the value <reg_num>.
315 Each floating point register has predefined names of the form:
316 1. f<reg_num> which has the value <reg_num>.
317 2. f.<reg_num> which has the value <reg_num>.
319 Each vector unit register has predefined names of the form:
320 1. v<reg_num> which has the value <reg_num>.
321 2. v.<reg_num> which has the value <reg_num>.
323 Each condition register has predefined names of the form:
324 1. cr<reg_num> which has the value <reg_num>.
325 2. cr.<reg_num> which has the value <reg_num>.
327 There are individual registers as well:
328 sp or r.sp has the value 1
329 rtoc or r.toc has the value 2
330 fpscr has the value 0
336 dsisr has the value 18
338 sdr1 has the value 25
339 srr0 has the value 26
340 srr1 has the value 27
342 The table is sorted. Suitable for searching by a binary search. */
344 static const struct pd_reg pre_defined_registers
[] =
346 { "cr.0", 0 }, /* Condition Registers */
366 { "dar", 19 }, /* Data Access Register */
367 { "dec", 22 }, /* Decrementer */
368 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
370 { "f.0", 0 }, /* Floating point registers */
397 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
463 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
504 /* Quantization registers used with pair single instructions. */
522 { "lr", 8 }, /* Link Register */
526 { "r.0", 0 }, /* General Purpose Registers */
559 { "r.sp", 1 }, /* Stack Pointer */
561 { "r.toc", 2 }, /* Pointer to the table of contents */
563 { "r0", 0 }, /* More general purpose registers */
596 { "rtoc", 2 }, /* Table of contents */
598 { "sdr1", 25 }, /* Storage Description Register 1 */
602 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
603 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
605 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
671 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
805 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
807 /* Given NAME, find the register number associated with that name, return
808 the integer value associated with the given name or -1 on failure. */
811 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
813 int middle
, low
, high
;
821 middle
= (low
+ high
) / 2;
822 cmp
= strcasecmp (name
, regs
[middle
].name
);
828 return regs
[middle
].value
;
836 * Summary of register_name.
838 * in: Input_line_pointer points to 1st char of operand.
840 * out: A expressionS.
841 * The operand may have been a register: in this case, X_op == O_register,
842 * X_add_number is set to the register number, and truth is returned.
843 * Input_line_pointer->(next non-blank) char after operand, or is in its
848 register_name (expressionS
*expressionP
)
855 /* Find the spelling of the operand. */
856 start
= name
= input_line_pointer
;
857 if (name
[0] == '%' && ISALPHA (name
[1]))
858 name
= ++input_line_pointer
;
860 else if (!reg_names_p
|| !ISALPHA (name
[0]))
863 c
= get_symbol_end ();
864 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
866 /* Put back the delimiting char. */
867 *input_line_pointer
= c
;
869 /* Look to see if it's in the register table. */
872 expressionP
->X_op
= O_register
;
873 expressionP
->X_add_number
= reg_number
;
875 /* Make the rest nice. */
876 expressionP
->X_add_symbol
= NULL
;
877 expressionP
->X_op_symbol
= NULL
;
881 /* Reset the line as if we had not done anything. */
882 input_line_pointer
= start
;
886 /* This function is called for each symbol seen in an expression. It
887 handles the special parsing which PowerPC assemblers are supposed
888 to use for condition codes. */
890 /* Whether to do the special parsing. */
891 static bfd_boolean cr_operand
;
893 /* Names to recognize in a condition code. This table is sorted. */
894 static const struct pd_reg cr_names
[] =
911 /* Parsing function. This returns non-zero if it recognized an
915 ppc_parse_name (const char *name
, expressionS
*exp
)
924 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
929 exp
->X_op
= O_constant
;
930 exp
->X_add_number
= val
;
935 /* Local variables. */
937 /* Whether to target xcoff64/elf64. */
938 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
940 /* Opcode hash table. */
941 static struct hash_control
*ppc_hash
;
943 /* Macro hash table. */
944 static struct hash_control
*ppc_macro_hash
;
947 /* What type of shared library support to use. */
948 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
950 /* Flags to set in the elf header. */
951 static flagword ppc_flags
= 0;
953 /* Whether this is Solaris or not. */
954 #ifdef TARGET_SOLARIS_COMMENT
955 #define SOLARIS_P TRUE
957 #define SOLARIS_P FALSE
960 static bfd_boolean msolaris
= SOLARIS_P
;
965 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
966 using a bunch of different sections. These assembler sections,
967 however, are all encompassed within the .text or .data sections of
968 the final output file. We handle this by using different
969 subsegments within these main segments. */
971 /* Next subsegment to allocate within the .text segment. */
972 static subsegT ppc_text_subsegment
= 2;
974 /* Linked list of csects in the text section. */
975 static symbolS
*ppc_text_csects
;
977 /* Next subsegment to allocate within the .data segment. */
978 static subsegT ppc_data_subsegment
= 2;
980 /* Linked list of csects in the data section. */
981 static symbolS
*ppc_data_csects
;
983 /* The current csect. */
984 static symbolS
*ppc_current_csect
;
986 /* The RS/6000 assembler uses a TOC which holds addresses of functions
987 and variables. Symbols are put in the TOC with the .tc pseudo-op.
988 A special relocation is used when accessing TOC entries. We handle
989 the TOC as a subsegment within the .data segment. We set it up if
990 we see a .toc pseudo-op, and save the csect symbol here. */
991 static symbolS
*ppc_toc_csect
;
993 /* The first frag in the TOC subsegment. */
994 static fragS
*ppc_toc_frag
;
996 /* The first frag in the first subsegment after the TOC in the .data
997 segment. NULL if there are no subsegments after the TOC. */
998 static fragS
*ppc_after_toc_frag
;
1000 /* The current static block. */
1001 static symbolS
*ppc_current_block
;
1003 /* The COFF debugging section; set by md_begin. This is not the
1004 .debug section, but is instead the secret BFD section which will
1005 cause BFD to set the section number of a symbol to N_DEBUG. */
1006 static asection
*ppc_coff_debug_section
;
1008 /* Structure to set the length field of the dwarf sections. */
1009 struct dw_subsection
{
1010 /* Subsections are simply linked. */
1011 struct dw_subsection
*link
;
1013 /* The subsection number. */
1016 /* Expression to compute the length of the section. */
1017 expressionS end_exp
;
1020 static struct dw_section
{
1021 /* Corresponding section. */
1024 /* Simply linked list of subsections with a label. */
1025 struct dw_subsection
*list_subseg
;
1027 /* The anonymous subsection. */
1028 struct dw_subsection
*anon_subseg
;
1029 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1030 #endif /* OBJ_XCOFF */
1034 /* Various sections that we need for PE coff support. */
1035 static segT ydata_section
;
1036 static segT pdata_section
;
1037 static segT reldata_section
;
1038 static segT rdata_section
;
1039 static segT tocdata_section
;
1041 /* The current section and the previous section. See ppc_previous. */
1042 static segT ppc_previous_section
;
1043 static segT ppc_current_section
;
1048 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1049 #define PPC_APUINFO_ISEL 0x40
1050 #define PPC_APUINFO_PMR 0x41
1051 #define PPC_APUINFO_RFMCI 0x42
1052 #define PPC_APUINFO_CACHELCK 0x43
1053 #define PPC_APUINFO_SPE 0x100
1054 #define PPC_APUINFO_EFS 0x101
1055 #define PPC_APUINFO_BRLOCK 0x102
1056 #define PPC_APUINFO_VLE 0x104
1059 * We keep a list of APUinfo
1061 unsigned long *ppc_apuinfo_list
;
1062 unsigned int ppc_apuinfo_num
;
1063 unsigned int ppc_apuinfo_num_alloc
;
1064 #endif /* OBJ_ELF */
1067 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1069 const char *const md_shortopts
= "um:";
1071 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1072 const struct option md_longopts
[] = {
1073 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1074 {"ppc476-workaround", no_argument
, &warn_476
, 1},
1075 {"no-ppc476-workaround", no_argument
, &warn_476
, 0},
1076 {NULL
, no_argument
, NULL
, 0}
1078 const size_t md_longopts_size
= sizeof (md_longopts
);
1081 md_parse_option (int c
, char *arg
)
1088 /* -u means that any undefined symbols should be treated as
1089 external, which is the default for gas anyhow. */
1094 /* Solaris as takes -le (presumably for little endian). For completeness
1095 sake, recognize -be also. */
1096 if (strcmp (arg
, "e") == 0)
1098 target_big_endian
= 0;
1099 set_target_endian
= 1;
1100 if (ppc_cpu
& PPC_OPCODE_VLE
)
1101 as_bad (_("the use of -mvle requires big endian."));
1109 if (strcmp (arg
, "e") == 0)
1111 target_big_endian
= 1;
1112 set_target_endian
= 1;
1120 /* Recognize -K PIC. */
1121 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1124 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1132 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1134 if (strcmp (arg
, "64") == 0)
1138 if (ppc_cpu
& PPC_OPCODE_VLE
)
1139 as_bad (_("the use of -mvle requires -a32."));
1141 as_fatal (_("%s unsupported"), "-a64");
1144 else if (strcmp (arg
, "32") == 0)
1151 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1155 if (strcmp (arg
, "vle") == 0)
1157 if (set_target_endian
&& target_big_endian
== 0)
1158 as_bad (_("the use of -mvle requires big endian."));
1160 as_bad (_("the use of -mvle requires -a32."));
1164 else if (strcmp (arg
, "regnames") == 0)
1167 else if (strcmp (arg
, "no-regnames") == 0)
1168 reg_names_p
= FALSE
;
1171 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1172 that require relocation. */
1173 else if (strcmp (arg
, "relocatable") == 0)
1175 shlib
= SHLIB_MRELOCATABLE
;
1176 ppc_flags
|= EF_PPC_RELOCATABLE
;
1179 else if (strcmp (arg
, "relocatable-lib") == 0)
1181 shlib
= SHLIB_MRELOCATABLE
;
1182 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1185 /* -memb, set embedded bit. */
1186 else if (strcmp (arg
, "emb") == 0)
1187 ppc_flags
|= EF_PPC_EMB
;
1189 /* -mlittle/-mbig set the endianness. */
1190 else if (strcmp (arg
, "little") == 0
1191 || strcmp (arg
, "little-endian") == 0)
1193 target_big_endian
= 0;
1194 set_target_endian
= 1;
1195 if (ppc_cpu
& PPC_OPCODE_VLE
)
1196 as_bad (_("the use of -mvle requires big endian."));
1199 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1201 target_big_endian
= 1;
1202 set_target_endian
= 1;
1205 else if (strcmp (arg
, "solaris") == 0)
1208 ppc_comment_chars
= ppc_solaris_comment_chars
;
1211 else if (strcmp (arg
, "no-solaris") == 0)
1214 ppc_comment_chars
= ppc_eabi_comment_chars
;
1219 as_bad (_("invalid switch -m%s"), arg
);
1225 /* -V: SVR4 argument to print version ID. */
1227 print_version_id ();
1230 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1231 should be emitted or not. FIXME: Not implemented. */
1235 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1236 rather than .stabs.excl, which is ignored by the linker.
1237 FIXME: Not implemented. */
1248 nop_limit
= strtoul (optarg
, &end
, 0);
1250 as_bad (_("--nops needs a numeric argument"));
1265 md_show_usage (FILE *stream
)
1267 fprintf (stream
, _("\
1269 -a32 generate ELF32/XCOFF32\n\
1270 -a64 generate ELF64/XCOFF64\n\
1272 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1273 -mpwr generate code for POWER (RIOS1)\n\
1274 -m601 generate code for PowerPC 601\n\
1275 -mppc, -mppc32, -m603, -m604\n\
1276 generate code for PowerPC 603/604\n\
1277 -m403 generate code for PowerPC 403\n\
1278 -m405 generate code for PowerPC 405\n\
1279 -m440 generate code for PowerPC 440\n\
1280 -m464 generate code for PowerPC 464\n\
1281 -m476 generate code for PowerPC 476\n\
1282 -m7400, -m7410, -m7450, -m7455\n\
1283 generate code for PowerPC 7400/7410/7450/7455\n\
1284 -m750cl generate code for PowerPC 750cl\n"));
1285 fprintf (stream
, _("\
1286 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1287 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1288 -mbooke generate code for 32-bit PowerPC BookE\n\
1289 -ma2 generate code for A2 architecture\n\
1290 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1291 -mpower5, -mpwr5, -mpwr5x\n\
1292 generate code for Power5 architecture\n\
1293 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1294 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1295 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1296 -mcell generate code for Cell Broadband Engine architecture\n\
1297 -mcom generate code Power/PowerPC common instructions\n\
1298 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1299 fprintf (stream
, _("\
1300 -maltivec generate code for AltiVec\n\
1301 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1302 -mhtm generate code for Hardware Transactional Memory\n\
1303 -me300 generate code for PowerPC e300 family\n\
1304 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1305 -me500mc, generate code for Freescale e500mc core complex\n\
1306 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1307 -me5500, generate code for Freescale e5500 core complex\n\
1308 -me6500, generate code for Freescale e6500 core complex\n\
1309 -mspe generate code for Motorola SPE instructions\n\
1310 -mvle generate code for Freescale VLE instructions\n\
1311 -mtitan generate code for AppliedMicro Titan core complex\n\
1312 -mregnames Allow symbolic names for registers\n\
1313 -mno-regnames Do not allow symbolic names for registers\n"));
1315 fprintf (stream
, _("\
1316 -mrelocatable support for GCC's -mrelocatble option\n\
1317 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1318 -memb set PPC_EMB bit in ELF flags\n\
1319 -mlittle, -mlittle-endian, -le\n\
1320 generate code for a little endian machine\n\
1321 -mbig, -mbig-endian, -be\n\
1322 generate code for a big endian machine\n\
1323 -msolaris generate code for Solaris\n\
1324 -mno-solaris do not generate code for Solaris\n\
1325 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1326 -V print assembler version number\n\
1327 -Qy, -Qn ignored\n"));
1329 fprintf (stream
, _("\
1330 -nops=count when aligning, more than COUNT nops uses a branch\n\
1331 -ppc476-workaround warn if emitting data to code sections\n"));
1334 /* Set ppc_cpu if it is not already set. */
1339 const char *default_os
= TARGET_OS
;
1340 const char *default_cpu
= TARGET_CPU
;
1342 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1345 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1346 else if (strncmp (default_os
, "aix", 3) == 0
1347 && default_os
[3] >= '4' && default_os
[3] <= '9')
1348 ppc_cpu
|= PPC_OPCODE_COMMON
;
1349 else if (strncmp (default_os
, "aix3", 4) == 0)
1350 ppc_cpu
|= PPC_OPCODE_POWER
;
1351 else if (strcmp (default_cpu
, "rs6000") == 0)
1352 ppc_cpu
|= PPC_OPCODE_POWER
;
1353 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1354 ppc_cpu
|= PPC_OPCODE_PPC
;
1356 as_fatal (_("unknown default cpu = %s, os = %s"),
1357 default_cpu
, default_os
);
1361 /* Figure out the BFD architecture to use. This function and ppc_mach
1362 are called well before md_begin, when the output file is opened. */
1364 enum bfd_architecture
1367 const char *default_cpu
= TARGET_CPU
;
1370 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1371 return bfd_arch_powerpc
;
1372 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1373 return bfd_arch_powerpc
;
1374 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1375 return bfd_arch_rs6000
;
1376 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1378 if (strcmp (default_cpu
, "rs6000") == 0)
1379 return bfd_arch_rs6000
;
1380 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1381 return bfd_arch_powerpc
;
1384 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1385 return bfd_arch_unknown
;
1392 return bfd_mach_ppc64
;
1393 else if (ppc_arch () == bfd_arch_rs6000
)
1394 return bfd_mach_rs6k
;
1395 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1396 return bfd_mach_ppc_titan
;
1397 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1398 return bfd_mach_ppc_vle
;
1400 return bfd_mach_ppc
;
1404 ppc_target_format (void)
1408 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1410 return "xcoff-powermac";
1413 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1415 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1421 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1422 # elif defined (TE_VXWORKS)
1423 return "elf32-powerpc-vxworks";
1425 return (target_big_endian
1426 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1427 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1432 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1433 Return TRUE if there's a problem, otherwise FALSE. */
1436 insn_validate (const struct powerpc_opcode
*op
)
1438 const unsigned char *o
;
1439 unsigned long omask
= op
->mask
;
1441 /* The mask had better not trim off opcode bits. */
1442 if ((op
->opcode
& omask
) != op
->opcode
)
1444 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1448 /* The operands must not overlap the opcode or each other. */
1449 for (o
= op
->operands
; *o
; ++o
)
1451 if (*o
>= num_powerpc_operands
)
1453 as_bad (_("operand index error for %s"), op
->name
);
1458 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1459 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1463 if (operand
->shift
>= 0)
1464 mask
= operand
->bitm
<< operand
->shift
;
1466 mask
= operand
->bitm
>> -operand
->shift
;
1469 as_bad (_("operand %d overlap in %s"),
1470 (int) (o
- op
->operands
), op
->name
);
1480 /* Insert opcodes and macros into hash tables. Called at startup and
1481 for .machine pseudo. */
1484 ppc_setup_opcodes (void)
1486 const struct powerpc_opcode
*op
;
1487 const struct powerpc_opcode
*op_end
;
1488 const struct powerpc_macro
*macro
;
1489 const struct powerpc_macro
*macro_end
;
1490 bfd_boolean bad_insn
= FALSE
;
1492 if (ppc_hash
!= NULL
)
1493 hash_die (ppc_hash
);
1494 if (ppc_macro_hash
!= NULL
)
1495 hash_die (ppc_macro_hash
);
1497 /* Insert the opcodes into a hash table. */
1498 ppc_hash
= hash_new ();
1500 if (ENABLE_CHECKING
)
1504 /* An index into powerpc_operands is stored in struct fix
1505 fx_pcrel_adjust which is 8 bits wide. */
1506 gas_assert (num_powerpc_operands
< 256);
1508 /* Check operand masks. Code here and in the disassembler assumes
1509 all the 1's in the mask are contiguous. */
1510 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1512 unsigned long mask
= powerpc_operands
[i
].bitm
;
1513 unsigned long right_bit
;
1516 right_bit
= mask
& -mask
;
1518 right_bit
= mask
& -mask
;
1519 if (mask
!= right_bit
)
1521 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1524 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1525 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1526 sizeof (powerpc_operands
[0])) == 0)
1528 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1535 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1536 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1538 if (ENABLE_CHECKING
)
1540 if (op
!= powerpc_opcodes
)
1542 int old_opcode
= PPC_OP (op
[-1].opcode
);
1543 int new_opcode
= PPC_OP (op
[0].opcode
);
1545 #ifdef PRINT_OPCODE_TABLE
1546 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1547 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1548 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1549 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1552 /* The major opcodes had better be sorted. Code in the
1553 disassembler assumes the insns are sorted according to
1555 if (new_opcode
< old_opcode
)
1557 as_bad (_("major opcode is not sorted for %s"),
1562 bad_insn
|= insn_validate (op
);
1565 if ((ppc_cpu
& op
->flags
) != 0
1566 && !(ppc_cpu
& op
->deprecated
))
1570 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1573 as_bad (_("duplicate instruction %s"),
1580 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1581 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1582 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1584 op_end
= vle_opcodes
+ vle_num_opcodes
;
1585 for (op
= vle_opcodes
; op
< op_end
; op
++)
1587 if (ENABLE_CHECKING
)
1589 if (op
!= vle_opcodes
)
1591 unsigned old_seg
, new_seg
;
1593 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1594 old_seg
= VLE_OP_TO_SEG (old_seg
);
1595 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1596 new_seg
= VLE_OP_TO_SEG (new_seg
);
1598 #ifdef PRINT_OPCODE_TABLE
1599 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1600 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1601 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1602 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1604 /* The major opcodes had better be sorted. Code in the
1605 disassembler assumes the insns are sorted according to
1607 if (new_seg
< old_seg
)
1609 as_bad (_("major opcode is not sorted for %s"),
1615 bad_insn
|= insn_validate (op
);
1618 if ((ppc_cpu
& op
->flags
) != 0
1619 && !(ppc_cpu
& op
->deprecated
))
1623 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1626 as_bad (_("duplicate instruction %s"),
1633 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1634 for (op
= vle_opcodes
; op
< op_end
; op
++)
1635 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1637 /* Insert the macros into a hash table. */
1638 ppc_macro_hash
= hash_new ();
1640 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1641 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1643 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1647 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1648 if (retval
!= (const char *) NULL
)
1650 as_bad (_("duplicate macro %s"), macro
->name
);
1660 /* This function is called when the assembler starts up. It is called
1661 after the options have been parsed and the output file has been
1669 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1670 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1673 /* Set the ELF flags if desired. */
1674 if (ppc_flags
&& !msolaris
)
1675 bfd_set_private_flags (stdoutput
, ppc_flags
);
1678 ppc_setup_opcodes ();
1680 /* Tell the main code what the endianness is if it is not overridden
1682 if (!set_target_endian
)
1684 set_target_endian
= 1;
1685 target_big_endian
= PPC_BIG_ENDIAN
;
1689 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1691 /* Create dummy symbols to serve as initial csects. This forces the
1692 text csects to precede the data csects. These symbols will not
1694 ppc_text_csects
= symbol_make ("dummy\001");
1695 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1696 ppc_data_csects
= symbol_make ("dummy\001");
1697 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1702 ppc_current_section
= text_section
;
1703 ppc_previous_section
= 0;
1712 if (ppc_apuinfo_list
== NULL
)
1715 /* Ok, so write the section info out. We have this layout:
1719 0 8 length of "APUinfo\0"
1720 4 (n*4) number of APU's (4 bytes each)
1723 20 APU#1 first APU's info
1724 24 APU#2 second APU's info
1729 asection
*seg
= now_seg
;
1730 subsegT subseg
= now_subseg
;
1731 asection
*apuinfo_secp
= (asection
*) NULL
;
1734 /* Create the .PPC.EMB.apuinfo section. */
1735 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1736 bfd_set_section_flags (stdoutput
,
1738 SEC_HAS_CONTENTS
| SEC_READONLY
);
1741 md_number_to_chars (p
, (valueT
) 8, 4);
1744 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1747 md_number_to_chars (p
, (valueT
) 2, 4);
1750 strcpy (p
, "APUinfo");
1752 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1755 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1758 frag_align (2, 0, 0);
1760 /* We probably can't restore the current segment, for there likely
1763 subseg_set (seg
, subseg
);
1768 /* Insert an operand value into an instruction. */
1770 static unsigned long
1771 ppc_insert_operand (unsigned long insn
,
1772 const struct powerpc_operand
*operand
,
1778 long min
, max
, right
;
1780 max
= operand
->bitm
;
1784 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1786 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1787 max
= (max
>> 1) & -right
;
1788 min
= ~max
& -right
;
1791 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1794 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1803 /* Some people write constants with the sign extension done by
1804 hand but only up to 32 bits. This shouldn't really be valid,
1805 but, to permit this code to assemble on a 64-bit host, we
1806 sign extend the 32-bit value to 64 bits if so doing makes the
1809 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1810 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1811 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1812 val
= val
- 0x80000000 - 0x80000000;
1814 /* Similarly, people write expressions like ~(1<<15), and expect
1815 this to be OK for a 32-bit unsigned value. */
1817 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1818 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1819 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1820 val
= val
+ 0x80000000 + 0x80000000;
1824 || (val
& (right
- 1)) != 0)
1825 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1828 if (operand
->insert
)
1833 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1834 if (errmsg
!= (const char *) NULL
)
1835 as_bad_where (file
, line
, "%s", errmsg
);
1837 else if (operand
->shift
>= 0)
1838 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1840 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1847 /* Parse @got, etc. and return the desired relocation. */
1848 static bfd_reloc_code_real_type
1849 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1853 unsigned int length
: 8;
1854 unsigned int valid32
: 1;
1855 unsigned int valid64
: 1;
1864 const struct map_bfd
*ptr
;
1866 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1867 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1868 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1870 static const struct map_bfd mapping
[] = {
1871 MAP ("l", BFD_RELOC_LO16
),
1872 MAP ("h", BFD_RELOC_HI16
),
1873 MAP ("ha", BFD_RELOC_HI16_S
),
1874 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1875 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1876 MAP ("got", BFD_RELOC_16_GOTOFF
),
1877 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1878 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1879 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1880 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1881 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1882 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1883 MAP ("copy", BFD_RELOC_PPC_COPY
),
1884 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1885 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1886 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1887 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1888 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1889 MAP ("tls", BFD_RELOC_PPC_TLS
),
1890 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1891 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1892 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1893 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1894 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1895 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1896 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1897 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1898 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1899 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1900 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1901 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1902 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1903 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1904 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1905 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1906 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1907 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1908 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1909 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1910 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1911 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1912 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1913 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1914 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1915 MAP32 ("fixup", BFD_RELOC_CTOR
),
1916 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1917 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1918 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1919 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1920 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1921 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1922 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1923 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1924 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1925 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1926 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1927 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1928 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1929 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1930 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1931 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1932 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1933 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1934 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1935 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1936 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1937 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1938 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1939 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1940 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1941 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1942 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1943 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1944 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1945 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1946 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1947 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1948 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1949 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1950 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1951 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1952 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1953 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1954 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1955 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1956 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1957 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1958 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1959 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1960 MAP64 ("localentry", BFD_RELOC_PPC64_ADDR64_LOCAL
),
1961 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1962 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1963 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1964 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1965 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1966 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1967 { (char *) 0, 0, 0, 0, BFD_RELOC_NONE
}
1971 return BFD_RELOC_NONE
;
1973 for (ch
= *str
, str2
= ident
;
1974 (str2
< ident
+ sizeof (ident
) - 1
1975 && (ISALNUM (ch
) || ch
== '@'));
1978 *str2
++ = TOLOWER (ch
);
1985 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1986 if (ch
== ptr
->string
[0]
1987 && len
== ptr
->length
1988 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1989 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1991 int reloc
= ptr
->reloc
;
1993 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1997 case BFD_RELOC_16_GOTOFF
:
1998 case BFD_RELOC_LO16_GOTOFF
:
1999 case BFD_RELOC_HI16_GOTOFF
:
2000 case BFD_RELOC_HI16_S_GOTOFF
:
2001 as_warn (_("identifier+constant@got means "
2002 "identifier@got+constant"));
2005 case BFD_RELOC_PPC_GOT_TLSGD16
:
2006 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2007 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2008 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2009 case BFD_RELOC_PPC_GOT_TLSLD16
:
2010 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2011 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2012 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2013 case BFD_RELOC_PPC_GOT_DTPREL16
:
2014 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2015 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2016 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2017 case BFD_RELOC_PPC_GOT_TPREL16
:
2018 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2019 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2020 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2021 as_bad (_("symbol+offset not supported for got tls"));
2026 /* Now check for identifier@suffix+constant. */
2027 if (*str
== '-' || *str
== '+')
2029 char *orig_line
= input_line_pointer
;
2030 expressionS new_exp
;
2032 input_line_pointer
= str
;
2033 expression (&new_exp
);
2034 if (new_exp
.X_op
== O_constant
)
2036 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2037 str
= input_line_pointer
;
2040 if (&input_line_pointer
!= str_p
)
2041 input_line_pointer
= orig_line
;
2045 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2046 && exp_p
->X_op
== O_symbol
2047 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2049 /* Change the symbol so that the dummy .TOC. symbol can be
2050 omitted from the object file. */
2051 exp_p
->X_add_symbol
= &abs_symbol
;
2054 return (bfd_reloc_code_real_type
) reloc
;
2057 return BFD_RELOC_NONE
;
2060 /* Support @got, etc. on constants emitted via .short, .int etc. */
2062 bfd_reloc_code_real_type
2063 ppc_elf_parse_cons (expressionS
*exp
, unsigned int nbytes
)
2066 if (nbytes
>= 2 && *input_line_pointer
== '@')
2067 return ppc_elf_suffix (&input_line_pointer
, exp
);
2068 return BFD_RELOC_NONE
;
2071 /* Warn when emitting data to code sections, unless we are emitting
2072 a relocation that ld --ppc476-workaround uses to recognise data
2073 *and* there was an unconditional branch prior to the data. */
2076 ppc_elf_cons_fix_check (expressionS
*exp ATTRIBUTE_UNUSED
,
2077 unsigned int nbytes
, fixS
*fix
)
2080 && (now_seg
->flags
& SEC_CODE
) != 0
2083 || !(fix
->fx_r_type
== BFD_RELOC_32
2084 || fix
->fx_r_type
== BFD_RELOC_CTOR
2085 || fix
->fx_r_type
== BFD_RELOC_32_PCREL
)
2086 || !(last_seg
== now_seg
&& last_subseg
== now_subseg
)
2087 || !((last_insn
& (0x3f << 26)) == (18u << 26)
2088 || ((last_insn
& (0x3f << 26)) == (16u << 26)
2089 && (last_insn
& (0x14 << 21)) == (0x14 << 21))
2090 || ((last_insn
& (0x3f << 26)) == (19u << 26)
2091 && (last_insn
& (0x3ff << 1)) == (16u << 1)
2092 && (last_insn
& (0x14 << 21)) == (0x14 << 21)))))
2094 /* Flag that we've warned. */
2098 as_warn (_("data in executable section"));
2102 /* Solaris pseduo op to change to the .rodata section. */
2104 ppc_elf_rdata (int xxx
)
2106 char *save_line
= input_line_pointer
;
2107 static char section
[] = ".rodata\n";
2109 /* Just pretend this is .section .rodata */
2110 input_line_pointer
= section
;
2111 obj_elf_section (xxx
);
2113 input_line_pointer
= save_line
;
2116 /* Pseudo op to make file scope bss items. */
2118 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2131 name
= input_line_pointer
;
2132 c
= get_symbol_end ();
2134 /* just after name is now '\0'. */
2135 p
= input_line_pointer
;
2138 if (*input_line_pointer
!= ',')
2140 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2141 ignore_rest_of_line ();
2145 input_line_pointer
++; /* skip ',' */
2146 if ((size
= get_absolute_expression ()) < 0)
2148 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2149 ignore_rest_of_line ();
2153 /* The third argument to .lcomm is the alignment. */
2154 if (*input_line_pointer
!= ',')
2158 ++input_line_pointer
;
2159 align
= get_absolute_expression ();
2162 as_warn (_("ignoring bad alignment"));
2168 symbolP
= symbol_find_or_make (name
);
2171 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2173 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2174 S_GET_NAME (symbolP
));
2175 ignore_rest_of_line ();
2179 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2181 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2182 S_GET_NAME (symbolP
),
2183 (long) S_GET_VALUE (symbolP
),
2186 ignore_rest_of_line ();
2192 old_subsec
= now_subseg
;
2195 /* Convert to a power of 2 alignment. */
2196 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2199 as_bad (_("common alignment not a power of 2"));
2200 ignore_rest_of_line ();
2207 record_alignment (bss_section
, align2
);
2208 subseg_set (bss_section
, 1);
2210 frag_align (align2
, 0, 0);
2211 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2212 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2213 symbol_set_frag (symbolP
, frag_now
);
2214 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2217 S_SET_SIZE (symbolP
, size
);
2218 S_SET_SEGMENT (symbolP
, bss_section
);
2219 subseg_set (old_sec
, old_subsec
);
2220 demand_empty_rest_of_line ();
2223 /* Pseudo op to set symbol local entry point. */
2225 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED
)
2227 char *name
= input_line_pointer
;
2228 char c
= get_symbol_end ();
2233 elf_symbol_type
*elfsym
;
2235 p
= input_line_pointer
;
2238 if (*input_line_pointer
!= ',')
2241 as_bad (_("expected comma after name `%s' in .localentry directive"),
2244 ignore_rest_of_line ();
2247 input_line_pointer
++;
2249 if (exp
.X_op
== O_absent
)
2251 as_bad (_("missing expression in .localentry directive"));
2252 exp
.X_op
= O_constant
;
2253 exp
.X_add_number
= 0;
2256 sym
= symbol_find_or_make (name
);
2259 if (resolve_expression (&exp
)
2260 && exp
.X_op
== O_constant
)
2262 unsigned char encoded
= PPC64_SET_LOCAL_ENTRY_OFFSET (exp
.X_add_number
);
2264 if (exp
.X_add_number
!= (offsetT
) PPC64_LOCAL_ENTRY_OFFSET (encoded
))
2265 as_bad (_(".localentry expression for `%s' "
2266 "is not a valid power of 2"), S_GET_NAME (sym
));
2269 bfdsym
= symbol_get_bfdsym (sym
);
2270 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
2271 gas_assert (elfsym
);
2272 elfsym
->internal_elf_sym
.st_other
&= ~STO_PPC64_LOCAL_MASK
;
2273 elfsym
->internal_elf_sym
.st_other
|= encoded
;
2274 if (ppc_abiversion
== 0)
2279 as_bad (_(".localentry expression for `%s' "
2280 "does not evaluate to a constant"), S_GET_NAME (sym
));
2282 demand_empty_rest_of_line ();
2285 /* Pseudo op to set ABI version. */
2287 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2292 if (exp
.X_op
== O_absent
)
2294 as_bad (_("missing expression in .abiversion directive"));
2295 exp
.X_op
= O_constant
;
2296 exp
.X_add_number
= 0;
2299 if (resolve_expression (&exp
)
2300 && exp
.X_op
== O_constant
)
2301 ppc_abiversion
= exp
.X_add_number
;
2303 as_bad (_(".abiversion expression does not evaluate to a constant"));
2304 demand_empty_rest_of_line ();
2307 /* Set ABI version in output file. */
2311 if (ppc_obj64
&& ppc_abiversion
!= 0)
2313 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2314 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2318 /* Validate any relocations emitted for -mrelocatable, possibly adding
2319 fixups for word relocations in writable segments, so we can adjust
2322 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2324 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2333 case SHLIB_MRELOCATABLE
:
2334 if (fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2335 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2336 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2337 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2338 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2339 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2340 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2341 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2342 && (seg
->flags
& SEC_LOAD
) != 0
2343 && strcmp (segment_name (seg
), ".got2") != 0
2344 && strcmp (segment_name (seg
), ".dtors") != 0
2345 && strcmp (segment_name (seg
), ".ctors") != 0
2346 && strcmp (segment_name (seg
), ".fixup") != 0
2347 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2348 && strcmp (segment_name (seg
), ".eh_frame") != 0
2349 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2351 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2352 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2354 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2355 _("relocation cannot be done when using -mrelocatable"));
2362 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2363 function descriptor sym if the corresponding code sym is used. */
2366 ppc_frob_file_before_adjust (void)
2374 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2381 name
= S_GET_NAME (symp
);
2385 if (! S_IS_WEAK (symp
)
2386 || S_IS_DEFINED (symp
))
2389 len
= strlen (name
) + 1;
2390 dotname
= xmalloc (len
+ 1);
2392 memcpy (dotname
+ 1, name
, len
);
2393 dotsym
= symbol_find_noref (dotname
, 1);
2395 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2396 || symbol_used_in_reloc_p (dotsym
)))
2397 symbol_mark_used (symp
);
2401 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2403 && toc_reloc_types
!= has_large_toc_reloc
2404 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2405 as_warn (_("TOC section size exceeds 64k"));
2408 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2409 emitted. Other uses of .TOC. will cause the symbol to be marked
2410 with BSF_KEEP in md_apply_fix. */
2413 ppc_elf_adjust_symtab (void)
2418 symp
= symbol_find (".TOC.");
2421 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2422 if ((bsym
->flags
& BSF_KEEP
) == 0)
2423 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2427 #endif /* OBJ_ELF */
2432 * Summary of parse_toc_entry.
2434 * in: Input_line_pointer points to the '[' in one of:
2436 * [toc] [tocv] [toc32] [toc64]
2438 * Anything else is an error of one kind or another.
2441 * return value: success or failure
2442 * toc_kind: kind of toc reference
2443 * input_line_pointer:
2444 * success: first char after the ']'
2445 * failure: unchanged
2449 * [toc] - rv == success, toc_kind = default_toc
2450 * [tocv] - rv == success, toc_kind = data_in_toc
2451 * [toc32] - rv == success, toc_kind = must_be_32
2452 * [toc64] - rv == success, toc_kind = must_be_64
2456 enum toc_size_qualifier
2458 default_toc
, /* The toc cell constructed should be the system default size */
2459 data_in_toc
, /* This is a direct reference to a toc cell */
2460 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2461 must_be_64
/* The toc cell constructed must be 64 bits wide */
2465 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2470 enum toc_size_qualifier t
;
2472 /* Save the input_line_pointer. */
2473 start
= input_line_pointer
;
2475 /* Skip over the '[' , and whitespace. */
2476 ++input_line_pointer
;
2479 /* Find the spelling of the operand. */
2480 toc_spec
= input_line_pointer
;
2481 c
= get_symbol_end ();
2483 if (strcmp (toc_spec
, "toc") == 0)
2487 else if (strcmp (toc_spec
, "tocv") == 0)
2491 else if (strcmp (toc_spec
, "toc32") == 0)
2495 else if (strcmp (toc_spec
, "toc64") == 0)
2501 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2502 *input_line_pointer
= c
;
2503 input_line_pointer
= start
;
2507 /* Now find the ']'. */
2508 *input_line_pointer
= c
;
2510 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2511 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2515 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2516 input_line_pointer
= start
;
2525 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2526 /* See whether a symbol is in the TOC section. */
2529 ppc_is_toc_sym (symbolS
*sym
)
2532 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2533 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2536 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2538 return strcmp (sname
, ".toc") == 0;
2540 return strcmp (sname
, ".got") == 0;
2543 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2547 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2549 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2553 /* Check we don't already exist. */
2554 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2555 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2558 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2560 if (ppc_apuinfo_num_alloc
== 0)
2562 ppc_apuinfo_num_alloc
= 4;
2563 ppc_apuinfo_list
= (unsigned long *)
2564 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2568 ppc_apuinfo_num_alloc
+= 4;
2569 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2570 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2573 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2579 /* We need to keep a list of fixups. We can't simply generate them as
2580 we go, because that would require us to first create the frag, and
2581 that would screw up references to ``.''. */
2587 bfd_reloc_code_real_type reloc
;
2590 #define MAX_INSN_FIXUPS (5)
2593 #define E_OR2I_INSN 0x7000C000
2594 #define E_AND2I_DOT_INSN 0x7000C800
2595 #define E_OR2IS_INSN 0x7000D000
2596 #define E_LIS_INSN 0x7000E000
2597 #define E_AND2IS_DOT_INSN 0x7000E800
2600 #define E_ADD2I_DOT_INSN 0x70008800
2601 #define E_ADD2IS_INSN 0x70009000
2602 #define E_CMP16I_INSN 0x70009800
2603 #define E_MULL2I_INSN 0x7000A000
2604 #define E_CMPL16I_INSN 0x7000A800
2605 #define E_CMPH16I_INSN 0x7000B000
2606 #define E_CMPHL16I_INSN 0x7000B800
2608 /* This routine is called for each instruction to be assembled. */
2611 md_assemble (char *str
)
2614 const struct powerpc_opcode
*opcode
;
2616 const unsigned char *opindex_ptr
;
2620 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2625 unsigned int insn_length
;
2627 /* Get the opcode. */
2628 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2633 /* Look up the opcode in the hash table. */
2634 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2635 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2637 const struct powerpc_macro
*macro
;
2639 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2640 if (macro
== (const struct powerpc_macro
*) NULL
)
2641 as_bad (_("unrecognized opcode: `%s'"), str
);
2643 ppc_macro (s
, macro
);
2648 insn
= opcode
->opcode
;
2651 while (ISSPACE (*str
))
2654 /* PowerPC operands are just expressions. The only real issue is
2655 that a few operand types are optional. All cases which might use
2656 an optional operand separate the operands only with commas (in some
2657 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2658 have optional operands). Most instructions with optional operands
2659 have only one. Those that have more than one optional operand can
2660 take either all their operands or none. So, before we start seriously
2661 parsing the operands, we check to see if we have optional operands,
2662 and if we do, we count the number of commas to see which operands
2663 have been omitted. */
2665 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2667 const struct powerpc_operand
*operand
;
2669 operand
= &powerpc_operands
[*opindex_ptr
];
2670 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2672 unsigned int opcount
;
2673 unsigned int num_operands_expected
;
2675 /* There is an optional operand. Count the number of
2676 commas in the input line. */
2683 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2690 /* Compute the number of expected operands.
2691 Do not count fake operands. */
2692 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2693 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2694 ++ num_operands_expected
;
2696 /* If there are fewer operands in the line then are called
2697 for by the instruction, we want to skip the optional
2699 if (opcount
< num_operands_expected
)
2706 /* Gather the operands. */
2710 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2712 const struct powerpc_operand
*operand
;
2718 if (next_opindex
== 0)
2719 operand
= &powerpc_operands
[*opindex_ptr
];
2722 operand
= &powerpc_operands
[next_opindex
];
2727 /* If this is a fake operand, then we do not expect anything
2729 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2731 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2732 if (errmsg
!= (const char *) NULL
)
2733 as_bad ("%s", errmsg
);
2737 /* If this is an optional operand, and we are skipping it, just
2739 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2742 if (operand
->insert
)
2744 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2745 if (errmsg
!= (const char *) NULL
)
2746 as_bad ("%s", errmsg
);
2748 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2749 next_opindex
= *opindex_ptr
+ 1;
2753 /* Gather the operand. */
2754 hold
= input_line_pointer
;
2755 input_line_pointer
= str
;
2758 if (*input_line_pointer
== '[')
2760 /* We are expecting something like the second argument here:
2762 * lwz r4,[toc].GS.0.static_int(rtoc)
2763 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2764 * The argument following the `]' must be a symbol name, and the
2765 * register must be the toc register: 'rtoc' or '2'
2767 * The effect is to 0 as the displacement field
2768 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2769 * the appropriate variation) reloc against it based on the symbol.
2770 * The linker will build the toc, and insert the resolved toc offset.
2773 * o The size of the toc entry is currently assumed to be
2774 * 32 bits. This should not be assumed to be a hard coded
2776 * o In an effort to cope with a change from 32 to 64 bits,
2777 * there are also toc entries that are specified to be
2778 * either 32 or 64 bits:
2779 * lwz r4,[toc32].GS.0.static_int(rtoc)
2780 * lwz r4,[toc64].GS.0.static_int(rtoc)
2781 * These demand toc entries of the specified size, and the
2782 * instruction probably requires it.
2786 enum toc_size_qualifier toc_kind
;
2787 bfd_reloc_code_real_type toc_reloc
;
2789 /* Go parse off the [tocXX] part. */
2790 valid_toc
= parse_toc_entry (&toc_kind
);
2794 ignore_rest_of_line ();
2798 /* Now get the symbol following the ']'. */
2804 /* In this case, we may not have seen the symbol yet,
2805 since it is allowed to appear on a .extern or .globl
2806 or just be a label in the .data section. */
2807 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2810 /* 1. The symbol must be defined and either in the toc
2811 section, or a global.
2812 2. The reloc generated must have the TOCDEFN flag set
2813 in upper bit mess of the reloc type.
2814 FIXME: It's a little confusing what the tocv
2815 qualifier can be used for. At the very least, I've
2816 seen three uses, only one of which I'm sure I can
2818 if (ex
.X_op
== O_symbol
)
2820 gas_assert (ex
.X_add_symbol
!= NULL
);
2821 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2824 as_bad (_("[tocv] symbol is not a toc symbol"));
2828 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2831 /* FIXME: these next two specifically specify 32/64 bit
2832 toc entries. We don't support them today. Is this
2833 the right way to say that? */
2834 toc_reloc
= BFD_RELOC_NONE
;
2835 as_bad (_("unimplemented toc32 expression modifier"));
2838 /* FIXME: see above. */
2839 toc_reloc
= BFD_RELOC_NONE
;
2840 as_bad (_("unimplemented toc64 expression modifier"));
2844 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2850 /* We need to generate a fixup for this expression. */
2851 if (fc
>= MAX_INSN_FIXUPS
)
2852 as_fatal (_("too many fixups"));
2854 fixups
[fc
].reloc
= toc_reloc
;
2855 fixups
[fc
].exp
= ex
;
2856 fixups
[fc
].opindex
= *opindex_ptr
;
2859 /* Ok. We've set up the fixup for the instruction. Now make it
2860 look like the constant 0 was found here. */
2862 ex
.X_op
= O_constant
;
2863 ex
.X_add_number
= 0;
2864 ex
.X_add_symbol
= NULL
;
2865 ex
.X_op_symbol
= NULL
;
2872 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2873 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2874 || !register_name (&ex
))
2876 char save_lex
= lex_type
['%'];
2878 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2879 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2882 lex_type
['%'] |= LEX_BEGIN_NAME
;
2886 lex_type
['%'] = save_lex
;
2890 str
= input_line_pointer
;
2891 input_line_pointer
= hold
;
2893 if (ex
.X_op
== O_illegal
)
2894 as_bad (_("illegal operand"));
2895 else if (ex
.X_op
== O_absent
)
2896 as_bad (_("missing operand"));
2897 else if (ex
.X_op
== O_register
)
2899 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2900 ppc_cpu
, (char *) NULL
, 0);
2902 else if (ex
.X_op
== O_constant
)
2905 /* Allow @HA, @L, @H on constants. */
2906 bfd_reloc_code_real_type reloc
;
2907 char *orig_str
= str
;
2909 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
2916 case BFD_RELOC_LO16
:
2917 ex
.X_add_number
&= 0xffff;
2918 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2919 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2922 case BFD_RELOC_HI16
:
2923 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2925 /* PowerPC64 @h is tested for overflow. */
2926 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2927 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2929 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2931 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2937 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2938 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2939 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2940 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2943 case BFD_RELOC_HI16_S
:
2944 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2946 /* PowerPC64 @ha is tested for overflow. */
2948 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2949 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2951 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2953 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2959 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2960 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2961 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2962 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2965 case BFD_RELOC_PPC64_HIGHER
:
2966 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2967 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2968 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2971 case BFD_RELOC_PPC64_HIGHER_S
:
2972 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2973 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2974 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2977 case BFD_RELOC_PPC64_HIGHEST
:
2978 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2979 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2980 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2983 case BFD_RELOC_PPC64_HIGHEST_S
:
2984 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2985 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2986 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2989 #endif /* OBJ_ELF */
2990 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2991 ppc_cpu
, (char *) NULL
, 0);
2995 bfd_reloc_code_real_type reloc
= BFD_RELOC_NONE
;
2997 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2999 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
3000 if (sym_name
[0] == '.')
3003 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
3005 expressionS tls_exp
;
3007 hold
= input_line_pointer
;
3008 input_line_pointer
= str
+ 1;
3009 expression (&tls_exp
);
3010 if (tls_exp
.X_op
== O_symbol
)
3012 reloc
= BFD_RELOC_NONE
;
3013 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
3015 reloc
= BFD_RELOC_PPC_TLSGD
;
3016 input_line_pointer
+= 7;
3018 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
3020 reloc
= BFD_RELOC_PPC_TLSLD
;
3021 input_line_pointer
+= 7;
3023 if (reloc
!= BFD_RELOC_NONE
)
3026 str
= input_line_pointer
;
3028 if (fc
>= MAX_INSN_FIXUPS
)
3029 as_fatal (_("too many fixups"));
3030 fixups
[fc
].exp
= tls_exp
;
3031 fixups
[fc
].opindex
= *opindex_ptr
;
3032 fixups
[fc
].reloc
= reloc
;
3036 input_line_pointer
= hold
;
3040 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
3042 /* Some TLS tweaks. */
3048 case BFD_RELOC_PPC_TLS
:
3049 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
3050 as_bad (_("@tls may not be used with \"%s\" operands"),
3052 else if (operand
->shift
!= 11)
3053 as_bad (_("@tls may only be used in last operand"));
3055 insn
= ppc_insert_operand (insn
, operand
,
3057 ppc_cpu
, (char *) NULL
, 0);
3060 /* We'll only use the 32 (or 64) bit form of these relocations
3061 in constants. Instructions get the 16 bit form. */
3062 case BFD_RELOC_PPC_DTPREL
:
3063 reloc
= BFD_RELOC_PPC_DTPREL16
;
3065 case BFD_RELOC_PPC_TPREL
:
3066 reloc
= BFD_RELOC_PPC_TPREL16
;
3070 /* If VLE-mode convert LO/HI/HA relocations. */
3071 if (opcode
->flags
& PPC_OPCODE_VLE
)
3073 int tmp_insn
= insn
& opcode
->mask
;
3075 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3076 || tmp_insn
== E_AND2I_DOT_INSN
3077 || tmp_insn
== E_OR2IS_INSN
3078 || tmp_insn
== E_LIS_INSN
3079 || tmp_insn
== E_AND2IS_DOT_INSN
);
3082 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3083 || tmp_insn
== E_ADD2IS_INSN
3084 || tmp_insn
== E_CMP16I_INSN
3085 || tmp_insn
== E_MULL2I_INSN
3086 || tmp_insn
== E_CMPL16I_INSN
3087 || tmp_insn
== E_CMPH16I_INSN
3088 || tmp_insn
== E_CMPHL16I_INSN
);
3095 case BFD_RELOC_PPC_EMB_SDA21
:
3096 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3099 case BFD_RELOC_LO16
:
3101 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3102 else if (use_a_reloc
)
3103 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3106 case BFD_RELOC_HI16
:
3108 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3109 else if (use_a_reloc
)
3110 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3113 case BFD_RELOC_HI16_S
:
3115 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3116 else if (use_a_reloc
)
3117 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3120 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3122 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3125 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3127 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3130 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3132 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3137 #endif /* OBJ_ELF */
3139 if (reloc
!= BFD_RELOC_NONE
)
3141 /* Determine a BFD reloc value based on the operand information.
3142 We are only prepared to turn a few of the operands into
3144 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3145 | PPC_OPERAND_ABSOLUTE
)) != 0
3146 && operand
->bitm
== 0x3fffffc
3147 && operand
->shift
== 0)
3148 reloc
= BFD_RELOC_PPC_B26
;
3149 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3150 | PPC_OPERAND_ABSOLUTE
)) != 0
3151 && operand
->bitm
== 0xfffc
3152 && operand
->shift
== 0)
3153 reloc
= BFD_RELOC_PPC_B16
;
3154 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3155 && operand
->bitm
== 0x1fe
3156 && operand
->shift
== -1)
3157 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3158 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3159 && operand
->bitm
== 0xfffe
3160 && operand
->shift
== 0)
3161 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3162 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3163 && operand
->bitm
== 0x1fffffe
3164 && operand
->shift
== 0)
3165 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3166 else if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) == 0
3167 && (operand
->bitm
& 0xfff0) == 0xfff0
3168 && operand
->shift
== 0)
3170 reloc
= BFD_RELOC_16
;
3171 #if defined OBJ_XCOFF || defined OBJ_ELF
3172 /* Note: the symbol may be not yet defined. */
3173 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3174 && ppc_is_toc_sym (ex
.X_add_symbol
))
3176 reloc
= BFD_RELOC_PPC_TOC16
;
3178 as_warn (_("assuming %s on symbol"),
3179 ppc_obj64
? "@toc" : "@xgot");
3185 /* For the absolute forms of branches, convert the PC
3186 relative form back into the absolute. */
3187 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3191 case BFD_RELOC_PPC_B26
:
3192 reloc
= BFD_RELOC_PPC_BA26
;
3194 case BFD_RELOC_PPC_B16
:
3195 reloc
= BFD_RELOC_PPC_BA16
;
3198 case BFD_RELOC_PPC_B16_BRTAKEN
:
3199 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3201 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3202 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3213 case BFD_RELOC_PPC_TOC16
:
3214 toc_reloc_types
|= has_small_toc_reloc
;
3216 case BFD_RELOC_PPC64_TOC16_LO
:
3217 case BFD_RELOC_PPC64_TOC16_HI
:
3218 case BFD_RELOC_PPC64_TOC16_HA
:
3219 toc_reloc_types
|= has_large_toc_reloc
;
3226 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3231 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3233 case BFD_RELOC_LO16
:
3234 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3236 case BFD_RELOC_16_GOTOFF
:
3237 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3239 case BFD_RELOC_LO16_GOTOFF
:
3240 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3242 case BFD_RELOC_LO16_PLTOFF
:
3243 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3245 case BFD_RELOC_16_BASEREL
:
3246 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3248 case BFD_RELOC_LO16_BASEREL
:
3249 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3251 case BFD_RELOC_PPC_TOC16
:
3252 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3254 case BFD_RELOC_PPC64_TOC16_LO
:
3255 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3257 case BFD_RELOC_PPC64_PLTGOT16
:
3258 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3260 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3261 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3263 case BFD_RELOC_PPC_DTPREL16
:
3264 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3266 case BFD_RELOC_PPC_DTPREL16_LO
:
3267 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3269 case BFD_RELOC_PPC_TPREL16
:
3270 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3272 case BFD_RELOC_PPC_TPREL16_LO
:
3273 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3275 case BFD_RELOC_PPC_GOT_DTPREL16
:
3276 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3277 case BFD_RELOC_PPC_GOT_TPREL16
:
3278 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3281 as_bad (_("unsupported relocation for DS offset field"));
3287 /* We need to generate a fixup for this expression. */
3288 if (fc
>= MAX_INSN_FIXUPS
)
3289 as_fatal (_("too many fixups"));
3290 fixups
[fc
].exp
= ex
;
3291 fixups
[fc
].opindex
= *opindex_ptr
;
3292 fixups
[fc
].reloc
= reloc
;
3300 /* If expecting more operands, then we want to see "),". */
3301 if (*str
== endc
&& opindex_ptr
[1] != 0)
3305 while (ISSPACE (*str
));
3309 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3317 /* The call to expression should have advanced str past any
3320 && (endc
!= ',' || *str
!= '\0'))
3323 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3325 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3333 while (ISSPACE (*str
))
3337 as_bad (_("junk at end of line: `%s'"), str
);
3340 /* Do we need/want an APUinfo section? */
3341 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3344 /* These are all version "1". */
3345 if (opcode
->flags
& PPC_OPCODE_SPE
)
3346 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3347 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3348 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3349 if (opcode
->flags
& PPC_OPCODE_EFS
)
3350 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3351 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3352 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3353 if (opcode
->flags
& PPC_OPCODE_PMR
)
3354 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3355 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3356 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3357 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3358 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3359 if (opcode
->flags
& PPC_OPCODE_VLE
)
3360 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3364 /* Write out the instruction. */
3365 /* Differentiate between two and four byte insns. */
3366 if (ppc_mach () == bfd_mach_ppc_vle
)
3368 if (PPC_OP_SE_VLE (insn
))
3372 addr_mod
= frag_now_fix () & 1;
3377 addr_mod
= frag_now_fix () & 3;
3379 /* All instructions can start on a 2 byte boundary for VLE. */
3380 f
= frag_more (insn_length
);
3381 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3383 if (ppc_mach() == bfd_mach_ppc_vle
)
3384 as_bad (_("instruction address is not a multiple of 2"));
3386 as_bad (_("instruction address is not a multiple of 4"));
3388 frag_now
->insn_addr
= addr_mod
;
3389 frag_now
->has_code
= 1;
3390 md_number_to_chars (f
, insn
, insn_length
);
3393 last_subseg
= now_subseg
;
3396 dwarf2_emit_insn (insn_length
);
3399 /* Create any fixups. */
3400 for (i
= 0; i
< fc
; i
++)
3403 if (fixups
[i
].reloc
!= BFD_RELOC_NONE
)
3405 reloc_howto_type
*reloc_howto
;
3409 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3413 size
= bfd_get_reloc_size (reloc_howto
);
3414 offset
= target_big_endian
? (insn_length
- size
) : 0;
3416 if (size
< 1 || size
> 4)
3419 fixP
= fix_new_exp (frag_now
,
3420 f
- frag_now
->fr_literal
+ offset
,
3423 reloc_howto
->pc_relative
,
3428 const struct powerpc_operand
*operand
;
3430 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3431 fixP
= fix_new_exp (frag_now
,
3432 f
- frag_now
->fr_literal
,
3435 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3438 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3442 /* Handle a macro. Gather all the operands, transform them as
3443 described by the macro, and call md_assemble recursively. All the
3444 operands are separated by commas; we don't accept parentheses
3445 around operands here. */
3448 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3459 /* Gather the users operands into the operands array. */
3464 if (count
>= sizeof operands
/ sizeof operands
[0])
3466 operands
[count
++] = s
;
3467 s
= strchr (s
, ',');
3468 if (s
== (char *) NULL
)
3473 if (count
!= macro
->operands
)
3475 as_bad (_("wrong number of operands"));
3479 /* Work out how large the string must be (the size is unbounded
3480 because it includes user input). */
3482 format
= macro
->format
;
3483 while (*format
!= '\0')
3492 arg
= strtol (format
+ 1, &send
, 10);
3493 know (send
!= format
&& arg
< count
);
3494 len
+= strlen (operands
[arg
]);
3499 /* Put the string together. */
3500 complete
= s
= (char *) alloca (len
+ 1);
3501 format
= macro
->format
;
3502 while (*format
!= '\0')
3508 arg
= strtol (format
+ 1, &send
, 10);
3509 strcpy (s
, operands
[arg
]);
3516 /* Assemble the constructed instruction. */
3517 md_assemble (complete
);
3521 /* For ELF, add support for SHT_ORDERED. */
3524 ppc_section_type (char *str
, size_t len
)
3526 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3533 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3535 if (type
== SHT_ORDERED
)
3536 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3540 #endif /* OBJ_ELF */
3543 /* Pseudo-op handling. */
3545 /* The .byte pseudo-op. This is similar to the normal .byte
3546 pseudo-op, but it can also take a single ASCII string. */
3549 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3553 if (*input_line_pointer
!= '\"')
3559 /* Gather characters. A real double quote is doubled. Unusual
3560 characters are not permitted. */
3561 ++input_line_pointer
;
3566 c
= *input_line_pointer
++;
3570 if (*input_line_pointer
!= '\"')
3572 ++input_line_pointer
;
3575 FRAG_APPEND_1_CHAR (c
);
3579 if (warn_476
&& count
!= 0 && (now_seg
->flags
& SEC_CODE
) != 0)
3580 as_warn (_("data in executable section"));
3581 demand_empty_rest_of_line ();
3586 /* XCOFF specific pseudo-op handling. */
3588 /* This is set if we are creating a .stabx symbol, since we don't want
3589 to handle symbol suffixes for such symbols. */
3590 static bfd_boolean ppc_stab_symbol
;
3592 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3593 symbols in the .bss segment as though they were local common
3594 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3595 aligns .comm and .lcomm to 4 bytes. */
3598 ppc_comm (int lcomm
)
3600 asection
*current_seg
= now_seg
;
3601 subsegT current_subseg
= now_subseg
;
3607 symbolS
*lcomm_sym
= NULL
;
3611 name
= input_line_pointer
;
3612 endc
= get_symbol_end ();
3613 end_name
= input_line_pointer
;
3616 if (*input_line_pointer
!= ',')
3618 as_bad (_("missing size"));
3619 ignore_rest_of_line ();
3622 ++input_line_pointer
;
3624 size
= get_absolute_expression ();
3627 as_bad (_("negative size"));
3628 ignore_rest_of_line ();
3634 /* The third argument to .comm is the alignment. */
3635 if (*input_line_pointer
!= ',')
3639 ++input_line_pointer
;
3640 align
= get_absolute_expression ();
3643 as_warn (_("ignoring bad alignment"));
3653 /* The third argument to .lcomm appears to be the real local
3654 common symbol to create. References to the symbol named in
3655 the first argument are turned into references to the third
3657 if (*input_line_pointer
!= ',')
3659 as_bad (_("missing real symbol name"));
3660 ignore_rest_of_line ();
3663 ++input_line_pointer
;
3665 lcomm_name
= input_line_pointer
;
3666 lcomm_endc
= get_symbol_end ();
3668 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3670 *input_line_pointer
= lcomm_endc
;
3672 /* The fourth argument to .lcomm is the alignment. */
3673 if (*input_line_pointer
!= ',')
3682 ++input_line_pointer
;
3683 align
= get_absolute_expression ();
3686 as_warn (_("ignoring bad alignment"));
3693 sym
= symbol_find_or_make (name
);
3696 if (S_IS_DEFINED (sym
)
3697 || S_GET_VALUE (sym
) != 0)
3699 as_bad (_("attempt to redefine symbol"));
3700 ignore_rest_of_line ();
3704 record_alignment (bss_section
, align
);
3707 || ! S_IS_DEFINED (lcomm_sym
))
3716 S_SET_EXTERNAL (sym
);
3720 symbol_get_tc (lcomm_sym
)->output
= 1;
3721 def_sym
= lcomm_sym
;
3725 subseg_set (bss_section
, 1);
3726 frag_align (align
, 0, 0);
3728 symbol_set_frag (def_sym
, frag_now
);
3729 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3730 def_size
, (char *) NULL
);
3732 S_SET_SEGMENT (def_sym
, bss_section
);
3733 symbol_get_tc (def_sym
)->align
= align
;
3737 /* Align the size of lcomm_sym. */
3738 symbol_get_frag (lcomm_sym
)->fr_offset
=
3739 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3740 &~ ((1 << align
) - 1));
3741 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3742 symbol_get_tc (lcomm_sym
)->align
= align
;
3747 /* Make sym an offset from lcomm_sym. */
3748 S_SET_SEGMENT (sym
, bss_section
);
3749 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3750 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3751 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3754 subseg_set (current_seg
, current_subseg
);
3756 demand_empty_rest_of_line ();
3759 /* The .csect pseudo-op. This switches us into a different
3760 subsegment. The first argument is a symbol whose value is the
3761 start of the .csect. In COFF, csect symbols get special aux
3762 entries defined by the x_csect field of union internal_auxent. The
3763 optional second argument is the alignment (the default is 2). */
3766 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3773 name
= input_line_pointer
;
3774 endc
= get_symbol_end ();
3776 sym
= symbol_find_or_make (name
);
3778 *input_line_pointer
= endc
;
3780 if (S_GET_NAME (sym
)[0] == '\0')
3782 /* An unnamed csect is assumed to be [PR]. */
3783 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3787 if (*input_line_pointer
== ',')
3789 ++input_line_pointer
;
3790 align
= get_absolute_expression ();
3793 ppc_change_csect (sym
, align
);
3795 demand_empty_rest_of_line ();
3798 /* Change to a different csect. */
3801 ppc_change_csect (symbolS
*sym
, offsetT align
)
3803 if (S_IS_DEFINED (sym
))
3804 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3814 /* This is a new csect. We need to look at the symbol class to
3815 figure out whether it should go in the text section or the
3819 switch (symbol_get_tc (sym
)->symbol_class
)
3829 S_SET_SEGMENT (sym
, text_section
);
3830 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3831 ++ppc_text_subsegment
;
3832 list_ptr
= &ppc_text_csects
;
3842 if (ppc_toc_csect
!= NULL
3843 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3844 == ppc_data_subsegment
))
3846 S_SET_SEGMENT (sym
, data_section
);
3847 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3848 ++ppc_data_subsegment
;
3849 list_ptr
= &ppc_data_csects
;
3855 /* We set the obstack chunk size to a small value before
3856 changing subsegments, so that we don't use a lot of memory
3857 space for what may be a small section. */
3858 hold_chunksize
= chunksize
;
3861 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3862 symbol_get_tc (sym
)->subseg
);
3864 chunksize
= hold_chunksize
;
3867 ppc_after_toc_frag
= frag_now
;
3869 record_alignment (sec
, align
);
3871 frag_align_code (align
, 0);
3873 frag_align (align
, 0, 0);
3875 symbol_set_frag (sym
, frag_now
);
3876 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3878 symbol_get_tc (sym
)->align
= align
;
3879 symbol_get_tc (sym
)->output
= 1;
3880 symbol_get_tc (sym
)->within
= sym
;
3882 for (list
= *list_ptr
;
3883 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3884 list
= symbol_get_tc (list
)->next
)
3886 symbol_get_tc (list
)->next
= sym
;
3888 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3889 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3893 ppc_current_csect
= sym
;
3897 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3901 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3903 sec
= subseg_new (dw
->name
, subseg
);
3904 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3905 if (oldflags
== SEC_NO_FLAGS
)
3907 /* Just created section. */
3908 gas_assert (dw_sections
[idx
].sect
== NULL
);
3910 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3911 bfd_set_section_alignment (stdoutput
, sec
, 0);
3912 dw_sections
[idx
].sect
= sec
;
3915 /* Not anymore in a csect. */
3916 ppc_current_csect
= NULL
;
3919 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3920 .dwsect flag [, opt-label ]
3924 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3928 const struct xcoff_dwsect_name
*dw
;
3929 struct dw_subsection
*subseg
;
3930 struct dw_section
*dws
;
3934 flag
= get_absolute_expression ();
3936 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3937 if (xcoff_dwsect_names
[i
].flag
== flag
)
3939 dw
= &xcoff_dwsect_names
[i
];
3943 /* Parse opt-label. */
3944 if (*input_line_pointer
== ',')
3949 ++input_line_pointer
;
3951 label
= input_line_pointer
;
3952 c
= get_symbol_end ();
3953 opt_label
= symbol_find_or_make (label
);
3954 *input_line_pointer
= c
;
3959 demand_empty_rest_of_line ();
3961 /* Return now in case of unknown subsection. */
3964 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3969 /* Find the subsection. */
3970 dws
= &dw_sections
[i
];
3972 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3974 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3975 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3977 as_bad (_("label %s was not defined in this dwarf section"),
3978 S_GET_NAME (opt_label
));
3979 subseg
= dws
->anon_subseg
;
3983 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3988 /* Switch to the subsection. */
3989 ppc_change_debug_section (i
, subseg
->subseg
);
3993 /* Create a new dw subsection. */
3994 subseg
= (struct dw_subsection
*)
3995 xmalloc (sizeof (struct dw_subsection
));
3997 if (opt_label
== NULL
)
3999 /* The anonymous one. */
4001 subseg
->link
= NULL
;
4002 dws
->anon_subseg
= subseg
;
4007 if (dws
->list_subseg
!= NULL
)
4008 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
4012 subseg
->link
= dws
->list_subseg
;
4013 dws
->list_subseg
= subseg
;
4014 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
4017 ppc_change_debug_section (i
, subseg
->subseg
);
4021 /* Add the length field. */
4022 expressionS
*exp
= &subseg
->end_exp
;
4025 if (opt_label
!= NULL
)
4026 symbol_set_value_now (opt_label
);
4028 /* Add the length field. Note that according to the AIX assembler
4029 manual, the size of the length field is 4 for powerpc32 but
4030 12 for powerpc64. */
4033 /* Write the 64bit marker. */
4034 md_number_to_chars (frag_more (4), -1, 4);
4037 exp
->X_op
= O_subtract
;
4038 exp
->X_op_symbol
= symbol_temp_new_now ();
4039 exp
->X_add_symbol
= symbol_temp_make ();
4041 sz
= ppc_obj64
? 8 : 4;
4042 exp
->X_add_number
= -sz
;
4043 emit_expr (exp
, sz
);
4048 /* This function handles the .text and .data pseudo-ops. These
4049 pseudo-ops aren't really used by XCOFF; we implement them for the
4050 convenience of people who aren't used to XCOFF. */
4053 ppc_section (int type
)
4060 else if (type
== 'd')
4065 sym
= symbol_find_or_make (name
);
4067 ppc_change_csect (sym
, 2);
4069 demand_empty_rest_of_line ();
4072 /* This function handles the .section pseudo-op. This is mostly to
4073 give an error, since XCOFF only supports .text, .data and .bss, but
4074 we do permit the user to name the text or data section. */
4077 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4080 const char *real_name
;
4084 user_name
= input_line_pointer
;
4085 c
= get_symbol_end ();
4087 if (strcmp (user_name
, ".text") == 0)
4088 real_name
= ".text[PR]";
4089 else if (strcmp (user_name
, ".data") == 0)
4090 real_name
= ".data[RW]";
4093 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4094 *input_line_pointer
= c
;
4095 ignore_rest_of_line ();
4099 *input_line_pointer
= c
;
4101 sym
= symbol_find_or_make (real_name
);
4103 ppc_change_csect (sym
, 2);
4105 demand_empty_rest_of_line ();
4108 /* The .extern pseudo-op. We create an undefined symbol. */
4111 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4116 name
= input_line_pointer
;
4117 endc
= get_symbol_end ();
4119 (void) symbol_find_or_make (name
);
4121 *input_line_pointer
= endc
;
4123 demand_empty_rest_of_line ();
4126 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4129 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4135 name
= input_line_pointer
;
4136 endc
= get_symbol_end ();
4138 sym
= symbol_find_or_make (name
);
4140 *input_line_pointer
= endc
;
4142 symbol_get_tc (sym
)->output
= 1;
4144 demand_empty_rest_of_line ();
4147 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4148 relocations at the beginning of the current csect.
4150 (In principle, there's no reason why the relocations _have_ to be at
4151 the beginning. Anywhere in the csect would do. However, inserting
4152 at the beginning is what the native assmebler does, and it helps to
4153 deal with cases where the .ref statements follow the section contents.)
4155 ??? .refs don't work for empty .csects. However, the native assembler
4156 doesn't report an error in this case, and neither yet do we. */
4159 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4164 if (ppc_current_csect
== NULL
)
4166 as_bad (_(".ref outside .csect"));
4167 ignore_rest_of_line ();
4173 name
= input_line_pointer
;
4174 c
= get_symbol_end ();
4176 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4177 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4179 *input_line_pointer
= c
;
4181 c
= *input_line_pointer
;
4184 input_line_pointer
++;
4186 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4188 as_bad (_("missing symbol name"));
4189 ignore_rest_of_line ();
4196 demand_empty_rest_of_line ();
4199 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4200 although I don't know why it bothers. */
4203 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4210 name
= input_line_pointer
;
4211 endc
= get_symbol_end ();
4213 sym
= symbol_find_or_make (name
);
4215 *input_line_pointer
= endc
;
4217 if (*input_line_pointer
!= ',')
4219 as_bad (_("missing rename string"));
4220 ignore_rest_of_line ();
4223 ++input_line_pointer
;
4225 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4227 demand_empty_rest_of_line ();
4230 /* The .stabx pseudo-op. This is similar to a normal .stabs
4231 pseudo-op, but slightly different. A sample is
4232 .stabx "main:F-1",.main,142,0
4233 The first argument is the symbol name to create. The second is the
4234 value, and the third is the storage class. The fourth seems to be
4235 always zero, and I am assuming it is the type. */
4238 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4245 name
= demand_copy_C_string (&len
);
4247 if (*input_line_pointer
!= ',')
4249 as_bad (_("missing value"));
4252 ++input_line_pointer
;
4254 ppc_stab_symbol
= TRUE
;
4255 sym
= symbol_make (name
);
4256 ppc_stab_symbol
= FALSE
;
4258 symbol_get_tc (sym
)->real_name
= name
;
4260 (void) expression (&exp
);
4267 as_bad (_("illegal .stabx expression; zero assumed"));
4268 exp
.X_add_number
= 0;
4271 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4272 symbol_set_frag (sym
, &zero_address_frag
);
4276 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4277 symbol_set_value_expression (sym
, &exp
);
4281 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4282 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4287 /* The value is some complex expression. This will probably
4288 fail at some later point, but this is probably the right
4289 thing to do here. */
4290 symbol_set_value_expression (sym
, &exp
);
4294 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4295 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4297 if (*input_line_pointer
!= ',')
4299 as_bad (_("missing class"));
4302 ++input_line_pointer
;
4304 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4306 if (*input_line_pointer
!= ',')
4308 as_bad (_("missing type"));
4311 ++input_line_pointer
;
4313 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4315 symbol_get_tc (sym
)->output
= 1;
4317 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4322 .stabx "z",arrays_,133,0
4325 .comm arrays_,13768,3
4327 resolve_symbol_value will copy the exp's "within" into sym's when the
4328 offset is 0. Since this seems to be corner case problem,
4329 only do the correction for storage class C_STSYM. A better solution
4330 would be to have the tc field updated in ppc_symbol_new_hook. */
4332 if (exp
.X_op
== O_symbol
)
4334 if (ppc_current_block
== NULL
)
4335 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4337 symbol_get_tc (sym
)->within
= ppc_current_block
;
4338 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4342 if (exp
.X_op
!= O_symbol
4343 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4344 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4345 ppc_frob_label (sym
);
4348 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4349 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4350 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4351 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4354 demand_empty_rest_of_line ();
4357 /* The .function pseudo-op. This takes several arguments. The first
4358 argument seems to be the external name of the symbol. The second
4359 argument seems to be the label for the start of the function. gcc
4360 uses the same name for both. I have no idea what the third and
4361 fourth arguments are meant to be. The optional fifth argument is
4362 an expression for the size of the function. In COFF this symbol
4363 gets an aux entry like that used for a csect. */
4366 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4374 name
= input_line_pointer
;
4375 endc
= get_symbol_end ();
4377 /* Ignore any [PR] suffix. */
4378 name
= ppc_canonicalize_symbol_name (name
);
4379 s
= strchr (name
, '[');
4380 if (s
!= (char *) NULL
4381 && strcmp (s
+ 1, "PR]") == 0)
4384 ext_sym
= symbol_find_or_make (name
);
4386 *input_line_pointer
= endc
;
4388 if (*input_line_pointer
!= ',')
4390 as_bad (_("missing symbol name"));
4391 ignore_rest_of_line ();
4394 ++input_line_pointer
;
4396 name
= input_line_pointer
;
4397 endc
= get_symbol_end ();
4399 lab_sym
= symbol_find_or_make (name
);
4401 *input_line_pointer
= endc
;
4403 if (ext_sym
!= lab_sym
)
4407 exp
.X_op
= O_symbol
;
4408 exp
.X_add_symbol
= lab_sym
;
4409 exp
.X_op_symbol
= NULL
;
4410 exp
.X_add_number
= 0;
4412 symbol_set_value_expression (ext_sym
, &exp
);
4415 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4416 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4417 symbol_get_tc (ext_sym
)->output
= 1;
4419 if (*input_line_pointer
== ',')
4423 /* Ignore the third argument. */
4424 ++input_line_pointer
;
4426 if (*input_line_pointer
== ',')
4428 /* Ignore the fourth argument. */
4429 ++input_line_pointer
;
4431 if (*input_line_pointer
== ',')
4433 /* The fifth argument is the function size. */
4434 ++input_line_pointer
;
4435 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4436 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4437 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4442 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4443 SF_SET_FUNCTION (ext_sym
);
4444 SF_SET_PROCESS (ext_sym
);
4445 coff_add_linesym (ext_sym
);
4447 demand_empty_rest_of_line ();
4450 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4451 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4452 with the correct line number */
4454 static symbolS
*saved_bi_sym
= 0;
4457 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4461 sym
= symbol_make (".bf");
4462 S_SET_SEGMENT (sym
, text_section
);
4463 symbol_set_frag (sym
, frag_now
);
4464 S_SET_VALUE (sym
, frag_now_fix ());
4465 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4467 coff_line_base
= get_absolute_expression ();
4469 S_SET_NUMBER_AUXILIARY (sym
, 1);
4470 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4472 /* Line number for bi. */
4475 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4480 symbol_get_tc (sym
)->output
= 1;
4482 ppc_frob_label (sym
);
4484 demand_empty_rest_of_line ();
4487 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4488 ".ef", except that the line number is absolute, not relative to the
4489 most recent ".bf" symbol. */
4492 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4496 sym
= symbol_make (".ef");
4497 S_SET_SEGMENT (sym
, text_section
);
4498 symbol_set_frag (sym
, frag_now
);
4499 S_SET_VALUE (sym
, frag_now_fix ());
4500 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4501 S_SET_NUMBER_AUXILIARY (sym
, 1);
4502 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4503 symbol_get_tc (sym
)->output
= 1;
4505 ppc_frob_label (sym
);
4507 demand_empty_rest_of_line ();
4510 /* The .bi and .ei pseudo-ops. These take a string argument and
4511 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4512 the symbol list. The value of .bi will be know when the next .bf
4518 static symbolS
*last_biei
;
4525 name
= demand_copy_C_string (&len
);
4527 /* The value of these symbols is actually file offset. Here we set
4528 the value to the index into the line number entries. In
4529 ppc_frob_symbols we set the fix_line field, which will cause BFD
4530 to do the right thing. */
4532 sym
= symbol_make (name
);
4533 /* obj-coff.c currently only handles line numbers correctly in the
4535 S_SET_SEGMENT (sym
, text_section
);
4536 S_SET_VALUE (sym
, coff_n_line_nos
);
4537 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4539 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4540 symbol_get_tc (sym
)->output
= 1;
4548 for (look
= last_biei
? last_biei
: symbol_rootP
;
4549 (look
!= (symbolS
*) NULL
4550 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4551 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4552 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4553 look
= symbol_next (look
))
4555 if (look
!= (symbolS
*) NULL
)
4557 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4558 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4562 demand_empty_rest_of_line ();
4565 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4566 There is one argument, which is a csect symbol. The value of the
4567 .bs symbol is the index of this csect symbol. */
4570 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4577 if (ppc_current_block
!= NULL
)
4578 as_bad (_("nested .bs blocks"));
4580 name
= input_line_pointer
;
4581 endc
= get_symbol_end ();
4583 csect
= symbol_find_or_make (name
);
4585 *input_line_pointer
= endc
;
4587 sym
= symbol_make (".bs");
4588 S_SET_SEGMENT (sym
, now_seg
);
4589 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4590 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4591 symbol_get_tc (sym
)->output
= 1;
4593 symbol_get_tc (sym
)->within
= csect
;
4595 ppc_frob_label (sym
);
4597 ppc_current_block
= sym
;
4599 demand_empty_rest_of_line ();
4602 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4605 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4609 if (ppc_current_block
== NULL
)
4610 as_bad (_(".es without preceding .bs"));
4612 sym
= symbol_make (".es");
4613 S_SET_SEGMENT (sym
, now_seg
);
4614 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4615 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4616 symbol_get_tc (sym
)->output
= 1;
4618 ppc_frob_label (sym
);
4620 ppc_current_block
= NULL
;
4622 demand_empty_rest_of_line ();
4625 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4629 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4633 sym
= symbol_make (".bb");
4634 S_SET_SEGMENT (sym
, text_section
);
4635 symbol_set_frag (sym
, frag_now
);
4636 S_SET_VALUE (sym
, frag_now_fix ());
4637 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4639 S_SET_NUMBER_AUXILIARY (sym
, 1);
4640 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4642 symbol_get_tc (sym
)->output
= 1;
4644 SF_SET_PROCESS (sym
);
4646 ppc_frob_label (sym
);
4648 demand_empty_rest_of_line ();
4651 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4655 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4659 sym
= symbol_make (".eb");
4660 S_SET_SEGMENT (sym
, text_section
);
4661 symbol_set_frag (sym
, frag_now
);
4662 S_SET_VALUE (sym
, frag_now_fix ());
4663 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4664 S_SET_NUMBER_AUXILIARY (sym
, 1);
4665 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4666 symbol_get_tc (sym
)->output
= 1;
4668 SF_SET_PROCESS (sym
);
4670 ppc_frob_label (sym
);
4672 demand_empty_rest_of_line ();
4675 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4679 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4685 name
= demand_copy_C_string (&len
);
4686 sym
= symbol_make (name
);
4687 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4688 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4689 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4690 S_SET_VALUE (sym
, 0);
4691 symbol_get_tc (sym
)->output
= 1;
4693 ppc_frob_label (sym
);
4695 demand_empty_rest_of_line ();
4698 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4701 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4705 sym
= symbol_make (".ec");
4706 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4707 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4708 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4709 S_SET_VALUE (sym
, 0);
4710 symbol_get_tc (sym
)->output
= 1;
4712 ppc_frob_label (sym
);
4714 demand_empty_rest_of_line ();
4717 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4720 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4722 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4723 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4730 subseg
= ppc_data_subsegment
;
4731 ++ppc_data_subsegment
;
4733 subseg_new (segment_name (data_section
), subseg
);
4734 ppc_toc_frag
= frag_now
;
4736 sym
= symbol_find_or_make ("TOC[TC0]");
4737 symbol_set_frag (sym
, frag_now
);
4738 S_SET_SEGMENT (sym
, data_section
);
4739 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4740 symbol_get_tc (sym
)->subseg
= subseg
;
4741 symbol_get_tc (sym
)->output
= 1;
4742 symbol_get_tc (sym
)->within
= sym
;
4744 ppc_toc_csect
= sym
;
4746 for (list
= ppc_data_csects
;
4747 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4748 list
= symbol_get_tc (list
)->next
)
4750 symbol_get_tc (list
)->next
= sym
;
4752 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4753 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4757 ppc_current_csect
= ppc_toc_csect
;
4759 demand_empty_rest_of_line ();
4762 /* The AIX assembler automatically aligns the operands of a .long or
4763 .short pseudo-op, and we want to be compatible. */
4766 ppc_xcoff_cons (int log_size
)
4768 frag_align (log_size
, 0, 0);
4769 record_alignment (now_seg
, log_size
);
4770 cons (1 << log_size
);
4774 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4779 (void) expression (&exp
);
4781 if (exp
.X_op
!= O_constant
)
4783 as_bad (_("non-constant byte count"));
4787 byte_count
= exp
.X_add_number
;
4789 if (*input_line_pointer
!= ',')
4791 as_bad (_("missing value"));
4795 ++input_line_pointer
;
4800 ppc_xcoff_end (void)
4804 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4806 struct dw_section
*dws
= &dw_sections
[i
];
4807 struct dw_subsection
*dwss
;
4809 if (dws
->anon_subseg
)
4811 dwss
= dws
->anon_subseg
;
4812 dwss
->link
= dws
->list_subseg
;
4815 dwss
= dws
->list_subseg
;
4817 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4818 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4820 subseg_set (dws
->sect
, dwss
->subseg
);
4821 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4826 #endif /* OBJ_XCOFF */
4827 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4829 /* The .tc pseudo-op. This is used when generating either XCOFF or
4830 ELF. This takes two or more arguments.
4832 When generating XCOFF output, the first argument is the name to
4833 give to this location in the toc; this will be a symbol with class
4834 TC. The rest of the arguments are N-byte values to actually put at
4835 this location in the TOC; often there is just one more argument, a
4836 relocatable symbol reference. The size of the value to store
4837 depends on target word size. A 32-bit target uses 4-byte values, a
4838 64-bit target uses 8-byte values.
4840 When not generating XCOFF output, the arguments are the same, but
4841 the first argument is simply ignored. */
4844 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4848 /* Define the TOC symbol name. */
4854 if (ppc_toc_csect
== (symbolS
*) NULL
4855 || ppc_toc_csect
!= ppc_current_csect
)
4857 as_bad (_(".tc not in .toc section"));
4858 ignore_rest_of_line ();
4862 name
= input_line_pointer
;
4863 endc
= get_symbol_end ();
4865 sym
= symbol_find_or_make (name
);
4867 *input_line_pointer
= endc
;
4869 if (S_IS_DEFINED (sym
))
4873 label
= symbol_get_tc (ppc_current_csect
)->within
;
4874 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4876 as_bad (_(".tc with no label"));
4877 ignore_rest_of_line ();
4881 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4882 symbol_set_frag (label
, symbol_get_frag (sym
));
4883 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4885 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4886 ++input_line_pointer
;
4891 S_SET_SEGMENT (sym
, now_seg
);
4892 symbol_set_frag (sym
, frag_now
);
4893 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4894 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4895 symbol_get_tc (sym
)->output
= 1;
4897 ppc_frob_label (sym
);
4900 #endif /* OBJ_XCOFF */
4904 /* Skip the TOC symbol name. */
4905 while (is_part_of_name (*input_line_pointer
)
4906 || *input_line_pointer
== ' '
4907 || *input_line_pointer
== '['
4908 || *input_line_pointer
== ']'
4909 || *input_line_pointer
== '{'
4910 || *input_line_pointer
== '}')
4911 ++input_line_pointer
;
4913 /* Align to a four/eight byte boundary. */
4914 align
= ppc_obj64
? 3 : 2;
4915 frag_align (align
, 0, 0);
4916 record_alignment (now_seg
, align
);
4917 #endif /* OBJ_ELF */
4919 if (*input_line_pointer
!= ',')
4920 demand_empty_rest_of_line ();
4923 ++input_line_pointer
;
4924 cons (ppc_obj64
? 8 : 4);
4928 /* Pseudo-op .machine. */
4931 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4934 #define MAX_HISTORY 100
4935 static ppc_cpu_t
*cpu_history
;
4936 static int curr_hist
;
4940 if (*input_line_pointer
== '"')
4943 cpu_string
= demand_copy_C_string (&len
);
4948 cpu_string
= input_line_pointer
;
4949 c
= get_symbol_end ();
4950 cpu_string
= xstrdup (cpu_string
);
4951 *input_line_pointer
= c
;
4954 if (cpu_string
!= NULL
)
4956 ppc_cpu_t old_cpu
= ppc_cpu
;
4960 for (p
= cpu_string
; *p
!= 0; p
++)
4963 if (strcmp (cpu_string
, "push") == 0)
4965 if (cpu_history
== NULL
)
4966 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4968 if (curr_hist
>= MAX_HISTORY
)
4969 as_bad (_(".machine stack overflow"));
4971 cpu_history
[curr_hist
++] = ppc_cpu
;
4973 else if (strcmp (cpu_string
, "pop") == 0)
4976 as_bad (_(".machine stack underflow"));
4978 ppc_cpu
= cpu_history
[--curr_hist
];
4980 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4983 as_bad (_("invalid machine `%s'"), cpu_string
);
4985 if (ppc_cpu
!= old_cpu
)
4986 ppc_setup_opcodes ();
4989 demand_empty_rest_of_line ();
4991 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4995 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4997 /* Set the current section. */
4999 ppc_set_current_section (segT
new)
5001 ppc_previous_section
= ppc_current_section
;
5002 ppc_current_section
= new;
5005 /* pseudo-op: .previous
5006 behaviour: toggles the current section with the previous section.
5008 warnings: "No previous section" */
5011 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
5013 if (ppc_previous_section
== NULL
)
5015 as_warn (_("no previous section to return to, ignored."));
5019 subseg_set (ppc_previous_section
, 0);
5021 ppc_set_current_section (ppc_previous_section
);
5024 /* pseudo-op: .pdata
5025 behaviour: predefined read only data section
5029 initial: .section .pdata "adr3"
5030 a - don't know -- maybe a misprint
5031 d - initialized data
5033 3 - double word aligned (that would be 4 byte boundary)
5036 Tag index tables (also known as the function table) for exception
5037 handling, debugging, etc. */
5040 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
5042 if (pdata_section
== 0)
5044 pdata_section
= subseg_new (".pdata", 0);
5046 bfd_set_section_flags (stdoutput
, pdata_section
,
5047 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5048 | SEC_READONLY
| SEC_DATA
));
5050 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5054 pdata_section
= subseg_new (".pdata", 0);
5056 ppc_set_current_section (pdata_section
);
5059 /* pseudo-op: .ydata
5060 behaviour: predefined read only data section
5064 initial: .section .ydata "drw3"
5065 a - don't know -- maybe a misprint
5066 d - initialized data
5068 3 - double word aligned (that would be 4 byte boundary)
5070 Tag tables (also known as the scope table) for exception handling,
5074 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5076 if (ydata_section
== 0)
5078 ydata_section
= subseg_new (".ydata", 0);
5079 bfd_set_section_flags (stdoutput
, ydata_section
,
5080 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5081 | SEC_READONLY
| SEC_DATA
));
5083 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5087 ydata_section
= subseg_new (".ydata", 0);
5089 ppc_set_current_section (ydata_section
);
5092 /* pseudo-op: .reldata
5093 behaviour: predefined read write data section
5094 double word aligned (4-byte)
5095 FIXME: relocation is applied to it
5096 FIXME: what's the difference between this and .data?
5099 initial: .section .reldata "drw3"
5100 d - initialized data
5103 3 - double word aligned (that would be 8 byte boundary)
5106 Like .data, but intended to hold data subject to relocation, such as
5107 function descriptors, etc. */
5110 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5112 if (reldata_section
== 0)
5114 reldata_section
= subseg_new (".reldata", 0);
5116 bfd_set_section_flags (stdoutput
, reldata_section
,
5117 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5120 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5124 reldata_section
= subseg_new (".reldata", 0);
5126 ppc_set_current_section (reldata_section
);
5129 /* pseudo-op: .rdata
5130 behaviour: predefined read only data section
5134 initial: .section .rdata "dr3"
5135 d - initialized data
5137 3 - double word aligned (that would be 4 byte boundary) */
5140 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5142 if (rdata_section
== 0)
5144 rdata_section
= subseg_new (".rdata", 0);
5145 bfd_set_section_flags (stdoutput
, rdata_section
,
5146 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5147 | SEC_READONLY
| SEC_DATA
));
5149 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5153 rdata_section
= subseg_new (".rdata", 0);
5155 ppc_set_current_section (rdata_section
);
5158 /* pseudo-op: .ualong
5159 behaviour: much like .int, with the exception that no alignment is
5161 FIXME: test the alignment statement
5166 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5172 /* pseudo-op: .znop <symbol name>
5173 behaviour: Issue a nop instruction
5174 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5175 the supplied symbol name.
5177 warnings: Missing symbol name */
5180 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5183 const struct powerpc_opcode
*opcode
;
5190 /* Strip out the symbol name. */
5191 symbol_name
= input_line_pointer
;
5192 c
= get_symbol_end ();
5194 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5195 strcpy (name
, symbol_name
);
5197 sym
= symbol_find_or_make (name
);
5199 *input_line_pointer
= c
;
5203 /* Look up the opcode in the hash table. */
5204 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5206 /* Stick in the nop. */
5207 insn
= opcode
->opcode
;
5209 /* Write out the instruction. */
5211 md_number_to_chars (f
, insn
, 4);
5213 f
- frag_now
->fr_literal
,
5218 BFD_RELOC_16_GOT_PCREL
);
5228 ppc_pe_comm (int lcomm
)
5237 name
= input_line_pointer
;
5238 c
= get_symbol_end ();
5240 /* just after name is now '\0'. */
5241 p
= input_line_pointer
;
5244 if (*input_line_pointer
!= ',')
5246 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5247 ignore_rest_of_line ();
5251 input_line_pointer
++; /* skip ',' */
5252 if ((temp
= get_absolute_expression ()) < 0)
5254 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5255 ignore_rest_of_line ();
5261 /* The third argument to .comm is the alignment. */
5262 if (*input_line_pointer
!= ',')
5266 ++input_line_pointer
;
5267 align
= get_absolute_expression ();
5270 as_warn (_("ignoring bad alignment"));
5277 symbolP
= symbol_find_or_make (name
);
5280 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5282 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5283 S_GET_NAME (symbolP
));
5284 ignore_rest_of_line ();
5288 if (S_GET_VALUE (symbolP
))
5290 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5291 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5292 S_GET_NAME (symbolP
),
5293 (long) S_GET_VALUE (symbolP
),
5298 S_SET_VALUE (symbolP
, (valueT
) temp
);
5299 S_SET_EXTERNAL (symbolP
);
5300 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5303 demand_empty_rest_of_line ();
5307 * implement the .section pseudo op:
5308 * .section name {, "flags"}
5310 * | +--- optional flags: 'b' for bss
5312 * +-- section name 'l' for lib
5316 * 'd' (apparently m88k for data)
5318 * But if the argument is not a quoted string, treat it as a
5319 * subsegment number.
5321 * FIXME: this is a copy of the section processing from obj-coff.c, with
5322 * additions/changes for the moto-pas assembler support. There are three
5325 * FIXME: I just noticed this. This doesn't work at all really. It it
5326 * setting bits that bfd probably neither understands or uses. The
5327 * correct approach (?) will have to incorporate extra fields attached
5328 * to the section to hold the system specific stuff. (krk)
5331 * 'a' - unknown - referred to in documentation, but no definition supplied
5332 * 'c' - section has code
5333 * 'd' - section has initialized data
5334 * 'u' - section has uninitialized data
5335 * 'i' - section contains directives (info)
5336 * 'n' - section can be discarded
5337 * 'R' - remove section at link time
5339 * Section Protection:
5340 * 'r' - section is readable
5341 * 'w' - section is writeable
5342 * 'x' - section is executable
5343 * 's' - section is sharable
5345 * Section Alignment:
5346 * '0' - align to byte boundary
5347 * '1' - align to halfword undary
5348 * '2' - align to word boundary
5349 * '3' - align to doubleword boundary
5350 * '4' - align to quadword boundary
5351 * '5' - align to 32 byte boundary
5352 * '6' - align to 64 byte boundary
5357 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5359 /* Strip out the section name. */
5368 section_name
= input_line_pointer
;
5369 c
= get_symbol_end ();
5371 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5372 strcpy (name
, section_name
);
5374 *input_line_pointer
= c
;
5379 flags
= SEC_NO_FLAGS
;
5381 if (strcmp (name
, ".idata$2") == 0)
5385 else if (strcmp (name
, ".idata$3") == 0)
5389 else if (strcmp (name
, ".idata$4") == 0)
5393 else if (strcmp (name
, ".idata$5") == 0)
5397 else if (strcmp (name
, ".idata$6") == 0)
5402 /* Default alignment to 16 byte boundary. */
5405 if (*input_line_pointer
== ',')
5407 ++input_line_pointer
;
5409 if (*input_line_pointer
!= '"')
5410 exp
= get_absolute_expression ();
5413 ++input_line_pointer
;
5414 while (*input_line_pointer
!= '"'
5415 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5417 switch (*input_line_pointer
)
5419 /* Section Contents */
5420 case 'a': /* unknown */
5421 as_bad (_("unsupported section attribute -- 'a'"));
5423 case 'c': /* code section */
5426 case 'd': /* section has initialized data */
5429 case 'u': /* section has uninitialized data */
5430 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5434 case 'i': /* section contains directives (info) */
5435 /* FIXME: This is IMAGE_SCN_LNK_INFO
5437 flags
|= SEC_HAS_CONTENTS
;
5439 case 'n': /* section can be discarded */
5442 case 'R': /* Remove section at link time */
5443 flags
|= SEC_NEVER_LOAD
;
5445 #if IFLICT_BRAIN_DAMAGE
5446 /* Section Protection */
5447 case 'r': /* section is readable */
5448 flags
|= IMAGE_SCN_MEM_READ
;
5450 case 'w': /* section is writeable */
5451 flags
|= IMAGE_SCN_MEM_WRITE
;
5453 case 'x': /* section is executable */
5454 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5456 case 's': /* section is sharable */
5457 flags
|= IMAGE_SCN_MEM_SHARED
;
5460 /* Section Alignment */
5461 case '0': /* align to byte boundary */
5462 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5465 case '1': /* align to halfword boundary */
5466 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5469 case '2': /* align to word boundary */
5470 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5473 case '3': /* align to doubleword boundary */
5474 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5477 case '4': /* align to quadword boundary */
5478 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5481 case '5': /* align to 32 byte boundary */
5482 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5485 case '6': /* align to 64 byte boundary */
5486 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5491 as_bad (_("unknown section attribute '%c'"),
5492 *input_line_pointer
);
5495 ++input_line_pointer
;
5497 if (*input_line_pointer
== '"')
5498 ++input_line_pointer
;
5502 sec
= subseg_new (name
, (subsegT
) exp
);
5504 ppc_set_current_section (sec
);
5506 if (flags
!= SEC_NO_FLAGS
)
5508 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5509 as_bad (_("error setting flags for \"%s\": %s"),
5510 bfd_section_name (stdoutput
, sec
),
5511 bfd_errmsg (bfd_get_error ()));
5514 bfd_set_section_alignment (stdoutput
, sec
, align
);
5518 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5524 name
= input_line_pointer
;
5525 endc
= get_symbol_end ();
5527 ext_sym
= symbol_find_or_make (name
);
5529 *input_line_pointer
= endc
;
5531 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5532 SF_SET_FUNCTION (ext_sym
);
5533 SF_SET_PROCESS (ext_sym
);
5534 coff_add_linesym (ext_sym
);
5536 demand_empty_rest_of_line ();
5540 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5542 if (tocdata_section
== 0)
5544 tocdata_section
= subseg_new (".tocd", 0);
5545 /* FIXME: section flags won't work. */
5546 bfd_set_section_flags (stdoutput
, tocdata_section
,
5547 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5548 | SEC_READONLY
| SEC_DATA
));
5550 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5554 rdata_section
= subseg_new (".tocd", 0);
5557 ppc_set_current_section (tocdata_section
);
5559 demand_empty_rest_of_line ();
5562 /* Don't adjust TOC relocs to use the section symbol. */
5565 ppc_pe_fix_adjustable (fixS
*fix
)
5567 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5574 /* XCOFF specific symbol and file handling. */
5576 /* Canonicalize the symbol name. We use the to force the suffix, if
5577 any, to use square brackets, and to be in upper case. */
5580 ppc_canonicalize_symbol_name (char *name
)
5584 if (ppc_stab_symbol
)
5587 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5601 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5604 if (*s
== '\0' || s
[1] != '\0')
5605 as_bad (_("bad symbol suffix"));
5613 /* Set the class of a symbol based on the suffix, if any. This is
5614 called whenever a new symbol is created. */
5617 ppc_symbol_new_hook (symbolS
*sym
)
5619 struct ppc_tc_sy
*tc
;
5622 tc
= symbol_get_tc (sym
);
5625 tc
->symbol_class
= -1;
5626 tc
->real_name
= NULL
;
5633 if (ppc_stab_symbol
)
5636 s
= strchr (S_GET_NAME (sym
), '[');
5637 if (s
== (const char *) NULL
)
5639 /* There is no suffix. */
5648 if (strcmp (s
, "BS]") == 0)
5649 tc
->symbol_class
= XMC_BS
;
5652 if (strcmp (s
, "DB]") == 0)
5653 tc
->symbol_class
= XMC_DB
;
5654 else if (strcmp (s
, "DS]") == 0)
5655 tc
->symbol_class
= XMC_DS
;
5658 if (strcmp (s
, "GL]") == 0)
5659 tc
->symbol_class
= XMC_GL
;
5662 if (strcmp (s
, "PR]") == 0)
5663 tc
->symbol_class
= XMC_PR
;
5666 if (strcmp (s
, "RO]") == 0)
5667 tc
->symbol_class
= XMC_RO
;
5668 else if (strcmp (s
, "RW]") == 0)
5669 tc
->symbol_class
= XMC_RW
;
5672 if (strcmp (s
, "SV]") == 0)
5673 tc
->symbol_class
= XMC_SV
;
5676 if (strcmp (s
, "TC]") == 0)
5677 tc
->symbol_class
= XMC_TC
;
5678 else if (strcmp (s
, "TI]") == 0)
5679 tc
->symbol_class
= XMC_TI
;
5680 else if (strcmp (s
, "TB]") == 0)
5681 tc
->symbol_class
= XMC_TB
;
5682 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5683 tc
->symbol_class
= XMC_TC0
;
5686 if (strcmp (s
, "UA]") == 0)
5687 tc
->symbol_class
= XMC_UA
;
5688 else if (strcmp (s
, "UC]") == 0)
5689 tc
->symbol_class
= XMC_UC
;
5692 if (strcmp (s
, "XO]") == 0)
5693 tc
->symbol_class
= XMC_XO
;
5697 if (tc
->symbol_class
== -1)
5698 as_bad (_("unrecognized symbol suffix"));
5701 /* Set the class of a label based on where it is defined. This
5702 handles symbols without suffixes. Also, move the symbol so that it
5703 follows the csect symbol. */
5706 ppc_frob_label (symbolS
*sym
)
5708 if (ppc_current_csect
!= (symbolS
*) NULL
)
5710 if (symbol_get_tc (sym
)->symbol_class
== -1)
5711 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5713 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5714 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5715 &symbol_rootP
, &symbol_lastP
);
5716 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5717 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5721 dwarf2_emit_label (sym
);
5725 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5726 seen. It tells ppc_adjust_symtab whether it needs to look through
5729 static bfd_boolean ppc_saw_abs
;
5731 /* Change the name of a symbol just before writing it out. Set the
5732 real name if the .rename pseudo-op was used. Otherwise, remove any
5733 class suffix. Return 1 if the symbol should not be included in the
5737 ppc_frob_symbol (symbolS
*sym
)
5739 static symbolS
*ppc_last_function
;
5740 static symbolS
*set_end
;
5742 /* Discard symbols that should not be included in the output symbol
5744 if (! symbol_used_in_reloc_p (sym
)
5745 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5746 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5747 && ! symbol_get_tc (sym
)->output
5748 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5751 /* This one will disappear anyway. Don't make a csect sym for it. */
5752 if (sym
== abs_section_sym
)
5755 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5756 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5762 name
= S_GET_NAME (sym
);
5763 s
= strchr (name
, '[');
5764 if (s
!= (char *) NULL
)
5770 snew
= xmalloc (len
+ 1);
5771 memcpy (snew
, name
, len
);
5774 S_SET_NAME (sym
, snew
);
5778 if (set_end
!= (symbolS
*) NULL
)
5780 SA_SET_SYM_ENDNDX (set_end
, sym
);
5784 if (SF_GET_FUNCTION (sym
))
5786 if (ppc_last_function
!= (symbolS
*) NULL
)
5787 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5788 ppc_last_function
= sym
;
5789 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5791 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5792 SA_SET_SYM_FSIZE (sym
,
5793 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5796 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5797 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5799 if (ppc_last_function
== (symbolS
*) NULL
)
5800 as_bad (_(".ef with no preceding .function"));
5803 set_end
= ppc_last_function
;
5804 ppc_last_function
= NULL
;
5806 /* We don't have a C_EFCN symbol, but we need to force the
5807 COFF backend to believe that it has seen one. */
5808 coff_last_function
= NULL
;
5812 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5813 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5814 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5815 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5816 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5817 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5818 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5819 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5820 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5821 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5822 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5824 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5825 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5826 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5829 union internal_auxent
*a
;
5831 /* Create a csect aux. */
5832 i
= S_GET_NUMBER_AUXILIARY (sym
);
5833 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5834 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5835 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5837 /* This is the TOC table. */
5838 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5839 a
->x_csect
.x_scnlen
.l
= 0;
5840 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5842 else if (symbol_get_tc (sym
)->subseg
!= 0)
5844 /* This is a csect symbol. x_scnlen is the size of the
5846 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5847 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5848 S_GET_SEGMENT (sym
))
5849 - S_GET_VALUE (sym
));
5852 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5853 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5854 - S_GET_VALUE (sym
));
5856 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5858 else if (S_GET_SEGMENT (sym
) == bss_section
)
5860 /* This is a common symbol. */
5861 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5862 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5863 if (S_IS_EXTERNAL (sym
))
5864 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5866 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5868 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5870 /* This is an absolute symbol. The csect will be created by
5871 ppc_adjust_symtab. */
5873 a
->x_csect
.x_smtyp
= XTY_LD
;
5874 if (symbol_get_tc (sym
)->symbol_class
== -1)
5875 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5877 else if (! S_IS_DEFINED (sym
))
5879 /* This is an external symbol. */
5880 a
->x_csect
.x_scnlen
.l
= 0;
5881 a
->x_csect
.x_smtyp
= XTY_ER
;
5883 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5887 /* This is a TOC definition. x_scnlen is the size of the
5889 next
= symbol_next (sym
);
5890 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5891 next
= symbol_next (next
);
5892 if (next
== (symbolS
*) NULL
5893 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5895 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5896 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5898 - S_GET_VALUE (sym
));
5900 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5901 - S_GET_VALUE (sym
));
5905 resolve_symbol_value (next
);
5906 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5907 - S_GET_VALUE (sym
));
5909 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5915 /* This is a normal symbol definition. x_scnlen is the
5916 symbol index of the containing csect. */
5917 if (S_GET_SEGMENT (sym
) == text_section
)
5918 csect
= ppc_text_csects
;
5919 else if (S_GET_SEGMENT (sym
) == data_section
)
5920 csect
= ppc_data_csects
;
5924 /* Skip the initial dummy symbol. */
5925 csect
= symbol_get_tc (csect
)->next
;
5927 if (csect
== (symbolS
*) NULL
)
5929 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5930 a
->x_csect
.x_scnlen
.l
= 0;
5934 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5936 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5937 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5938 > S_GET_VALUE (sym
))
5940 csect
= symbol_get_tc (csect
)->next
;
5943 a
->x_csect
.x_scnlen
.p
=
5944 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5945 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5948 a
->x_csect
.x_smtyp
= XTY_LD
;
5951 a
->x_csect
.x_parmhash
= 0;
5952 a
->x_csect
.x_snhash
= 0;
5953 if (symbol_get_tc (sym
)->symbol_class
== -1)
5954 a
->x_csect
.x_smclas
= XMC_PR
;
5956 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5957 a
->x_csect
.x_stab
= 0;
5958 a
->x_csect
.x_snstab
= 0;
5960 /* Don't let the COFF backend resort these symbols. */
5961 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5963 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5965 /* We want the value to be the symbol index of the referenced
5966 csect symbol. BFD will do that for us if we set the right
5968 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5969 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5971 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5972 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5974 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5979 block
= symbol_get_tc (sym
)->within
;
5982 /* The value is the offset from the enclosing csect. */
5985 csect
= symbol_get_tc (block
)->within
;
5986 resolve_symbol_value (csect
);
5987 base
= S_GET_VALUE (csect
);
5992 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5994 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5995 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5997 /* We want the value to be a file offset into the line numbers.
5998 BFD will do that for us if we set the right flags. We have
5999 already set the value correctly. */
6000 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
6006 /* Adjust the symbol table. This creates csect symbols for all
6007 absolute symbols. */
6010 ppc_adjust_symtab (void)
6017 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
6021 union internal_auxent
*a
;
6023 if (S_GET_SEGMENT (sym
) != absolute_section
)
6026 csect
= symbol_create (".abs[XO]", absolute_section
,
6027 S_GET_VALUE (sym
), &zero_address_frag
);
6028 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
6029 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
6030 i
= S_GET_NUMBER_AUXILIARY (csect
);
6031 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
6032 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
6033 a
->x_csect
.x_scnlen
.l
= 0;
6034 a
->x_csect
.x_smtyp
= XTY_SD
;
6035 a
->x_csect
.x_parmhash
= 0;
6036 a
->x_csect
.x_snhash
= 0;
6037 a
->x_csect
.x_smclas
= XMC_XO
;
6038 a
->x_csect
.x_stab
= 0;
6039 a
->x_csect
.x_snstab
= 0;
6041 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
6043 i
= S_GET_NUMBER_AUXILIARY (sym
);
6044 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
6045 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
6046 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
6049 ppc_saw_abs
= FALSE
;
6052 /* Set the VMA for a section. This is called on all the sections in
6056 ppc_frob_section (asection
*sec
)
6058 static bfd_vma vma
= 0;
6060 /* Dwarf sections start at 0. */
6061 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6064 vma
= md_section_align (sec
, vma
);
6065 bfd_set_section_vma (stdoutput
, sec
, vma
);
6066 vma
+= bfd_section_size (stdoutput
, sec
);
6069 #endif /* OBJ_XCOFF */
6072 md_atof (int type
, char *litp
, int *sizep
)
6074 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6077 /* Write a value out to the object file, using the appropriate
6081 md_number_to_chars (char *buf
, valueT val
, int n
)
6083 if (target_big_endian
)
6084 number_to_chars_bigendian (buf
, val
, n
);
6086 number_to_chars_littleendian (buf
, val
, n
);
6089 /* Align a section (I don't know why this is machine dependent). */
6092 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6097 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6099 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
6103 /* We don't have any form of relaxing. */
6106 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6107 asection
*seg ATTRIBUTE_UNUSED
)
6113 /* Convert a machine dependent frag. We never generate these. */
6116 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6117 asection
*sec ATTRIBUTE_UNUSED
,
6118 fragS
*fragp ATTRIBUTE_UNUSED
)
6123 /* We have no need to default values of symbols. */
6126 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6131 /* Functions concerning relocs. */
6133 /* The location from which a PC relative jump should be calculated,
6134 given a PC relative reloc. */
6137 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6139 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6144 /* This is called to see whether a fixup should be adjusted to use a
6145 section symbol. We take the opportunity to change a fixup against
6146 a symbol in the TOC subsegment into a reloc against the
6147 corresponding .tc symbol. */
6150 ppc_fix_adjustable (fixS
*fix
)
6152 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6153 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6154 TC_SYMFIELD_TYPE
*tc
;
6156 if (symseg
== absolute_section
)
6159 /* Always adjust symbols in debugging sections. */
6160 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6163 if (ppc_toc_csect
!= (symbolS
*) NULL
6164 && fix
->fx_addsy
!= ppc_toc_csect
6165 && symseg
== data_section
6166 && val
>= ppc_toc_frag
->fr_address
6167 && (ppc_after_toc_frag
== (fragS
*) NULL
6168 || val
< ppc_after_toc_frag
->fr_address
))
6172 for (sy
= symbol_next (ppc_toc_csect
);
6173 sy
!= (symbolS
*) NULL
;
6174 sy
= symbol_next (sy
))
6176 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6178 if (sy_tc
->symbol_class
== XMC_TC0
)
6180 if (sy_tc
->symbol_class
!= XMC_TC
)
6182 if (val
== resolve_symbol_value (sy
))
6185 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6190 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6191 _("symbol in .toc does not match any .tc"));
6194 /* Possibly adjust the reloc to be against the csect. */
6195 tc
= symbol_get_tc (fix
->fx_addsy
);
6197 && tc
->symbol_class
!= XMC_TC0
6198 && tc
->symbol_class
!= XMC_TC
6199 && symseg
!= bss_section
6200 /* Don't adjust if this is a reloc in the toc section. */
6201 && (symseg
!= data_section
6202 || ppc_toc_csect
== NULL
6203 || val
< ppc_toc_frag
->fr_address
6204 || (ppc_after_toc_frag
!= NULL
6205 && val
>= ppc_after_toc_frag
->fr_address
)))
6207 symbolS
*csect
= tc
->within
;
6209 /* If the symbol was not declared by a label (eg: a section symbol),
6210 use the section instead of the csect. This doesn't happen in
6211 normal AIX assembly code. */
6213 csect
= seg_info (symseg
)->sym
;
6215 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6216 fix
->fx_addsy
= csect
;
6221 /* Adjust a reloc against a .lcomm symbol to be against the base
6223 if (symseg
== bss_section
6224 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6226 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6228 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6235 /* A reloc from one csect to another must be kept. The assembler
6236 will, of course, keep relocs between sections, and it will keep
6237 absolute relocs, but we need to force it to keep PC relative relocs
6238 between two csects in the same section. */
6241 ppc_force_relocation (fixS
*fix
)
6243 /* At this point fix->fx_addsy should already have been converted to
6244 a csect symbol. If the csect does not include the fragment, then
6245 we need to force the relocation. */
6247 && fix
->fx_addsy
!= NULL
6248 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6249 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6250 > fix
->fx_frag
->fr_address
)
6251 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6252 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6253 <= fix
->fx_frag
->fr_address
))))
6256 return generic_force_reloc (fix
);
6260 ppc_new_dot_label (symbolS
*sym
)
6262 /* Anchor this label to the current csect for relocations. */
6263 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6266 #endif /* OBJ_XCOFF */
6269 /* If this function returns non-zero, it guarantees that a relocation
6270 will be emitted for a fixup. */
6273 ppc_force_relocation (fixS
*fix
)
6275 /* Branch prediction relocations must force a relocation, as must
6276 the vtable description relocs. */
6277 switch (fix
->fx_r_type
)
6279 case BFD_RELOC_PPC_B16_BRTAKEN
:
6280 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6281 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6282 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6283 case BFD_RELOC_24_PLT_PCREL
:
6284 case BFD_RELOC_PPC64_TOC
:
6286 case BFD_RELOC_PPC_B26
:
6287 case BFD_RELOC_PPC_BA26
:
6288 case BFD_RELOC_PPC_B16
:
6289 case BFD_RELOC_PPC_BA16
:
6290 /* All branch fixups targeting a localentry symbol must
6291 force a relocation. */
6294 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6295 elf_symbol_type
*elfsym
6296 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6297 gas_assert (elfsym
);
6298 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6306 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6307 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6310 return generic_force_reloc (fix
);
6314 ppc_fix_adjustable (fixS
*fix
)
6316 switch (fix
->fx_r_type
)
6318 /* All branch fixups targeting a localentry symbol must
6319 continue using the symbol. */
6320 case BFD_RELOC_PPC_B26
:
6321 case BFD_RELOC_PPC_BA26
:
6322 case BFD_RELOC_PPC_B16
:
6323 case BFD_RELOC_PPC_BA16
:
6324 case BFD_RELOC_PPC_B16_BRTAKEN
:
6325 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6326 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6327 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6330 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6331 elf_symbol_type
*elfsym
6332 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6333 gas_assert (elfsym
);
6334 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6342 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6343 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6344 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6345 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6346 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6347 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6348 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6349 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6350 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6351 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6352 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6357 ppc_frag_check (struct frag
*fragP
)
6359 if (!fragP
->has_code
)
6362 if (ppc_mach() == bfd_mach_ppc_vle
)
6364 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6365 as_bad (_("instruction address is not a multiple of 2"));
6369 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6370 as_bad (_("instruction address is not a multiple of 4"));
6374 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6375 rs_align_code frag. */
6378 ppc_handle_align (struct frag
*fragP
)
6380 valueT count
= (fragP
->fr_next
->fr_address
6381 - (fragP
->fr_address
+ fragP
->fr_fix
));
6383 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6385 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6388 md_number_to_chars (dest
, 0x4400, 2);
6390 else if (count
!= 0 && (count
& 3) == 0)
6392 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6396 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6400 /* Make a branch, then follow with nops. Insert another
6401 frag to handle the nops. */
6402 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6407 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6408 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6409 fragP
->fr_next
= rest
;
6411 rest
->fr_address
+= rest
->fr_fix
+ 4;
6413 /* If we leave the next frag as rs_align_code we'll come here
6414 again, resulting in a bunch of branches rather than a
6415 branch followed by nops. */
6416 rest
->fr_type
= rs_align
;
6417 dest
= rest
->fr_literal
;
6420 md_number_to_chars (dest
, 0x60000000, 4);
6422 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6423 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6424 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6426 /* For power6, power7 and power8, we want the last nop to be a group
6427 terminating one. Do this by inserting an rs_fill frag immediately
6428 after this one, with its address set to the last nop location.
6429 This will automatically reduce the number of nops in the current
6433 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6435 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6436 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6437 group_nop
->fr_fix
= 0;
6438 group_nop
->fr_offset
= 1;
6439 group_nop
->fr_type
= rs_fill
;
6440 fragP
->fr_next
= group_nop
;
6441 dest
= group_nop
->fr_literal
;
6444 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6445 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6447 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6448 /* e500mc group terminating nop: "ori 0,0,0". */
6449 md_number_to_chars (dest
, 0x60000000, 4);
6451 /* power7/power8 group terminating nop: "ori 2,2,0". */
6452 md_number_to_chars (dest
, 0x60420000, 4);
6455 /* power6 group terminating nop: "ori 1,1,0". */
6456 md_number_to_chars (dest
, 0x60210000, 4);
6461 /* Apply a fixup to the object code. This is called for all the
6462 fixups we generated by the calls to fix_new_exp, above. */
6465 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg
)
6467 valueT value
= * valP
;
6469 const struct powerpc_operand
*operand
;
6472 if (fixP
->fx_addsy
!= NULL
)
6474 /* Hack around bfd_install_relocation brain damage. */
6476 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6481 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6482 the symbol values. If we are doing this relocation the code in
6483 write.c is going to call bfd_install_relocation, which is also
6484 going to use the symbol value. That means that if the reloc is
6485 fully resolved we want to use *valP since bfd_install_relocation is
6487 However, if the reloc is not fully resolved we do not want to
6488 use *valP, and must use fx_offset instead. If the relocation
6489 is PC-relative, we then need to re-apply md_pcrel_from_section
6490 to this new relocation value. */
6491 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6496 value
= fixP
->fx_offset
;
6498 value
-= md_pcrel_from_section (fixP
, seg
);
6502 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6504 /* We can't actually support subtracting a symbol. */
6505 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6509 if (fixP
->fx_pcrel_adjust
!= 0)
6511 /* This is a fixup on an instruction. */
6512 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6514 operand
= &powerpc_operands
[opindex
];
6516 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6517 does not generate a reloc. It uses the offset of `sym' within its
6518 csect. Other usages, such as `.long sym', generate relocs. This
6519 is the documented behaviour of non-TOC symbols. */
6520 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6521 && (operand
->bitm
& 0xfff0) == 0xfff0
6522 && operand
->shift
== 0
6523 && (operand
->insert
== NULL
|| ppc_obj64
)
6524 && fixP
->fx_addsy
!= NULL
6525 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6526 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6527 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6528 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6530 value
= fixP
->fx_offset
;
6534 /* During parsing of instructions, a TOC16 reloc is generated for
6535 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6536 in the toc. But at parse time, SYM may be not yet defined, so
6537 check again here. */
6538 if (fixP
->fx_r_type
== BFD_RELOC_16
6539 && fixP
->fx_addsy
!= NULL
6540 && ppc_is_toc_sym (fixP
->fx_addsy
))
6541 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6545 /* Calculate value to be stored in field. */
6547 switch (fixP
->fx_r_type
)
6550 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6551 case BFD_RELOC_PPC_VLE_LO16A
:
6552 case BFD_RELOC_PPC_VLE_LO16D
:
6554 case BFD_RELOC_LO16
:
6555 case BFD_RELOC_LO16_PCREL
:
6556 fieldval
= value
& 0xffff;
6558 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6559 fieldval
= SEX16 (fieldval
);
6560 fixP
->fx_no_overflow
= 1;
6563 case BFD_RELOC_HI16
:
6564 case BFD_RELOC_HI16_PCREL
:
6566 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6568 fieldval
= value
>> 16;
6569 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6571 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6572 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6578 case BFD_RELOC_PPC_VLE_HI16A
:
6579 case BFD_RELOC_PPC_VLE_HI16D
:
6580 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6582 fieldval
= PPC_HI (value
);
6583 goto sign_extend_16
;
6585 case BFD_RELOC_HI16_S
:
6586 case BFD_RELOC_HI16_S_PCREL
:
6588 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6590 fieldval
= (value
+ 0x8000) >> 16;
6591 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6593 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6594 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6600 case BFD_RELOC_PPC_VLE_HA16A
:
6601 case BFD_RELOC_PPC_VLE_HA16D
:
6602 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6604 fieldval
= PPC_HA (value
);
6605 goto sign_extend_16
;
6608 case BFD_RELOC_PPC64_HIGHER
:
6609 fieldval
= PPC_HIGHER (value
);
6610 goto sign_extend_16
;
6612 case BFD_RELOC_PPC64_HIGHER_S
:
6613 fieldval
= PPC_HIGHERA (value
);
6614 goto sign_extend_16
;
6616 case BFD_RELOC_PPC64_HIGHEST
:
6617 fieldval
= PPC_HIGHEST (value
);
6618 goto sign_extend_16
;
6620 case BFD_RELOC_PPC64_HIGHEST_S
:
6621 fieldval
= PPC_HIGHESTA (value
);
6622 goto sign_extend_16
;
6629 if (operand
!= NULL
)
6631 /* Handle relocs in an insn. */
6635 switch (fixP
->fx_r_type
)
6638 /* The following relocs can't be calculated by the assembler.
6639 Leave the field zero. */
6640 case BFD_RELOC_PPC_TPREL16
:
6641 case BFD_RELOC_PPC_TPREL16_LO
:
6642 case BFD_RELOC_PPC_TPREL16_HI
:
6643 case BFD_RELOC_PPC_TPREL16_HA
:
6644 case BFD_RELOC_PPC_DTPREL16
:
6645 case BFD_RELOC_PPC_DTPREL16_LO
:
6646 case BFD_RELOC_PPC_DTPREL16_HI
:
6647 case BFD_RELOC_PPC_DTPREL16_HA
:
6648 case BFD_RELOC_PPC_GOT_TLSGD16
:
6649 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6650 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6651 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6652 case BFD_RELOC_PPC_GOT_TLSLD16
:
6653 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6654 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6655 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6656 case BFD_RELOC_PPC_GOT_TPREL16
:
6657 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6658 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6659 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6660 case BFD_RELOC_PPC_GOT_DTPREL16
:
6661 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6662 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6663 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6664 case BFD_RELOC_PPC64_TPREL16_DS
:
6665 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6666 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6667 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6668 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6669 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6670 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6671 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6672 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6673 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6674 case BFD_RELOC_PPC64_DTPREL16_DS
:
6675 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6676 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6677 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6678 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6679 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6680 gas_assert (fixP
->fx_addsy
!= NULL
);
6681 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6685 /* These also should leave the field zero for the same
6686 reason. Note that older versions of gas wrote values
6687 here. If we want to go back to the old behaviour, then
6688 all _LO and _LO_DS cases will need to be treated like
6689 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6690 case BFD_RELOC_16_GOTOFF
:
6691 case BFD_RELOC_LO16_GOTOFF
:
6692 case BFD_RELOC_HI16_GOTOFF
:
6693 case BFD_RELOC_HI16_S_GOTOFF
:
6694 case BFD_RELOC_LO16_PLTOFF
:
6695 case BFD_RELOC_HI16_PLTOFF
:
6696 case BFD_RELOC_HI16_S_PLTOFF
:
6697 case BFD_RELOC_GPREL16
:
6698 case BFD_RELOC_16_BASEREL
:
6699 case BFD_RELOC_LO16_BASEREL
:
6700 case BFD_RELOC_HI16_BASEREL
:
6701 case BFD_RELOC_HI16_S_BASEREL
:
6702 case BFD_RELOC_PPC_TOC16
:
6703 case BFD_RELOC_PPC64_TOC16_LO
:
6704 case BFD_RELOC_PPC64_TOC16_HI
:
6705 case BFD_RELOC_PPC64_TOC16_HA
:
6706 case BFD_RELOC_PPC64_PLTGOT16
:
6707 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6708 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6709 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6710 case BFD_RELOC_PPC64_GOT16_DS
:
6711 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6712 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6713 case BFD_RELOC_PPC64_SECTOFF_DS
:
6714 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6715 case BFD_RELOC_PPC64_TOC16_DS
:
6716 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6717 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6718 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6719 case BFD_RELOC_PPC_EMB_NADDR16
:
6720 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6721 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6722 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6723 case BFD_RELOC_PPC_EMB_SDAI16
:
6724 case BFD_RELOC_PPC_EMB_SDA2I16
:
6725 case BFD_RELOC_PPC_EMB_SDA2REL
:
6726 case BFD_RELOC_PPC_EMB_SDA21
:
6727 case BFD_RELOC_PPC_EMB_MRKREF
:
6728 case BFD_RELOC_PPC_EMB_RELSEC16
:
6729 case BFD_RELOC_PPC_EMB_RELST_LO
:
6730 case BFD_RELOC_PPC_EMB_RELST_HI
:
6731 case BFD_RELOC_PPC_EMB_RELST_HA
:
6732 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6733 case BFD_RELOC_PPC_EMB_RELSDA
:
6734 case BFD_RELOC_PPC_VLE_SDA21
:
6735 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6736 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6737 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6738 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6739 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6740 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6741 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6742 gas_assert (fixP
->fx_addsy
!= NULL
);
6745 case BFD_RELOC_PPC_TLS
:
6746 case BFD_RELOC_PPC_TLSGD
:
6747 case BFD_RELOC_PPC_TLSLD
:
6753 case BFD_RELOC_PPC_B16
:
6754 /* Adjust the offset to the instruction boundary. */
6764 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6765 contents can stay at zero. */
6766 #define APPLY_RELOC fixP->fx_done
6768 #define APPLY_RELOC 1
6770 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6772 /* Fetch the instruction, insert the fully resolved operand
6773 value, and stuff the instruction back again. */
6774 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6775 if (target_big_endian
)
6777 if (fixP
->fx_size
== 4)
6778 insn
= bfd_getb32 ((unsigned char *) where
);
6780 insn
= bfd_getb16 ((unsigned char *) where
);
6784 if (fixP
->fx_size
== 4)
6785 insn
= bfd_getl32 ((unsigned char *) where
);
6787 insn
= bfd_getl16 ((unsigned char *) where
);
6789 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6790 fixP
->tc_fix_data
.ppc_cpu
,
6791 fixP
->fx_file
, fixP
->fx_line
);
6792 if (target_big_endian
)
6794 if (fixP
->fx_size
== 4)
6795 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6797 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6801 if (fixP
->fx_size
== 4)
6802 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6804 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6809 /* Nothing else to do here. */
6812 gas_assert (fixP
->fx_addsy
!= NULL
);
6813 if (fixP
->fx_r_type
== BFD_RELOC_NONE
)
6818 /* Use expr_symbol_where to see if this is an expression
6820 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6821 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6822 _("unresolved expression that must be resolved"));
6824 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6825 _("unsupported relocation against %s"),
6826 S_GET_NAME (fixP
->fx_addsy
));
6833 /* Handle relocs in data. */
6834 switch (fixP
->fx_r_type
)
6836 case BFD_RELOC_VTABLE_INHERIT
:
6838 && !S_IS_DEFINED (fixP
->fx_addsy
)
6839 && !S_IS_WEAK (fixP
->fx_addsy
))
6840 S_SET_WEAK (fixP
->fx_addsy
);
6843 case BFD_RELOC_VTABLE_ENTRY
:
6848 /* These can appear with @l etc. in data. */
6849 case BFD_RELOC_LO16
:
6850 case BFD_RELOC_LO16_PCREL
:
6851 case BFD_RELOC_HI16
:
6852 case BFD_RELOC_HI16_PCREL
:
6853 case BFD_RELOC_HI16_S
:
6854 case BFD_RELOC_HI16_S_PCREL
:
6855 case BFD_RELOC_PPC64_HIGHER
:
6856 case BFD_RELOC_PPC64_HIGHER_S
:
6857 case BFD_RELOC_PPC64_HIGHEST
:
6858 case BFD_RELOC_PPC64_HIGHEST_S
:
6859 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6860 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6861 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6864 case BFD_RELOC_PPC_DTPMOD
:
6865 case BFD_RELOC_PPC_TPREL
:
6866 case BFD_RELOC_PPC_DTPREL
:
6867 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6870 /* Just punt all of these to the linker. */
6871 case BFD_RELOC_PPC_B16_BRTAKEN
:
6872 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6873 case BFD_RELOC_16_GOTOFF
:
6874 case BFD_RELOC_LO16_GOTOFF
:
6875 case BFD_RELOC_HI16_GOTOFF
:
6876 case BFD_RELOC_HI16_S_GOTOFF
:
6877 case BFD_RELOC_LO16_PLTOFF
:
6878 case BFD_RELOC_HI16_PLTOFF
:
6879 case BFD_RELOC_HI16_S_PLTOFF
:
6880 case BFD_RELOC_PPC_COPY
:
6881 case BFD_RELOC_PPC_GLOB_DAT
:
6882 case BFD_RELOC_16_BASEREL
:
6883 case BFD_RELOC_LO16_BASEREL
:
6884 case BFD_RELOC_HI16_BASEREL
:
6885 case BFD_RELOC_HI16_S_BASEREL
:
6886 case BFD_RELOC_PPC_TLS
:
6887 case BFD_RELOC_PPC_DTPREL16_LO
:
6888 case BFD_RELOC_PPC_DTPREL16_HI
:
6889 case BFD_RELOC_PPC_DTPREL16_HA
:
6890 case BFD_RELOC_PPC_TPREL16_LO
:
6891 case BFD_RELOC_PPC_TPREL16_HI
:
6892 case BFD_RELOC_PPC_TPREL16_HA
:
6893 case BFD_RELOC_PPC_GOT_TLSGD16
:
6894 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6895 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6896 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6897 case BFD_RELOC_PPC_GOT_TLSLD16
:
6898 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6899 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6900 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6901 case BFD_RELOC_PPC_GOT_DTPREL16
:
6902 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6903 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6904 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6905 case BFD_RELOC_PPC_GOT_TPREL16
:
6906 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6907 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6908 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6909 case BFD_RELOC_24_PLT_PCREL
:
6910 case BFD_RELOC_PPC_LOCAL24PC
:
6911 case BFD_RELOC_32_PLT_PCREL
:
6912 case BFD_RELOC_GPREL16
:
6913 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6914 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6915 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6916 case BFD_RELOC_PPC_EMB_NADDR32
:
6917 case BFD_RELOC_PPC_EMB_NADDR16
:
6918 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6919 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6920 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6921 case BFD_RELOC_PPC_EMB_SDAI16
:
6922 case BFD_RELOC_PPC_EMB_SDA2REL
:
6923 case BFD_RELOC_PPC_EMB_SDA2I16
:
6924 case BFD_RELOC_PPC_EMB_SDA21
:
6925 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6926 case BFD_RELOC_PPC_EMB_MRKREF
:
6927 case BFD_RELOC_PPC_EMB_RELSEC16
:
6928 case BFD_RELOC_PPC_EMB_RELST_LO
:
6929 case BFD_RELOC_PPC_EMB_RELST_HI
:
6930 case BFD_RELOC_PPC_EMB_RELST_HA
:
6931 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6932 case BFD_RELOC_PPC_EMB_RELSDA
:
6933 case BFD_RELOC_PPC64_TOC
:
6934 case BFD_RELOC_PPC_TOC16
:
6935 case BFD_RELOC_PPC64_TOC16_LO
:
6936 case BFD_RELOC_PPC64_TOC16_HI
:
6937 case BFD_RELOC_PPC64_TOC16_HA
:
6938 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6939 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6940 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6941 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6942 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6943 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6944 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6945 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6946 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6947 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6948 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6949 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6955 case BFD_RELOC_NONE
:
6957 case BFD_RELOC_CTOR
:
6959 case BFD_RELOC_32_PCREL
:
6962 case BFD_RELOC_64_PCREL
:
6964 case BFD_RELOC_16_PCREL
:
6970 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6975 if (fixP
->fx_size
&& APPLY_RELOC
)
6976 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6977 fieldval
, fixP
->fx_size
);
6979 && (seg
->flags
& SEC_CODE
) != 0
6980 && fixP
->fx_size
== 4
6983 && (fixP
->fx_r_type
== BFD_RELOC_32
6984 || fixP
->fx_r_type
== BFD_RELOC_CTOR
6985 || fixP
->fx_r_type
== BFD_RELOC_32_PCREL
))
6986 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
6987 _("data in executable section"));
6990 /* We are only able to convert some relocs to pc-relative. */
6991 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
6993 switch (fixP
->fx_r_type
)
6995 case BFD_RELOC_LO16
:
6996 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6999 case BFD_RELOC_HI16
:
7000 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
7003 case BFD_RELOC_HI16_S
:
7004 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
7008 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7012 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7016 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7019 /* Some of course are already pc-relative. */
7020 case BFD_RELOC_LO16_PCREL
:
7021 case BFD_RELOC_HI16_PCREL
:
7022 case BFD_RELOC_HI16_S_PCREL
:
7023 case BFD_RELOC_64_PCREL
:
7024 case BFD_RELOC_32_PCREL
:
7025 case BFD_RELOC_16_PCREL
:
7026 case BFD_RELOC_PPC_B16
:
7027 case BFD_RELOC_PPC_B16_BRTAKEN
:
7028 case BFD_RELOC_PPC_B16_BRNTAKEN
:
7029 case BFD_RELOC_PPC_B26
:
7030 case BFD_RELOC_PPC_LOCAL24PC
:
7031 case BFD_RELOC_24_PLT_PCREL
:
7032 case BFD_RELOC_32_PLT_PCREL
:
7033 case BFD_RELOC_64_PLT_PCREL
:
7034 case BFD_RELOC_PPC_VLE_REL8
:
7035 case BFD_RELOC_PPC_VLE_REL15
:
7036 case BFD_RELOC_PPC_VLE_REL24
:
7045 /* Use expr_symbol_where to see if this is an
7046 expression symbol. */
7047 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
7048 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7049 _("unresolved expression that must"
7052 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7053 _("cannot emit PC relative %s relocation"
7055 bfd_get_reloc_code_name (fixP
->fx_r_type
),
7056 S_GET_NAME (fixP
->fx_addsy
));
7059 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7060 _("unable to resolve expression"));
7067 ppc_elf_validate_fix (fixP
, seg
);
7068 fixP
->fx_addnumber
= value
;
7070 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
7071 from the section contents. If we are going to be emitting a reloc
7072 then the section contents are immaterial, so don't warn if they
7073 happen to overflow. Leave such warnings to ld. */
7076 fixP
->fx_no_overflow
= 1;
7078 /* Arrange to emit .TOC. as a normal symbol if used in anything
7079 but .TOC.@tocbase. */
7081 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
7082 && fixP
->fx_addsy
!= NULL
7083 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
7084 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
7087 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
7088 fixP
->fx_addnumber
= 0;
7092 fixP
->fx_addnumber
= 0;
7094 /* We want to use the offset within the toc, not the actual VMA
7096 fixP
->fx_addnumber
=
7097 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
7098 - S_GET_VALUE (ppc_toc_csect
);
7099 /* Set *valP to avoid errors. */
7106 /* Generate a reloc for a fixup. */
7109 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
7113 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
7115 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
7116 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
7117 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
7118 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
7119 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
7121 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
7122 _("reloc %d not supported by object file format"),
7123 (int) fixp
->fx_r_type
);
7126 reloc
->addend
= fixp
->fx_addnumber
;
7132 ppc_cfi_frame_initial_instructions (void)
7134 cfi_add_CFA_def_cfa (1, 0);
7138 tc_ppc_regname_to_dw2regnum (char *regname
)
7140 unsigned int regnum
= -1;
7144 static struct { char *name
; int dw2regnum
; } regnames
[] =
7146 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7147 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7148 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7149 { "spe_acc", 111 }, { "spefscr", 112 }
7152 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7153 if (strcmp (regnames
[i
].name
, regname
) == 0)
7154 return regnames
[i
].dw2regnum
;
7156 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7158 p
= regname
+ 1 + (regname
[1] == '.');
7159 regnum
= strtoul (p
, &q
, 10);
7160 if (p
== q
|| *q
|| regnum
>= 32)
7162 if (regname
[0] == 'f')
7164 else if (regname
[0] == 'v')
7167 else if (regname
[0] == 'c' && regname
[1] == 'r')
7169 p
= regname
+ 2 + (regname
[2] == '.');
7170 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7172 regnum
= p
[0] - '0' + 68;