1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994-2015 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_SIGNOPT
) != 0)
1786 /* Extend the allowed range for addis to [-65536, 65535].
1787 Similarly for some VLE high part insns. For 64-bit it
1788 would be good to disable this for signed fields since the
1789 value is sign extended into the high 32 bits of the register.
1790 If the value is, say, an address, then we might care about
1791 the high bits. However, gcc as of 2014-06 uses unsigned
1792 values when loading the high part of 64-bit constants using
1794 Use the same extended range for cmpli, to allow at least
1796 min
= ~max
& -right
;
1798 else if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1800 max
= (max
>> 1) & -right
;
1801 min
= ~max
& -right
;
1804 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1807 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1816 /* Some people write constants with the sign extension done by
1817 hand but only up to 32 bits. This shouldn't really be valid,
1818 but, to permit this code to assemble on a 64-bit host, we
1819 sign extend the 32-bit value to 64 bits if so doing makes the
1822 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1823 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1824 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1825 val
= val
- 0x80000000 - 0x80000000;
1827 /* Similarly, people write expressions like ~(1<<15), and expect
1828 this to be OK for a 32-bit unsigned value. */
1830 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1831 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1832 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1833 val
= val
+ 0x80000000 + 0x80000000;
1837 || (val
& (right
- 1)) != 0)
1838 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1841 if (operand
->insert
)
1846 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1847 if (errmsg
!= (const char *) NULL
)
1848 as_bad_where (file
, line
, "%s", errmsg
);
1850 else if (operand
->shift
>= 0)
1851 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1853 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1860 /* Parse @got, etc. and return the desired relocation. */
1861 static bfd_reloc_code_real_type
1862 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1866 unsigned int length
: 8;
1867 unsigned int valid32
: 1;
1868 unsigned int valid64
: 1;
1877 const struct map_bfd
*ptr
;
1879 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1880 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1881 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1883 static const struct map_bfd mapping
[] = {
1884 MAP ("l", BFD_RELOC_LO16
),
1885 MAP ("h", BFD_RELOC_HI16
),
1886 MAP ("ha", BFD_RELOC_HI16_S
),
1887 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1888 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1889 MAP ("got", BFD_RELOC_16_GOTOFF
),
1890 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1891 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1892 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1893 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1894 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1895 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1896 MAP ("copy", BFD_RELOC_PPC_COPY
),
1897 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1898 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1899 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1900 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1901 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1902 MAP ("tls", BFD_RELOC_PPC_TLS
),
1903 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1904 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1905 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1906 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1907 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1908 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1909 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1910 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1911 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1912 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1913 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1914 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1915 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1916 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1917 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1918 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1919 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1920 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1921 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1922 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1923 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1924 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1925 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1926 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1927 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1928 MAP32 ("fixup", BFD_RELOC_CTOR
),
1929 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1930 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1931 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1932 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1933 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1934 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1935 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1936 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1937 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1938 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1939 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1940 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1941 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1942 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1943 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1944 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1945 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1946 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1947 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1948 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1949 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1950 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1951 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1952 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1953 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1954 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1955 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1956 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1957 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1958 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1959 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1960 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1961 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1962 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1963 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1964 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1965 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1966 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1967 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1968 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1969 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1970 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1971 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1972 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1973 MAP64 ("localentry", BFD_RELOC_PPC64_ADDR64_LOCAL
),
1974 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1975 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1976 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1977 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1978 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1979 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1980 { (char *) 0, 0, 0, 0, BFD_RELOC_NONE
}
1984 return BFD_RELOC_NONE
;
1986 for (ch
= *str
, str2
= ident
;
1987 (str2
< ident
+ sizeof (ident
) - 1
1988 && (ISALNUM (ch
) || ch
== '@'));
1991 *str2
++ = TOLOWER (ch
);
1998 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1999 if (ch
== ptr
->string
[0]
2000 && len
== ptr
->length
2001 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
2002 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
2004 int reloc
= ptr
->reloc
;
2006 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
2010 case BFD_RELOC_16_GOTOFF
:
2011 case BFD_RELOC_LO16_GOTOFF
:
2012 case BFD_RELOC_HI16_GOTOFF
:
2013 case BFD_RELOC_HI16_S_GOTOFF
:
2014 as_warn (_("identifier+constant@got means "
2015 "identifier@got+constant"));
2018 case BFD_RELOC_PPC_GOT_TLSGD16
:
2019 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2020 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2021 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2022 case BFD_RELOC_PPC_GOT_TLSLD16
:
2023 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2024 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2025 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2026 case BFD_RELOC_PPC_GOT_DTPREL16
:
2027 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2028 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2029 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2030 case BFD_RELOC_PPC_GOT_TPREL16
:
2031 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2032 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2033 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2034 as_bad (_("symbol+offset not supported for got tls"));
2039 /* Now check for identifier@suffix+constant. */
2040 if (*str
== '-' || *str
== '+')
2042 char *orig_line
= input_line_pointer
;
2043 expressionS new_exp
;
2045 input_line_pointer
= str
;
2046 expression (&new_exp
);
2047 if (new_exp
.X_op
== O_constant
)
2049 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2050 str
= input_line_pointer
;
2053 if (&input_line_pointer
!= str_p
)
2054 input_line_pointer
= orig_line
;
2058 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2059 && exp_p
->X_op
== O_symbol
2060 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2062 /* Change the symbol so that the dummy .TOC. symbol can be
2063 omitted from the object file. */
2064 exp_p
->X_add_symbol
= &abs_symbol
;
2067 return (bfd_reloc_code_real_type
) reloc
;
2070 return BFD_RELOC_NONE
;
2073 /* Support @got, etc. on constants emitted via .short, .int etc. */
2075 bfd_reloc_code_real_type
2076 ppc_elf_parse_cons (expressionS
*exp
, unsigned int nbytes
)
2079 if (nbytes
>= 2 && *input_line_pointer
== '@')
2080 return ppc_elf_suffix (&input_line_pointer
, exp
);
2081 return BFD_RELOC_NONE
;
2084 /* Warn when emitting data to code sections, unless we are emitting
2085 a relocation that ld --ppc476-workaround uses to recognise data
2086 *and* there was an unconditional branch prior to the data. */
2089 ppc_elf_cons_fix_check (expressionS
*exp ATTRIBUTE_UNUSED
,
2090 unsigned int nbytes
, fixS
*fix
)
2093 && (now_seg
->flags
& SEC_CODE
) != 0
2096 || !(fix
->fx_r_type
== BFD_RELOC_32
2097 || fix
->fx_r_type
== BFD_RELOC_CTOR
2098 || fix
->fx_r_type
== BFD_RELOC_32_PCREL
)
2099 || !(last_seg
== now_seg
&& last_subseg
== now_subseg
)
2100 || !((last_insn
& (0x3f << 26)) == (18u << 26)
2101 || ((last_insn
& (0x3f << 26)) == (16u << 26)
2102 && (last_insn
& (0x14 << 21)) == (0x14 << 21))
2103 || ((last_insn
& (0x3f << 26)) == (19u << 26)
2104 && (last_insn
& (0x3ff << 1)) == (16u << 1)
2105 && (last_insn
& (0x14 << 21)) == (0x14 << 21)))))
2107 /* Flag that we've warned. */
2111 as_warn (_("data in executable section"));
2115 /* Solaris pseduo op to change to the .rodata section. */
2117 ppc_elf_rdata (int xxx
)
2119 char *save_line
= input_line_pointer
;
2120 static char section
[] = ".rodata\n";
2122 /* Just pretend this is .section .rodata */
2123 input_line_pointer
= section
;
2124 obj_elf_section (xxx
);
2126 input_line_pointer
= save_line
;
2129 /* Pseudo op to make file scope bss items. */
2131 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2144 name
= input_line_pointer
;
2145 c
= get_symbol_end ();
2147 /* just after name is now '\0'. */
2148 p
= input_line_pointer
;
2151 if (*input_line_pointer
!= ',')
2153 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2154 ignore_rest_of_line ();
2158 input_line_pointer
++; /* skip ',' */
2159 if ((size
= get_absolute_expression ()) < 0)
2161 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2162 ignore_rest_of_line ();
2166 /* The third argument to .lcomm is the alignment. */
2167 if (*input_line_pointer
!= ',')
2171 ++input_line_pointer
;
2172 align
= get_absolute_expression ();
2175 as_warn (_("ignoring bad alignment"));
2181 symbolP
= symbol_find_or_make (name
);
2184 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2186 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2187 S_GET_NAME (symbolP
));
2188 ignore_rest_of_line ();
2192 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2194 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2195 S_GET_NAME (symbolP
),
2196 (long) S_GET_VALUE (symbolP
),
2199 ignore_rest_of_line ();
2205 old_subsec
= now_subseg
;
2208 /* Convert to a power of 2 alignment. */
2209 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2212 as_bad (_("common alignment not a power of 2"));
2213 ignore_rest_of_line ();
2220 record_alignment (bss_section
, align2
);
2221 subseg_set (bss_section
, 1);
2223 frag_align (align2
, 0, 0);
2224 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2225 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2226 symbol_set_frag (symbolP
, frag_now
);
2227 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2230 S_SET_SIZE (symbolP
, size
);
2231 S_SET_SEGMENT (symbolP
, bss_section
);
2232 subseg_set (old_sec
, old_subsec
);
2233 demand_empty_rest_of_line ();
2236 /* Pseudo op to set symbol local entry point. */
2238 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED
)
2240 char *name
= input_line_pointer
;
2241 char c
= get_symbol_end ();
2246 elf_symbol_type
*elfsym
;
2248 p
= input_line_pointer
;
2251 if (*input_line_pointer
!= ',')
2254 as_bad (_("expected comma after name `%s' in .localentry directive"),
2257 ignore_rest_of_line ();
2260 input_line_pointer
++;
2262 if (exp
.X_op
== O_absent
)
2264 as_bad (_("missing expression in .localentry directive"));
2265 exp
.X_op
= O_constant
;
2266 exp
.X_add_number
= 0;
2269 sym
= symbol_find_or_make (name
);
2272 if (resolve_expression (&exp
)
2273 && exp
.X_op
== O_constant
)
2275 unsigned char encoded
= PPC64_SET_LOCAL_ENTRY_OFFSET (exp
.X_add_number
);
2277 if (exp
.X_add_number
!= (offsetT
) PPC64_LOCAL_ENTRY_OFFSET (encoded
))
2278 as_bad (_(".localentry expression for `%s' "
2279 "is not a valid power of 2"), S_GET_NAME (sym
));
2282 bfdsym
= symbol_get_bfdsym (sym
);
2283 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
2284 gas_assert (elfsym
);
2285 elfsym
->internal_elf_sym
.st_other
&= ~STO_PPC64_LOCAL_MASK
;
2286 elfsym
->internal_elf_sym
.st_other
|= encoded
;
2287 if (ppc_abiversion
== 0)
2292 as_bad (_(".localentry expression for `%s' "
2293 "does not evaluate to a constant"), S_GET_NAME (sym
));
2295 demand_empty_rest_of_line ();
2298 /* Pseudo op to set ABI version. */
2300 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2305 if (exp
.X_op
== O_absent
)
2307 as_bad (_("missing expression in .abiversion directive"));
2308 exp
.X_op
= O_constant
;
2309 exp
.X_add_number
= 0;
2312 if (resolve_expression (&exp
)
2313 && exp
.X_op
== O_constant
)
2314 ppc_abiversion
= exp
.X_add_number
;
2316 as_bad (_(".abiversion expression does not evaluate to a constant"));
2317 demand_empty_rest_of_line ();
2320 /* Set ABI version in output file. */
2324 if (ppc_obj64
&& ppc_abiversion
!= 0)
2326 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2327 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2331 /* Validate any relocations emitted for -mrelocatable, possibly adding
2332 fixups for word relocations in writable segments, so we can adjust
2335 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2337 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2346 case SHLIB_MRELOCATABLE
:
2347 if (fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2348 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2349 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2350 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2351 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2352 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2353 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2354 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2355 && (seg
->flags
& SEC_LOAD
) != 0
2356 && strcmp (segment_name (seg
), ".got2") != 0
2357 && strcmp (segment_name (seg
), ".dtors") != 0
2358 && strcmp (segment_name (seg
), ".ctors") != 0
2359 && strcmp (segment_name (seg
), ".fixup") != 0
2360 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2361 && strcmp (segment_name (seg
), ".eh_frame") != 0
2362 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2364 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2365 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2367 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2368 _("relocation cannot be done when using -mrelocatable"));
2375 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2376 function descriptor sym if the corresponding code sym is used. */
2379 ppc_frob_file_before_adjust (void)
2387 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2394 name
= S_GET_NAME (symp
);
2398 if (! S_IS_WEAK (symp
)
2399 || S_IS_DEFINED (symp
))
2402 len
= strlen (name
) + 1;
2403 dotname
= xmalloc (len
+ 1);
2405 memcpy (dotname
+ 1, name
, len
);
2406 dotsym
= symbol_find_noref (dotname
, 1);
2408 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2409 || symbol_used_in_reloc_p (dotsym
)))
2410 symbol_mark_used (symp
);
2414 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2416 && toc_reloc_types
!= has_large_toc_reloc
2417 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2418 as_warn (_("TOC section size exceeds 64k"));
2421 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2422 emitted. Other uses of .TOC. will cause the symbol to be marked
2423 with BSF_KEEP in md_apply_fix. */
2426 ppc_elf_adjust_symtab (void)
2431 symp
= symbol_find (".TOC.");
2434 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2435 if ((bsym
->flags
& BSF_KEEP
) == 0)
2436 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2440 #endif /* OBJ_ELF */
2445 * Summary of parse_toc_entry.
2447 * in: Input_line_pointer points to the '[' in one of:
2449 * [toc] [tocv] [toc32] [toc64]
2451 * Anything else is an error of one kind or another.
2454 * return value: success or failure
2455 * toc_kind: kind of toc reference
2456 * input_line_pointer:
2457 * success: first char after the ']'
2458 * failure: unchanged
2462 * [toc] - rv == success, toc_kind = default_toc
2463 * [tocv] - rv == success, toc_kind = data_in_toc
2464 * [toc32] - rv == success, toc_kind = must_be_32
2465 * [toc64] - rv == success, toc_kind = must_be_64
2469 enum toc_size_qualifier
2471 default_toc
, /* The toc cell constructed should be the system default size */
2472 data_in_toc
, /* This is a direct reference to a toc cell */
2473 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2474 must_be_64
/* The toc cell constructed must be 64 bits wide */
2478 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2483 enum toc_size_qualifier t
;
2485 /* Save the input_line_pointer. */
2486 start
= input_line_pointer
;
2488 /* Skip over the '[' , and whitespace. */
2489 ++input_line_pointer
;
2492 /* Find the spelling of the operand. */
2493 toc_spec
= input_line_pointer
;
2494 c
= get_symbol_end ();
2496 if (strcmp (toc_spec
, "toc") == 0)
2500 else if (strcmp (toc_spec
, "tocv") == 0)
2504 else if (strcmp (toc_spec
, "toc32") == 0)
2508 else if (strcmp (toc_spec
, "toc64") == 0)
2514 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2515 *input_line_pointer
= c
;
2516 input_line_pointer
= start
;
2520 /* Now find the ']'. */
2521 *input_line_pointer
= c
;
2523 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2524 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2528 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2529 input_line_pointer
= start
;
2538 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2539 /* See whether a symbol is in the TOC section. */
2542 ppc_is_toc_sym (symbolS
*sym
)
2545 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2546 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2549 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2551 return strcmp (sname
, ".toc") == 0;
2553 return strcmp (sname
, ".got") == 0;
2556 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2560 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2562 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2566 /* Check we don't already exist. */
2567 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2568 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2571 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2573 if (ppc_apuinfo_num_alloc
== 0)
2575 ppc_apuinfo_num_alloc
= 4;
2576 ppc_apuinfo_list
= (unsigned long *)
2577 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2581 ppc_apuinfo_num_alloc
+= 4;
2582 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2583 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2586 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2592 /* We need to keep a list of fixups. We can't simply generate them as
2593 we go, because that would require us to first create the frag, and
2594 that would screw up references to ``.''. */
2600 bfd_reloc_code_real_type reloc
;
2603 #define MAX_INSN_FIXUPS (5)
2606 #define E_OR2I_INSN 0x7000C000
2607 #define E_AND2I_DOT_INSN 0x7000C800
2608 #define E_OR2IS_INSN 0x7000D000
2609 #define E_LIS_INSN 0x7000E000
2610 #define E_AND2IS_DOT_INSN 0x7000E800
2613 #define E_ADD2I_DOT_INSN 0x70008800
2614 #define E_ADD2IS_INSN 0x70009000
2615 #define E_CMP16I_INSN 0x70009800
2616 #define E_MULL2I_INSN 0x7000A000
2617 #define E_CMPL16I_INSN 0x7000A800
2618 #define E_CMPH16I_INSN 0x7000B000
2619 #define E_CMPHL16I_INSN 0x7000B800
2621 /* This routine is called for each instruction to be assembled. */
2624 md_assemble (char *str
)
2627 const struct powerpc_opcode
*opcode
;
2629 const unsigned char *opindex_ptr
;
2633 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2638 unsigned int insn_length
;
2640 /* Get the opcode. */
2641 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2646 /* Look up the opcode in the hash table. */
2647 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2648 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2650 const struct powerpc_macro
*macro
;
2652 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2653 if (macro
== (const struct powerpc_macro
*) NULL
)
2654 as_bad (_("unrecognized opcode: `%s'"), str
);
2656 ppc_macro (s
, macro
);
2661 insn
= opcode
->opcode
;
2664 while (ISSPACE (*str
))
2667 /* PowerPC operands are just expressions. The only real issue is
2668 that a few operand types are optional. All cases which might use
2669 an optional operand separate the operands only with commas (in some
2670 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2671 have optional operands). Most instructions with optional operands
2672 have only one. Those that have more than one optional operand can
2673 take either all their operands or none. So, before we start seriously
2674 parsing the operands, we check to see if we have optional operands,
2675 and if we do, we count the number of commas to see which operands
2676 have been omitted. */
2678 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2680 const struct powerpc_operand
*operand
;
2682 operand
= &powerpc_operands
[*opindex_ptr
];
2683 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2685 unsigned int opcount
;
2686 unsigned int num_operands_expected
;
2688 /* There is an optional operand. Count the number of
2689 commas in the input line. */
2696 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2703 /* Compute the number of expected operands.
2704 Do not count fake operands. */
2705 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2706 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2707 ++ num_operands_expected
;
2709 /* If there are fewer operands in the line then are called
2710 for by the instruction, we want to skip the optional
2712 if (opcount
< num_operands_expected
)
2719 /* Gather the operands. */
2723 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2725 const struct powerpc_operand
*operand
;
2731 if (next_opindex
== 0)
2732 operand
= &powerpc_operands
[*opindex_ptr
];
2735 operand
= &powerpc_operands
[next_opindex
];
2740 /* If this is a fake operand, then we do not expect anything
2742 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2744 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2745 if (errmsg
!= (const char *) NULL
)
2746 as_bad ("%s", errmsg
);
2750 /* If this is an optional operand, and we are skipping it, just
2752 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2755 long val
= ppc_optional_operand_value (operand
);
2756 if (operand
->insert
)
2758 insn
= (*operand
->insert
) (insn
, val
, ppc_cpu
, &errmsg
);
2759 if (errmsg
!= (const char *) NULL
)
2760 as_bad ("%s", errmsg
);
2762 else if (operand
->shift
>= 0)
2763 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
2765 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
2767 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2768 next_opindex
= *opindex_ptr
+ 1;
2772 /* Gather the operand. */
2773 hold
= input_line_pointer
;
2774 input_line_pointer
= str
;
2777 if (*input_line_pointer
== '[')
2779 /* We are expecting something like the second argument here:
2781 * lwz r4,[toc].GS.0.static_int(rtoc)
2782 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2783 * The argument following the `]' must be a symbol name, and the
2784 * register must be the toc register: 'rtoc' or '2'
2786 * The effect is to 0 as the displacement field
2787 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2788 * the appropriate variation) reloc against it based on the symbol.
2789 * The linker will build the toc, and insert the resolved toc offset.
2792 * o The size of the toc entry is currently assumed to be
2793 * 32 bits. This should not be assumed to be a hard coded
2795 * o In an effort to cope with a change from 32 to 64 bits,
2796 * there are also toc entries that are specified to be
2797 * either 32 or 64 bits:
2798 * lwz r4,[toc32].GS.0.static_int(rtoc)
2799 * lwz r4,[toc64].GS.0.static_int(rtoc)
2800 * These demand toc entries of the specified size, and the
2801 * instruction probably requires it.
2805 enum toc_size_qualifier toc_kind
;
2806 bfd_reloc_code_real_type toc_reloc
;
2808 /* Go parse off the [tocXX] part. */
2809 valid_toc
= parse_toc_entry (&toc_kind
);
2813 ignore_rest_of_line ();
2817 /* Now get the symbol following the ']'. */
2823 /* In this case, we may not have seen the symbol yet,
2824 since it is allowed to appear on a .extern or .globl
2825 or just be a label in the .data section. */
2826 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2829 /* 1. The symbol must be defined and either in the toc
2830 section, or a global.
2831 2. The reloc generated must have the TOCDEFN flag set
2832 in upper bit mess of the reloc type.
2833 FIXME: It's a little confusing what the tocv
2834 qualifier can be used for. At the very least, I've
2835 seen three uses, only one of which I'm sure I can
2837 if (ex
.X_op
== O_symbol
)
2839 gas_assert (ex
.X_add_symbol
!= NULL
);
2840 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2843 as_bad (_("[tocv] symbol is not a toc symbol"));
2847 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2850 /* FIXME: these next two specifically specify 32/64 bit
2851 toc entries. We don't support them today. Is this
2852 the right way to say that? */
2853 toc_reloc
= BFD_RELOC_NONE
;
2854 as_bad (_("unimplemented toc32 expression modifier"));
2857 /* FIXME: see above. */
2858 toc_reloc
= BFD_RELOC_NONE
;
2859 as_bad (_("unimplemented toc64 expression modifier"));
2863 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2869 /* We need to generate a fixup for this expression. */
2870 if (fc
>= MAX_INSN_FIXUPS
)
2871 as_fatal (_("too many fixups"));
2873 fixups
[fc
].reloc
= toc_reloc
;
2874 fixups
[fc
].exp
= ex
;
2875 fixups
[fc
].opindex
= *opindex_ptr
;
2878 /* Ok. We've set up the fixup for the instruction. Now make it
2879 look like the constant 0 was found here. */
2881 ex
.X_op
= O_constant
;
2882 ex
.X_add_number
= 0;
2883 ex
.X_add_symbol
= NULL
;
2884 ex
.X_op_symbol
= NULL
;
2891 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2892 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2893 || !register_name (&ex
))
2895 char save_lex
= lex_type
['%'];
2897 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2898 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2901 lex_type
['%'] |= LEX_BEGIN_NAME
;
2905 lex_type
['%'] = save_lex
;
2909 str
= input_line_pointer
;
2910 input_line_pointer
= hold
;
2912 if (ex
.X_op
== O_illegal
)
2913 as_bad (_("illegal operand"));
2914 else if (ex
.X_op
== O_absent
)
2915 as_bad (_("missing operand"));
2916 else if (ex
.X_op
== O_register
)
2918 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2919 ppc_cpu
, (char *) NULL
, 0);
2921 else if (ex
.X_op
== O_constant
)
2924 /* Allow @HA, @L, @H on constants. */
2925 bfd_reloc_code_real_type reloc
;
2926 char *orig_str
= str
;
2928 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
2935 case BFD_RELOC_LO16
:
2936 ex
.X_add_number
&= 0xffff;
2937 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2938 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2941 case BFD_RELOC_HI16
:
2942 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2944 /* PowerPC64 @h is tested for overflow. */
2945 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2946 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2948 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2950 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2956 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2957 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2958 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2959 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2962 case BFD_RELOC_HI16_S
:
2963 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2965 /* PowerPC64 @ha is tested for overflow. */
2967 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2968 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2970 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2972 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2978 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2979 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2980 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2981 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2984 case BFD_RELOC_PPC64_HIGHER
:
2985 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2986 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2987 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2990 case BFD_RELOC_PPC64_HIGHER_S
:
2991 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2992 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2993 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2996 case BFD_RELOC_PPC64_HIGHEST
:
2997 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2998 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2999 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3002 case BFD_RELOC_PPC64_HIGHEST_S
:
3003 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
3004 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3005 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3008 #endif /* OBJ_ELF */
3009 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
3010 ppc_cpu
, (char *) NULL
, 0);
3014 bfd_reloc_code_real_type reloc
= BFD_RELOC_NONE
;
3016 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
3018 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
3019 if (sym_name
[0] == '.')
3022 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
3024 expressionS tls_exp
;
3026 hold
= input_line_pointer
;
3027 input_line_pointer
= str
+ 1;
3028 expression (&tls_exp
);
3029 if (tls_exp
.X_op
== O_symbol
)
3031 reloc
= BFD_RELOC_NONE
;
3032 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
3034 reloc
= BFD_RELOC_PPC_TLSGD
;
3035 input_line_pointer
+= 7;
3037 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
3039 reloc
= BFD_RELOC_PPC_TLSLD
;
3040 input_line_pointer
+= 7;
3042 if (reloc
!= BFD_RELOC_NONE
)
3045 str
= input_line_pointer
;
3047 if (fc
>= MAX_INSN_FIXUPS
)
3048 as_fatal (_("too many fixups"));
3049 fixups
[fc
].exp
= tls_exp
;
3050 fixups
[fc
].opindex
= *opindex_ptr
;
3051 fixups
[fc
].reloc
= reloc
;
3055 input_line_pointer
= hold
;
3059 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
3061 /* Some TLS tweaks. */
3067 case BFD_RELOC_PPC_TLS
:
3068 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
3069 as_bad (_("@tls may not be used with \"%s\" operands"),
3071 else if (operand
->shift
!= 11)
3072 as_bad (_("@tls may only be used in last operand"));
3074 insn
= ppc_insert_operand (insn
, operand
,
3076 ppc_cpu
, (char *) NULL
, 0);
3079 /* We'll only use the 32 (or 64) bit form of these relocations
3080 in constants. Instructions get the 16 bit form. */
3081 case BFD_RELOC_PPC_DTPREL
:
3082 reloc
= BFD_RELOC_PPC_DTPREL16
;
3084 case BFD_RELOC_PPC_TPREL
:
3085 reloc
= BFD_RELOC_PPC_TPREL16
;
3089 /* If VLE-mode convert LO/HI/HA relocations. */
3090 if (opcode
->flags
& PPC_OPCODE_VLE
)
3092 int tmp_insn
= insn
& opcode
->mask
;
3094 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3095 || tmp_insn
== E_AND2I_DOT_INSN
3096 || tmp_insn
== E_OR2IS_INSN
3097 || tmp_insn
== E_LIS_INSN
3098 || tmp_insn
== E_AND2IS_DOT_INSN
);
3101 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3102 || tmp_insn
== E_ADD2IS_INSN
3103 || tmp_insn
== E_CMP16I_INSN
3104 || tmp_insn
== E_MULL2I_INSN
3105 || tmp_insn
== E_CMPL16I_INSN
3106 || tmp_insn
== E_CMPH16I_INSN
3107 || tmp_insn
== E_CMPHL16I_INSN
);
3114 case BFD_RELOC_PPC_EMB_SDA21
:
3115 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3118 case BFD_RELOC_LO16
:
3120 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3121 else if (use_a_reloc
)
3122 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3125 case BFD_RELOC_HI16
:
3127 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3128 else if (use_a_reloc
)
3129 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3132 case BFD_RELOC_HI16_S
:
3134 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3135 else if (use_a_reloc
)
3136 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3139 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3141 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3144 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3146 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3149 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3151 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3156 #endif /* OBJ_ELF */
3158 if (reloc
!= BFD_RELOC_NONE
)
3160 /* Determine a BFD reloc value based on the operand information.
3161 We are only prepared to turn a few of the operands into
3163 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3164 | PPC_OPERAND_ABSOLUTE
)) != 0
3165 && operand
->bitm
== 0x3fffffc
3166 && operand
->shift
== 0)
3167 reloc
= BFD_RELOC_PPC_B26
;
3168 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3169 | PPC_OPERAND_ABSOLUTE
)) != 0
3170 && operand
->bitm
== 0xfffc
3171 && operand
->shift
== 0)
3172 reloc
= BFD_RELOC_PPC_B16
;
3173 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3174 && operand
->bitm
== 0x1fe
3175 && operand
->shift
== -1)
3176 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3177 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3178 && operand
->bitm
== 0xfffe
3179 && operand
->shift
== 0)
3180 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3181 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3182 && operand
->bitm
== 0x1fffffe
3183 && operand
->shift
== 0)
3184 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3185 else if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) == 0
3186 && (operand
->bitm
& 0xfff0) == 0xfff0
3187 && operand
->shift
== 0)
3189 reloc
= BFD_RELOC_16
;
3190 #if defined OBJ_XCOFF || defined OBJ_ELF
3191 /* Note: the symbol may be not yet defined. */
3192 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3193 && ppc_is_toc_sym (ex
.X_add_symbol
))
3195 reloc
= BFD_RELOC_PPC_TOC16
;
3197 as_warn (_("assuming %s on symbol"),
3198 ppc_obj64
? "@toc" : "@xgot");
3204 /* For the absolute forms of branches, convert the PC
3205 relative form back into the absolute. */
3206 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3210 case BFD_RELOC_PPC_B26
:
3211 reloc
= BFD_RELOC_PPC_BA26
;
3213 case BFD_RELOC_PPC_B16
:
3214 reloc
= BFD_RELOC_PPC_BA16
;
3217 case BFD_RELOC_PPC_B16_BRTAKEN
:
3218 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3220 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3221 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3232 case BFD_RELOC_PPC_TOC16
:
3233 toc_reloc_types
|= has_small_toc_reloc
;
3235 case BFD_RELOC_PPC64_TOC16_LO
:
3236 case BFD_RELOC_PPC64_TOC16_HI
:
3237 case BFD_RELOC_PPC64_TOC16_HA
:
3238 toc_reloc_types
|= has_large_toc_reloc
;
3245 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3250 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3252 case BFD_RELOC_LO16
:
3253 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3255 case BFD_RELOC_16_GOTOFF
:
3256 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3258 case BFD_RELOC_LO16_GOTOFF
:
3259 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3261 case BFD_RELOC_LO16_PLTOFF
:
3262 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3264 case BFD_RELOC_16_BASEREL
:
3265 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3267 case BFD_RELOC_LO16_BASEREL
:
3268 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3270 case BFD_RELOC_PPC_TOC16
:
3271 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3273 case BFD_RELOC_PPC64_TOC16_LO
:
3274 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3276 case BFD_RELOC_PPC64_PLTGOT16
:
3277 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3279 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3280 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3282 case BFD_RELOC_PPC_DTPREL16
:
3283 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3285 case BFD_RELOC_PPC_DTPREL16_LO
:
3286 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3288 case BFD_RELOC_PPC_TPREL16
:
3289 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3291 case BFD_RELOC_PPC_TPREL16_LO
:
3292 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3294 case BFD_RELOC_PPC_GOT_DTPREL16
:
3295 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3296 case BFD_RELOC_PPC_GOT_TPREL16
:
3297 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3300 as_bad (_("unsupported relocation for DS offset field"));
3306 /* We need to generate a fixup for this expression. */
3307 if (fc
>= MAX_INSN_FIXUPS
)
3308 as_fatal (_("too many fixups"));
3309 fixups
[fc
].exp
= ex
;
3310 fixups
[fc
].opindex
= *opindex_ptr
;
3311 fixups
[fc
].reloc
= reloc
;
3319 /* If expecting more operands, then we want to see "),". */
3320 if (*str
== endc
&& opindex_ptr
[1] != 0)
3324 while (ISSPACE (*str
));
3328 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3336 /* The call to expression should have advanced str past any
3339 && (endc
!= ',' || *str
!= '\0'))
3342 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3344 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3352 while (ISSPACE (*str
))
3356 as_bad (_("junk at end of line: `%s'"), str
);
3359 /* Do we need/want an APUinfo section? */
3360 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3363 /* These are all version "1". */
3364 if (opcode
->flags
& PPC_OPCODE_SPE
)
3365 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3366 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3367 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3368 if (opcode
->flags
& PPC_OPCODE_EFS
)
3369 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3370 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3371 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3372 if (opcode
->flags
& PPC_OPCODE_PMR
)
3373 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3374 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3375 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3376 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3377 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3378 /* Only set the VLE flag if the instruction has been pulled via
3379 the VLE instruction set. This way the flag is guaranteed to
3380 be set for VLE-only instructions or for VLE-only processors,
3381 however it'll remain clear for dual-mode instructions on
3382 dual-mode and, more importantly, standard-mode processors. */
3383 if ((ppc_cpu
& opcode
->flags
) == PPC_OPCODE_VLE
)
3384 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3388 /* Write out the instruction. */
3389 /* Differentiate between two and four byte insns. */
3390 if (ppc_mach () == bfd_mach_ppc_vle
)
3392 if (PPC_OP_SE_VLE (insn
))
3396 addr_mod
= frag_now_fix () & 1;
3401 addr_mod
= frag_now_fix () & 3;
3403 /* All instructions can start on a 2 byte boundary for VLE. */
3404 f
= frag_more (insn_length
);
3405 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3407 if (ppc_mach() == bfd_mach_ppc_vle
)
3408 as_bad (_("instruction address is not a multiple of 2"));
3410 as_bad (_("instruction address is not a multiple of 4"));
3412 frag_now
->insn_addr
= addr_mod
;
3413 frag_now
->has_code
= 1;
3414 md_number_to_chars (f
, insn
, insn_length
);
3417 last_subseg
= now_subseg
;
3420 dwarf2_emit_insn (insn_length
);
3423 /* Create any fixups. */
3424 for (i
= 0; i
< fc
; i
++)
3427 if (fixups
[i
].reloc
!= BFD_RELOC_NONE
)
3429 reloc_howto_type
*reloc_howto
;
3433 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3437 size
= bfd_get_reloc_size (reloc_howto
);
3438 offset
= target_big_endian
? (insn_length
- size
) : 0;
3440 fixP
= fix_new_exp (frag_now
,
3441 f
- frag_now
->fr_literal
+ offset
,
3444 reloc_howto
->pc_relative
,
3449 const struct powerpc_operand
*operand
;
3451 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3452 fixP
= fix_new_exp (frag_now
,
3453 f
- frag_now
->fr_literal
,
3456 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3459 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3463 /* Handle a macro. Gather all the operands, transform them as
3464 described by the macro, and call md_assemble recursively. All the
3465 operands are separated by commas; we don't accept parentheses
3466 around operands here. */
3469 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3480 /* Gather the users operands into the operands array. */
3485 if (count
>= sizeof operands
/ sizeof operands
[0])
3487 operands
[count
++] = s
;
3488 s
= strchr (s
, ',');
3489 if (s
== (char *) NULL
)
3494 if (count
!= macro
->operands
)
3496 as_bad (_("wrong number of operands"));
3500 /* Work out how large the string must be (the size is unbounded
3501 because it includes user input). */
3503 format
= macro
->format
;
3504 while (*format
!= '\0')
3513 arg
= strtol (format
+ 1, &send
, 10);
3514 know (send
!= format
&& arg
< count
);
3515 len
+= strlen (operands
[arg
]);
3520 /* Put the string together. */
3521 complete
= s
= (char *) alloca (len
+ 1);
3522 format
= macro
->format
;
3523 while (*format
!= '\0')
3529 arg
= strtol (format
+ 1, &send
, 10);
3530 strcpy (s
, operands
[arg
]);
3537 /* Assemble the constructed instruction. */
3538 md_assemble (complete
);
3542 /* For ELF, add support for SHT_ORDERED. */
3545 ppc_section_type (char *str
, size_t len
)
3547 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3554 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3556 if (type
== SHT_ORDERED
)
3557 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3561 #endif /* OBJ_ELF */
3564 /* Pseudo-op handling. */
3566 /* The .byte pseudo-op. This is similar to the normal .byte
3567 pseudo-op, but it can also take a single ASCII string. */
3570 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3574 if (*input_line_pointer
!= '\"')
3580 /* Gather characters. A real double quote is doubled. Unusual
3581 characters are not permitted. */
3582 ++input_line_pointer
;
3587 c
= *input_line_pointer
++;
3591 if (*input_line_pointer
!= '\"')
3593 ++input_line_pointer
;
3596 FRAG_APPEND_1_CHAR (c
);
3600 if (warn_476
&& count
!= 0 && (now_seg
->flags
& SEC_CODE
) != 0)
3601 as_warn (_("data in executable section"));
3602 demand_empty_rest_of_line ();
3607 /* XCOFF specific pseudo-op handling. */
3609 /* This is set if we are creating a .stabx symbol, since we don't want
3610 to handle symbol suffixes for such symbols. */
3611 static bfd_boolean ppc_stab_symbol
;
3613 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3614 symbols in the .bss segment as though they were local common
3615 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3616 aligns .comm and .lcomm to 4 bytes. */
3619 ppc_comm (int lcomm
)
3621 asection
*current_seg
= now_seg
;
3622 subsegT current_subseg
= now_subseg
;
3628 symbolS
*lcomm_sym
= NULL
;
3632 name
= input_line_pointer
;
3633 endc
= get_symbol_end ();
3634 end_name
= input_line_pointer
;
3637 if (*input_line_pointer
!= ',')
3639 as_bad (_("missing size"));
3640 ignore_rest_of_line ();
3643 ++input_line_pointer
;
3645 size
= get_absolute_expression ();
3648 as_bad (_("negative size"));
3649 ignore_rest_of_line ();
3655 /* The third argument to .comm is the alignment. */
3656 if (*input_line_pointer
!= ',')
3660 ++input_line_pointer
;
3661 align
= get_absolute_expression ();
3664 as_warn (_("ignoring bad alignment"));
3674 /* The third argument to .lcomm appears to be the real local
3675 common symbol to create. References to the symbol named in
3676 the first argument are turned into references to the third
3678 if (*input_line_pointer
!= ',')
3680 as_bad (_("missing real symbol name"));
3681 ignore_rest_of_line ();
3684 ++input_line_pointer
;
3686 lcomm_name
= input_line_pointer
;
3687 lcomm_endc
= get_symbol_end ();
3689 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3691 *input_line_pointer
= lcomm_endc
;
3693 /* The fourth argument to .lcomm is the alignment. */
3694 if (*input_line_pointer
!= ',')
3703 ++input_line_pointer
;
3704 align
= get_absolute_expression ();
3707 as_warn (_("ignoring bad alignment"));
3714 sym
= symbol_find_or_make (name
);
3717 if (S_IS_DEFINED (sym
)
3718 || S_GET_VALUE (sym
) != 0)
3720 as_bad (_("attempt to redefine symbol"));
3721 ignore_rest_of_line ();
3725 record_alignment (bss_section
, align
);
3728 || ! S_IS_DEFINED (lcomm_sym
))
3737 S_SET_EXTERNAL (sym
);
3741 symbol_get_tc (lcomm_sym
)->output
= 1;
3742 def_sym
= lcomm_sym
;
3746 subseg_set (bss_section
, 1);
3747 frag_align (align
, 0, 0);
3749 symbol_set_frag (def_sym
, frag_now
);
3750 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3751 def_size
, (char *) NULL
);
3753 S_SET_SEGMENT (def_sym
, bss_section
);
3754 symbol_get_tc (def_sym
)->align
= align
;
3758 /* Align the size of lcomm_sym. */
3759 symbol_get_frag (lcomm_sym
)->fr_offset
=
3760 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3761 &~ ((1 << align
) - 1));
3762 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3763 symbol_get_tc (lcomm_sym
)->align
= align
;
3768 /* Make sym an offset from lcomm_sym. */
3769 S_SET_SEGMENT (sym
, bss_section
);
3770 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3771 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3772 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3775 subseg_set (current_seg
, current_subseg
);
3777 demand_empty_rest_of_line ();
3780 /* The .csect pseudo-op. This switches us into a different
3781 subsegment. The first argument is a symbol whose value is the
3782 start of the .csect. In COFF, csect symbols get special aux
3783 entries defined by the x_csect field of union internal_auxent. The
3784 optional second argument is the alignment (the default is 2). */
3787 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3794 name
= input_line_pointer
;
3795 endc
= get_symbol_end ();
3797 sym
= symbol_find_or_make (name
);
3799 *input_line_pointer
= endc
;
3801 if (S_GET_NAME (sym
)[0] == '\0')
3803 /* An unnamed csect is assumed to be [PR]. */
3804 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3808 if (*input_line_pointer
== ',')
3810 ++input_line_pointer
;
3811 align
= get_absolute_expression ();
3814 ppc_change_csect (sym
, align
);
3816 demand_empty_rest_of_line ();
3819 /* Change to a different csect. */
3822 ppc_change_csect (symbolS
*sym
, offsetT align
)
3824 if (S_IS_DEFINED (sym
))
3825 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3835 /* This is a new csect. We need to look at the symbol class to
3836 figure out whether it should go in the text section or the
3840 switch (symbol_get_tc (sym
)->symbol_class
)
3850 S_SET_SEGMENT (sym
, text_section
);
3851 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3852 ++ppc_text_subsegment
;
3853 list_ptr
= &ppc_text_csects
;
3863 if (ppc_toc_csect
!= NULL
3864 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3865 == ppc_data_subsegment
))
3867 S_SET_SEGMENT (sym
, data_section
);
3868 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3869 ++ppc_data_subsegment
;
3870 list_ptr
= &ppc_data_csects
;
3876 /* We set the obstack chunk size to a small value before
3877 changing subsegments, so that we don't use a lot of memory
3878 space for what may be a small section. */
3879 hold_chunksize
= chunksize
;
3882 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3883 symbol_get_tc (sym
)->subseg
);
3885 chunksize
= hold_chunksize
;
3888 ppc_after_toc_frag
= frag_now
;
3890 record_alignment (sec
, align
);
3892 frag_align_code (align
, 0);
3894 frag_align (align
, 0, 0);
3896 symbol_set_frag (sym
, frag_now
);
3897 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3899 symbol_get_tc (sym
)->align
= align
;
3900 symbol_get_tc (sym
)->output
= 1;
3901 symbol_get_tc (sym
)->within
= sym
;
3903 for (list
= *list_ptr
;
3904 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3905 list
= symbol_get_tc (list
)->next
)
3907 symbol_get_tc (list
)->next
= sym
;
3909 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3910 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3914 ppc_current_csect
= sym
;
3918 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3922 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3924 sec
= subseg_new (dw
->name
, subseg
);
3925 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3926 if (oldflags
== SEC_NO_FLAGS
)
3928 /* Just created section. */
3929 gas_assert (dw_sections
[idx
].sect
== NULL
);
3931 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3932 bfd_set_section_alignment (stdoutput
, sec
, 0);
3933 dw_sections
[idx
].sect
= sec
;
3936 /* Not anymore in a csect. */
3937 ppc_current_csect
= NULL
;
3940 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3941 .dwsect flag [, opt-label ]
3945 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3949 const struct xcoff_dwsect_name
*dw
;
3950 struct dw_subsection
*subseg
;
3951 struct dw_section
*dws
;
3955 flag
= get_absolute_expression ();
3957 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3958 if (xcoff_dwsect_names
[i
].flag
== flag
)
3960 dw
= &xcoff_dwsect_names
[i
];
3964 /* Parse opt-label. */
3965 if (*input_line_pointer
== ',')
3970 ++input_line_pointer
;
3972 label
= input_line_pointer
;
3973 c
= get_symbol_end ();
3974 opt_label
= symbol_find_or_make (label
);
3975 *input_line_pointer
= c
;
3980 demand_empty_rest_of_line ();
3982 /* Return now in case of unknown subsection. */
3985 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3990 /* Find the subsection. */
3991 dws
= &dw_sections
[i
];
3993 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3995 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3996 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3998 as_bad (_("label %s was not defined in this dwarf section"),
3999 S_GET_NAME (opt_label
));
4000 subseg
= dws
->anon_subseg
;
4004 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
4009 /* Switch to the subsection. */
4010 ppc_change_debug_section (i
, subseg
->subseg
);
4014 /* Create a new dw subsection. */
4015 subseg
= (struct dw_subsection
*)
4016 xmalloc (sizeof (struct dw_subsection
));
4018 if (opt_label
== NULL
)
4020 /* The anonymous one. */
4022 subseg
->link
= NULL
;
4023 dws
->anon_subseg
= subseg
;
4028 if (dws
->list_subseg
!= NULL
)
4029 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
4033 subseg
->link
= dws
->list_subseg
;
4034 dws
->list_subseg
= subseg
;
4035 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
4038 ppc_change_debug_section (i
, subseg
->subseg
);
4042 /* Add the length field. */
4043 expressionS
*exp
= &subseg
->end_exp
;
4046 if (opt_label
!= NULL
)
4047 symbol_set_value_now (opt_label
);
4049 /* Add the length field. Note that according to the AIX assembler
4050 manual, the size of the length field is 4 for powerpc32 but
4051 12 for powerpc64. */
4054 /* Write the 64bit marker. */
4055 md_number_to_chars (frag_more (4), -1, 4);
4058 exp
->X_op
= O_subtract
;
4059 exp
->X_op_symbol
= symbol_temp_new_now ();
4060 exp
->X_add_symbol
= symbol_temp_make ();
4062 sz
= ppc_obj64
? 8 : 4;
4063 exp
->X_add_number
= -sz
;
4064 emit_expr (exp
, sz
);
4069 /* This function handles the .text and .data pseudo-ops. These
4070 pseudo-ops aren't really used by XCOFF; we implement them for the
4071 convenience of people who aren't used to XCOFF. */
4074 ppc_section (int type
)
4081 else if (type
== 'd')
4086 sym
= symbol_find_or_make (name
);
4088 ppc_change_csect (sym
, 2);
4090 demand_empty_rest_of_line ();
4093 /* This function handles the .section pseudo-op. This is mostly to
4094 give an error, since XCOFF only supports .text, .data and .bss, but
4095 we do permit the user to name the text or data section. */
4098 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4101 const char *real_name
;
4105 user_name
= input_line_pointer
;
4106 c
= get_symbol_end ();
4108 if (strcmp (user_name
, ".text") == 0)
4109 real_name
= ".text[PR]";
4110 else if (strcmp (user_name
, ".data") == 0)
4111 real_name
= ".data[RW]";
4114 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4115 *input_line_pointer
= c
;
4116 ignore_rest_of_line ();
4120 *input_line_pointer
= c
;
4122 sym
= symbol_find_or_make (real_name
);
4124 ppc_change_csect (sym
, 2);
4126 demand_empty_rest_of_line ();
4129 /* The .extern pseudo-op. We create an undefined symbol. */
4132 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4137 name
= input_line_pointer
;
4138 endc
= get_symbol_end ();
4140 (void) symbol_find_or_make (name
);
4142 *input_line_pointer
= endc
;
4144 demand_empty_rest_of_line ();
4147 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4150 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4156 name
= input_line_pointer
;
4157 endc
= get_symbol_end ();
4159 sym
= symbol_find_or_make (name
);
4161 *input_line_pointer
= endc
;
4163 symbol_get_tc (sym
)->output
= 1;
4165 demand_empty_rest_of_line ();
4168 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4169 relocations at the beginning of the current csect.
4171 (In principle, there's no reason why the relocations _have_ to be at
4172 the beginning. Anywhere in the csect would do. However, inserting
4173 at the beginning is what the native assmebler does, and it helps to
4174 deal with cases where the .ref statements follow the section contents.)
4176 ??? .refs don't work for empty .csects. However, the native assembler
4177 doesn't report an error in this case, and neither yet do we. */
4180 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4185 if (ppc_current_csect
== NULL
)
4187 as_bad (_(".ref outside .csect"));
4188 ignore_rest_of_line ();
4194 name
= input_line_pointer
;
4195 c
= get_symbol_end ();
4197 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4198 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4200 *input_line_pointer
= c
;
4202 c
= *input_line_pointer
;
4205 input_line_pointer
++;
4207 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4209 as_bad (_("missing symbol name"));
4210 ignore_rest_of_line ();
4217 demand_empty_rest_of_line ();
4220 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4221 although I don't know why it bothers. */
4224 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4231 name
= input_line_pointer
;
4232 endc
= get_symbol_end ();
4234 sym
= symbol_find_or_make (name
);
4236 *input_line_pointer
= endc
;
4238 if (*input_line_pointer
!= ',')
4240 as_bad (_("missing rename string"));
4241 ignore_rest_of_line ();
4244 ++input_line_pointer
;
4246 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4248 demand_empty_rest_of_line ();
4251 /* The .stabx pseudo-op. This is similar to a normal .stabs
4252 pseudo-op, but slightly different. A sample is
4253 .stabx "main:F-1",.main,142,0
4254 The first argument is the symbol name to create. The second is the
4255 value, and the third is the storage class. The fourth seems to be
4256 always zero, and I am assuming it is the type. */
4259 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4266 name
= demand_copy_C_string (&len
);
4268 if (*input_line_pointer
!= ',')
4270 as_bad (_("missing value"));
4273 ++input_line_pointer
;
4275 ppc_stab_symbol
= TRUE
;
4276 sym
= symbol_make (name
);
4277 ppc_stab_symbol
= FALSE
;
4279 symbol_get_tc (sym
)->real_name
= name
;
4281 (void) expression (&exp
);
4288 as_bad (_("illegal .stabx expression; zero assumed"));
4289 exp
.X_add_number
= 0;
4292 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4293 symbol_set_frag (sym
, &zero_address_frag
);
4297 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4298 symbol_set_value_expression (sym
, &exp
);
4302 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4303 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4308 /* The value is some complex expression. This will probably
4309 fail at some later point, but this is probably the right
4310 thing to do here. */
4311 symbol_set_value_expression (sym
, &exp
);
4315 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4316 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4318 if (*input_line_pointer
!= ',')
4320 as_bad (_("missing class"));
4323 ++input_line_pointer
;
4325 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4327 if (*input_line_pointer
!= ',')
4329 as_bad (_("missing type"));
4332 ++input_line_pointer
;
4334 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4336 symbol_get_tc (sym
)->output
= 1;
4338 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4343 .stabx "z",arrays_,133,0
4346 .comm arrays_,13768,3
4348 resolve_symbol_value will copy the exp's "within" into sym's when the
4349 offset is 0. Since this seems to be corner case problem,
4350 only do the correction for storage class C_STSYM. A better solution
4351 would be to have the tc field updated in ppc_symbol_new_hook. */
4353 if (exp
.X_op
== O_symbol
)
4355 if (ppc_current_block
== NULL
)
4356 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4358 symbol_get_tc (sym
)->within
= ppc_current_block
;
4359 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4363 if (exp
.X_op
!= O_symbol
4364 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4365 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4366 ppc_frob_label (sym
);
4369 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4370 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4371 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4372 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4375 demand_empty_rest_of_line ();
4378 /* The .function pseudo-op. This takes several arguments. The first
4379 argument seems to be the external name of the symbol. The second
4380 argument seems to be the label for the start of the function. gcc
4381 uses the same name for both. I have no idea what the third and
4382 fourth arguments are meant to be. The optional fifth argument is
4383 an expression for the size of the function. In COFF this symbol
4384 gets an aux entry like that used for a csect. */
4387 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4395 name
= input_line_pointer
;
4396 endc
= get_symbol_end ();
4398 /* Ignore any [PR] suffix. */
4399 name
= ppc_canonicalize_symbol_name (name
);
4400 s
= strchr (name
, '[');
4401 if (s
!= (char *) NULL
4402 && strcmp (s
+ 1, "PR]") == 0)
4405 ext_sym
= symbol_find_or_make (name
);
4407 *input_line_pointer
= endc
;
4409 if (*input_line_pointer
!= ',')
4411 as_bad (_("missing symbol name"));
4412 ignore_rest_of_line ();
4415 ++input_line_pointer
;
4417 name
= input_line_pointer
;
4418 endc
= get_symbol_end ();
4420 lab_sym
= symbol_find_or_make (name
);
4422 *input_line_pointer
= endc
;
4424 if (ext_sym
!= lab_sym
)
4428 exp
.X_op
= O_symbol
;
4429 exp
.X_add_symbol
= lab_sym
;
4430 exp
.X_op_symbol
= NULL
;
4431 exp
.X_add_number
= 0;
4433 symbol_set_value_expression (ext_sym
, &exp
);
4436 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4437 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4438 symbol_get_tc (ext_sym
)->output
= 1;
4440 if (*input_line_pointer
== ',')
4444 /* Ignore the third argument. */
4445 ++input_line_pointer
;
4447 if (*input_line_pointer
== ',')
4449 /* Ignore the fourth argument. */
4450 ++input_line_pointer
;
4452 if (*input_line_pointer
== ',')
4454 /* The fifth argument is the function size. */
4455 ++input_line_pointer
;
4456 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4457 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4458 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4463 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4464 SF_SET_FUNCTION (ext_sym
);
4465 SF_SET_PROCESS (ext_sym
);
4466 coff_add_linesym (ext_sym
);
4468 demand_empty_rest_of_line ();
4471 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4472 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4473 with the correct line number */
4475 static symbolS
*saved_bi_sym
= 0;
4478 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4482 sym
= symbol_make (".bf");
4483 S_SET_SEGMENT (sym
, text_section
);
4484 symbol_set_frag (sym
, frag_now
);
4485 S_SET_VALUE (sym
, frag_now_fix ());
4486 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4488 coff_line_base
= get_absolute_expression ();
4490 S_SET_NUMBER_AUXILIARY (sym
, 1);
4491 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4493 /* Line number for bi. */
4496 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4501 symbol_get_tc (sym
)->output
= 1;
4503 ppc_frob_label (sym
);
4505 demand_empty_rest_of_line ();
4508 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4509 ".ef", except that the line number is absolute, not relative to the
4510 most recent ".bf" symbol. */
4513 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4517 sym
= symbol_make (".ef");
4518 S_SET_SEGMENT (sym
, text_section
);
4519 symbol_set_frag (sym
, frag_now
);
4520 S_SET_VALUE (sym
, frag_now_fix ());
4521 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4522 S_SET_NUMBER_AUXILIARY (sym
, 1);
4523 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4524 symbol_get_tc (sym
)->output
= 1;
4526 ppc_frob_label (sym
);
4528 demand_empty_rest_of_line ();
4531 /* The .bi and .ei pseudo-ops. These take a string argument and
4532 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4533 the symbol list. The value of .bi will be know when the next .bf
4539 static symbolS
*last_biei
;
4546 name
= demand_copy_C_string (&len
);
4548 /* The value of these symbols is actually file offset. Here we set
4549 the value to the index into the line number entries. In
4550 ppc_frob_symbols we set the fix_line field, which will cause BFD
4551 to do the right thing. */
4553 sym
= symbol_make (name
);
4554 /* obj-coff.c currently only handles line numbers correctly in the
4556 S_SET_SEGMENT (sym
, text_section
);
4557 S_SET_VALUE (sym
, coff_n_line_nos
);
4558 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4560 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4561 symbol_get_tc (sym
)->output
= 1;
4569 for (look
= last_biei
? last_biei
: symbol_rootP
;
4570 (look
!= (symbolS
*) NULL
4571 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4572 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4573 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4574 look
= symbol_next (look
))
4576 if (look
!= (symbolS
*) NULL
)
4578 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4579 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4583 demand_empty_rest_of_line ();
4586 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4587 There is one argument, which is a csect symbol. The value of the
4588 .bs symbol is the index of this csect symbol. */
4591 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4598 if (ppc_current_block
!= NULL
)
4599 as_bad (_("nested .bs blocks"));
4601 name
= input_line_pointer
;
4602 endc
= get_symbol_end ();
4604 csect
= symbol_find_or_make (name
);
4606 *input_line_pointer
= endc
;
4608 sym
= symbol_make (".bs");
4609 S_SET_SEGMENT (sym
, now_seg
);
4610 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4611 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4612 symbol_get_tc (sym
)->output
= 1;
4614 symbol_get_tc (sym
)->within
= csect
;
4616 ppc_frob_label (sym
);
4618 ppc_current_block
= sym
;
4620 demand_empty_rest_of_line ();
4623 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4626 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4630 if (ppc_current_block
== NULL
)
4631 as_bad (_(".es without preceding .bs"));
4633 sym
= symbol_make (".es");
4634 S_SET_SEGMENT (sym
, now_seg
);
4635 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4636 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4637 symbol_get_tc (sym
)->output
= 1;
4639 ppc_frob_label (sym
);
4641 ppc_current_block
= NULL
;
4643 demand_empty_rest_of_line ();
4646 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4650 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4654 sym
= symbol_make (".bb");
4655 S_SET_SEGMENT (sym
, text_section
);
4656 symbol_set_frag (sym
, frag_now
);
4657 S_SET_VALUE (sym
, frag_now_fix ());
4658 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4660 S_SET_NUMBER_AUXILIARY (sym
, 1);
4661 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4663 symbol_get_tc (sym
)->output
= 1;
4665 SF_SET_PROCESS (sym
);
4667 ppc_frob_label (sym
);
4669 demand_empty_rest_of_line ();
4672 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4676 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4680 sym
= symbol_make (".eb");
4681 S_SET_SEGMENT (sym
, text_section
);
4682 symbol_set_frag (sym
, frag_now
);
4683 S_SET_VALUE (sym
, frag_now_fix ());
4684 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4685 S_SET_NUMBER_AUXILIARY (sym
, 1);
4686 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4687 symbol_get_tc (sym
)->output
= 1;
4689 SF_SET_PROCESS (sym
);
4691 ppc_frob_label (sym
);
4693 demand_empty_rest_of_line ();
4696 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4700 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4706 name
= demand_copy_C_string (&len
);
4707 sym
= symbol_make (name
);
4708 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4709 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4710 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4711 S_SET_VALUE (sym
, 0);
4712 symbol_get_tc (sym
)->output
= 1;
4714 ppc_frob_label (sym
);
4716 demand_empty_rest_of_line ();
4719 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4722 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4726 sym
= symbol_make (".ec");
4727 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4728 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4729 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4730 S_SET_VALUE (sym
, 0);
4731 symbol_get_tc (sym
)->output
= 1;
4733 ppc_frob_label (sym
);
4735 demand_empty_rest_of_line ();
4738 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4741 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4743 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4744 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4751 subseg
= ppc_data_subsegment
;
4752 ++ppc_data_subsegment
;
4754 subseg_new (segment_name (data_section
), subseg
);
4755 ppc_toc_frag
= frag_now
;
4757 sym
= symbol_find_or_make ("TOC[TC0]");
4758 symbol_set_frag (sym
, frag_now
);
4759 S_SET_SEGMENT (sym
, data_section
);
4760 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4761 symbol_get_tc (sym
)->subseg
= subseg
;
4762 symbol_get_tc (sym
)->output
= 1;
4763 symbol_get_tc (sym
)->within
= sym
;
4765 ppc_toc_csect
= sym
;
4767 for (list
= ppc_data_csects
;
4768 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4769 list
= symbol_get_tc (list
)->next
)
4771 symbol_get_tc (list
)->next
= sym
;
4773 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4774 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4778 ppc_current_csect
= ppc_toc_csect
;
4780 demand_empty_rest_of_line ();
4783 /* The AIX assembler automatically aligns the operands of a .long or
4784 .short pseudo-op, and we want to be compatible. */
4787 ppc_xcoff_cons (int log_size
)
4789 frag_align (log_size
, 0, 0);
4790 record_alignment (now_seg
, log_size
);
4791 cons (1 << log_size
);
4795 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4800 (void) expression (&exp
);
4802 if (exp
.X_op
!= O_constant
)
4804 as_bad (_("non-constant byte count"));
4808 byte_count
= exp
.X_add_number
;
4810 if (*input_line_pointer
!= ',')
4812 as_bad (_("missing value"));
4816 ++input_line_pointer
;
4821 ppc_xcoff_end (void)
4825 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4827 struct dw_section
*dws
= &dw_sections
[i
];
4828 struct dw_subsection
*dwss
;
4830 if (dws
->anon_subseg
)
4832 dwss
= dws
->anon_subseg
;
4833 dwss
->link
= dws
->list_subseg
;
4836 dwss
= dws
->list_subseg
;
4838 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4839 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4841 subseg_set (dws
->sect
, dwss
->subseg
);
4842 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4847 #endif /* OBJ_XCOFF */
4848 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4850 /* The .tc pseudo-op. This is used when generating either XCOFF or
4851 ELF. This takes two or more arguments.
4853 When generating XCOFF output, the first argument is the name to
4854 give to this location in the toc; this will be a symbol with class
4855 TC. The rest of the arguments are N-byte values to actually put at
4856 this location in the TOC; often there is just one more argument, a
4857 relocatable symbol reference. The size of the value to store
4858 depends on target word size. A 32-bit target uses 4-byte values, a
4859 64-bit target uses 8-byte values.
4861 When not generating XCOFF output, the arguments are the same, but
4862 the first argument is simply ignored. */
4865 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4869 /* Define the TOC symbol name. */
4875 if (ppc_toc_csect
== (symbolS
*) NULL
4876 || ppc_toc_csect
!= ppc_current_csect
)
4878 as_bad (_(".tc not in .toc section"));
4879 ignore_rest_of_line ();
4883 name
= input_line_pointer
;
4884 endc
= get_symbol_end ();
4886 sym
= symbol_find_or_make (name
);
4888 *input_line_pointer
= endc
;
4890 if (S_IS_DEFINED (sym
))
4894 label
= symbol_get_tc (ppc_current_csect
)->within
;
4895 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4897 as_bad (_(".tc with no label"));
4898 ignore_rest_of_line ();
4902 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4903 symbol_set_frag (label
, symbol_get_frag (sym
));
4904 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4906 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4907 ++input_line_pointer
;
4912 S_SET_SEGMENT (sym
, now_seg
);
4913 symbol_set_frag (sym
, frag_now
);
4914 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4915 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4916 symbol_get_tc (sym
)->output
= 1;
4918 ppc_frob_label (sym
);
4921 #endif /* OBJ_XCOFF */
4925 /* Skip the TOC symbol name. */
4926 while (is_part_of_name (*input_line_pointer
)
4927 || *input_line_pointer
== ' '
4928 || *input_line_pointer
== '['
4929 || *input_line_pointer
== ']'
4930 || *input_line_pointer
== '{'
4931 || *input_line_pointer
== '}')
4932 ++input_line_pointer
;
4934 /* Align to a four/eight byte boundary. */
4935 align
= ppc_obj64
? 3 : 2;
4936 frag_align (align
, 0, 0);
4937 record_alignment (now_seg
, align
);
4938 #endif /* OBJ_ELF */
4940 if (*input_line_pointer
!= ',')
4941 demand_empty_rest_of_line ();
4944 ++input_line_pointer
;
4945 cons (ppc_obj64
? 8 : 4);
4949 /* Pseudo-op .machine. */
4952 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4955 #define MAX_HISTORY 100
4956 static ppc_cpu_t
*cpu_history
;
4957 static int curr_hist
;
4961 if (*input_line_pointer
== '"')
4964 cpu_string
= demand_copy_C_string (&len
);
4969 cpu_string
= input_line_pointer
;
4970 c
= get_symbol_end ();
4971 cpu_string
= xstrdup (cpu_string
);
4972 *input_line_pointer
= c
;
4975 if (cpu_string
!= NULL
)
4977 ppc_cpu_t old_cpu
= ppc_cpu
;
4981 for (p
= cpu_string
; *p
!= 0; p
++)
4984 if (strcmp (cpu_string
, "push") == 0)
4986 if (cpu_history
== NULL
)
4987 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4989 if (curr_hist
>= MAX_HISTORY
)
4990 as_bad (_(".machine stack overflow"));
4992 cpu_history
[curr_hist
++] = ppc_cpu
;
4994 else if (strcmp (cpu_string
, "pop") == 0)
4997 as_bad (_(".machine stack underflow"));
4999 ppc_cpu
= cpu_history
[--curr_hist
];
5001 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
5004 as_bad (_("invalid machine `%s'"), cpu_string
);
5006 if (ppc_cpu
!= old_cpu
)
5007 ppc_setup_opcodes ();
5010 demand_empty_rest_of_line ();
5012 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5016 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
5018 /* Set the current section. */
5020 ppc_set_current_section (segT
new)
5022 ppc_previous_section
= ppc_current_section
;
5023 ppc_current_section
= new;
5026 /* pseudo-op: .previous
5027 behaviour: toggles the current section with the previous section.
5029 warnings: "No previous section" */
5032 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
5034 if (ppc_previous_section
== NULL
)
5036 as_warn (_("no previous section to return to, ignored."));
5040 subseg_set (ppc_previous_section
, 0);
5042 ppc_set_current_section (ppc_previous_section
);
5045 /* pseudo-op: .pdata
5046 behaviour: predefined read only data section
5050 initial: .section .pdata "adr3"
5051 a - don't know -- maybe a misprint
5052 d - initialized data
5054 3 - double word aligned (that would be 4 byte boundary)
5057 Tag index tables (also known as the function table) for exception
5058 handling, debugging, etc. */
5061 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
5063 if (pdata_section
== 0)
5065 pdata_section
= subseg_new (".pdata", 0);
5067 bfd_set_section_flags (stdoutput
, pdata_section
,
5068 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5069 | SEC_READONLY
| SEC_DATA
));
5071 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5075 pdata_section
= subseg_new (".pdata", 0);
5077 ppc_set_current_section (pdata_section
);
5080 /* pseudo-op: .ydata
5081 behaviour: predefined read only data section
5085 initial: .section .ydata "drw3"
5086 a - don't know -- maybe a misprint
5087 d - initialized data
5089 3 - double word aligned (that would be 4 byte boundary)
5091 Tag tables (also known as the scope table) for exception handling,
5095 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5097 if (ydata_section
== 0)
5099 ydata_section
= subseg_new (".ydata", 0);
5100 bfd_set_section_flags (stdoutput
, ydata_section
,
5101 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5102 | SEC_READONLY
| SEC_DATA
));
5104 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5108 ydata_section
= subseg_new (".ydata", 0);
5110 ppc_set_current_section (ydata_section
);
5113 /* pseudo-op: .reldata
5114 behaviour: predefined read write data section
5115 double word aligned (4-byte)
5116 FIXME: relocation is applied to it
5117 FIXME: what's the difference between this and .data?
5120 initial: .section .reldata "drw3"
5121 d - initialized data
5124 3 - double word aligned (that would be 8 byte boundary)
5127 Like .data, but intended to hold data subject to relocation, such as
5128 function descriptors, etc. */
5131 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5133 if (reldata_section
== 0)
5135 reldata_section
= subseg_new (".reldata", 0);
5137 bfd_set_section_flags (stdoutput
, reldata_section
,
5138 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5141 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5145 reldata_section
= subseg_new (".reldata", 0);
5147 ppc_set_current_section (reldata_section
);
5150 /* pseudo-op: .rdata
5151 behaviour: predefined read only data section
5155 initial: .section .rdata "dr3"
5156 d - initialized data
5158 3 - double word aligned (that would be 4 byte boundary) */
5161 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5163 if (rdata_section
== 0)
5165 rdata_section
= subseg_new (".rdata", 0);
5166 bfd_set_section_flags (stdoutput
, rdata_section
,
5167 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5168 | SEC_READONLY
| SEC_DATA
));
5170 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5174 rdata_section
= subseg_new (".rdata", 0);
5176 ppc_set_current_section (rdata_section
);
5179 /* pseudo-op: .ualong
5180 behaviour: much like .int, with the exception that no alignment is
5182 FIXME: test the alignment statement
5187 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5193 /* pseudo-op: .znop <symbol name>
5194 behaviour: Issue a nop instruction
5195 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5196 the supplied symbol name.
5198 warnings: Missing symbol name */
5201 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5204 const struct powerpc_opcode
*opcode
;
5211 /* Strip out the symbol name. */
5212 symbol_name
= input_line_pointer
;
5213 c
= get_symbol_end ();
5215 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5216 strcpy (name
, symbol_name
);
5218 sym
= symbol_find_or_make (name
);
5220 *input_line_pointer
= c
;
5224 /* Look up the opcode in the hash table. */
5225 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5227 /* Stick in the nop. */
5228 insn
= opcode
->opcode
;
5230 /* Write out the instruction. */
5232 md_number_to_chars (f
, insn
, 4);
5234 f
- frag_now
->fr_literal
,
5239 BFD_RELOC_16_GOT_PCREL
);
5249 ppc_pe_comm (int lcomm
)
5258 name
= input_line_pointer
;
5259 c
= get_symbol_end ();
5261 /* just after name is now '\0'. */
5262 p
= input_line_pointer
;
5265 if (*input_line_pointer
!= ',')
5267 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5268 ignore_rest_of_line ();
5272 input_line_pointer
++; /* skip ',' */
5273 if ((temp
= get_absolute_expression ()) < 0)
5275 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5276 ignore_rest_of_line ();
5282 /* The third argument to .comm is the alignment. */
5283 if (*input_line_pointer
!= ',')
5287 ++input_line_pointer
;
5288 align
= get_absolute_expression ();
5291 as_warn (_("ignoring bad alignment"));
5298 symbolP
= symbol_find_or_make (name
);
5301 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5303 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5304 S_GET_NAME (symbolP
));
5305 ignore_rest_of_line ();
5309 if (S_GET_VALUE (symbolP
))
5311 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5312 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5313 S_GET_NAME (symbolP
),
5314 (long) S_GET_VALUE (symbolP
),
5319 S_SET_VALUE (symbolP
, (valueT
) temp
);
5320 S_SET_EXTERNAL (symbolP
);
5321 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5324 demand_empty_rest_of_line ();
5328 * implement the .section pseudo op:
5329 * .section name {, "flags"}
5331 * | +--- optional flags: 'b' for bss
5333 * +-- section name 'l' for lib
5337 * 'd' (apparently m88k for data)
5339 * But if the argument is not a quoted string, treat it as a
5340 * subsegment number.
5342 * FIXME: this is a copy of the section processing from obj-coff.c, with
5343 * additions/changes for the moto-pas assembler support. There are three
5346 * FIXME: I just noticed this. This doesn't work at all really. It it
5347 * setting bits that bfd probably neither understands or uses. The
5348 * correct approach (?) will have to incorporate extra fields attached
5349 * to the section to hold the system specific stuff. (krk)
5352 * 'a' - unknown - referred to in documentation, but no definition supplied
5353 * 'c' - section has code
5354 * 'd' - section has initialized data
5355 * 'u' - section has uninitialized data
5356 * 'i' - section contains directives (info)
5357 * 'n' - section can be discarded
5358 * 'R' - remove section at link time
5360 * Section Protection:
5361 * 'r' - section is readable
5362 * 'w' - section is writeable
5363 * 'x' - section is executable
5364 * 's' - section is sharable
5366 * Section Alignment:
5367 * '0' - align to byte boundary
5368 * '1' - align to halfword undary
5369 * '2' - align to word boundary
5370 * '3' - align to doubleword boundary
5371 * '4' - align to quadword boundary
5372 * '5' - align to 32 byte boundary
5373 * '6' - align to 64 byte boundary
5378 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5380 /* Strip out the section name. */
5389 section_name
= input_line_pointer
;
5390 c
= get_symbol_end ();
5392 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5393 strcpy (name
, section_name
);
5395 *input_line_pointer
= c
;
5400 flags
= SEC_NO_FLAGS
;
5402 if (strcmp (name
, ".idata$2") == 0)
5406 else if (strcmp (name
, ".idata$3") == 0)
5410 else if (strcmp (name
, ".idata$4") == 0)
5414 else if (strcmp (name
, ".idata$5") == 0)
5418 else if (strcmp (name
, ".idata$6") == 0)
5423 /* Default alignment to 16 byte boundary. */
5426 if (*input_line_pointer
== ',')
5428 ++input_line_pointer
;
5430 if (*input_line_pointer
!= '"')
5431 exp
= get_absolute_expression ();
5434 ++input_line_pointer
;
5435 while (*input_line_pointer
!= '"'
5436 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5438 switch (*input_line_pointer
)
5440 /* Section Contents */
5441 case 'a': /* unknown */
5442 as_bad (_("unsupported section attribute -- 'a'"));
5444 case 'c': /* code section */
5447 case 'd': /* section has initialized data */
5450 case 'u': /* section has uninitialized data */
5451 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5455 case 'i': /* section contains directives (info) */
5456 /* FIXME: This is IMAGE_SCN_LNK_INFO
5458 flags
|= SEC_HAS_CONTENTS
;
5460 case 'n': /* section can be discarded */
5463 case 'R': /* Remove section at link time */
5464 flags
|= SEC_NEVER_LOAD
;
5466 #if IFLICT_BRAIN_DAMAGE
5467 /* Section Protection */
5468 case 'r': /* section is readable */
5469 flags
|= IMAGE_SCN_MEM_READ
;
5471 case 'w': /* section is writeable */
5472 flags
|= IMAGE_SCN_MEM_WRITE
;
5474 case 'x': /* section is executable */
5475 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5477 case 's': /* section is sharable */
5478 flags
|= IMAGE_SCN_MEM_SHARED
;
5481 /* Section Alignment */
5482 case '0': /* align to byte boundary */
5483 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5486 case '1': /* align to halfword boundary */
5487 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5490 case '2': /* align to word boundary */
5491 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5494 case '3': /* align to doubleword boundary */
5495 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5498 case '4': /* align to quadword boundary */
5499 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5502 case '5': /* align to 32 byte boundary */
5503 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5506 case '6': /* align to 64 byte boundary */
5507 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5512 as_bad (_("unknown section attribute '%c'"),
5513 *input_line_pointer
);
5516 ++input_line_pointer
;
5518 if (*input_line_pointer
== '"')
5519 ++input_line_pointer
;
5523 sec
= subseg_new (name
, (subsegT
) exp
);
5525 ppc_set_current_section (sec
);
5527 if (flags
!= SEC_NO_FLAGS
)
5529 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5530 as_bad (_("error setting flags for \"%s\": %s"),
5531 bfd_section_name (stdoutput
, sec
),
5532 bfd_errmsg (bfd_get_error ()));
5535 bfd_set_section_alignment (stdoutput
, sec
, align
);
5539 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5545 name
= input_line_pointer
;
5546 endc
= get_symbol_end ();
5548 ext_sym
= symbol_find_or_make (name
);
5550 *input_line_pointer
= endc
;
5552 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5553 SF_SET_FUNCTION (ext_sym
);
5554 SF_SET_PROCESS (ext_sym
);
5555 coff_add_linesym (ext_sym
);
5557 demand_empty_rest_of_line ();
5561 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5563 if (tocdata_section
== 0)
5565 tocdata_section
= subseg_new (".tocd", 0);
5566 /* FIXME: section flags won't work. */
5567 bfd_set_section_flags (stdoutput
, tocdata_section
,
5568 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5569 | SEC_READONLY
| SEC_DATA
));
5571 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5575 rdata_section
= subseg_new (".tocd", 0);
5578 ppc_set_current_section (tocdata_section
);
5580 demand_empty_rest_of_line ();
5583 /* Don't adjust TOC relocs to use the section symbol. */
5586 ppc_pe_fix_adjustable (fixS
*fix
)
5588 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5595 /* XCOFF specific symbol and file handling. */
5597 /* Canonicalize the symbol name. We use the to force the suffix, if
5598 any, to use square brackets, and to be in upper case. */
5601 ppc_canonicalize_symbol_name (char *name
)
5605 if (ppc_stab_symbol
)
5608 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5622 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5625 if (*s
== '\0' || s
[1] != '\0')
5626 as_bad (_("bad symbol suffix"));
5634 /* Set the class of a symbol based on the suffix, if any. This is
5635 called whenever a new symbol is created. */
5638 ppc_symbol_new_hook (symbolS
*sym
)
5640 struct ppc_tc_sy
*tc
;
5643 tc
= symbol_get_tc (sym
);
5646 tc
->symbol_class
= -1;
5647 tc
->real_name
= NULL
;
5654 if (ppc_stab_symbol
)
5657 s
= strchr (S_GET_NAME (sym
), '[');
5658 if (s
== (const char *) NULL
)
5660 /* There is no suffix. */
5669 if (strcmp (s
, "BS]") == 0)
5670 tc
->symbol_class
= XMC_BS
;
5673 if (strcmp (s
, "DB]") == 0)
5674 tc
->symbol_class
= XMC_DB
;
5675 else if (strcmp (s
, "DS]") == 0)
5676 tc
->symbol_class
= XMC_DS
;
5679 if (strcmp (s
, "GL]") == 0)
5680 tc
->symbol_class
= XMC_GL
;
5683 if (strcmp (s
, "PR]") == 0)
5684 tc
->symbol_class
= XMC_PR
;
5687 if (strcmp (s
, "RO]") == 0)
5688 tc
->symbol_class
= XMC_RO
;
5689 else if (strcmp (s
, "RW]") == 0)
5690 tc
->symbol_class
= XMC_RW
;
5693 if (strcmp (s
, "SV]") == 0)
5694 tc
->symbol_class
= XMC_SV
;
5697 if (strcmp (s
, "TC]") == 0)
5698 tc
->symbol_class
= XMC_TC
;
5699 else if (strcmp (s
, "TI]") == 0)
5700 tc
->symbol_class
= XMC_TI
;
5701 else if (strcmp (s
, "TB]") == 0)
5702 tc
->symbol_class
= XMC_TB
;
5703 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5704 tc
->symbol_class
= XMC_TC0
;
5707 if (strcmp (s
, "UA]") == 0)
5708 tc
->symbol_class
= XMC_UA
;
5709 else if (strcmp (s
, "UC]") == 0)
5710 tc
->symbol_class
= XMC_UC
;
5713 if (strcmp (s
, "XO]") == 0)
5714 tc
->symbol_class
= XMC_XO
;
5718 if (tc
->symbol_class
== -1)
5719 as_bad (_("unrecognized symbol suffix"));
5722 /* Set the class of a label based on where it is defined. This
5723 handles symbols without suffixes. Also, move the symbol so that it
5724 follows the csect symbol. */
5727 ppc_frob_label (symbolS
*sym
)
5729 if (ppc_current_csect
!= (symbolS
*) NULL
)
5731 if (symbol_get_tc (sym
)->symbol_class
== -1)
5732 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5734 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5735 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5736 &symbol_rootP
, &symbol_lastP
);
5737 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5738 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5742 dwarf2_emit_label (sym
);
5746 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5747 seen. It tells ppc_adjust_symtab whether it needs to look through
5750 static bfd_boolean ppc_saw_abs
;
5752 /* Change the name of a symbol just before writing it out. Set the
5753 real name if the .rename pseudo-op was used. Otherwise, remove any
5754 class suffix. Return 1 if the symbol should not be included in the
5758 ppc_frob_symbol (symbolS
*sym
)
5760 static symbolS
*ppc_last_function
;
5761 static symbolS
*set_end
;
5763 /* Discard symbols that should not be included in the output symbol
5765 if (! symbol_used_in_reloc_p (sym
)
5766 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5767 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5768 && ! symbol_get_tc (sym
)->output
5769 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5772 /* This one will disappear anyway. Don't make a csect sym for it. */
5773 if (sym
== abs_section_sym
)
5776 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5777 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5783 name
= S_GET_NAME (sym
);
5784 s
= strchr (name
, '[');
5785 if (s
!= (char *) NULL
)
5791 snew
= xmalloc (len
+ 1);
5792 memcpy (snew
, name
, len
);
5795 S_SET_NAME (sym
, snew
);
5799 if (set_end
!= (symbolS
*) NULL
)
5801 SA_SET_SYM_ENDNDX (set_end
, sym
);
5805 if (SF_GET_FUNCTION (sym
))
5807 if (ppc_last_function
!= (symbolS
*) NULL
)
5808 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5809 ppc_last_function
= sym
;
5810 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5812 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5813 SA_SET_SYM_FSIZE (sym
,
5814 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5817 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5818 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5820 if (ppc_last_function
== (symbolS
*) NULL
)
5821 as_bad (_(".ef with no preceding .function"));
5824 set_end
= ppc_last_function
;
5825 ppc_last_function
= NULL
;
5827 /* We don't have a C_EFCN symbol, but we need to force the
5828 COFF backend to believe that it has seen one. */
5829 coff_last_function
= NULL
;
5833 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5834 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5835 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5836 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5837 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5838 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5839 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5840 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5841 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5842 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5843 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5845 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5846 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5847 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5850 union internal_auxent
*a
;
5852 /* Create a csect aux. */
5853 i
= S_GET_NUMBER_AUXILIARY (sym
);
5854 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5855 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5856 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5858 /* This is the TOC table. */
5859 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5860 a
->x_csect
.x_scnlen
.l
= 0;
5861 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5863 else if (symbol_get_tc (sym
)->subseg
!= 0)
5865 /* This is a csect symbol. x_scnlen is the size of the
5867 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5868 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5869 S_GET_SEGMENT (sym
))
5870 - S_GET_VALUE (sym
));
5873 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5874 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5875 - S_GET_VALUE (sym
));
5877 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5879 else if (S_GET_SEGMENT (sym
) == bss_section
)
5881 /* This is a common symbol. */
5882 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5883 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5884 if (S_IS_EXTERNAL (sym
))
5885 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5887 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5889 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5891 /* This is an absolute symbol. The csect will be created by
5892 ppc_adjust_symtab. */
5894 a
->x_csect
.x_smtyp
= XTY_LD
;
5895 if (symbol_get_tc (sym
)->symbol_class
== -1)
5896 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5898 else if (! S_IS_DEFINED (sym
))
5900 /* This is an external symbol. */
5901 a
->x_csect
.x_scnlen
.l
= 0;
5902 a
->x_csect
.x_smtyp
= XTY_ER
;
5904 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5908 /* This is a TOC definition. x_scnlen is the size of the
5910 next
= symbol_next (sym
);
5911 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5912 next
= symbol_next (next
);
5913 if (next
== (symbolS
*) NULL
5914 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5916 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5917 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5919 - S_GET_VALUE (sym
));
5921 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5922 - S_GET_VALUE (sym
));
5926 resolve_symbol_value (next
);
5927 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5928 - S_GET_VALUE (sym
));
5930 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5936 /* This is a normal symbol definition. x_scnlen is the
5937 symbol index of the containing csect. */
5938 if (S_GET_SEGMENT (sym
) == text_section
)
5939 csect
= ppc_text_csects
;
5940 else if (S_GET_SEGMENT (sym
) == data_section
)
5941 csect
= ppc_data_csects
;
5945 /* Skip the initial dummy symbol. */
5946 csect
= symbol_get_tc (csect
)->next
;
5948 if (csect
== (symbolS
*) NULL
)
5950 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5951 a
->x_csect
.x_scnlen
.l
= 0;
5955 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5957 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5958 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5959 > S_GET_VALUE (sym
))
5961 csect
= symbol_get_tc (csect
)->next
;
5964 a
->x_csect
.x_scnlen
.p
=
5965 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5966 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5969 a
->x_csect
.x_smtyp
= XTY_LD
;
5972 a
->x_csect
.x_parmhash
= 0;
5973 a
->x_csect
.x_snhash
= 0;
5974 if (symbol_get_tc (sym
)->symbol_class
== -1)
5975 a
->x_csect
.x_smclas
= XMC_PR
;
5977 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5978 a
->x_csect
.x_stab
= 0;
5979 a
->x_csect
.x_snstab
= 0;
5981 /* Don't let the COFF backend resort these symbols. */
5982 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5984 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5986 /* We want the value to be the symbol index of the referenced
5987 csect symbol. BFD will do that for us if we set the right
5989 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5990 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5992 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5993 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5995 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
6000 block
= symbol_get_tc (sym
)->within
;
6003 /* The value is the offset from the enclosing csect. */
6006 csect
= symbol_get_tc (block
)->within
;
6007 resolve_symbol_value (csect
);
6008 base
= S_GET_VALUE (csect
);
6013 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
6015 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
6016 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
6018 /* We want the value to be a file offset into the line numbers.
6019 BFD will do that for us if we set the right flags. We have
6020 already set the value correctly. */
6021 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
6027 /* Adjust the symbol table. This creates csect symbols for all
6028 absolute symbols. */
6031 ppc_adjust_symtab (void)
6038 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
6042 union internal_auxent
*a
;
6044 if (S_GET_SEGMENT (sym
) != absolute_section
)
6047 csect
= symbol_create (".abs[XO]", absolute_section
,
6048 S_GET_VALUE (sym
), &zero_address_frag
);
6049 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
6050 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
6051 i
= S_GET_NUMBER_AUXILIARY (csect
);
6052 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
6053 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
6054 a
->x_csect
.x_scnlen
.l
= 0;
6055 a
->x_csect
.x_smtyp
= XTY_SD
;
6056 a
->x_csect
.x_parmhash
= 0;
6057 a
->x_csect
.x_snhash
= 0;
6058 a
->x_csect
.x_smclas
= XMC_XO
;
6059 a
->x_csect
.x_stab
= 0;
6060 a
->x_csect
.x_snstab
= 0;
6062 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
6064 i
= S_GET_NUMBER_AUXILIARY (sym
);
6065 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
6066 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
6067 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
6070 ppc_saw_abs
= FALSE
;
6073 /* Set the VMA for a section. This is called on all the sections in
6077 ppc_frob_section (asection
*sec
)
6079 static bfd_vma vma
= 0;
6081 /* Dwarf sections start at 0. */
6082 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6085 vma
= md_section_align (sec
, vma
);
6086 bfd_set_section_vma (stdoutput
, sec
, vma
);
6087 vma
+= bfd_section_size (stdoutput
, sec
);
6090 #endif /* OBJ_XCOFF */
6093 md_atof (int type
, char *litp
, int *sizep
)
6095 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6098 /* Write a value out to the object file, using the appropriate
6102 md_number_to_chars (char *buf
, valueT val
, int n
)
6104 if (target_big_endian
)
6105 number_to_chars_bigendian (buf
, val
, n
);
6107 number_to_chars_littleendian (buf
, val
, n
);
6110 /* Align a section (I don't know why this is machine dependent). */
6113 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6118 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6120 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
6124 /* We don't have any form of relaxing. */
6127 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6128 asection
*seg ATTRIBUTE_UNUSED
)
6134 /* Convert a machine dependent frag. We never generate these. */
6137 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6138 asection
*sec ATTRIBUTE_UNUSED
,
6139 fragS
*fragp ATTRIBUTE_UNUSED
)
6144 /* We have no need to default values of symbols. */
6147 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6152 /* Functions concerning relocs. */
6154 /* The location from which a PC relative jump should be calculated,
6155 given a PC relative reloc. */
6158 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6160 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6165 /* This is called to see whether a fixup should be adjusted to use a
6166 section symbol. We take the opportunity to change a fixup against
6167 a symbol in the TOC subsegment into a reloc against the
6168 corresponding .tc symbol. */
6171 ppc_fix_adjustable (fixS
*fix
)
6173 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6174 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6175 TC_SYMFIELD_TYPE
*tc
;
6177 if (symseg
== absolute_section
)
6180 /* Always adjust symbols in debugging sections. */
6181 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6184 if (ppc_toc_csect
!= (symbolS
*) NULL
6185 && fix
->fx_addsy
!= ppc_toc_csect
6186 && symseg
== data_section
6187 && val
>= ppc_toc_frag
->fr_address
6188 && (ppc_after_toc_frag
== (fragS
*) NULL
6189 || val
< ppc_after_toc_frag
->fr_address
))
6193 for (sy
= symbol_next (ppc_toc_csect
);
6194 sy
!= (symbolS
*) NULL
;
6195 sy
= symbol_next (sy
))
6197 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6199 if (sy_tc
->symbol_class
== XMC_TC0
)
6201 if (sy_tc
->symbol_class
!= XMC_TC
)
6203 if (val
== resolve_symbol_value (sy
))
6206 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6211 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6212 _("symbol in .toc does not match any .tc"));
6215 /* Possibly adjust the reloc to be against the csect. */
6216 tc
= symbol_get_tc (fix
->fx_addsy
);
6218 && tc
->symbol_class
!= XMC_TC0
6219 && tc
->symbol_class
!= XMC_TC
6220 && symseg
!= bss_section
6221 /* Don't adjust if this is a reloc in the toc section. */
6222 && (symseg
!= data_section
6223 || ppc_toc_csect
== NULL
6224 || val
< ppc_toc_frag
->fr_address
6225 || (ppc_after_toc_frag
!= NULL
6226 && val
>= ppc_after_toc_frag
->fr_address
)))
6228 symbolS
*csect
= tc
->within
;
6230 /* If the symbol was not declared by a label (eg: a section symbol),
6231 use the section instead of the csect. This doesn't happen in
6232 normal AIX assembly code. */
6234 csect
= seg_info (symseg
)->sym
;
6236 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6237 fix
->fx_addsy
= csect
;
6242 /* Adjust a reloc against a .lcomm symbol to be against the base
6244 if (symseg
== bss_section
6245 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6247 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6249 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6256 /* A reloc from one csect to another must be kept. The assembler
6257 will, of course, keep relocs between sections, and it will keep
6258 absolute relocs, but we need to force it to keep PC relative relocs
6259 between two csects in the same section. */
6262 ppc_force_relocation (fixS
*fix
)
6264 /* At this point fix->fx_addsy should already have been converted to
6265 a csect symbol. If the csect does not include the fragment, then
6266 we need to force the relocation. */
6268 && fix
->fx_addsy
!= NULL
6269 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6270 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6271 > fix
->fx_frag
->fr_address
)
6272 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6273 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6274 <= fix
->fx_frag
->fr_address
))))
6277 return generic_force_reloc (fix
);
6281 ppc_new_dot_label (symbolS
*sym
)
6283 /* Anchor this label to the current csect for relocations. */
6284 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6287 #endif /* OBJ_XCOFF */
6290 /* If this function returns non-zero, it guarantees that a relocation
6291 will be emitted for a fixup. */
6294 ppc_force_relocation (fixS
*fix
)
6296 /* Branch prediction relocations must force a relocation, as must
6297 the vtable description relocs. */
6298 switch (fix
->fx_r_type
)
6300 case BFD_RELOC_PPC_B16_BRTAKEN
:
6301 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6302 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6303 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6304 case BFD_RELOC_24_PLT_PCREL
:
6305 case BFD_RELOC_PPC64_TOC
:
6307 case BFD_RELOC_PPC_B26
:
6308 case BFD_RELOC_PPC_BA26
:
6309 case BFD_RELOC_PPC_B16
:
6310 case BFD_RELOC_PPC_BA16
:
6311 /* All branch fixups targeting a localentry symbol must
6312 force a relocation. */
6315 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6316 elf_symbol_type
*elfsym
6317 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6318 gas_assert (elfsym
);
6319 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6327 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6328 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6331 return generic_force_reloc (fix
);
6335 ppc_fix_adjustable (fixS
*fix
)
6337 switch (fix
->fx_r_type
)
6339 /* All branch fixups targeting a localentry symbol must
6340 continue using the symbol. */
6341 case BFD_RELOC_PPC_B26
:
6342 case BFD_RELOC_PPC_BA26
:
6343 case BFD_RELOC_PPC_B16
:
6344 case BFD_RELOC_PPC_BA16
:
6345 case BFD_RELOC_PPC_B16_BRTAKEN
:
6346 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6347 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6348 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6351 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6352 elf_symbol_type
*elfsym
6353 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6354 gas_assert (elfsym
);
6355 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6363 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6364 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6365 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6366 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6367 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6368 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6369 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6370 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6371 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6372 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6373 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6378 ppc_frag_check (struct frag
*fragP
)
6380 if (!fragP
->has_code
)
6383 if (ppc_mach() == bfd_mach_ppc_vle
)
6385 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6386 as_bad (_("instruction address is not a multiple of 2"));
6390 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6391 as_bad (_("instruction address is not a multiple of 4"));
6395 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6396 rs_align_code frag. */
6399 ppc_handle_align (struct frag
*fragP
)
6401 valueT count
= (fragP
->fr_next
->fr_address
6402 - (fragP
->fr_address
+ fragP
->fr_fix
));
6404 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6406 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6409 md_number_to_chars (dest
, 0x4400, 2);
6411 else if (count
!= 0 && (count
& 3) == 0)
6413 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6417 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6421 /* Make a branch, then follow with nops. Insert another
6422 frag to handle the nops. */
6423 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6428 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6429 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6430 fragP
->fr_next
= rest
;
6432 rest
->fr_address
+= rest
->fr_fix
+ 4;
6434 /* If we leave the next frag as rs_align_code we'll come here
6435 again, resulting in a bunch of branches rather than a
6436 branch followed by nops. */
6437 rest
->fr_type
= rs_align
;
6438 dest
= rest
->fr_literal
;
6441 md_number_to_chars (dest
, 0x60000000, 4);
6443 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6444 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6445 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6447 /* For power6, power7 and power8, we want the last nop to be a group
6448 terminating one. Do this by inserting an rs_fill frag immediately
6449 after this one, with its address set to the last nop location.
6450 This will automatically reduce the number of nops in the current
6454 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6456 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6457 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6458 group_nop
->fr_fix
= 0;
6459 group_nop
->fr_offset
= 1;
6460 group_nop
->fr_type
= rs_fill
;
6461 fragP
->fr_next
= group_nop
;
6462 dest
= group_nop
->fr_literal
;
6465 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6466 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6468 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6469 /* e500mc group terminating nop: "ori 0,0,0". */
6470 md_number_to_chars (dest
, 0x60000000, 4);
6472 /* power7/power8 group terminating nop: "ori 2,2,0". */
6473 md_number_to_chars (dest
, 0x60420000, 4);
6476 /* power6 group terminating nop: "ori 1,1,0". */
6477 md_number_to_chars (dest
, 0x60210000, 4);
6482 /* Apply a fixup to the object code. This is called for all the
6483 fixups we generated by the calls to fix_new_exp, above. */
6486 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg
)
6488 valueT value
= * valP
;
6490 const struct powerpc_operand
*operand
;
6493 if (fixP
->fx_addsy
!= NULL
)
6495 /* Hack around bfd_install_relocation brain damage. */
6497 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6502 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6503 the symbol values. If we are doing this relocation the code in
6504 write.c is going to call bfd_install_relocation, which is also
6505 going to use the symbol value. That means that if the reloc is
6506 fully resolved we want to use *valP since bfd_install_relocation is
6508 However, if the reloc is not fully resolved we do not want to
6509 use *valP, and must use fx_offset instead. If the relocation
6510 is PC-relative, we then need to re-apply md_pcrel_from_section
6511 to this new relocation value. */
6512 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6517 value
= fixP
->fx_offset
;
6519 value
-= md_pcrel_from_section (fixP
, seg
);
6523 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6525 /* We can't actually support subtracting a symbol. */
6526 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6530 if (fixP
->fx_pcrel_adjust
!= 0)
6532 /* This is a fixup on an instruction. */
6533 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6535 operand
= &powerpc_operands
[opindex
];
6537 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6538 does not generate a reloc. It uses the offset of `sym' within its
6539 csect. Other usages, such as `.long sym', generate relocs. This
6540 is the documented behaviour of non-TOC symbols. */
6541 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6542 && (operand
->bitm
& 0xfff0) == 0xfff0
6543 && operand
->shift
== 0
6544 && (operand
->insert
== NULL
|| ppc_obj64
)
6545 && fixP
->fx_addsy
!= NULL
6546 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6547 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6548 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6549 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6551 value
= fixP
->fx_offset
;
6555 /* During parsing of instructions, a TOC16 reloc is generated for
6556 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6557 in the toc. But at parse time, SYM may be not yet defined, so
6558 check again here. */
6559 if (fixP
->fx_r_type
== BFD_RELOC_16
6560 && fixP
->fx_addsy
!= NULL
6561 && ppc_is_toc_sym (fixP
->fx_addsy
))
6562 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6566 /* Calculate value to be stored in field. */
6568 switch (fixP
->fx_r_type
)
6571 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6572 case BFD_RELOC_PPC_VLE_LO16A
:
6573 case BFD_RELOC_PPC_VLE_LO16D
:
6575 case BFD_RELOC_LO16
:
6576 case BFD_RELOC_LO16_PCREL
:
6577 fieldval
= value
& 0xffff;
6579 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6580 fieldval
= SEX16 (fieldval
);
6581 fixP
->fx_no_overflow
= 1;
6584 case BFD_RELOC_HI16
:
6585 case BFD_RELOC_HI16_PCREL
:
6587 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6589 fieldval
= value
>> 16;
6590 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6592 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6593 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6599 case BFD_RELOC_PPC_VLE_HI16A
:
6600 case BFD_RELOC_PPC_VLE_HI16D
:
6601 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6603 fieldval
= PPC_HI (value
);
6604 goto sign_extend_16
;
6606 case BFD_RELOC_HI16_S
:
6607 case BFD_RELOC_HI16_S_PCREL
:
6609 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6611 fieldval
= (value
+ 0x8000) >> 16;
6612 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6614 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6615 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6621 case BFD_RELOC_PPC_VLE_HA16A
:
6622 case BFD_RELOC_PPC_VLE_HA16D
:
6623 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6625 fieldval
= PPC_HA (value
);
6626 goto sign_extend_16
;
6629 case BFD_RELOC_PPC64_HIGHER
:
6630 fieldval
= PPC_HIGHER (value
);
6631 goto sign_extend_16
;
6633 case BFD_RELOC_PPC64_HIGHER_S
:
6634 fieldval
= PPC_HIGHERA (value
);
6635 goto sign_extend_16
;
6637 case BFD_RELOC_PPC64_HIGHEST
:
6638 fieldval
= PPC_HIGHEST (value
);
6639 goto sign_extend_16
;
6641 case BFD_RELOC_PPC64_HIGHEST_S
:
6642 fieldval
= PPC_HIGHESTA (value
);
6643 goto sign_extend_16
;
6650 if (operand
!= NULL
)
6652 /* Handle relocs in an insn. */
6656 switch (fixP
->fx_r_type
)
6659 /* The following relocs can't be calculated by the assembler.
6660 Leave the field zero. */
6661 case BFD_RELOC_PPC_TPREL16
:
6662 case BFD_RELOC_PPC_TPREL16_LO
:
6663 case BFD_RELOC_PPC_TPREL16_HI
:
6664 case BFD_RELOC_PPC_TPREL16_HA
:
6665 case BFD_RELOC_PPC_DTPREL16
:
6666 case BFD_RELOC_PPC_DTPREL16_LO
:
6667 case BFD_RELOC_PPC_DTPREL16_HI
:
6668 case BFD_RELOC_PPC_DTPREL16_HA
:
6669 case BFD_RELOC_PPC_GOT_TLSGD16
:
6670 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6671 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6672 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6673 case BFD_RELOC_PPC_GOT_TLSLD16
:
6674 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6675 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6676 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6677 case BFD_RELOC_PPC_GOT_TPREL16
:
6678 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6679 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6680 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6681 case BFD_RELOC_PPC_GOT_DTPREL16
:
6682 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6683 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6684 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6685 case BFD_RELOC_PPC64_TPREL16_DS
:
6686 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6687 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6688 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6689 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6690 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6691 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6692 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6693 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6694 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6695 case BFD_RELOC_PPC64_DTPREL16_DS
:
6696 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6697 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6698 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6699 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6700 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6701 gas_assert (fixP
->fx_addsy
!= NULL
);
6702 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6706 /* These also should leave the field zero for the same
6707 reason. Note that older versions of gas wrote values
6708 here. If we want to go back to the old behaviour, then
6709 all _LO and _LO_DS cases will need to be treated like
6710 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6711 case BFD_RELOC_16_GOTOFF
:
6712 case BFD_RELOC_LO16_GOTOFF
:
6713 case BFD_RELOC_HI16_GOTOFF
:
6714 case BFD_RELOC_HI16_S_GOTOFF
:
6715 case BFD_RELOC_LO16_PLTOFF
:
6716 case BFD_RELOC_HI16_PLTOFF
:
6717 case BFD_RELOC_HI16_S_PLTOFF
:
6718 case BFD_RELOC_GPREL16
:
6719 case BFD_RELOC_16_BASEREL
:
6720 case BFD_RELOC_LO16_BASEREL
:
6721 case BFD_RELOC_HI16_BASEREL
:
6722 case BFD_RELOC_HI16_S_BASEREL
:
6723 case BFD_RELOC_PPC_TOC16
:
6724 case BFD_RELOC_PPC64_TOC16_LO
:
6725 case BFD_RELOC_PPC64_TOC16_HI
:
6726 case BFD_RELOC_PPC64_TOC16_HA
:
6727 case BFD_RELOC_PPC64_PLTGOT16
:
6728 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6729 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6730 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6731 case BFD_RELOC_PPC64_GOT16_DS
:
6732 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6733 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6734 case BFD_RELOC_PPC64_SECTOFF_DS
:
6735 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6736 case BFD_RELOC_PPC64_TOC16_DS
:
6737 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6738 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6739 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6740 case BFD_RELOC_PPC_EMB_NADDR16
:
6741 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6742 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6743 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6744 case BFD_RELOC_PPC_EMB_SDAI16
:
6745 case BFD_RELOC_PPC_EMB_SDA2I16
:
6746 case BFD_RELOC_PPC_EMB_SDA2REL
:
6747 case BFD_RELOC_PPC_EMB_SDA21
:
6748 case BFD_RELOC_PPC_EMB_MRKREF
:
6749 case BFD_RELOC_PPC_EMB_RELSEC16
:
6750 case BFD_RELOC_PPC_EMB_RELST_LO
:
6751 case BFD_RELOC_PPC_EMB_RELST_HI
:
6752 case BFD_RELOC_PPC_EMB_RELST_HA
:
6753 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6754 case BFD_RELOC_PPC_EMB_RELSDA
:
6755 case BFD_RELOC_PPC_VLE_SDA21
:
6756 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6757 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6758 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6759 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6760 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6761 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6762 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6763 gas_assert (fixP
->fx_addsy
!= NULL
);
6766 case BFD_RELOC_PPC_TLS
:
6767 case BFD_RELOC_PPC_TLSGD
:
6768 case BFD_RELOC_PPC_TLSLD
:
6774 case BFD_RELOC_PPC_B16
:
6775 /* Adjust the offset to the instruction boundary. */
6780 case BFD_RELOC_VTABLE_INHERIT
:
6781 case BFD_RELOC_VTABLE_ENTRY
:
6782 case BFD_RELOC_PPC_DTPMOD
:
6783 case BFD_RELOC_PPC_TPREL
:
6784 case BFD_RELOC_PPC_DTPREL
:
6785 case BFD_RELOC_PPC_COPY
:
6786 case BFD_RELOC_PPC_GLOB_DAT
:
6787 case BFD_RELOC_32_PLT_PCREL
:
6788 case BFD_RELOC_PPC_EMB_NADDR32
:
6789 case BFD_RELOC_PPC64_TOC
:
6790 case BFD_RELOC_CTOR
:
6792 case BFD_RELOC_32_PCREL
:
6795 case BFD_RELOC_64_PCREL
:
6796 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6797 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6798 _("%s unsupported as instruction fixup"),
6799 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6808 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6809 contents can stay at zero. */
6810 #define APPLY_RELOC fixP->fx_done
6812 #define APPLY_RELOC 1
6814 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6816 /* Fetch the instruction, insert the fully resolved operand
6817 value, and stuff the instruction back again. */
6818 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6819 if (target_big_endian
)
6821 if (fixP
->fx_size
== 4)
6822 insn
= bfd_getb32 ((unsigned char *) where
);
6824 insn
= bfd_getb16 ((unsigned char *) where
);
6828 if (fixP
->fx_size
== 4)
6829 insn
= bfd_getl32 ((unsigned char *) where
);
6831 insn
= bfd_getl16 ((unsigned char *) where
);
6833 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6834 fixP
->tc_fix_data
.ppc_cpu
,
6835 fixP
->fx_file
, fixP
->fx_line
);
6836 if (target_big_endian
)
6838 if (fixP
->fx_size
== 4)
6839 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6841 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6845 if (fixP
->fx_size
== 4)
6846 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6848 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6853 /* Nothing else to do here. */
6856 gas_assert (fixP
->fx_addsy
!= NULL
);
6857 if (fixP
->fx_r_type
== BFD_RELOC_NONE
)
6862 /* Use expr_symbol_where to see if this is an expression
6864 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6865 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6866 _("unresolved expression that must be resolved"));
6868 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6869 _("unsupported relocation against %s"),
6870 S_GET_NAME (fixP
->fx_addsy
));
6877 /* Handle relocs in data. */
6878 switch (fixP
->fx_r_type
)
6880 case BFD_RELOC_VTABLE_INHERIT
:
6882 && !S_IS_DEFINED (fixP
->fx_addsy
)
6883 && !S_IS_WEAK (fixP
->fx_addsy
))
6884 S_SET_WEAK (fixP
->fx_addsy
);
6887 case BFD_RELOC_VTABLE_ENTRY
:
6892 /* These can appear with @l etc. in data. */
6893 case BFD_RELOC_LO16
:
6894 case BFD_RELOC_LO16_PCREL
:
6895 case BFD_RELOC_HI16
:
6896 case BFD_RELOC_HI16_PCREL
:
6897 case BFD_RELOC_HI16_S
:
6898 case BFD_RELOC_HI16_S_PCREL
:
6899 case BFD_RELOC_PPC64_HIGHER
:
6900 case BFD_RELOC_PPC64_HIGHER_S
:
6901 case BFD_RELOC_PPC64_HIGHEST
:
6902 case BFD_RELOC_PPC64_HIGHEST_S
:
6903 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6904 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6905 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6908 case BFD_RELOC_PPC_DTPMOD
:
6909 case BFD_RELOC_PPC_TPREL
:
6910 case BFD_RELOC_PPC_DTPREL
:
6911 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6914 /* Just punt all of these to the linker. */
6915 case BFD_RELOC_PPC_B16_BRTAKEN
:
6916 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6917 case BFD_RELOC_16_GOTOFF
:
6918 case BFD_RELOC_LO16_GOTOFF
:
6919 case BFD_RELOC_HI16_GOTOFF
:
6920 case BFD_RELOC_HI16_S_GOTOFF
:
6921 case BFD_RELOC_LO16_PLTOFF
:
6922 case BFD_RELOC_HI16_PLTOFF
:
6923 case BFD_RELOC_HI16_S_PLTOFF
:
6924 case BFD_RELOC_PPC_COPY
:
6925 case BFD_RELOC_PPC_GLOB_DAT
:
6926 case BFD_RELOC_16_BASEREL
:
6927 case BFD_RELOC_LO16_BASEREL
:
6928 case BFD_RELOC_HI16_BASEREL
:
6929 case BFD_RELOC_HI16_S_BASEREL
:
6930 case BFD_RELOC_PPC_TLS
:
6931 case BFD_RELOC_PPC_DTPREL16_LO
:
6932 case BFD_RELOC_PPC_DTPREL16_HI
:
6933 case BFD_RELOC_PPC_DTPREL16_HA
:
6934 case BFD_RELOC_PPC_TPREL16_LO
:
6935 case BFD_RELOC_PPC_TPREL16_HI
:
6936 case BFD_RELOC_PPC_TPREL16_HA
:
6937 case BFD_RELOC_PPC_GOT_TLSGD16
:
6938 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6939 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6940 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6941 case BFD_RELOC_PPC_GOT_TLSLD16
:
6942 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6943 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6944 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6945 case BFD_RELOC_PPC_GOT_DTPREL16
:
6946 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6947 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6948 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6949 case BFD_RELOC_PPC_GOT_TPREL16
:
6950 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6951 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6952 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6953 case BFD_RELOC_24_PLT_PCREL
:
6954 case BFD_RELOC_PPC_LOCAL24PC
:
6955 case BFD_RELOC_32_PLT_PCREL
:
6956 case BFD_RELOC_GPREL16
:
6957 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6958 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6959 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6960 case BFD_RELOC_PPC_EMB_NADDR32
:
6961 case BFD_RELOC_PPC_EMB_NADDR16
:
6962 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6963 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6964 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6965 case BFD_RELOC_PPC_EMB_SDAI16
:
6966 case BFD_RELOC_PPC_EMB_SDA2REL
:
6967 case BFD_RELOC_PPC_EMB_SDA2I16
:
6968 case BFD_RELOC_PPC_EMB_SDA21
:
6969 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6970 case BFD_RELOC_PPC_EMB_MRKREF
:
6971 case BFD_RELOC_PPC_EMB_RELSEC16
:
6972 case BFD_RELOC_PPC_EMB_RELST_LO
:
6973 case BFD_RELOC_PPC_EMB_RELST_HI
:
6974 case BFD_RELOC_PPC_EMB_RELST_HA
:
6975 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6976 case BFD_RELOC_PPC_EMB_RELSDA
:
6977 case BFD_RELOC_PPC64_TOC
:
6978 case BFD_RELOC_PPC_TOC16
:
6979 case BFD_RELOC_PPC64_TOC16_LO
:
6980 case BFD_RELOC_PPC64_TOC16_HI
:
6981 case BFD_RELOC_PPC64_TOC16_HA
:
6982 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6983 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6984 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6985 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6986 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6987 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6988 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6989 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6990 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6991 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6992 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6993 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6999 case BFD_RELOC_NONE
:
7001 case BFD_RELOC_CTOR
:
7003 case BFD_RELOC_32_PCREL
:
7006 case BFD_RELOC_64_PCREL
:
7008 case BFD_RELOC_16_PCREL
:
7014 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
7019 if (fixP
->fx_size
&& APPLY_RELOC
)
7020 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
7021 fieldval
, fixP
->fx_size
);
7023 && (seg
->flags
& SEC_CODE
) != 0
7024 && fixP
->fx_size
== 4
7027 && (fixP
->fx_r_type
== BFD_RELOC_32
7028 || fixP
->fx_r_type
== BFD_RELOC_CTOR
7029 || fixP
->fx_r_type
== BFD_RELOC_32_PCREL
))
7030 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
7031 _("data in executable section"));
7034 /* We are only able to convert some relocs to pc-relative. */
7035 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
7037 switch (fixP
->fx_r_type
)
7039 case BFD_RELOC_LO16
:
7040 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
7043 case BFD_RELOC_HI16
:
7044 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
7047 case BFD_RELOC_HI16_S
:
7048 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
7052 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7056 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7060 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7063 /* Some of course are already pc-relative. */
7064 case BFD_RELOC_LO16_PCREL
:
7065 case BFD_RELOC_HI16_PCREL
:
7066 case BFD_RELOC_HI16_S_PCREL
:
7067 case BFD_RELOC_64_PCREL
:
7068 case BFD_RELOC_32_PCREL
:
7069 case BFD_RELOC_16_PCREL
:
7070 case BFD_RELOC_PPC_B16
:
7071 case BFD_RELOC_PPC_B16_BRTAKEN
:
7072 case BFD_RELOC_PPC_B16_BRNTAKEN
:
7073 case BFD_RELOC_PPC_B26
:
7074 case BFD_RELOC_PPC_LOCAL24PC
:
7075 case BFD_RELOC_24_PLT_PCREL
:
7076 case BFD_RELOC_32_PLT_PCREL
:
7077 case BFD_RELOC_64_PLT_PCREL
:
7078 case BFD_RELOC_PPC_VLE_REL8
:
7079 case BFD_RELOC_PPC_VLE_REL15
:
7080 case BFD_RELOC_PPC_VLE_REL24
:
7089 /* Use expr_symbol_where to see if this is an
7090 expression symbol. */
7091 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
7092 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7093 _("unresolved expression that must"
7096 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7097 _("cannot emit PC relative %s relocation"
7099 bfd_get_reloc_code_name (fixP
->fx_r_type
),
7100 S_GET_NAME (fixP
->fx_addsy
));
7103 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7104 _("unable to resolve expression"));
7111 ppc_elf_validate_fix (fixP
, seg
);
7112 fixP
->fx_addnumber
= value
;
7114 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
7115 from the section contents. If we are going to be emitting a reloc
7116 then the section contents are immaterial, so don't warn if they
7117 happen to overflow. Leave such warnings to ld. */
7120 fixP
->fx_no_overflow
= 1;
7122 /* Arrange to emit .TOC. as a normal symbol if used in anything
7123 but .TOC.@tocbase. */
7125 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
7126 && fixP
->fx_addsy
!= NULL
7127 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
7128 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
7131 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
7132 fixP
->fx_addnumber
= 0;
7136 fixP
->fx_addnumber
= 0;
7138 /* We want to use the offset within the toc, not the actual VMA
7140 fixP
->fx_addnumber
=
7141 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
7142 - S_GET_VALUE (ppc_toc_csect
);
7143 /* Set *valP to avoid errors. */
7150 /* Generate a reloc for a fixup. */
7153 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
7157 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
7159 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
7160 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
7161 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
7162 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
7163 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
7165 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
7166 _("reloc %d not supported by object file format"),
7167 (int) fixp
->fx_r_type
);
7170 reloc
->addend
= fixp
->fx_addnumber
;
7176 ppc_cfi_frame_initial_instructions (void)
7178 cfi_add_CFA_def_cfa (1, 0);
7182 tc_ppc_regname_to_dw2regnum (char *regname
)
7184 unsigned int regnum
= -1;
7188 static struct { char *name
; int dw2regnum
; } regnames
[] =
7190 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7191 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7192 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7193 { "spe_acc", 111 }, { "spefscr", 112 }
7196 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7197 if (strcmp (regnames
[i
].name
, regname
) == 0)
7198 return regnames
[i
].dw2regnum
;
7200 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7202 p
= regname
+ 1 + (regname
[1] == '.');
7203 regnum
= strtoul (p
, &q
, 10);
7204 if (p
== q
|| *q
|| regnum
>= 32)
7206 if (regname
[0] == 'f')
7208 else if (regname
[0] == 'v')
7211 else if (regname
[0] == 'c' && regname
[1] == 'r')
7213 p
= regname
+ 2 + (regname
[2] == '.');
7214 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7216 regnum
= p
[0] - '0' + 68;