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 -m821, -m850, -m860 generate code for PowerPC 821/850/860\n"));
1286 fprintf (stream
, _("\
1287 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1288 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1289 -mbooke generate code for 32-bit PowerPC BookE\n\
1290 -ma2 generate code for A2 architecture\n\
1291 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1292 -mpower5, -mpwr5, -mpwr5x\n\
1293 generate code for Power5 architecture\n\
1294 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1295 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1296 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1297 -mcell generate code for Cell Broadband Engine architecture\n\
1298 -mcom generate code Power/PowerPC common instructions\n\
1299 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1300 fprintf (stream
, _("\
1301 -maltivec generate code for AltiVec\n\
1302 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1303 -mhtm generate code for Hardware Transactional Memory\n\
1304 -me300 generate code for PowerPC e300 family\n\
1305 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1306 -me500mc, generate code for Freescale e500mc core complex\n\
1307 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1308 -me5500, generate code for Freescale e5500 core complex\n\
1309 -me6500, generate code for Freescale e6500 core complex\n\
1310 -mspe generate code for Motorola SPE instructions\n\
1311 -mvle generate code for Freescale VLE instructions\n\
1312 -mtitan generate code for AppliedMicro Titan core complex\n\
1313 -mregnames Allow symbolic names for registers\n\
1314 -mno-regnames Do not allow symbolic names for registers\n"));
1316 fprintf (stream
, _("\
1317 -mrelocatable support for GCC's -mrelocatble option\n\
1318 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1319 -memb set PPC_EMB bit in ELF flags\n\
1320 -mlittle, -mlittle-endian, -le\n\
1321 generate code for a little endian machine\n\
1322 -mbig, -mbig-endian, -be\n\
1323 generate code for a big endian machine\n\
1324 -msolaris generate code for Solaris\n\
1325 -mno-solaris do not generate code for Solaris\n\
1326 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1327 -V print assembler version number\n\
1328 -Qy, -Qn ignored\n"));
1330 fprintf (stream
, _("\
1331 -nops=count when aligning, more than COUNT nops uses a branch\n\
1332 -ppc476-workaround warn if emitting data to code sections\n"));
1335 /* Set ppc_cpu if it is not already set. */
1340 const char *default_os
= TARGET_OS
;
1341 const char *default_cpu
= TARGET_CPU
;
1343 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1346 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1347 else if (strncmp (default_os
, "aix", 3) == 0
1348 && default_os
[3] >= '4' && default_os
[3] <= '9')
1349 ppc_cpu
|= PPC_OPCODE_COMMON
;
1350 else if (strncmp (default_os
, "aix3", 4) == 0)
1351 ppc_cpu
|= PPC_OPCODE_POWER
;
1352 else if (strcmp (default_cpu
, "rs6000") == 0)
1353 ppc_cpu
|= PPC_OPCODE_POWER
;
1354 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1355 ppc_cpu
|= PPC_OPCODE_PPC
;
1357 as_fatal (_("unknown default cpu = %s, os = %s"),
1358 default_cpu
, default_os
);
1362 /* Figure out the BFD architecture to use. This function and ppc_mach
1363 are called well before md_begin, when the output file is opened. */
1365 enum bfd_architecture
1368 const char *default_cpu
= TARGET_CPU
;
1371 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1372 return bfd_arch_powerpc
;
1373 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1374 return bfd_arch_powerpc
;
1375 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1376 return bfd_arch_rs6000
;
1377 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1379 if (strcmp (default_cpu
, "rs6000") == 0)
1380 return bfd_arch_rs6000
;
1381 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1382 return bfd_arch_powerpc
;
1385 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1386 return bfd_arch_unknown
;
1393 return bfd_mach_ppc64
;
1394 else if (ppc_arch () == bfd_arch_rs6000
)
1395 return bfd_mach_rs6k
;
1396 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1397 return bfd_mach_ppc_titan
;
1398 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1399 return bfd_mach_ppc_vle
;
1401 return bfd_mach_ppc
;
1405 ppc_target_format (void)
1409 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1411 return "xcoff-powermac";
1414 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1416 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1422 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1423 # elif defined (TE_VXWORKS)
1424 return "elf32-powerpc-vxworks";
1426 return (target_big_endian
1427 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1428 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1433 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1434 Return TRUE if there's a problem, otherwise FALSE. */
1437 insn_validate (const struct powerpc_opcode
*op
)
1439 const unsigned char *o
;
1440 unsigned long omask
= op
->mask
;
1442 /* The mask had better not trim off opcode bits. */
1443 if ((op
->opcode
& omask
) != op
->opcode
)
1445 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1449 /* The operands must not overlap the opcode or each other. */
1450 for (o
= op
->operands
; *o
; ++o
)
1452 if (*o
>= num_powerpc_operands
)
1454 as_bad (_("operand index error for %s"), op
->name
);
1459 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1460 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1464 if (operand
->shift
>= 0)
1465 mask
= operand
->bitm
<< operand
->shift
;
1467 mask
= operand
->bitm
>> -operand
->shift
;
1470 as_bad (_("operand %d overlap in %s"),
1471 (int) (o
- op
->operands
), op
->name
);
1481 /* Insert opcodes and macros into hash tables. Called at startup and
1482 for .machine pseudo. */
1485 ppc_setup_opcodes (void)
1487 const struct powerpc_opcode
*op
;
1488 const struct powerpc_opcode
*op_end
;
1489 const struct powerpc_macro
*macro
;
1490 const struct powerpc_macro
*macro_end
;
1491 bfd_boolean bad_insn
= FALSE
;
1493 if (ppc_hash
!= NULL
)
1494 hash_die (ppc_hash
);
1495 if (ppc_macro_hash
!= NULL
)
1496 hash_die (ppc_macro_hash
);
1498 /* Insert the opcodes into a hash table. */
1499 ppc_hash
= hash_new ();
1501 if (ENABLE_CHECKING
)
1505 /* An index into powerpc_operands is stored in struct fix
1506 fx_pcrel_adjust which is 8 bits wide. */
1507 gas_assert (num_powerpc_operands
< 256);
1509 /* Check operand masks. Code here and in the disassembler assumes
1510 all the 1's in the mask are contiguous. */
1511 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1513 unsigned long mask
= powerpc_operands
[i
].bitm
;
1514 unsigned long right_bit
;
1517 right_bit
= mask
& -mask
;
1519 right_bit
= mask
& -mask
;
1520 if (mask
!= right_bit
)
1522 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1525 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1526 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1527 sizeof (powerpc_operands
[0])) == 0)
1529 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1536 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1537 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1539 if (ENABLE_CHECKING
)
1541 if (op
!= powerpc_opcodes
)
1543 int old_opcode
= PPC_OP (op
[-1].opcode
);
1544 int new_opcode
= PPC_OP (op
[0].opcode
);
1546 #ifdef PRINT_OPCODE_TABLE
1547 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1548 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1549 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1550 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1553 /* The major opcodes had better be sorted. Code in the
1554 disassembler assumes the insns are sorted according to
1556 if (new_opcode
< old_opcode
)
1558 as_bad (_("major opcode is not sorted for %s"),
1563 bad_insn
|= insn_validate (op
);
1566 if ((ppc_cpu
& op
->flags
) != 0
1567 && !(ppc_cpu
& op
->deprecated
))
1571 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1574 as_bad (_("duplicate instruction %s"),
1581 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1582 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1583 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1585 op_end
= vle_opcodes
+ vle_num_opcodes
;
1586 for (op
= vle_opcodes
; op
< op_end
; op
++)
1588 if (ENABLE_CHECKING
)
1590 if (op
!= vle_opcodes
)
1592 unsigned old_seg
, new_seg
;
1594 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1595 old_seg
= VLE_OP_TO_SEG (old_seg
);
1596 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1597 new_seg
= VLE_OP_TO_SEG (new_seg
);
1599 #ifdef PRINT_OPCODE_TABLE
1600 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1601 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1602 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1603 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1605 /* The major opcodes had better be sorted. Code in the
1606 disassembler assumes the insns are sorted according to
1608 if (new_seg
< old_seg
)
1610 as_bad (_("major opcode is not sorted for %s"),
1616 bad_insn
|= insn_validate (op
);
1619 if ((ppc_cpu
& op
->flags
) != 0
1620 && !(ppc_cpu
& op
->deprecated
))
1624 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1627 as_bad (_("duplicate instruction %s"),
1634 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1635 for (op
= vle_opcodes
; op
< op_end
; op
++)
1636 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1638 /* Insert the macros into a hash table. */
1639 ppc_macro_hash
= hash_new ();
1641 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1642 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1644 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1648 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1649 if (retval
!= (const char *) NULL
)
1651 as_bad (_("duplicate macro %s"), macro
->name
);
1661 /* This function is called when the assembler starts up. It is called
1662 after the options have been parsed and the output file has been
1670 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1671 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1674 /* Set the ELF flags if desired. */
1675 if (ppc_flags
&& !msolaris
)
1676 bfd_set_private_flags (stdoutput
, ppc_flags
);
1679 ppc_setup_opcodes ();
1681 /* Tell the main code what the endianness is if it is not overridden
1683 if (!set_target_endian
)
1685 set_target_endian
= 1;
1686 target_big_endian
= PPC_BIG_ENDIAN
;
1690 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1692 /* Create dummy symbols to serve as initial csects. This forces the
1693 text csects to precede the data csects. These symbols will not
1695 ppc_text_csects
= symbol_make ("dummy\001");
1696 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1697 ppc_data_csects
= symbol_make ("dummy\001");
1698 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1703 ppc_current_section
= text_section
;
1704 ppc_previous_section
= 0;
1713 if (ppc_apuinfo_list
== NULL
)
1716 /* Ok, so write the section info out. We have this layout:
1720 0 8 length of "APUinfo\0"
1721 4 (n*4) number of APU's (4 bytes each)
1724 20 APU#1 first APU's info
1725 24 APU#2 second APU's info
1730 asection
*seg
= now_seg
;
1731 subsegT subseg
= now_subseg
;
1732 asection
*apuinfo_secp
= (asection
*) NULL
;
1735 /* Create the .PPC.EMB.apuinfo section. */
1736 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1737 bfd_set_section_flags (stdoutput
,
1739 SEC_HAS_CONTENTS
| SEC_READONLY
);
1742 md_number_to_chars (p
, (valueT
) 8, 4);
1745 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1748 md_number_to_chars (p
, (valueT
) 2, 4);
1751 strcpy (p
, "APUinfo");
1753 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1756 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1759 frag_align (2, 0, 0);
1761 /* We probably can't restore the current segment, for there likely
1764 subseg_set (seg
, subseg
);
1769 /* Insert an operand value into an instruction. */
1771 static unsigned long
1772 ppc_insert_operand (unsigned long insn
,
1773 const struct powerpc_operand
*operand
,
1779 long min
, max
, right
;
1781 max
= operand
->bitm
;
1785 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1787 /* Extend the allowed range for addis to [-65536, 65535].
1788 Similarly for some VLE high part insns. For 64-bit it
1789 would be good to disable this for signed fields since the
1790 value is sign extended into the high 32 bits of the register.
1791 If the value is, say, an address, then we might care about
1792 the high bits. However, gcc as of 2014-06 uses unsigned
1793 values when loading the high part of 64-bit constants using
1795 Use the same extended range for cmpli, to allow at least
1797 min
= ~max
& -right
;
1799 else if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1801 max
= (max
>> 1) & -right
;
1802 min
= ~max
& -right
;
1805 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1808 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1817 /* Some people write constants with the sign extension done by
1818 hand but only up to 32 bits. This shouldn't really be valid,
1819 but, to permit this code to assemble on a 64-bit host, we
1820 sign extend the 32-bit value to 64 bits if so doing makes the
1823 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1824 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1825 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1826 val
= val
- 0x80000000 - 0x80000000;
1828 /* Similarly, people write expressions like ~(1<<15), and expect
1829 this to be OK for a 32-bit unsigned value. */
1831 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1832 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1833 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1834 val
= val
+ 0x80000000 + 0x80000000;
1838 || (val
& (right
- 1)) != 0)
1839 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1842 if (operand
->insert
)
1847 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1848 if (errmsg
!= (const char *) NULL
)
1849 as_bad_where (file
, line
, "%s", errmsg
);
1851 else if (operand
->shift
>= 0)
1852 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1854 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1861 /* Parse @got, etc. and return the desired relocation. */
1862 static bfd_reloc_code_real_type
1863 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1867 unsigned int length
: 8;
1868 unsigned int valid32
: 1;
1869 unsigned int valid64
: 1;
1878 const struct map_bfd
*ptr
;
1880 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1881 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1882 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1884 static const struct map_bfd mapping
[] = {
1885 MAP ("l", BFD_RELOC_LO16
),
1886 MAP ("h", BFD_RELOC_HI16
),
1887 MAP ("ha", BFD_RELOC_HI16_S
),
1888 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1889 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1890 MAP ("got", BFD_RELOC_16_GOTOFF
),
1891 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1892 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1893 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1894 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1895 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1896 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1897 MAP ("copy", BFD_RELOC_PPC_COPY
),
1898 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1899 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1900 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1901 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1902 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1903 MAP ("tls", BFD_RELOC_PPC_TLS
),
1904 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1905 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1906 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1907 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1908 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1909 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1910 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1911 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1912 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1913 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1914 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1915 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1916 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1917 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1918 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1919 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1920 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1921 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1922 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1923 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1924 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1925 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1926 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1927 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1928 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1929 MAP32 ("fixup", BFD_RELOC_CTOR
),
1930 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1931 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1932 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1933 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1934 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1935 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1936 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1937 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1938 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1939 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1940 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1941 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1942 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1943 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1944 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1945 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1946 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1947 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1948 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1949 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1950 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1951 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1952 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1953 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1954 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1955 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1956 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1957 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1958 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1959 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1960 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1961 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1962 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1963 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1964 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1965 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1966 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1967 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1968 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1969 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1970 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1971 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1972 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1973 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1974 MAP64 ("localentry", BFD_RELOC_PPC64_ADDR64_LOCAL
),
1975 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1976 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1977 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1978 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1979 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1980 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1981 { (char *) 0, 0, 0, 0, BFD_RELOC_NONE
}
1985 return BFD_RELOC_NONE
;
1987 for (ch
= *str
, str2
= ident
;
1988 (str2
< ident
+ sizeof (ident
) - 1
1989 && (ISALNUM (ch
) || ch
== '@'));
1992 *str2
++ = TOLOWER (ch
);
1999 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
2000 if (ch
== ptr
->string
[0]
2001 && len
== ptr
->length
2002 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
2003 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
2005 int reloc
= ptr
->reloc
;
2007 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
2011 case BFD_RELOC_16_GOTOFF
:
2012 case BFD_RELOC_LO16_GOTOFF
:
2013 case BFD_RELOC_HI16_GOTOFF
:
2014 case BFD_RELOC_HI16_S_GOTOFF
:
2015 as_warn (_("identifier+constant@got means "
2016 "identifier@got+constant"));
2019 case BFD_RELOC_PPC_GOT_TLSGD16
:
2020 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2021 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2022 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2023 case BFD_RELOC_PPC_GOT_TLSLD16
:
2024 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2025 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2026 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2027 case BFD_RELOC_PPC_GOT_DTPREL16
:
2028 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2029 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2030 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2031 case BFD_RELOC_PPC_GOT_TPREL16
:
2032 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2033 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2034 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2035 as_bad (_("symbol+offset not supported for got tls"));
2040 /* Now check for identifier@suffix+constant. */
2041 if (*str
== '-' || *str
== '+')
2043 char *orig_line
= input_line_pointer
;
2044 expressionS new_exp
;
2046 input_line_pointer
= str
;
2047 expression (&new_exp
);
2048 if (new_exp
.X_op
== O_constant
)
2050 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2051 str
= input_line_pointer
;
2054 if (&input_line_pointer
!= str_p
)
2055 input_line_pointer
= orig_line
;
2059 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2060 && exp_p
->X_op
== O_symbol
2061 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2063 /* Change the symbol so that the dummy .TOC. symbol can be
2064 omitted from the object file. */
2065 exp_p
->X_add_symbol
= &abs_symbol
;
2068 return (bfd_reloc_code_real_type
) reloc
;
2071 return BFD_RELOC_NONE
;
2074 /* Support @got, etc. on constants emitted via .short, .int etc. */
2076 bfd_reloc_code_real_type
2077 ppc_elf_parse_cons (expressionS
*exp
, unsigned int nbytes
)
2080 if (nbytes
>= 2 && *input_line_pointer
== '@')
2081 return ppc_elf_suffix (&input_line_pointer
, exp
);
2082 return BFD_RELOC_NONE
;
2085 /* Warn when emitting data to code sections, unless we are emitting
2086 a relocation that ld --ppc476-workaround uses to recognise data
2087 *and* there was an unconditional branch prior to the data. */
2090 ppc_elf_cons_fix_check (expressionS
*exp ATTRIBUTE_UNUSED
,
2091 unsigned int nbytes
, fixS
*fix
)
2094 && (now_seg
->flags
& SEC_CODE
) != 0
2097 || !(fix
->fx_r_type
== BFD_RELOC_32
2098 || fix
->fx_r_type
== BFD_RELOC_CTOR
2099 || fix
->fx_r_type
== BFD_RELOC_32_PCREL
)
2100 || !(last_seg
== now_seg
&& last_subseg
== now_subseg
)
2101 || !((last_insn
& (0x3f << 26)) == (18u << 26)
2102 || ((last_insn
& (0x3f << 26)) == (16u << 26)
2103 && (last_insn
& (0x14 << 21)) == (0x14 << 21))
2104 || ((last_insn
& (0x3f << 26)) == (19u << 26)
2105 && (last_insn
& (0x3ff << 1)) == (16u << 1)
2106 && (last_insn
& (0x14 << 21)) == (0x14 << 21)))))
2108 /* Flag that we've warned. */
2112 as_warn (_("data in executable section"));
2116 /* Solaris pseduo op to change to the .rodata section. */
2118 ppc_elf_rdata (int xxx
)
2120 char *save_line
= input_line_pointer
;
2121 static char section
[] = ".rodata\n";
2123 /* Just pretend this is .section .rodata */
2124 input_line_pointer
= section
;
2125 obj_elf_section (xxx
);
2127 input_line_pointer
= save_line
;
2130 /* Pseudo op to make file scope bss items. */
2132 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2145 name
= input_line_pointer
;
2146 c
= get_symbol_end ();
2148 /* just after name is now '\0'. */
2149 p
= input_line_pointer
;
2152 if (*input_line_pointer
!= ',')
2154 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2155 ignore_rest_of_line ();
2159 input_line_pointer
++; /* skip ',' */
2160 if ((size
= get_absolute_expression ()) < 0)
2162 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2163 ignore_rest_of_line ();
2167 /* The third argument to .lcomm is the alignment. */
2168 if (*input_line_pointer
!= ',')
2172 ++input_line_pointer
;
2173 align
= get_absolute_expression ();
2176 as_warn (_("ignoring bad alignment"));
2182 symbolP
= symbol_find_or_make (name
);
2185 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2187 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2188 S_GET_NAME (symbolP
));
2189 ignore_rest_of_line ();
2193 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2195 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2196 S_GET_NAME (symbolP
),
2197 (long) S_GET_VALUE (symbolP
),
2200 ignore_rest_of_line ();
2206 old_subsec
= now_subseg
;
2209 /* Convert to a power of 2 alignment. */
2210 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2213 as_bad (_("common alignment not a power of 2"));
2214 ignore_rest_of_line ();
2221 record_alignment (bss_section
, align2
);
2222 subseg_set (bss_section
, 1);
2224 frag_align (align2
, 0, 0);
2225 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2226 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2227 symbol_set_frag (symbolP
, frag_now
);
2228 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2231 S_SET_SIZE (symbolP
, size
);
2232 S_SET_SEGMENT (symbolP
, bss_section
);
2233 subseg_set (old_sec
, old_subsec
);
2234 demand_empty_rest_of_line ();
2237 /* Pseudo op to set symbol local entry point. */
2239 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED
)
2241 char *name
= input_line_pointer
;
2242 char c
= get_symbol_end ();
2247 elf_symbol_type
*elfsym
;
2249 p
= input_line_pointer
;
2252 if (*input_line_pointer
!= ',')
2255 as_bad (_("expected comma after name `%s' in .localentry directive"),
2258 ignore_rest_of_line ();
2261 input_line_pointer
++;
2263 if (exp
.X_op
== O_absent
)
2265 as_bad (_("missing expression in .localentry directive"));
2266 exp
.X_op
= O_constant
;
2267 exp
.X_add_number
= 0;
2270 sym
= symbol_find_or_make (name
);
2273 if (resolve_expression (&exp
)
2274 && exp
.X_op
== O_constant
)
2276 unsigned char encoded
= PPC64_SET_LOCAL_ENTRY_OFFSET (exp
.X_add_number
);
2278 if (exp
.X_add_number
!= (offsetT
) PPC64_LOCAL_ENTRY_OFFSET (encoded
))
2279 as_bad (_(".localentry expression for `%s' "
2280 "is not a valid power of 2"), S_GET_NAME (sym
));
2283 bfdsym
= symbol_get_bfdsym (sym
);
2284 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
2285 gas_assert (elfsym
);
2286 elfsym
->internal_elf_sym
.st_other
&= ~STO_PPC64_LOCAL_MASK
;
2287 elfsym
->internal_elf_sym
.st_other
|= encoded
;
2288 if (ppc_abiversion
== 0)
2293 as_bad (_(".localentry expression for `%s' "
2294 "does not evaluate to a constant"), S_GET_NAME (sym
));
2296 demand_empty_rest_of_line ();
2299 /* Pseudo op to set ABI version. */
2301 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2306 if (exp
.X_op
== O_absent
)
2308 as_bad (_("missing expression in .abiversion directive"));
2309 exp
.X_op
= O_constant
;
2310 exp
.X_add_number
= 0;
2313 if (resolve_expression (&exp
)
2314 && exp
.X_op
== O_constant
)
2315 ppc_abiversion
= exp
.X_add_number
;
2317 as_bad (_(".abiversion expression does not evaluate to a constant"));
2318 demand_empty_rest_of_line ();
2321 /* Set ABI version in output file. */
2325 if (ppc_obj64
&& ppc_abiversion
!= 0)
2327 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2328 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2332 /* Validate any relocations emitted for -mrelocatable, possibly adding
2333 fixups for word relocations in writable segments, so we can adjust
2336 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2338 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2347 case SHLIB_MRELOCATABLE
:
2348 if (fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2349 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2350 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2351 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2352 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2353 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2354 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2355 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2356 && (seg
->flags
& SEC_LOAD
) != 0
2357 && strcmp (segment_name (seg
), ".got2") != 0
2358 && strcmp (segment_name (seg
), ".dtors") != 0
2359 && strcmp (segment_name (seg
), ".ctors") != 0
2360 && strcmp (segment_name (seg
), ".fixup") != 0
2361 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2362 && strcmp (segment_name (seg
), ".eh_frame") != 0
2363 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2365 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2366 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2368 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2369 _("relocation cannot be done when using -mrelocatable"));
2376 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2377 function descriptor sym if the corresponding code sym is used. */
2380 ppc_frob_file_before_adjust (void)
2388 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2395 name
= S_GET_NAME (symp
);
2399 if (! S_IS_WEAK (symp
)
2400 || S_IS_DEFINED (symp
))
2403 len
= strlen (name
) + 1;
2404 dotname
= xmalloc (len
+ 1);
2406 memcpy (dotname
+ 1, name
, len
);
2407 dotsym
= symbol_find_noref (dotname
, 1);
2409 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2410 || symbol_used_in_reloc_p (dotsym
)))
2411 symbol_mark_used (symp
);
2415 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2417 && toc_reloc_types
!= has_large_toc_reloc
2418 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2419 as_warn (_("TOC section size exceeds 64k"));
2422 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2423 emitted. Other uses of .TOC. will cause the symbol to be marked
2424 with BSF_KEEP in md_apply_fix. */
2427 ppc_elf_adjust_symtab (void)
2432 symp
= symbol_find (".TOC.");
2435 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2436 if ((bsym
->flags
& BSF_KEEP
) == 0)
2437 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2441 #endif /* OBJ_ELF */
2446 * Summary of parse_toc_entry.
2448 * in: Input_line_pointer points to the '[' in one of:
2450 * [toc] [tocv] [toc32] [toc64]
2452 * Anything else is an error of one kind or another.
2455 * return value: success or failure
2456 * toc_kind: kind of toc reference
2457 * input_line_pointer:
2458 * success: first char after the ']'
2459 * failure: unchanged
2463 * [toc] - rv == success, toc_kind = default_toc
2464 * [tocv] - rv == success, toc_kind = data_in_toc
2465 * [toc32] - rv == success, toc_kind = must_be_32
2466 * [toc64] - rv == success, toc_kind = must_be_64
2470 enum toc_size_qualifier
2472 default_toc
, /* The toc cell constructed should be the system default size */
2473 data_in_toc
, /* This is a direct reference to a toc cell */
2474 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2475 must_be_64
/* The toc cell constructed must be 64 bits wide */
2479 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2484 enum toc_size_qualifier t
;
2486 /* Save the input_line_pointer. */
2487 start
= input_line_pointer
;
2489 /* Skip over the '[' , and whitespace. */
2490 ++input_line_pointer
;
2493 /* Find the spelling of the operand. */
2494 toc_spec
= input_line_pointer
;
2495 c
= get_symbol_end ();
2497 if (strcmp (toc_spec
, "toc") == 0)
2501 else if (strcmp (toc_spec
, "tocv") == 0)
2505 else if (strcmp (toc_spec
, "toc32") == 0)
2509 else if (strcmp (toc_spec
, "toc64") == 0)
2515 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2516 *input_line_pointer
= c
;
2517 input_line_pointer
= start
;
2521 /* Now find the ']'. */
2522 *input_line_pointer
= c
;
2524 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2525 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2529 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2530 input_line_pointer
= start
;
2539 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2540 /* See whether a symbol is in the TOC section. */
2543 ppc_is_toc_sym (symbolS
*sym
)
2546 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2547 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2550 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2552 return strcmp (sname
, ".toc") == 0;
2554 return strcmp (sname
, ".got") == 0;
2557 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2561 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2563 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2567 /* Check we don't already exist. */
2568 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2569 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2572 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2574 if (ppc_apuinfo_num_alloc
== 0)
2576 ppc_apuinfo_num_alloc
= 4;
2577 ppc_apuinfo_list
= (unsigned long *)
2578 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2582 ppc_apuinfo_num_alloc
+= 4;
2583 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2584 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2587 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2593 /* We need to keep a list of fixups. We can't simply generate them as
2594 we go, because that would require us to first create the frag, and
2595 that would screw up references to ``.''. */
2601 bfd_reloc_code_real_type reloc
;
2604 #define MAX_INSN_FIXUPS (5)
2607 #define E_OR2I_INSN 0x7000C000
2608 #define E_AND2I_DOT_INSN 0x7000C800
2609 #define E_OR2IS_INSN 0x7000D000
2610 #define E_LIS_INSN 0x7000E000
2611 #define E_AND2IS_DOT_INSN 0x7000E800
2614 #define E_ADD2I_DOT_INSN 0x70008800
2615 #define E_ADD2IS_INSN 0x70009000
2616 #define E_CMP16I_INSN 0x70009800
2617 #define E_MULL2I_INSN 0x7000A000
2618 #define E_CMPL16I_INSN 0x7000A800
2619 #define E_CMPH16I_INSN 0x7000B000
2620 #define E_CMPHL16I_INSN 0x7000B800
2622 /* This routine is called for each instruction to be assembled. */
2625 md_assemble (char *str
)
2628 const struct powerpc_opcode
*opcode
;
2630 const unsigned char *opindex_ptr
;
2634 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2639 unsigned int insn_length
;
2641 /* Get the opcode. */
2642 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2647 /* Look up the opcode in the hash table. */
2648 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2649 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2651 const struct powerpc_macro
*macro
;
2653 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2654 if (macro
== (const struct powerpc_macro
*) NULL
)
2655 as_bad (_("unrecognized opcode: `%s'"), str
);
2657 ppc_macro (s
, macro
);
2662 insn
= opcode
->opcode
;
2665 while (ISSPACE (*str
))
2668 /* PowerPC operands are just expressions. The only real issue is
2669 that a few operand types are optional. All cases which might use
2670 an optional operand separate the operands only with commas (in some
2671 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2672 have optional operands). Most instructions with optional operands
2673 have only one. Those that have more than one optional operand can
2674 take either all their operands or none. So, before we start seriously
2675 parsing the operands, we check to see if we have optional operands,
2676 and if we do, we count the number of commas to see which operands
2677 have been omitted. */
2679 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2681 const struct powerpc_operand
*operand
;
2683 operand
= &powerpc_operands
[*opindex_ptr
];
2684 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2686 unsigned int opcount
;
2687 unsigned int num_operands_expected
;
2689 /* There is an optional operand. Count the number of
2690 commas in the input line. */
2697 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2704 /* Compute the number of expected operands.
2705 Do not count fake operands. */
2706 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2707 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2708 ++ num_operands_expected
;
2710 /* If there are fewer operands in the line then are called
2711 for by the instruction, we want to skip the optional
2713 if (opcount
< num_operands_expected
)
2720 /* Gather the operands. */
2724 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2726 const struct powerpc_operand
*operand
;
2732 if (next_opindex
== 0)
2733 operand
= &powerpc_operands
[*opindex_ptr
];
2736 operand
= &powerpc_operands
[next_opindex
];
2741 /* If this is a fake operand, then we do not expect anything
2743 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2745 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2746 if (errmsg
!= (const char *) NULL
)
2747 as_bad ("%s", errmsg
);
2751 /* If this is an optional operand, and we are skipping it, just
2753 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2756 long val
= ppc_optional_operand_value (operand
);
2757 if (operand
->insert
)
2759 insn
= (*operand
->insert
) (insn
, val
, ppc_cpu
, &errmsg
);
2760 if (errmsg
!= (const char *) NULL
)
2761 as_bad ("%s", errmsg
);
2763 else if (operand
->shift
>= 0)
2764 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
2766 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
2768 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2769 next_opindex
= *opindex_ptr
+ 1;
2773 /* Gather the operand. */
2774 hold
= input_line_pointer
;
2775 input_line_pointer
= str
;
2778 if (*input_line_pointer
== '[')
2780 /* We are expecting something like the second argument here:
2782 * lwz r4,[toc].GS.0.static_int(rtoc)
2783 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2784 * The argument following the `]' must be a symbol name, and the
2785 * register must be the toc register: 'rtoc' or '2'
2787 * The effect is to 0 as the displacement field
2788 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2789 * the appropriate variation) reloc against it based on the symbol.
2790 * The linker will build the toc, and insert the resolved toc offset.
2793 * o The size of the toc entry is currently assumed to be
2794 * 32 bits. This should not be assumed to be a hard coded
2796 * o In an effort to cope with a change from 32 to 64 bits,
2797 * there are also toc entries that are specified to be
2798 * either 32 or 64 bits:
2799 * lwz r4,[toc32].GS.0.static_int(rtoc)
2800 * lwz r4,[toc64].GS.0.static_int(rtoc)
2801 * These demand toc entries of the specified size, and the
2802 * instruction probably requires it.
2806 enum toc_size_qualifier toc_kind
;
2807 bfd_reloc_code_real_type toc_reloc
;
2809 /* Go parse off the [tocXX] part. */
2810 valid_toc
= parse_toc_entry (&toc_kind
);
2814 ignore_rest_of_line ();
2818 /* Now get the symbol following the ']'. */
2824 /* In this case, we may not have seen the symbol yet,
2825 since it is allowed to appear on a .extern or .globl
2826 or just be a label in the .data section. */
2827 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2830 /* 1. The symbol must be defined and either in the toc
2831 section, or a global.
2832 2. The reloc generated must have the TOCDEFN flag set
2833 in upper bit mess of the reloc type.
2834 FIXME: It's a little confusing what the tocv
2835 qualifier can be used for. At the very least, I've
2836 seen three uses, only one of which I'm sure I can
2838 if (ex
.X_op
== O_symbol
)
2840 gas_assert (ex
.X_add_symbol
!= NULL
);
2841 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2844 as_bad (_("[tocv] symbol is not a toc symbol"));
2848 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2851 /* FIXME: these next two specifically specify 32/64 bit
2852 toc entries. We don't support them today. Is this
2853 the right way to say that? */
2854 toc_reloc
= BFD_RELOC_NONE
;
2855 as_bad (_("unimplemented toc32 expression modifier"));
2858 /* FIXME: see above. */
2859 toc_reloc
= BFD_RELOC_NONE
;
2860 as_bad (_("unimplemented toc64 expression modifier"));
2864 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2870 /* We need to generate a fixup for this expression. */
2871 if (fc
>= MAX_INSN_FIXUPS
)
2872 as_fatal (_("too many fixups"));
2874 fixups
[fc
].reloc
= toc_reloc
;
2875 fixups
[fc
].exp
= ex
;
2876 fixups
[fc
].opindex
= *opindex_ptr
;
2879 /* Ok. We've set up the fixup for the instruction. Now make it
2880 look like the constant 0 was found here. */
2882 ex
.X_op
= O_constant
;
2883 ex
.X_add_number
= 0;
2884 ex
.X_add_symbol
= NULL
;
2885 ex
.X_op_symbol
= NULL
;
2892 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2893 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2894 || !register_name (&ex
))
2896 char save_lex
= lex_type
['%'];
2898 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2899 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2902 lex_type
['%'] |= LEX_BEGIN_NAME
;
2906 lex_type
['%'] = save_lex
;
2910 str
= input_line_pointer
;
2911 input_line_pointer
= hold
;
2913 if (ex
.X_op
== O_illegal
)
2914 as_bad (_("illegal operand"));
2915 else if (ex
.X_op
== O_absent
)
2916 as_bad (_("missing operand"));
2917 else if (ex
.X_op
== O_register
)
2919 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2920 ppc_cpu
, (char *) NULL
, 0);
2922 else if (ex
.X_op
== O_constant
)
2925 /* Allow @HA, @L, @H on constants. */
2926 bfd_reloc_code_real_type reloc
;
2927 char *orig_str
= str
;
2929 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
2936 case BFD_RELOC_LO16
:
2937 ex
.X_add_number
&= 0xffff;
2938 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2939 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2942 case BFD_RELOC_HI16
:
2943 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2945 /* PowerPC64 @h is tested for overflow. */
2946 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2947 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2949 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2951 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2957 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2958 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2959 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2960 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2963 case BFD_RELOC_HI16_S
:
2964 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2966 /* PowerPC64 @ha is tested for overflow. */
2968 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2969 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2971 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2973 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2979 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2980 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2981 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2982 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2985 case BFD_RELOC_PPC64_HIGHER
:
2986 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2987 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2988 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2991 case BFD_RELOC_PPC64_HIGHER_S
:
2992 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2993 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2994 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2997 case BFD_RELOC_PPC64_HIGHEST
:
2998 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2999 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3000 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3003 case BFD_RELOC_PPC64_HIGHEST_S
:
3004 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
3005 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3006 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3009 #endif /* OBJ_ELF */
3010 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
3011 ppc_cpu
, (char *) NULL
, 0);
3015 bfd_reloc_code_real_type reloc
= BFD_RELOC_NONE
;
3017 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
3019 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
3020 if (sym_name
[0] == '.')
3023 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
3025 expressionS tls_exp
;
3027 hold
= input_line_pointer
;
3028 input_line_pointer
= str
+ 1;
3029 expression (&tls_exp
);
3030 if (tls_exp
.X_op
== O_symbol
)
3032 reloc
= BFD_RELOC_NONE
;
3033 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
3035 reloc
= BFD_RELOC_PPC_TLSGD
;
3036 input_line_pointer
+= 7;
3038 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
3040 reloc
= BFD_RELOC_PPC_TLSLD
;
3041 input_line_pointer
+= 7;
3043 if (reloc
!= BFD_RELOC_NONE
)
3046 str
= input_line_pointer
;
3048 if (fc
>= MAX_INSN_FIXUPS
)
3049 as_fatal (_("too many fixups"));
3050 fixups
[fc
].exp
= tls_exp
;
3051 fixups
[fc
].opindex
= *opindex_ptr
;
3052 fixups
[fc
].reloc
= reloc
;
3056 input_line_pointer
= hold
;
3060 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
3062 /* Some TLS tweaks. */
3068 case BFD_RELOC_PPC_TLS
:
3069 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
3070 as_bad (_("@tls may not be used with \"%s\" operands"),
3072 else if (operand
->shift
!= 11)
3073 as_bad (_("@tls may only be used in last operand"));
3075 insn
= ppc_insert_operand (insn
, operand
,
3077 ppc_cpu
, (char *) NULL
, 0);
3080 /* We'll only use the 32 (or 64) bit form of these relocations
3081 in constants. Instructions get the 16 bit form. */
3082 case BFD_RELOC_PPC_DTPREL
:
3083 reloc
= BFD_RELOC_PPC_DTPREL16
;
3085 case BFD_RELOC_PPC_TPREL
:
3086 reloc
= BFD_RELOC_PPC_TPREL16
;
3090 /* If VLE-mode convert LO/HI/HA relocations. */
3091 if (opcode
->flags
& PPC_OPCODE_VLE
)
3093 int tmp_insn
= insn
& opcode
->mask
;
3095 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3096 || tmp_insn
== E_AND2I_DOT_INSN
3097 || tmp_insn
== E_OR2IS_INSN
3098 || tmp_insn
== E_LIS_INSN
3099 || tmp_insn
== E_AND2IS_DOT_INSN
);
3102 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3103 || tmp_insn
== E_ADD2IS_INSN
3104 || tmp_insn
== E_CMP16I_INSN
3105 || tmp_insn
== E_MULL2I_INSN
3106 || tmp_insn
== E_CMPL16I_INSN
3107 || tmp_insn
== E_CMPH16I_INSN
3108 || tmp_insn
== E_CMPHL16I_INSN
);
3115 case BFD_RELOC_PPC_EMB_SDA21
:
3116 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3119 case BFD_RELOC_LO16
:
3121 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3122 else if (use_a_reloc
)
3123 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3126 case BFD_RELOC_HI16
:
3128 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3129 else if (use_a_reloc
)
3130 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3133 case BFD_RELOC_HI16_S
:
3135 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3136 else if (use_a_reloc
)
3137 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3140 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3142 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3145 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3147 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3150 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3152 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3157 #endif /* OBJ_ELF */
3159 if (reloc
!= BFD_RELOC_NONE
)
3161 /* Determine a BFD reloc value based on the operand information.
3162 We are only prepared to turn a few of the operands into
3164 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3165 | PPC_OPERAND_ABSOLUTE
)) != 0
3166 && operand
->bitm
== 0x3fffffc
3167 && operand
->shift
== 0)
3168 reloc
= BFD_RELOC_PPC_B26
;
3169 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3170 | PPC_OPERAND_ABSOLUTE
)) != 0
3171 && operand
->bitm
== 0xfffc
3172 && operand
->shift
== 0)
3173 reloc
= BFD_RELOC_PPC_B16
;
3174 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3175 && operand
->bitm
== 0x1fe
3176 && operand
->shift
== -1)
3177 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3178 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3179 && operand
->bitm
== 0xfffe
3180 && operand
->shift
== 0)
3181 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3182 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3183 && operand
->bitm
== 0x1fffffe
3184 && operand
->shift
== 0)
3185 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3186 else if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) == 0
3187 && (operand
->bitm
& 0xfff0) == 0xfff0
3188 && operand
->shift
== 0)
3190 reloc
= BFD_RELOC_16
;
3191 #if defined OBJ_XCOFF || defined OBJ_ELF
3192 /* Note: the symbol may be not yet defined. */
3193 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3194 && ppc_is_toc_sym (ex
.X_add_symbol
))
3196 reloc
= BFD_RELOC_PPC_TOC16
;
3198 as_warn (_("assuming %s on symbol"),
3199 ppc_obj64
? "@toc" : "@xgot");
3205 /* For the absolute forms of branches, convert the PC
3206 relative form back into the absolute. */
3207 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3211 case BFD_RELOC_PPC_B26
:
3212 reloc
= BFD_RELOC_PPC_BA26
;
3214 case BFD_RELOC_PPC_B16
:
3215 reloc
= BFD_RELOC_PPC_BA16
;
3218 case BFD_RELOC_PPC_B16_BRTAKEN
:
3219 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3221 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3222 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3233 case BFD_RELOC_PPC_TOC16
:
3234 toc_reloc_types
|= has_small_toc_reloc
;
3236 case BFD_RELOC_PPC64_TOC16_LO
:
3237 case BFD_RELOC_PPC64_TOC16_HI
:
3238 case BFD_RELOC_PPC64_TOC16_HA
:
3239 toc_reloc_types
|= has_large_toc_reloc
;
3246 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3251 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3253 case BFD_RELOC_LO16
:
3254 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3256 case BFD_RELOC_16_GOTOFF
:
3257 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3259 case BFD_RELOC_LO16_GOTOFF
:
3260 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3262 case BFD_RELOC_LO16_PLTOFF
:
3263 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3265 case BFD_RELOC_16_BASEREL
:
3266 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3268 case BFD_RELOC_LO16_BASEREL
:
3269 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3271 case BFD_RELOC_PPC_TOC16
:
3272 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3274 case BFD_RELOC_PPC64_TOC16_LO
:
3275 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3277 case BFD_RELOC_PPC64_PLTGOT16
:
3278 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3280 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3281 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3283 case BFD_RELOC_PPC_DTPREL16
:
3284 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3286 case BFD_RELOC_PPC_DTPREL16_LO
:
3287 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3289 case BFD_RELOC_PPC_TPREL16
:
3290 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3292 case BFD_RELOC_PPC_TPREL16_LO
:
3293 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3295 case BFD_RELOC_PPC_GOT_DTPREL16
:
3296 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3297 case BFD_RELOC_PPC_GOT_TPREL16
:
3298 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3301 as_bad (_("unsupported relocation for DS offset field"));
3307 /* We need to generate a fixup for this expression. */
3308 if (fc
>= MAX_INSN_FIXUPS
)
3309 as_fatal (_("too many fixups"));
3310 fixups
[fc
].exp
= ex
;
3311 fixups
[fc
].opindex
= *opindex_ptr
;
3312 fixups
[fc
].reloc
= reloc
;
3320 /* If expecting more operands, then we want to see "),". */
3321 if (*str
== endc
&& opindex_ptr
[1] != 0)
3325 while (ISSPACE (*str
));
3329 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3337 /* The call to expression should have advanced str past any
3340 && (endc
!= ',' || *str
!= '\0'))
3343 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3345 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3353 while (ISSPACE (*str
))
3357 as_bad (_("junk at end of line: `%s'"), str
);
3360 /* Do we need/want an APUinfo section? */
3361 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3364 /* These are all version "1". */
3365 if (opcode
->flags
& PPC_OPCODE_SPE
)
3366 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3367 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3368 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3369 if (opcode
->flags
& PPC_OPCODE_EFS
)
3370 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3371 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3372 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3373 if (opcode
->flags
& PPC_OPCODE_PMR
)
3374 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3375 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3376 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3377 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3378 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3379 /* Only set the VLE flag if the instruction has been pulled via
3380 the VLE instruction set. This way the flag is guaranteed to
3381 be set for VLE-only instructions or for VLE-only processors,
3382 however it'll remain clear for dual-mode instructions on
3383 dual-mode and, more importantly, standard-mode processors. */
3384 if ((ppc_cpu
& opcode
->flags
) == PPC_OPCODE_VLE
)
3385 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3389 /* Write out the instruction. */
3390 /* Differentiate between two and four byte insns. */
3391 if (ppc_mach () == bfd_mach_ppc_vle
)
3393 if (PPC_OP_SE_VLE (insn
))
3397 addr_mod
= frag_now_fix () & 1;
3402 addr_mod
= frag_now_fix () & 3;
3404 /* All instructions can start on a 2 byte boundary for VLE. */
3405 f
= frag_more (insn_length
);
3406 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3408 if (ppc_mach() == bfd_mach_ppc_vle
)
3409 as_bad (_("instruction address is not a multiple of 2"));
3411 as_bad (_("instruction address is not a multiple of 4"));
3413 frag_now
->insn_addr
= addr_mod
;
3414 frag_now
->has_code
= 1;
3415 md_number_to_chars (f
, insn
, insn_length
);
3418 last_subseg
= now_subseg
;
3421 dwarf2_emit_insn (insn_length
);
3424 /* Create any fixups. */
3425 for (i
= 0; i
< fc
; i
++)
3428 if (fixups
[i
].reloc
!= BFD_RELOC_NONE
)
3430 reloc_howto_type
*reloc_howto
;
3434 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3438 size
= bfd_get_reloc_size (reloc_howto
);
3439 offset
= target_big_endian
? (insn_length
- size
) : 0;
3441 fixP
= fix_new_exp (frag_now
,
3442 f
- frag_now
->fr_literal
+ offset
,
3445 reloc_howto
->pc_relative
,
3450 const struct powerpc_operand
*operand
;
3452 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3453 fixP
= fix_new_exp (frag_now
,
3454 f
- frag_now
->fr_literal
,
3457 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3460 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3464 /* Handle a macro. Gather all the operands, transform them as
3465 described by the macro, and call md_assemble recursively. All the
3466 operands are separated by commas; we don't accept parentheses
3467 around operands here. */
3470 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3481 /* Gather the users operands into the operands array. */
3486 if (count
>= sizeof operands
/ sizeof operands
[0])
3488 operands
[count
++] = s
;
3489 s
= strchr (s
, ',');
3490 if (s
== (char *) NULL
)
3495 if (count
!= macro
->operands
)
3497 as_bad (_("wrong number of operands"));
3501 /* Work out how large the string must be (the size is unbounded
3502 because it includes user input). */
3504 format
= macro
->format
;
3505 while (*format
!= '\0')
3514 arg
= strtol (format
+ 1, &send
, 10);
3515 know (send
!= format
&& arg
< count
);
3516 len
+= strlen (operands
[arg
]);
3521 /* Put the string together. */
3522 complete
= s
= (char *) alloca (len
+ 1);
3523 format
= macro
->format
;
3524 while (*format
!= '\0')
3530 arg
= strtol (format
+ 1, &send
, 10);
3531 strcpy (s
, operands
[arg
]);
3538 /* Assemble the constructed instruction. */
3539 md_assemble (complete
);
3543 /* For ELF, add support for SHT_ORDERED. */
3546 ppc_section_type (char *str
, size_t len
)
3548 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3555 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3557 if (type
== SHT_ORDERED
)
3558 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3562 #endif /* OBJ_ELF */
3565 /* Pseudo-op handling. */
3567 /* The .byte pseudo-op. This is similar to the normal .byte
3568 pseudo-op, but it can also take a single ASCII string. */
3571 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3575 if (*input_line_pointer
!= '\"')
3581 /* Gather characters. A real double quote is doubled. Unusual
3582 characters are not permitted. */
3583 ++input_line_pointer
;
3588 c
= *input_line_pointer
++;
3592 if (*input_line_pointer
!= '\"')
3594 ++input_line_pointer
;
3597 FRAG_APPEND_1_CHAR (c
);
3601 if (warn_476
&& count
!= 0 && (now_seg
->flags
& SEC_CODE
) != 0)
3602 as_warn (_("data in executable section"));
3603 demand_empty_rest_of_line ();
3608 /* XCOFF specific pseudo-op handling. */
3610 /* This is set if we are creating a .stabx symbol, since we don't want
3611 to handle symbol suffixes for such symbols. */
3612 static bfd_boolean ppc_stab_symbol
;
3614 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3615 symbols in the .bss segment as though they were local common
3616 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3617 aligns .comm and .lcomm to 4 bytes. */
3620 ppc_comm (int lcomm
)
3622 asection
*current_seg
= now_seg
;
3623 subsegT current_subseg
= now_subseg
;
3629 symbolS
*lcomm_sym
= NULL
;
3633 name
= input_line_pointer
;
3634 endc
= get_symbol_end ();
3635 end_name
= input_line_pointer
;
3638 if (*input_line_pointer
!= ',')
3640 as_bad (_("missing size"));
3641 ignore_rest_of_line ();
3644 ++input_line_pointer
;
3646 size
= get_absolute_expression ();
3649 as_bad (_("negative size"));
3650 ignore_rest_of_line ();
3656 /* The third argument to .comm is the alignment. */
3657 if (*input_line_pointer
!= ',')
3661 ++input_line_pointer
;
3662 align
= get_absolute_expression ();
3665 as_warn (_("ignoring bad alignment"));
3675 /* The third argument to .lcomm appears to be the real local
3676 common symbol to create. References to the symbol named in
3677 the first argument are turned into references to the third
3679 if (*input_line_pointer
!= ',')
3681 as_bad (_("missing real symbol name"));
3682 ignore_rest_of_line ();
3685 ++input_line_pointer
;
3687 lcomm_name
= input_line_pointer
;
3688 lcomm_endc
= get_symbol_end ();
3690 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3692 *input_line_pointer
= lcomm_endc
;
3694 /* The fourth argument to .lcomm is the alignment. */
3695 if (*input_line_pointer
!= ',')
3704 ++input_line_pointer
;
3705 align
= get_absolute_expression ();
3708 as_warn (_("ignoring bad alignment"));
3715 sym
= symbol_find_or_make (name
);
3718 if (S_IS_DEFINED (sym
)
3719 || S_GET_VALUE (sym
) != 0)
3721 as_bad (_("attempt to redefine symbol"));
3722 ignore_rest_of_line ();
3726 record_alignment (bss_section
, align
);
3729 || ! S_IS_DEFINED (lcomm_sym
))
3738 S_SET_EXTERNAL (sym
);
3742 symbol_get_tc (lcomm_sym
)->output
= 1;
3743 def_sym
= lcomm_sym
;
3747 subseg_set (bss_section
, 1);
3748 frag_align (align
, 0, 0);
3750 symbol_set_frag (def_sym
, frag_now
);
3751 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3752 def_size
, (char *) NULL
);
3754 S_SET_SEGMENT (def_sym
, bss_section
);
3755 symbol_get_tc (def_sym
)->align
= align
;
3759 /* Align the size of lcomm_sym. */
3760 symbol_get_frag (lcomm_sym
)->fr_offset
=
3761 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3762 &~ ((1 << align
) - 1));
3763 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3764 symbol_get_tc (lcomm_sym
)->align
= align
;
3769 /* Make sym an offset from lcomm_sym. */
3770 S_SET_SEGMENT (sym
, bss_section
);
3771 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3772 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3773 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3776 subseg_set (current_seg
, current_subseg
);
3778 demand_empty_rest_of_line ();
3781 /* The .csect pseudo-op. This switches us into a different
3782 subsegment. The first argument is a symbol whose value is the
3783 start of the .csect. In COFF, csect symbols get special aux
3784 entries defined by the x_csect field of union internal_auxent. The
3785 optional second argument is the alignment (the default is 2). */
3788 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3795 name
= input_line_pointer
;
3796 endc
= get_symbol_end ();
3798 sym
= symbol_find_or_make (name
);
3800 *input_line_pointer
= endc
;
3802 if (S_GET_NAME (sym
)[0] == '\0')
3804 /* An unnamed csect is assumed to be [PR]. */
3805 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3809 if (*input_line_pointer
== ',')
3811 ++input_line_pointer
;
3812 align
= get_absolute_expression ();
3815 ppc_change_csect (sym
, align
);
3817 demand_empty_rest_of_line ();
3820 /* Change to a different csect. */
3823 ppc_change_csect (symbolS
*sym
, offsetT align
)
3825 if (S_IS_DEFINED (sym
))
3826 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3836 /* This is a new csect. We need to look at the symbol class to
3837 figure out whether it should go in the text section or the
3841 switch (symbol_get_tc (sym
)->symbol_class
)
3851 S_SET_SEGMENT (sym
, text_section
);
3852 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3853 ++ppc_text_subsegment
;
3854 list_ptr
= &ppc_text_csects
;
3864 if (ppc_toc_csect
!= NULL
3865 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3866 == ppc_data_subsegment
))
3868 S_SET_SEGMENT (sym
, data_section
);
3869 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3870 ++ppc_data_subsegment
;
3871 list_ptr
= &ppc_data_csects
;
3877 /* We set the obstack chunk size to a small value before
3878 changing subsegments, so that we don't use a lot of memory
3879 space for what may be a small section. */
3880 hold_chunksize
= chunksize
;
3883 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3884 symbol_get_tc (sym
)->subseg
);
3886 chunksize
= hold_chunksize
;
3889 ppc_after_toc_frag
= frag_now
;
3891 record_alignment (sec
, align
);
3893 frag_align_code (align
, 0);
3895 frag_align (align
, 0, 0);
3897 symbol_set_frag (sym
, frag_now
);
3898 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3900 symbol_get_tc (sym
)->align
= align
;
3901 symbol_get_tc (sym
)->output
= 1;
3902 symbol_get_tc (sym
)->within
= sym
;
3904 for (list
= *list_ptr
;
3905 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3906 list
= symbol_get_tc (list
)->next
)
3908 symbol_get_tc (list
)->next
= sym
;
3910 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3911 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3915 ppc_current_csect
= sym
;
3919 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3923 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3925 sec
= subseg_new (dw
->name
, subseg
);
3926 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3927 if (oldflags
== SEC_NO_FLAGS
)
3929 /* Just created section. */
3930 gas_assert (dw_sections
[idx
].sect
== NULL
);
3932 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3933 bfd_set_section_alignment (stdoutput
, sec
, 0);
3934 dw_sections
[idx
].sect
= sec
;
3937 /* Not anymore in a csect. */
3938 ppc_current_csect
= NULL
;
3941 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3942 .dwsect flag [, opt-label ]
3946 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3950 const struct xcoff_dwsect_name
*dw
;
3951 struct dw_subsection
*subseg
;
3952 struct dw_section
*dws
;
3956 flag
= get_absolute_expression ();
3958 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3959 if (xcoff_dwsect_names
[i
].flag
== flag
)
3961 dw
= &xcoff_dwsect_names
[i
];
3965 /* Parse opt-label. */
3966 if (*input_line_pointer
== ',')
3971 ++input_line_pointer
;
3973 label
= input_line_pointer
;
3974 c
= get_symbol_end ();
3975 opt_label
= symbol_find_or_make (label
);
3976 *input_line_pointer
= c
;
3981 demand_empty_rest_of_line ();
3983 /* Return now in case of unknown subsection. */
3986 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3991 /* Find the subsection. */
3992 dws
= &dw_sections
[i
];
3994 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3996 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3997 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3999 as_bad (_("label %s was not defined in this dwarf section"),
4000 S_GET_NAME (opt_label
));
4001 subseg
= dws
->anon_subseg
;
4005 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
4010 /* Switch to the subsection. */
4011 ppc_change_debug_section (i
, subseg
->subseg
);
4015 /* Create a new dw subsection. */
4016 subseg
= (struct dw_subsection
*)
4017 xmalloc (sizeof (struct dw_subsection
));
4019 if (opt_label
== NULL
)
4021 /* The anonymous one. */
4023 subseg
->link
= NULL
;
4024 dws
->anon_subseg
= subseg
;
4029 if (dws
->list_subseg
!= NULL
)
4030 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
4034 subseg
->link
= dws
->list_subseg
;
4035 dws
->list_subseg
= subseg
;
4036 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
4039 ppc_change_debug_section (i
, subseg
->subseg
);
4043 /* Add the length field. */
4044 expressionS
*exp
= &subseg
->end_exp
;
4047 if (opt_label
!= NULL
)
4048 symbol_set_value_now (opt_label
);
4050 /* Add the length field. Note that according to the AIX assembler
4051 manual, the size of the length field is 4 for powerpc32 but
4052 12 for powerpc64. */
4055 /* Write the 64bit marker. */
4056 md_number_to_chars (frag_more (4), -1, 4);
4059 exp
->X_op
= O_subtract
;
4060 exp
->X_op_symbol
= symbol_temp_new_now ();
4061 exp
->X_add_symbol
= symbol_temp_make ();
4063 sz
= ppc_obj64
? 8 : 4;
4064 exp
->X_add_number
= -sz
;
4065 emit_expr (exp
, sz
);
4070 /* This function handles the .text and .data pseudo-ops. These
4071 pseudo-ops aren't really used by XCOFF; we implement them for the
4072 convenience of people who aren't used to XCOFF. */
4075 ppc_section (int type
)
4082 else if (type
== 'd')
4087 sym
= symbol_find_or_make (name
);
4089 ppc_change_csect (sym
, 2);
4091 demand_empty_rest_of_line ();
4094 /* This function handles the .section pseudo-op. This is mostly to
4095 give an error, since XCOFF only supports .text, .data and .bss, but
4096 we do permit the user to name the text or data section. */
4099 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4102 const char *real_name
;
4106 user_name
= input_line_pointer
;
4107 c
= get_symbol_end ();
4109 if (strcmp (user_name
, ".text") == 0)
4110 real_name
= ".text[PR]";
4111 else if (strcmp (user_name
, ".data") == 0)
4112 real_name
= ".data[RW]";
4115 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4116 *input_line_pointer
= c
;
4117 ignore_rest_of_line ();
4121 *input_line_pointer
= c
;
4123 sym
= symbol_find_or_make (real_name
);
4125 ppc_change_csect (sym
, 2);
4127 demand_empty_rest_of_line ();
4130 /* The .extern pseudo-op. We create an undefined symbol. */
4133 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4138 name
= input_line_pointer
;
4139 endc
= get_symbol_end ();
4141 (void) symbol_find_or_make (name
);
4143 *input_line_pointer
= endc
;
4145 demand_empty_rest_of_line ();
4148 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4151 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4157 name
= input_line_pointer
;
4158 endc
= get_symbol_end ();
4160 sym
= symbol_find_or_make (name
);
4162 *input_line_pointer
= endc
;
4164 symbol_get_tc (sym
)->output
= 1;
4166 demand_empty_rest_of_line ();
4169 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4170 relocations at the beginning of the current csect.
4172 (In principle, there's no reason why the relocations _have_ to be at
4173 the beginning. Anywhere in the csect would do. However, inserting
4174 at the beginning is what the native assmebler does, and it helps to
4175 deal with cases where the .ref statements follow the section contents.)
4177 ??? .refs don't work for empty .csects. However, the native assembler
4178 doesn't report an error in this case, and neither yet do we. */
4181 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4186 if (ppc_current_csect
== NULL
)
4188 as_bad (_(".ref outside .csect"));
4189 ignore_rest_of_line ();
4195 name
= input_line_pointer
;
4196 c
= get_symbol_end ();
4198 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4199 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4201 *input_line_pointer
= c
;
4203 c
= *input_line_pointer
;
4206 input_line_pointer
++;
4208 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4210 as_bad (_("missing symbol name"));
4211 ignore_rest_of_line ();
4218 demand_empty_rest_of_line ();
4221 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4222 although I don't know why it bothers. */
4225 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4232 name
= input_line_pointer
;
4233 endc
= get_symbol_end ();
4235 sym
= symbol_find_or_make (name
);
4237 *input_line_pointer
= endc
;
4239 if (*input_line_pointer
!= ',')
4241 as_bad (_("missing rename string"));
4242 ignore_rest_of_line ();
4245 ++input_line_pointer
;
4247 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4249 demand_empty_rest_of_line ();
4252 /* The .stabx pseudo-op. This is similar to a normal .stabs
4253 pseudo-op, but slightly different. A sample is
4254 .stabx "main:F-1",.main,142,0
4255 The first argument is the symbol name to create. The second is the
4256 value, and the third is the storage class. The fourth seems to be
4257 always zero, and I am assuming it is the type. */
4260 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4267 name
= demand_copy_C_string (&len
);
4269 if (*input_line_pointer
!= ',')
4271 as_bad (_("missing value"));
4274 ++input_line_pointer
;
4276 ppc_stab_symbol
= TRUE
;
4277 sym
= symbol_make (name
);
4278 ppc_stab_symbol
= FALSE
;
4280 symbol_get_tc (sym
)->real_name
= name
;
4282 (void) expression (&exp
);
4289 as_bad (_("illegal .stabx expression; zero assumed"));
4290 exp
.X_add_number
= 0;
4293 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4294 symbol_set_frag (sym
, &zero_address_frag
);
4298 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4299 symbol_set_value_expression (sym
, &exp
);
4303 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4304 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4309 /* The value is some complex expression. This will probably
4310 fail at some later point, but this is probably the right
4311 thing to do here. */
4312 symbol_set_value_expression (sym
, &exp
);
4316 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4317 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4319 if (*input_line_pointer
!= ',')
4321 as_bad (_("missing class"));
4324 ++input_line_pointer
;
4326 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4328 if (*input_line_pointer
!= ',')
4330 as_bad (_("missing type"));
4333 ++input_line_pointer
;
4335 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4337 symbol_get_tc (sym
)->output
= 1;
4339 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4344 .stabx "z",arrays_,133,0
4347 .comm arrays_,13768,3
4349 resolve_symbol_value will copy the exp's "within" into sym's when the
4350 offset is 0. Since this seems to be corner case problem,
4351 only do the correction for storage class C_STSYM. A better solution
4352 would be to have the tc field updated in ppc_symbol_new_hook. */
4354 if (exp
.X_op
== O_symbol
)
4356 if (ppc_current_block
== NULL
)
4357 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4359 symbol_get_tc (sym
)->within
= ppc_current_block
;
4360 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4364 if (exp
.X_op
!= O_symbol
4365 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4366 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4367 ppc_frob_label (sym
);
4370 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4371 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4372 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4373 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4376 demand_empty_rest_of_line ();
4379 /* The .function pseudo-op. This takes several arguments. The first
4380 argument seems to be the external name of the symbol. The second
4381 argument seems to be the label for the start of the function. gcc
4382 uses the same name for both. I have no idea what the third and
4383 fourth arguments are meant to be. The optional fifth argument is
4384 an expression for the size of the function. In COFF this symbol
4385 gets an aux entry like that used for a csect. */
4388 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4396 name
= input_line_pointer
;
4397 endc
= get_symbol_end ();
4399 /* Ignore any [PR] suffix. */
4400 name
= ppc_canonicalize_symbol_name (name
);
4401 s
= strchr (name
, '[');
4402 if (s
!= (char *) NULL
4403 && strcmp (s
+ 1, "PR]") == 0)
4406 ext_sym
= symbol_find_or_make (name
);
4408 *input_line_pointer
= endc
;
4410 if (*input_line_pointer
!= ',')
4412 as_bad (_("missing symbol name"));
4413 ignore_rest_of_line ();
4416 ++input_line_pointer
;
4418 name
= input_line_pointer
;
4419 endc
= get_symbol_end ();
4421 lab_sym
= symbol_find_or_make (name
);
4423 *input_line_pointer
= endc
;
4425 if (ext_sym
!= lab_sym
)
4429 exp
.X_op
= O_symbol
;
4430 exp
.X_add_symbol
= lab_sym
;
4431 exp
.X_op_symbol
= NULL
;
4432 exp
.X_add_number
= 0;
4434 symbol_set_value_expression (ext_sym
, &exp
);
4437 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4438 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4439 symbol_get_tc (ext_sym
)->output
= 1;
4441 if (*input_line_pointer
== ',')
4445 /* Ignore the third argument. */
4446 ++input_line_pointer
;
4448 if (*input_line_pointer
== ',')
4450 /* Ignore the fourth argument. */
4451 ++input_line_pointer
;
4453 if (*input_line_pointer
== ',')
4455 /* The fifth argument is the function size. */
4456 ++input_line_pointer
;
4457 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4458 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4459 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4464 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4465 SF_SET_FUNCTION (ext_sym
);
4466 SF_SET_PROCESS (ext_sym
);
4467 coff_add_linesym (ext_sym
);
4469 demand_empty_rest_of_line ();
4472 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4473 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4474 with the correct line number */
4476 static symbolS
*saved_bi_sym
= 0;
4479 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4483 sym
= symbol_make (".bf");
4484 S_SET_SEGMENT (sym
, text_section
);
4485 symbol_set_frag (sym
, frag_now
);
4486 S_SET_VALUE (sym
, frag_now_fix ());
4487 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4489 coff_line_base
= get_absolute_expression ();
4491 S_SET_NUMBER_AUXILIARY (sym
, 1);
4492 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4494 /* Line number for bi. */
4497 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4502 symbol_get_tc (sym
)->output
= 1;
4504 ppc_frob_label (sym
);
4506 demand_empty_rest_of_line ();
4509 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4510 ".ef", except that the line number is absolute, not relative to the
4511 most recent ".bf" symbol. */
4514 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4518 sym
= symbol_make (".ef");
4519 S_SET_SEGMENT (sym
, text_section
);
4520 symbol_set_frag (sym
, frag_now
);
4521 S_SET_VALUE (sym
, frag_now_fix ());
4522 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4523 S_SET_NUMBER_AUXILIARY (sym
, 1);
4524 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4525 symbol_get_tc (sym
)->output
= 1;
4527 ppc_frob_label (sym
);
4529 demand_empty_rest_of_line ();
4532 /* The .bi and .ei pseudo-ops. These take a string argument and
4533 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4534 the symbol list. The value of .bi will be know when the next .bf
4540 static symbolS
*last_biei
;
4547 name
= demand_copy_C_string (&len
);
4549 /* The value of these symbols is actually file offset. Here we set
4550 the value to the index into the line number entries. In
4551 ppc_frob_symbols we set the fix_line field, which will cause BFD
4552 to do the right thing. */
4554 sym
= symbol_make (name
);
4555 /* obj-coff.c currently only handles line numbers correctly in the
4557 S_SET_SEGMENT (sym
, text_section
);
4558 S_SET_VALUE (sym
, coff_n_line_nos
);
4559 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4561 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4562 symbol_get_tc (sym
)->output
= 1;
4570 for (look
= last_biei
? last_biei
: symbol_rootP
;
4571 (look
!= (symbolS
*) NULL
4572 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4573 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4574 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4575 look
= symbol_next (look
))
4577 if (look
!= (symbolS
*) NULL
)
4579 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4580 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4584 demand_empty_rest_of_line ();
4587 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4588 There is one argument, which is a csect symbol. The value of the
4589 .bs symbol is the index of this csect symbol. */
4592 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4599 if (ppc_current_block
!= NULL
)
4600 as_bad (_("nested .bs blocks"));
4602 name
= input_line_pointer
;
4603 endc
= get_symbol_end ();
4605 csect
= symbol_find_or_make (name
);
4607 *input_line_pointer
= endc
;
4609 sym
= symbol_make (".bs");
4610 S_SET_SEGMENT (sym
, now_seg
);
4611 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4612 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4613 symbol_get_tc (sym
)->output
= 1;
4615 symbol_get_tc (sym
)->within
= csect
;
4617 ppc_frob_label (sym
);
4619 ppc_current_block
= sym
;
4621 demand_empty_rest_of_line ();
4624 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4627 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4631 if (ppc_current_block
== NULL
)
4632 as_bad (_(".es without preceding .bs"));
4634 sym
= symbol_make (".es");
4635 S_SET_SEGMENT (sym
, now_seg
);
4636 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4637 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4638 symbol_get_tc (sym
)->output
= 1;
4640 ppc_frob_label (sym
);
4642 ppc_current_block
= NULL
;
4644 demand_empty_rest_of_line ();
4647 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4651 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4655 sym
= symbol_make (".bb");
4656 S_SET_SEGMENT (sym
, text_section
);
4657 symbol_set_frag (sym
, frag_now
);
4658 S_SET_VALUE (sym
, frag_now_fix ());
4659 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4661 S_SET_NUMBER_AUXILIARY (sym
, 1);
4662 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4664 symbol_get_tc (sym
)->output
= 1;
4666 SF_SET_PROCESS (sym
);
4668 ppc_frob_label (sym
);
4670 demand_empty_rest_of_line ();
4673 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4677 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4681 sym
= symbol_make (".eb");
4682 S_SET_SEGMENT (sym
, text_section
);
4683 symbol_set_frag (sym
, frag_now
);
4684 S_SET_VALUE (sym
, frag_now_fix ());
4685 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4686 S_SET_NUMBER_AUXILIARY (sym
, 1);
4687 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4688 symbol_get_tc (sym
)->output
= 1;
4690 SF_SET_PROCESS (sym
);
4692 ppc_frob_label (sym
);
4694 demand_empty_rest_of_line ();
4697 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4701 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4707 name
= demand_copy_C_string (&len
);
4708 sym
= symbol_make (name
);
4709 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4710 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4711 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4712 S_SET_VALUE (sym
, 0);
4713 symbol_get_tc (sym
)->output
= 1;
4715 ppc_frob_label (sym
);
4717 demand_empty_rest_of_line ();
4720 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4723 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4727 sym
= symbol_make (".ec");
4728 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4729 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4730 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4731 S_SET_VALUE (sym
, 0);
4732 symbol_get_tc (sym
)->output
= 1;
4734 ppc_frob_label (sym
);
4736 demand_empty_rest_of_line ();
4739 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4742 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4744 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4745 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4752 subseg
= ppc_data_subsegment
;
4753 ++ppc_data_subsegment
;
4755 subseg_new (segment_name (data_section
), subseg
);
4756 ppc_toc_frag
= frag_now
;
4758 sym
= symbol_find_or_make ("TOC[TC0]");
4759 symbol_set_frag (sym
, frag_now
);
4760 S_SET_SEGMENT (sym
, data_section
);
4761 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4762 symbol_get_tc (sym
)->subseg
= subseg
;
4763 symbol_get_tc (sym
)->output
= 1;
4764 symbol_get_tc (sym
)->within
= sym
;
4766 ppc_toc_csect
= sym
;
4768 for (list
= ppc_data_csects
;
4769 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4770 list
= symbol_get_tc (list
)->next
)
4772 symbol_get_tc (list
)->next
= sym
;
4774 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4775 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4779 ppc_current_csect
= ppc_toc_csect
;
4781 demand_empty_rest_of_line ();
4784 /* The AIX assembler automatically aligns the operands of a .long or
4785 .short pseudo-op, and we want to be compatible. */
4788 ppc_xcoff_cons (int log_size
)
4790 frag_align (log_size
, 0, 0);
4791 record_alignment (now_seg
, log_size
);
4792 cons (1 << log_size
);
4796 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4801 (void) expression (&exp
);
4803 if (exp
.X_op
!= O_constant
)
4805 as_bad (_("non-constant byte count"));
4809 byte_count
= exp
.X_add_number
;
4811 if (*input_line_pointer
!= ',')
4813 as_bad (_("missing value"));
4817 ++input_line_pointer
;
4822 ppc_xcoff_end (void)
4826 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4828 struct dw_section
*dws
= &dw_sections
[i
];
4829 struct dw_subsection
*dwss
;
4831 if (dws
->anon_subseg
)
4833 dwss
= dws
->anon_subseg
;
4834 dwss
->link
= dws
->list_subseg
;
4837 dwss
= dws
->list_subseg
;
4839 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4840 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4842 subseg_set (dws
->sect
, dwss
->subseg
);
4843 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4848 #endif /* OBJ_XCOFF */
4849 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4851 /* The .tc pseudo-op. This is used when generating either XCOFF or
4852 ELF. This takes two or more arguments.
4854 When generating XCOFF output, the first argument is the name to
4855 give to this location in the toc; this will be a symbol with class
4856 TC. The rest of the arguments are N-byte values to actually put at
4857 this location in the TOC; often there is just one more argument, a
4858 relocatable symbol reference. The size of the value to store
4859 depends on target word size. A 32-bit target uses 4-byte values, a
4860 64-bit target uses 8-byte values.
4862 When not generating XCOFF output, the arguments are the same, but
4863 the first argument is simply ignored. */
4866 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4870 /* Define the TOC symbol name. */
4876 if (ppc_toc_csect
== (symbolS
*) NULL
4877 || ppc_toc_csect
!= ppc_current_csect
)
4879 as_bad (_(".tc not in .toc section"));
4880 ignore_rest_of_line ();
4884 name
= input_line_pointer
;
4885 endc
= get_symbol_end ();
4887 sym
= symbol_find_or_make (name
);
4889 *input_line_pointer
= endc
;
4891 if (S_IS_DEFINED (sym
))
4895 label
= symbol_get_tc (ppc_current_csect
)->within
;
4896 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4898 as_bad (_(".tc with no label"));
4899 ignore_rest_of_line ();
4903 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4904 symbol_set_frag (label
, symbol_get_frag (sym
));
4905 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4907 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4908 ++input_line_pointer
;
4913 S_SET_SEGMENT (sym
, now_seg
);
4914 symbol_set_frag (sym
, frag_now
);
4915 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4916 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4917 symbol_get_tc (sym
)->output
= 1;
4919 ppc_frob_label (sym
);
4922 #endif /* OBJ_XCOFF */
4926 /* Skip the TOC symbol name. */
4927 while (is_part_of_name (*input_line_pointer
)
4928 || *input_line_pointer
== ' '
4929 || *input_line_pointer
== '['
4930 || *input_line_pointer
== ']'
4931 || *input_line_pointer
== '{'
4932 || *input_line_pointer
== '}')
4933 ++input_line_pointer
;
4935 /* Align to a four/eight byte boundary. */
4936 align
= ppc_obj64
? 3 : 2;
4937 frag_align (align
, 0, 0);
4938 record_alignment (now_seg
, align
);
4939 #endif /* OBJ_ELF */
4941 if (*input_line_pointer
!= ',')
4942 demand_empty_rest_of_line ();
4945 ++input_line_pointer
;
4946 cons (ppc_obj64
? 8 : 4);
4950 /* Pseudo-op .machine. */
4953 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4956 #define MAX_HISTORY 100
4957 static ppc_cpu_t
*cpu_history
;
4958 static int curr_hist
;
4962 if (*input_line_pointer
== '"')
4965 cpu_string
= demand_copy_C_string (&len
);
4970 cpu_string
= input_line_pointer
;
4971 c
= get_symbol_end ();
4972 cpu_string
= xstrdup (cpu_string
);
4973 *input_line_pointer
= c
;
4976 if (cpu_string
!= NULL
)
4978 ppc_cpu_t old_cpu
= ppc_cpu
;
4982 for (p
= cpu_string
; *p
!= 0; p
++)
4985 if (strcmp (cpu_string
, "push") == 0)
4987 if (cpu_history
== NULL
)
4988 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4990 if (curr_hist
>= MAX_HISTORY
)
4991 as_bad (_(".machine stack overflow"));
4993 cpu_history
[curr_hist
++] = ppc_cpu
;
4995 else if (strcmp (cpu_string
, "pop") == 0)
4998 as_bad (_(".machine stack underflow"));
5000 ppc_cpu
= cpu_history
[--curr_hist
];
5002 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
5005 as_bad (_("invalid machine `%s'"), cpu_string
);
5007 if (ppc_cpu
!= old_cpu
)
5008 ppc_setup_opcodes ();
5011 demand_empty_rest_of_line ();
5013 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5017 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
5019 /* Set the current section. */
5021 ppc_set_current_section (segT
new)
5023 ppc_previous_section
= ppc_current_section
;
5024 ppc_current_section
= new;
5027 /* pseudo-op: .previous
5028 behaviour: toggles the current section with the previous section.
5030 warnings: "No previous section" */
5033 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
5035 if (ppc_previous_section
== NULL
)
5037 as_warn (_("no previous section to return to, ignored."));
5041 subseg_set (ppc_previous_section
, 0);
5043 ppc_set_current_section (ppc_previous_section
);
5046 /* pseudo-op: .pdata
5047 behaviour: predefined read only data section
5051 initial: .section .pdata "adr3"
5052 a - don't know -- maybe a misprint
5053 d - initialized data
5055 3 - double word aligned (that would be 4 byte boundary)
5058 Tag index tables (also known as the function table) for exception
5059 handling, debugging, etc. */
5062 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
5064 if (pdata_section
== 0)
5066 pdata_section
= subseg_new (".pdata", 0);
5068 bfd_set_section_flags (stdoutput
, pdata_section
,
5069 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5070 | SEC_READONLY
| SEC_DATA
));
5072 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5076 pdata_section
= subseg_new (".pdata", 0);
5078 ppc_set_current_section (pdata_section
);
5081 /* pseudo-op: .ydata
5082 behaviour: predefined read only data section
5086 initial: .section .ydata "drw3"
5087 a - don't know -- maybe a misprint
5088 d - initialized data
5090 3 - double word aligned (that would be 4 byte boundary)
5092 Tag tables (also known as the scope table) for exception handling,
5096 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5098 if (ydata_section
== 0)
5100 ydata_section
= subseg_new (".ydata", 0);
5101 bfd_set_section_flags (stdoutput
, ydata_section
,
5102 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5103 | SEC_READONLY
| SEC_DATA
));
5105 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5109 ydata_section
= subseg_new (".ydata", 0);
5111 ppc_set_current_section (ydata_section
);
5114 /* pseudo-op: .reldata
5115 behaviour: predefined read write data section
5116 double word aligned (4-byte)
5117 FIXME: relocation is applied to it
5118 FIXME: what's the difference between this and .data?
5121 initial: .section .reldata "drw3"
5122 d - initialized data
5125 3 - double word aligned (that would be 8 byte boundary)
5128 Like .data, but intended to hold data subject to relocation, such as
5129 function descriptors, etc. */
5132 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5134 if (reldata_section
== 0)
5136 reldata_section
= subseg_new (".reldata", 0);
5138 bfd_set_section_flags (stdoutput
, reldata_section
,
5139 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5142 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5146 reldata_section
= subseg_new (".reldata", 0);
5148 ppc_set_current_section (reldata_section
);
5151 /* pseudo-op: .rdata
5152 behaviour: predefined read only data section
5156 initial: .section .rdata "dr3"
5157 d - initialized data
5159 3 - double word aligned (that would be 4 byte boundary) */
5162 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5164 if (rdata_section
== 0)
5166 rdata_section
= subseg_new (".rdata", 0);
5167 bfd_set_section_flags (stdoutput
, rdata_section
,
5168 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5169 | SEC_READONLY
| SEC_DATA
));
5171 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5175 rdata_section
= subseg_new (".rdata", 0);
5177 ppc_set_current_section (rdata_section
);
5180 /* pseudo-op: .ualong
5181 behaviour: much like .int, with the exception that no alignment is
5183 FIXME: test the alignment statement
5188 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5194 /* pseudo-op: .znop <symbol name>
5195 behaviour: Issue a nop instruction
5196 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5197 the supplied symbol name.
5199 warnings: Missing symbol name */
5202 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5205 const struct powerpc_opcode
*opcode
;
5212 /* Strip out the symbol name. */
5213 symbol_name
= input_line_pointer
;
5214 c
= get_symbol_end ();
5216 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5217 strcpy (name
, symbol_name
);
5219 sym
= symbol_find_or_make (name
);
5221 *input_line_pointer
= c
;
5225 /* Look up the opcode in the hash table. */
5226 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5228 /* Stick in the nop. */
5229 insn
= opcode
->opcode
;
5231 /* Write out the instruction. */
5233 md_number_to_chars (f
, insn
, 4);
5235 f
- frag_now
->fr_literal
,
5240 BFD_RELOC_16_GOT_PCREL
);
5250 ppc_pe_comm (int lcomm
)
5259 name
= input_line_pointer
;
5260 c
= get_symbol_end ();
5262 /* just after name is now '\0'. */
5263 p
= input_line_pointer
;
5266 if (*input_line_pointer
!= ',')
5268 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5269 ignore_rest_of_line ();
5273 input_line_pointer
++; /* skip ',' */
5274 if ((temp
= get_absolute_expression ()) < 0)
5276 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5277 ignore_rest_of_line ();
5283 /* The third argument to .comm is the alignment. */
5284 if (*input_line_pointer
!= ',')
5288 ++input_line_pointer
;
5289 align
= get_absolute_expression ();
5292 as_warn (_("ignoring bad alignment"));
5299 symbolP
= symbol_find_or_make (name
);
5302 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5304 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5305 S_GET_NAME (symbolP
));
5306 ignore_rest_of_line ();
5310 if (S_GET_VALUE (symbolP
))
5312 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5313 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5314 S_GET_NAME (symbolP
),
5315 (long) S_GET_VALUE (symbolP
),
5320 S_SET_VALUE (symbolP
, (valueT
) temp
);
5321 S_SET_EXTERNAL (symbolP
);
5322 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5325 demand_empty_rest_of_line ();
5329 * implement the .section pseudo op:
5330 * .section name {, "flags"}
5332 * | +--- optional flags: 'b' for bss
5334 * +-- section name 'l' for lib
5338 * 'd' (apparently m88k for data)
5340 * But if the argument is not a quoted string, treat it as a
5341 * subsegment number.
5343 * FIXME: this is a copy of the section processing from obj-coff.c, with
5344 * additions/changes for the moto-pas assembler support. There are three
5347 * FIXME: I just noticed this. This doesn't work at all really. It it
5348 * setting bits that bfd probably neither understands or uses. The
5349 * correct approach (?) will have to incorporate extra fields attached
5350 * to the section to hold the system specific stuff. (krk)
5353 * 'a' - unknown - referred to in documentation, but no definition supplied
5354 * 'c' - section has code
5355 * 'd' - section has initialized data
5356 * 'u' - section has uninitialized data
5357 * 'i' - section contains directives (info)
5358 * 'n' - section can be discarded
5359 * 'R' - remove section at link time
5361 * Section Protection:
5362 * 'r' - section is readable
5363 * 'w' - section is writeable
5364 * 'x' - section is executable
5365 * 's' - section is sharable
5367 * Section Alignment:
5368 * '0' - align to byte boundary
5369 * '1' - align to halfword undary
5370 * '2' - align to word boundary
5371 * '3' - align to doubleword boundary
5372 * '4' - align to quadword boundary
5373 * '5' - align to 32 byte boundary
5374 * '6' - align to 64 byte boundary
5379 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5381 /* Strip out the section name. */
5390 section_name
= input_line_pointer
;
5391 c
= get_symbol_end ();
5393 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5394 strcpy (name
, section_name
);
5396 *input_line_pointer
= c
;
5401 flags
= SEC_NO_FLAGS
;
5403 if (strcmp (name
, ".idata$2") == 0)
5407 else if (strcmp (name
, ".idata$3") == 0)
5411 else if (strcmp (name
, ".idata$4") == 0)
5415 else if (strcmp (name
, ".idata$5") == 0)
5419 else if (strcmp (name
, ".idata$6") == 0)
5424 /* Default alignment to 16 byte boundary. */
5427 if (*input_line_pointer
== ',')
5429 ++input_line_pointer
;
5431 if (*input_line_pointer
!= '"')
5432 exp
= get_absolute_expression ();
5435 ++input_line_pointer
;
5436 while (*input_line_pointer
!= '"'
5437 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5439 switch (*input_line_pointer
)
5441 /* Section Contents */
5442 case 'a': /* unknown */
5443 as_bad (_("unsupported section attribute -- 'a'"));
5445 case 'c': /* code section */
5448 case 'd': /* section has initialized data */
5451 case 'u': /* section has uninitialized data */
5452 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5456 case 'i': /* section contains directives (info) */
5457 /* FIXME: This is IMAGE_SCN_LNK_INFO
5459 flags
|= SEC_HAS_CONTENTS
;
5461 case 'n': /* section can be discarded */
5464 case 'R': /* Remove section at link time */
5465 flags
|= SEC_NEVER_LOAD
;
5467 #if IFLICT_BRAIN_DAMAGE
5468 /* Section Protection */
5469 case 'r': /* section is readable */
5470 flags
|= IMAGE_SCN_MEM_READ
;
5472 case 'w': /* section is writeable */
5473 flags
|= IMAGE_SCN_MEM_WRITE
;
5475 case 'x': /* section is executable */
5476 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5478 case 's': /* section is sharable */
5479 flags
|= IMAGE_SCN_MEM_SHARED
;
5482 /* Section Alignment */
5483 case '0': /* align to byte boundary */
5484 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5487 case '1': /* align to halfword boundary */
5488 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5491 case '2': /* align to word boundary */
5492 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5495 case '3': /* align to doubleword boundary */
5496 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5499 case '4': /* align to quadword boundary */
5500 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5503 case '5': /* align to 32 byte boundary */
5504 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5507 case '6': /* align to 64 byte boundary */
5508 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5513 as_bad (_("unknown section attribute '%c'"),
5514 *input_line_pointer
);
5517 ++input_line_pointer
;
5519 if (*input_line_pointer
== '"')
5520 ++input_line_pointer
;
5524 sec
= subseg_new (name
, (subsegT
) exp
);
5526 ppc_set_current_section (sec
);
5528 if (flags
!= SEC_NO_FLAGS
)
5530 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5531 as_bad (_("error setting flags for \"%s\": %s"),
5532 bfd_section_name (stdoutput
, sec
),
5533 bfd_errmsg (bfd_get_error ()));
5536 bfd_set_section_alignment (stdoutput
, sec
, align
);
5540 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5546 name
= input_line_pointer
;
5547 endc
= get_symbol_end ();
5549 ext_sym
= symbol_find_or_make (name
);
5551 *input_line_pointer
= endc
;
5553 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5554 SF_SET_FUNCTION (ext_sym
);
5555 SF_SET_PROCESS (ext_sym
);
5556 coff_add_linesym (ext_sym
);
5558 demand_empty_rest_of_line ();
5562 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5564 if (tocdata_section
== 0)
5566 tocdata_section
= subseg_new (".tocd", 0);
5567 /* FIXME: section flags won't work. */
5568 bfd_set_section_flags (stdoutput
, tocdata_section
,
5569 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5570 | SEC_READONLY
| SEC_DATA
));
5572 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5576 rdata_section
= subseg_new (".tocd", 0);
5579 ppc_set_current_section (tocdata_section
);
5581 demand_empty_rest_of_line ();
5584 /* Don't adjust TOC relocs to use the section symbol. */
5587 ppc_pe_fix_adjustable (fixS
*fix
)
5589 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5596 /* XCOFF specific symbol and file handling. */
5598 /* Canonicalize the symbol name. We use the to force the suffix, if
5599 any, to use square brackets, and to be in upper case. */
5602 ppc_canonicalize_symbol_name (char *name
)
5606 if (ppc_stab_symbol
)
5609 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5623 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5626 if (*s
== '\0' || s
[1] != '\0')
5627 as_bad (_("bad symbol suffix"));
5635 /* Set the class of a symbol based on the suffix, if any. This is
5636 called whenever a new symbol is created. */
5639 ppc_symbol_new_hook (symbolS
*sym
)
5641 struct ppc_tc_sy
*tc
;
5644 tc
= symbol_get_tc (sym
);
5647 tc
->symbol_class
= -1;
5648 tc
->real_name
= NULL
;
5655 if (ppc_stab_symbol
)
5658 s
= strchr (S_GET_NAME (sym
), '[');
5659 if (s
== (const char *) NULL
)
5661 /* There is no suffix. */
5670 if (strcmp (s
, "BS]") == 0)
5671 tc
->symbol_class
= XMC_BS
;
5674 if (strcmp (s
, "DB]") == 0)
5675 tc
->symbol_class
= XMC_DB
;
5676 else if (strcmp (s
, "DS]") == 0)
5677 tc
->symbol_class
= XMC_DS
;
5680 if (strcmp (s
, "GL]") == 0)
5681 tc
->symbol_class
= XMC_GL
;
5684 if (strcmp (s
, "PR]") == 0)
5685 tc
->symbol_class
= XMC_PR
;
5688 if (strcmp (s
, "RO]") == 0)
5689 tc
->symbol_class
= XMC_RO
;
5690 else if (strcmp (s
, "RW]") == 0)
5691 tc
->symbol_class
= XMC_RW
;
5694 if (strcmp (s
, "SV]") == 0)
5695 tc
->symbol_class
= XMC_SV
;
5698 if (strcmp (s
, "TC]") == 0)
5699 tc
->symbol_class
= XMC_TC
;
5700 else if (strcmp (s
, "TI]") == 0)
5701 tc
->symbol_class
= XMC_TI
;
5702 else if (strcmp (s
, "TB]") == 0)
5703 tc
->symbol_class
= XMC_TB
;
5704 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5705 tc
->symbol_class
= XMC_TC0
;
5708 if (strcmp (s
, "UA]") == 0)
5709 tc
->symbol_class
= XMC_UA
;
5710 else if (strcmp (s
, "UC]") == 0)
5711 tc
->symbol_class
= XMC_UC
;
5714 if (strcmp (s
, "XO]") == 0)
5715 tc
->symbol_class
= XMC_XO
;
5719 if (tc
->symbol_class
== -1)
5720 as_bad (_("unrecognized symbol suffix"));
5723 /* Set the class of a label based on where it is defined. This
5724 handles symbols without suffixes. Also, move the symbol so that it
5725 follows the csect symbol. */
5728 ppc_frob_label (symbolS
*sym
)
5730 if (ppc_current_csect
!= (symbolS
*) NULL
)
5732 if (symbol_get_tc (sym
)->symbol_class
== -1)
5733 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5735 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5736 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5737 &symbol_rootP
, &symbol_lastP
);
5738 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5739 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5743 dwarf2_emit_label (sym
);
5747 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5748 seen. It tells ppc_adjust_symtab whether it needs to look through
5751 static bfd_boolean ppc_saw_abs
;
5753 /* Change the name of a symbol just before writing it out. Set the
5754 real name if the .rename pseudo-op was used. Otherwise, remove any
5755 class suffix. Return 1 if the symbol should not be included in the
5759 ppc_frob_symbol (symbolS
*sym
)
5761 static symbolS
*ppc_last_function
;
5762 static symbolS
*set_end
;
5764 /* Discard symbols that should not be included in the output symbol
5766 if (! symbol_used_in_reloc_p (sym
)
5767 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5768 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5769 && ! symbol_get_tc (sym
)->output
5770 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5773 /* This one will disappear anyway. Don't make a csect sym for it. */
5774 if (sym
== abs_section_sym
)
5777 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5778 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5784 name
= S_GET_NAME (sym
);
5785 s
= strchr (name
, '[');
5786 if (s
!= (char *) NULL
)
5792 snew
= xmalloc (len
+ 1);
5793 memcpy (snew
, name
, len
);
5796 S_SET_NAME (sym
, snew
);
5800 if (set_end
!= (symbolS
*) NULL
)
5802 SA_SET_SYM_ENDNDX (set_end
, sym
);
5806 if (SF_GET_FUNCTION (sym
))
5808 if (ppc_last_function
!= (symbolS
*) NULL
)
5809 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5810 ppc_last_function
= sym
;
5811 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5813 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5814 SA_SET_SYM_FSIZE (sym
,
5815 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5818 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5819 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5821 if (ppc_last_function
== (symbolS
*) NULL
)
5822 as_bad (_(".ef with no preceding .function"));
5825 set_end
= ppc_last_function
;
5826 ppc_last_function
= NULL
;
5828 /* We don't have a C_EFCN symbol, but we need to force the
5829 COFF backend to believe that it has seen one. */
5830 coff_last_function
= NULL
;
5834 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5835 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5836 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5837 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5838 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5839 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5840 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5841 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5842 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5843 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5844 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5846 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5847 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5848 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5851 union internal_auxent
*a
;
5853 /* Create a csect aux. */
5854 i
= S_GET_NUMBER_AUXILIARY (sym
);
5855 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5856 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5857 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5859 /* This is the TOC table. */
5860 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5861 a
->x_csect
.x_scnlen
.l
= 0;
5862 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5864 else if (symbol_get_tc (sym
)->subseg
!= 0)
5866 /* This is a csect symbol. x_scnlen is the size of the
5868 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5869 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5870 S_GET_SEGMENT (sym
))
5871 - S_GET_VALUE (sym
));
5874 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5875 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5876 - S_GET_VALUE (sym
));
5878 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5880 else if (S_GET_SEGMENT (sym
) == bss_section
)
5882 /* This is a common symbol. */
5883 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5884 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5885 if (S_IS_EXTERNAL (sym
))
5886 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5888 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5890 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5892 /* This is an absolute symbol. The csect will be created by
5893 ppc_adjust_symtab. */
5895 a
->x_csect
.x_smtyp
= XTY_LD
;
5896 if (symbol_get_tc (sym
)->symbol_class
== -1)
5897 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5899 else if (! S_IS_DEFINED (sym
))
5901 /* This is an external symbol. */
5902 a
->x_csect
.x_scnlen
.l
= 0;
5903 a
->x_csect
.x_smtyp
= XTY_ER
;
5905 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5909 /* This is a TOC definition. x_scnlen is the size of the
5911 next
= symbol_next (sym
);
5912 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5913 next
= symbol_next (next
);
5914 if (next
== (symbolS
*) NULL
5915 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5917 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5918 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5920 - S_GET_VALUE (sym
));
5922 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5923 - S_GET_VALUE (sym
));
5927 resolve_symbol_value (next
);
5928 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5929 - S_GET_VALUE (sym
));
5931 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5937 /* This is a normal symbol definition. x_scnlen is the
5938 symbol index of the containing csect. */
5939 if (S_GET_SEGMENT (sym
) == text_section
)
5940 csect
= ppc_text_csects
;
5941 else if (S_GET_SEGMENT (sym
) == data_section
)
5942 csect
= ppc_data_csects
;
5946 /* Skip the initial dummy symbol. */
5947 csect
= symbol_get_tc (csect
)->next
;
5949 if (csect
== (symbolS
*) NULL
)
5951 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5952 a
->x_csect
.x_scnlen
.l
= 0;
5956 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5958 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5959 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5960 > S_GET_VALUE (sym
))
5962 csect
= symbol_get_tc (csect
)->next
;
5965 a
->x_csect
.x_scnlen
.p
=
5966 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5967 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5970 a
->x_csect
.x_smtyp
= XTY_LD
;
5973 a
->x_csect
.x_parmhash
= 0;
5974 a
->x_csect
.x_snhash
= 0;
5975 if (symbol_get_tc (sym
)->symbol_class
== -1)
5976 a
->x_csect
.x_smclas
= XMC_PR
;
5978 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5979 a
->x_csect
.x_stab
= 0;
5980 a
->x_csect
.x_snstab
= 0;
5982 /* Don't let the COFF backend resort these symbols. */
5983 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5985 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5987 /* We want the value to be the symbol index of the referenced
5988 csect symbol. BFD will do that for us if we set the right
5990 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5991 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5993 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5994 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5996 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
6001 block
= symbol_get_tc (sym
)->within
;
6004 /* The value is the offset from the enclosing csect. */
6007 csect
= symbol_get_tc (block
)->within
;
6008 resolve_symbol_value (csect
);
6009 base
= S_GET_VALUE (csect
);
6014 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
6016 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
6017 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
6019 /* We want the value to be a file offset into the line numbers.
6020 BFD will do that for us if we set the right flags. We have
6021 already set the value correctly. */
6022 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
6028 /* Adjust the symbol table. This creates csect symbols for all
6029 absolute symbols. */
6032 ppc_adjust_symtab (void)
6039 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
6043 union internal_auxent
*a
;
6045 if (S_GET_SEGMENT (sym
) != absolute_section
)
6048 csect
= symbol_create (".abs[XO]", absolute_section
,
6049 S_GET_VALUE (sym
), &zero_address_frag
);
6050 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
6051 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
6052 i
= S_GET_NUMBER_AUXILIARY (csect
);
6053 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
6054 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
6055 a
->x_csect
.x_scnlen
.l
= 0;
6056 a
->x_csect
.x_smtyp
= XTY_SD
;
6057 a
->x_csect
.x_parmhash
= 0;
6058 a
->x_csect
.x_snhash
= 0;
6059 a
->x_csect
.x_smclas
= XMC_XO
;
6060 a
->x_csect
.x_stab
= 0;
6061 a
->x_csect
.x_snstab
= 0;
6063 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
6065 i
= S_GET_NUMBER_AUXILIARY (sym
);
6066 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
6067 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
6068 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
6071 ppc_saw_abs
= FALSE
;
6074 /* Set the VMA for a section. This is called on all the sections in
6078 ppc_frob_section (asection
*sec
)
6080 static bfd_vma vma
= 0;
6082 /* Dwarf sections start at 0. */
6083 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6086 vma
= md_section_align (sec
, vma
);
6087 bfd_set_section_vma (stdoutput
, sec
, vma
);
6088 vma
+= bfd_section_size (stdoutput
, sec
);
6091 #endif /* OBJ_XCOFF */
6094 md_atof (int type
, char *litp
, int *sizep
)
6096 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6099 /* Write a value out to the object file, using the appropriate
6103 md_number_to_chars (char *buf
, valueT val
, int n
)
6105 if (target_big_endian
)
6106 number_to_chars_bigendian (buf
, val
, n
);
6108 number_to_chars_littleendian (buf
, val
, n
);
6111 /* Align a section (I don't know why this is machine dependent). */
6114 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6119 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6121 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
6125 /* We don't have any form of relaxing. */
6128 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6129 asection
*seg ATTRIBUTE_UNUSED
)
6135 /* Convert a machine dependent frag. We never generate these. */
6138 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6139 asection
*sec ATTRIBUTE_UNUSED
,
6140 fragS
*fragp ATTRIBUTE_UNUSED
)
6145 /* We have no need to default values of symbols. */
6148 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6153 /* Functions concerning relocs. */
6155 /* The location from which a PC relative jump should be calculated,
6156 given a PC relative reloc. */
6159 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6161 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6166 /* This is called to see whether a fixup should be adjusted to use a
6167 section symbol. We take the opportunity to change a fixup against
6168 a symbol in the TOC subsegment into a reloc against the
6169 corresponding .tc symbol. */
6172 ppc_fix_adjustable (fixS
*fix
)
6174 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6175 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6176 TC_SYMFIELD_TYPE
*tc
;
6178 if (symseg
== absolute_section
)
6181 /* Always adjust symbols in debugging sections. */
6182 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6185 if (ppc_toc_csect
!= (symbolS
*) NULL
6186 && fix
->fx_addsy
!= ppc_toc_csect
6187 && symseg
== data_section
6188 && val
>= ppc_toc_frag
->fr_address
6189 && (ppc_after_toc_frag
== (fragS
*) NULL
6190 || val
< ppc_after_toc_frag
->fr_address
))
6194 for (sy
= symbol_next (ppc_toc_csect
);
6195 sy
!= (symbolS
*) NULL
;
6196 sy
= symbol_next (sy
))
6198 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6200 if (sy_tc
->symbol_class
== XMC_TC0
)
6202 if (sy_tc
->symbol_class
!= XMC_TC
)
6204 if (val
== resolve_symbol_value (sy
))
6207 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6212 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6213 _("symbol in .toc does not match any .tc"));
6216 /* Possibly adjust the reloc to be against the csect. */
6217 tc
= symbol_get_tc (fix
->fx_addsy
);
6219 && tc
->symbol_class
!= XMC_TC0
6220 && tc
->symbol_class
!= XMC_TC
6221 && symseg
!= bss_section
6222 /* Don't adjust if this is a reloc in the toc section. */
6223 && (symseg
!= data_section
6224 || ppc_toc_csect
== NULL
6225 || val
< ppc_toc_frag
->fr_address
6226 || (ppc_after_toc_frag
!= NULL
6227 && val
>= ppc_after_toc_frag
->fr_address
)))
6229 symbolS
*csect
= tc
->within
;
6231 /* If the symbol was not declared by a label (eg: a section symbol),
6232 use the section instead of the csect. This doesn't happen in
6233 normal AIX assembly code. */
6235 csect
= seg_info (symseg
)->sym
;
6237 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6238 fix
->fx_addsy
= csect
;
6243 /* Adjust a reloc against a .lcomm symbol to be against the base
6245 if (symseg
== bss_section
6246 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6248 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6250 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6257 /* A reloc from one csect to another must be kept. The assembler
6258 will, of course, keep relocs between sections, and it will keep
6259 absolute relocs, but we need to force it to keep PC relative relocs
6260 between two csects in the same section. */
6263 ppc_force_relocation (fixS
*fix
)
6265 /* At this point fix->fx_addsy should already have been converted to
6266 a csect symbol. If the csect does not include the fragment, then
6267 we need to force the relocation. */
6269 && fix
->fx_addsy
!= NULL
6270 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6271 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6272 > fix
->fx_frag
->fr_address
)
6273 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6274 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6275 <= fix
->fx_frag
->fr_address
))))
6278 return generic_force_reloc (fix
);
6282 ppc_new_dot_label (symbolS
*sym
)
6284 /* Anchor this label to the current csect for relocations. */
6285 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6288 #endif /* OBJ_XCOFF */
6291 /* If this function returns non-zero, it guarantees that a relocation
6292 will be emitted for a fixup. */
6295 ppc_force_relocation (fixS
*fix
)
6297 /* Branch prediction relocations must force a relocation, as must
6298 the vtable description relocs. */
6299 switch (fix
->fx_r_type
)
6301 case BFD_RELOC_PPC_B16_BRTAKEN
:
6302 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6303 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6304 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6305 case BFD_RELOC_24_PLT_PCREL
:
6306 case BFD_RELOC_PPC64_TOC
:
6308 case BFD_RELOC_PPC_B26
:
6309 case BFD_RELOC_PPC_BA26
:
6310 case BFD_RELOC_PPC_B16
:
6311 case BFD_RELOC_PPC_BA16
:
6312 /* All branch fixups targeting a localentry symbol must
6313 force a relocation. */
6316 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6317 elf_symbol_type
*elfsym
6318 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6319 gas_assert (elfsym
);
6320 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6328 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6329 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6332 return generic_force_reloc (fix
);
6336 ppc_fix_adjustable (fixS
*fix
)
6338 switch (fix
->fx_r_type
)
6340 /* All branch fixups targeting a localentry symbol must
6341 continue using the symbol. */
6342 case BFD_RELOC_PPC_B26
:
6343 case BFD_RELOC_PPC_BA26
:
6344 case BFD_RELOC_PPC_B16
:
6345 case BFD_RELOC_PPC_BA16
:
6346 case BFD_RELOC_PPC_B16_BRTAKEN
:
6347 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6348 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6349 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6352 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6353 elf_symbol_type
*elfsym
6354 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6355 gas_assert (elfsym
);
6356 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6364 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6365 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6366 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6367 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6368 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6369 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6370 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6371 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6372 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6373 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6374 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6379 ppc_frag_check (struct frag
*fragP
)
6381 if (!fragP
->has_code
)
6384 if (ppc_mach() == bfd_mach_ppc_vle
)
6386 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6387 as_bad (_("instruction address is not a multiple of 2"));
6391 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6392 as_bad (_("instruction address is not a multiple of 4"));
6396 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6397 rs_align_code frag. */
6400 ppc_handle_align (struct frag
*fragP
)
6402 valueT count
= (fragP
->fr_next
->fr_address
6403 - (fragP
->fr_address
+ fragP
->fr_fix
));
6405 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6407 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6410 md_number_to_chars (dest
, 0x4400, 2);
6412 else if (count
!= 0 && (count
& 3) == 0)
6414 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6418 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6422 /* Make a branch, then follow with nops. Insert another
6423 frag to handle the nops. */
6424 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6429 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6430 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6431 fragP
->fr_next
= rest
;
6433 rest
->fr_address
+= rest
->fr_fix
+ 4;
6435 /* If we leave the next frag as rs_align_code we'll come here
6436 again, resulting in a bunch of branches rather than a
6437 branch followed by nops. */
6438 rest
->fr_type
= rs_align
;
6439 dest
= rest
->fr_literal
;
6442 md_number_to_chars (dest
, 0x60000000, 4);
6444 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6445 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6446 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6448 /* For power6, power7 and power8, we want the last nop to be a group
6449 terminating one. Do this by inserting an rs_fill frag immediately
6450 after this one, with its address set to the last nop location.
6451 This will automatically reduce the number of nops in the current
6455 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6457 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6458 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6459 group_nop
->fr_fix
= 0;
6460 group_nop
->fr_offset
= 1;
6461 group_nop
->fr_type
= rs_fill
;
6462 fragP
->fr_next
= group_nop
;
6463 dest
= group_nop
->fr_literal
;
6466 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6467 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6469 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6470 /* e500mc group terminating nop: "ori 0,0,0". */
6471 md_number_to_chars (dest
, 0x60000000, 4);
6473 /* power7/power8 group terminating nop: "ori 2,2,0". */
6474 md_number_to_chars (dest
, 0x60420000, 4);
6477 /* power6 group terminating nop: "ori 1,1,0". */
6478 md_number_to_chars (dest
, 0x60210000, 4);
6483 /* Apply a fixup to the object code. This is called for all the
6484 fixups we generated by the calls to fix_new_exp, above. */
6487 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg
)
6489 valueT value
= * valP
;
6491 const struct powerpc_operand
*operand
;
6494 if (fixP
->fx_addsy
!= NULL
)
6496 /* Hack around bfd_install_relocation brain damage. */
6498 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6503 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6504 the symbol values. If we are doing this relocation the code in
6505 write.c is going to call bfd_install_relocation, which is also
6506 going to use the symbol value. That means that if the reloc is
6507 fully resolved we want to use *valP since bfd_install_relocation is
6509 However, if the reloc is not fully resolved we do not want to
6510 use *valP, and must use fx_offset instead. If the relocation
6511 is PC-relative, we then need to re-apply md_pcrel_from_section
6512 to this new relocation value. */
6513 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6518 value
= fixP
->fx_offset
;
6520 value
-= md_pcrel_from_section (fixP
, seg
);
6524 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6526 /* We can't actually support subtracting a symbol. */
6527 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6531 if (fixP
->fx_pcrel_adjust
!= 0)
6533 /* This is a fixup on an instruction. */
6534 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6536 operand
= &powerpc_operands
[opindex
];
6538 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6539 does not generate a reloc. It uses the offset of `sym' within its
6540 csect. Other usages, such as `.long sym', generate relocs. This
6541 is the documented behaviour of non-TOC symbols. */
6542 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6543 && (operand
->bitm
& 0xfff0) == 0xfff0
6544 && operand
->shift
== 0
6545 && (operand
->insert
== NULL
|| ppc_obj64
)
6546 && fixP
->fx_addsy
!= NULL
6547 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6548 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6549 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6550 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6552 value
= fixP
->fx_offset
;
6556 /* During parsing of instructions, a TOC16 reloc is generated for
6557 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6558 in the toc. But at parse time, SYM may be not yet defined, so
6559 check again here. */
6560 if (fixP
->fx_r_type
== BFD_RELOC_16
6561 && fixP
->fx_addsy
!= NULL
6562 && ppc_is_toc_sym (fixP
->fx_addsy
))
6563 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6567 /* Calculate value to be stored in field. */
6569 switch (fixP
->fx_r_type
)
6572 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6573 case BFD_RELOC_PPC_VLE_LO16A
:
6574 case BFD_RELOC_PPC_VLE_LO16D
:
6576 case BFD_RELOC_LO16
:
6577 case BFD_RELOC_LO16_PCREL
:
6578 fieldval
= value
& 0xffff;
6580 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6581 fieldval
= SEX16 (fieldval
);
6582 fixP
->fx_no_overflow
= 1;
6585 case BFD_RELOC_HI16
:
6586 case BFD_RELOC_HI16_PCREL
:
6588 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6590 fieldval
= value
>> 16;
6591 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6593 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6594 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6600 case BFD_RELOC_PPC_VLE_HI16A
:
6601 case BFD_RELOC_PPC_VLE_HI16D
:
6602 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6604 fieldval
= PPC_HI (value
);
6605 goto sign_extend_16
;
6607 case BFD_RELOC_HI16_S
:
6608 case BFD_RELOC_HI16_S_PCREL
:
6610 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6612 fieldval
= (value
+ 0x8000) >> 16;
6613 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6615 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6616 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6622 case BFD_RELOC_PPC_VLE_HA16A
:
6623 case BFD_RELOC_PPC_VLE_HA16D
:
6624 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6626 fieldval
= PPC_HA (value
);
6627 goto sign_extend_16
;
6630 case BFD_RELOC_PPC64_HIGHER
:
6631 fieldval
= PPC_HIGHER (value
);
6632 goto sign_extend_16
;
6634 case BFD_RELOC_PPC64_HIGHER_S
:
6635 fieldval
= PPC_HIGHERA (value
);
6636 goto sign_extend_16
;
6638 case BFD_RELOC_PPC64_HIGHEST
:
6639 fieldval
= PPC_HIGHEST (value
);
6640 goto sign_extend_16
;
6642 case BFD_RELOC_PPC64_HIGHEST_S
:
6643 fieldval
= PPC_HIGHESTA (value
);
6644 goto sign_extend_16
;
6651 if (operand
!= NULL
)
6653 /* Handle relocs in an insn. */
6657 switch (fixP
->fx_r_type
)
6660 /* The following relocs can't be calculated by the assembler.
6661 Leave the field zero. */
6662 case BFD_RELOC_PPC_TPREL16
:
6663 case BFD_RELOC_PPC_TPREL16_LO
:
6664 case BFD_RELOC_PPC_TPREL16_HI
:
6665 case BFD_RELOC_PPC_TPREL16_HA
:
6666 case BFD_RELOC_PPC_DTPREL16
:
6667 case BFD_RELOC_PPC_DTPREL16_LO
:
6668 case BFD_RELOC_PPC_DTPREL16_HI
:
6669 case BFD_RELOC_PPC_DTPREL16_HA
:
6670 case BFD_RELOC_PPC_GOT_TLSGD16
:
6671 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6672 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6673 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6674 case BFD_RELOC_PPC_GOT_TLSLD16
:
6675 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6676 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6677 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6678 case BFD_RELOC_PPC_GOT_TPREL16
:
6679 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6680 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6681 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6682 case BFD_RELOC_PPC_GOT_DTPREL16
:
6683 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6684 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6685 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6686 case BFD_RELOC_PPC64_TPREL16_DS
:
6687 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6688 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6689 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6690 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6691 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6692 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6693 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6694 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6695 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6696 case BFD_RELOC_PPC64_DTPREL16_DS
:
6697 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6698 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6699 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6700 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6701 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6702 gas_assert (fixP
->fx_addsy
!= NULL
);
6703 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6707 /* These also should leave the field zero for the same
6708 reason. Note that older versions of gas wrote values
6709 here. If we want to go back to the old behaviour, then
6710 all _LO and _LO_DS cases will need to be treated like
6711 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6712 case BFD_RELOC_16_GOTOFF
:
6713 case BFD_RELOC_LO16_GOTOFF
:
6714 case BFD_RELOC_HI16_GOTOFF
:
6715 case BFD_RELOC_HI16_S_GOTOFF
:
6716 case BFD_RELOC_LO16_PLTOFF
:
6717 case BFD_RELOC_HI16_PLTOFF
:
6718 case BFD_RELOC_HI16_S_PLTOFF
:
6719 case BFD_RELOC_GPREL16
:
6720 case BFD_RELOC_16_BASEREL
:
6721 case BFD_RELOC_LO16_BASEREL
:
6722 case BFD_RELOC_HI16_BASEREL
:
6723 case BFD_RELOC_HI16_S_BASEREL
:
6724 case BFD_RELOC_PPC_TOC16
:
6725 case BFD_RELOC_PPC64_TOC16_LO
:
6726 case BFD_RELOC_PPC64_TOC16_HI
:
6727 case BFD_RELOC_PPC64_TOC16_HA
:
6728 case BFD_RELOC_PPC64_PLTGOT16
:
6729 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6730 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6731 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6732 case BFD_RELOC_PPC64_GOT16_DS
:
6733 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6734 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6735 case BFD_RELOC_PPC64_SECTOFF_DS
:
6736 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6737 case BFD_RELOC_PPC64_TOC16_DS
:
6738 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6739 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6740 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6741 case BFD_RELOC_PPC_EMB_NADDR16
:
6742 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6743 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6744 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6745 case BFD_RELOC_PPC_EMB_SDAI16
:
6746 case BFD_RELOC_PPC_EMB_SDA2I16
:
6747 case BFD_RELOC_PPC_EMB_SDA2REL
:
6748 case BFD_RELOC_PPC_EMB_SDA21
:
6749 case BFD_RELOC_PPC_EMB_MRKREF
:
6750 case BFD_RELOC_PPC_EMB_RELSEC16
:
6751 case BFD_RELOC_PPC_EMB_RELST_LO
:
6752 case BFD_RELOC_PPC_EMB_RELST_HI
:
6753 case BFD_RELOC_PPC_EMB_RELST_HA
:
6754 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6755 case BFD_RELOC_PPC_EMB_RELSDA
:
6756 case BFD_RELOC_PPC_VLE_SDA21
:
6757 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6758 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6759 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6760 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6761 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6762 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6763 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6764 gas_assert (fixP
->fx_addsy
!= NULL
);
6767 case BFD_RELOC_PPC_TLS
:
6768 case BFD_RELOC_PPC_TLSGD
:
6769 case BFD_RELOC_PPC_TLSLD
:
6775 case BFD_RELOC_PPC_B16
:
6776 /* Adjust the offset to the instruction boundary. */
6781 case BFD_RELOC_VTABLE_INHERIT
:
6782 case BFD_RELOC_VTABLE_ENTRY
:
6783 case BFD_RELOC_PPC_DTPMOD
:
6784 case BFD_RELOC_PPC_TPREL
:
6785 case BFD_RELOC_PPC_DTPREL
:
6786 case BFD_RELOC_PPC_COPY
:
6787 case BFD_RELOC_PPC_GLOB_DAT
:
6788 case BFD_RELOC_32_PLT_PCREL
:
6789 case BFD_RELOC_PPC_EMB_NADDR32
:
6790 case BFD_RELOC_PPC64_TOC
:
6791 case BFD_RELOC_CTOR
:
6793 case BFD_RELOC_32_PCREL
:
6796 case BFD_RELOC_64_PCREL
:
6797 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6798 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6799 _("%s unsupported as instruction fixup"),
6800 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6809 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6810 contents can stay at zero. */
6811 #define APPLY_RELOC fixP->fx_done
6813 #define APPLY_RELOC 1
6815 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6817 /* Fetch the instruction, insert the fully resolved operand
6818 value, and stuff the instruction back again. */
6819 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6820 if (target_big_endian
)
6822 if (fixP
->fx_size
== 4)
6823 insn
= bfd_getb32 ((unsigned char *) where
);
6825 insn
= bfd_getb16 ((unsigned char *) where
);
6829 if (fixP
->fx_size
== 4)
6830 insn
= bfd_getl32 ((unsigned char *) where
);
6832 insn
= bfd_getl16 ((unsigned char *) where
);
6834 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6835 fixP
->tc_fix_data
.ppc_cpu
,
6836 fixP
->fx_file
, fixP
->fx_line
);
6837 if (target_big_endian
)
6839 if (fixP
->fx_size
== 4)
6840 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6842 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6846 if (fixP
->fx_size
== 4)
6847 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6849 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6854 /* Nothing else to do here. */
6857 gas_assert (fixP
->fx_addsy
!= NULL
);
6858 if (fixP
->fx_r_type
== BFD_RELOC_NONE
)
6863 /* Use expr_symbol_where to see if this is an expression
6865 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6866 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6867 _("unresolved expression that must be resolved"));
6869 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6870 _("unsupported relocation against %s"),
6871 S_GET_NAME (fixP
->fx_addsy
));
6878 /* Handle relocs in data. */
6879 switch (fixP
->fx_r_type
)
6881 case BFD_RELOC_VTABLE_INHERIT
:
6883 && !S_IS_DEFINED (fixP
->fx_addsy
)
6884 && !S_IS_WEAK (fixP
->fx_addsy
))
6885 S_SET_WEAK (fixP
->fx_addsy
);
6888 case BFD_RELOC_VTABLE_ENTRY
:
6893 /* These can appear with @l etc. in data. */
6894 case BFD_RELOC_LO16
:
6895 case BFD_RELOC_LO16_PCREL
:
6896 case BFD_RELOC_HI16
:
6897 case BFD_RELOC_HI16_PCREL
:
6898 case BFD_RELOC_HI16_S
:
6899 case BFD_RELOC_HI16_S_PCREL
:
6900 case BFD_RELOC_PPC64_HIGHER
:
6901 case BFD_RELOC_PPC64_HIGHER_S
:
6902 case BFD_RELOC_PPC64_HIGHEST
:
6903 case BFD_RELOC_PPC64_HIGHEST_S
:
6904 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6905 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6906 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6909 case BFD_RELOC_PPC_DTPMOD
:
6910 case BFD_RELOC_PPC_TPREL
:
6911 case BFD_RELOC_PPC_DTPREL
:
6912 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6915 /* Just punt all of these to the linker. */
6916 case BFD_RELOC_PPC_B16_BRTAKEN
:
6917 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6918 case BFD_RELOC_16_GOTOFF
:
6919 case BFD_RELOC_LO16_GOTOFF
:
6920 case BFD_RELOC_HI16_GOTOFF
:
6921 case BFD_RELOC_HI16_S_GOTOFF
:
6922 case BFD_RELOC_LO16_PLTOFF
:
6923 case BFD_RELOC_HI16_PLTOFF
:
6924 case BFD_RELOC_HI16_S_PLTOFF
:
6925 case BFD_RELOC_PPC_COPY
:
6926 case BFD_RELOC_PPC_GLOB_DAT
:
6927 case BFD_RELOC_16_BASEREL
:
6928 case BFD_RELOC_LO16_BASEREL
:
6929 case BFD_RELOC_HI16_BASEREL
:
6930 case BFD_RELOC_HI16_S_BASEREL
:
6931 case BFD_RELOC_PPC_TLS
:
6932 case BFD_RELOC_PPC_DTPREL16_LO
:
6933 case BFD_RELOC_PPC_DTPREL16_HI
:
6934 case BFD_RELOC_PPC_DTPREL16_HA
:
6935 case BFD_RELOC_PPC_TPREL16_LO
:
6936 case BFD_RELOC_PPC_TPREL16_HI
:
6937 case BFD_RELOC_PPC_TPREL16_HA
:
6938 case BFD_RELOC_PPC_GOT_TLSGD16
:
6939 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6940 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6941 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6942 case BFD_RELOC_PPC_GOT_TLSLD16
:
6943 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6944 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6945 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6946 case BFD_RELOC_PPC_GOT_DTPREL16
:
6947 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6948 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6949 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6950 case BFD_RELOC_PPC_GOT_TPREL16
:
6951 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6952 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6953 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6954 case BFD_RELOC_24_PLT_PCREL
:
6955 case BFD_RELOC_PPC_LOCAL24PC
:
6956 case BFD_RELOC_32_PLT_PCREL
:
6957 case BFD_RELOC_GPREL16
:
6958 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6959 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6960 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6961 case BFD_RELOC_PPC_EMB_NADDR32
:
6962 case BFD_RELOC_PPC_EMB_NADDR16
:
6963 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6964 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6965 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6966 case BFD_RELOC_PPC_EMB_SDAI16
:
6967 case BFD_RELOC_PPC_EMB_SDA2REL
:
6968 case BFD_RELOC_PPC_EMB_SDA2I16
:
6969 case BFD_RELOC_PPC_EMB_SDA21
:
6970 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6971 case BFD_RELOC_PPC_EMB_MRKREF
:
6972 case BFD_RELOC_PPC_EMB_RELSEC16
:
6973 case BFD_RELOC_PPC_EMB_RELST_LO
:
6974 case BFD_RELOC_PPC_EMB_RELST_HI
:
6975 case BFD_RELOC_PPC_EMB_RELST_HA
:
6976 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6977 case BFD_RELOC_PPC_EMB_RELSDA
:
6978 case BFD_RELOC_PPC64_TOC
:
6979 case BFD_RELOC_PPC_TOC16
:
6980 case BFD_RELOC_PPC64_TOC16_LO
:
6981 case BFD_RELOC_PPC64_TOC16_HI
:
6982 case BFD_RELOC_PPC64_TOC16_HA
:
6983 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6984 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6985 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6986 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6987 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6988 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6989 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6990 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6991 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6992 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6993 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6994 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
7000 case BFD_RELOC_NONE
:
7002 case BFD_RELOC_CTOR
:
7004 case BFD_RELOC_32_PCREL
:
7007 case BFD_RELOC_64_PCREL
:
7009 case BFD_RELOC_16_PCREL
:
7015 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
7020 if (fixP
->fx_size
&& APPLY_RELOC
)
7021 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
7022 fieldval
, fixP
->fx_size
);
7024 && (seg
->flags
& SEC_CODE
) != 0
7025 && fixP
->fx_size
== 4
7028 && (fixP
->fx_r_type
== BFD_RELOC_32
7029 || fixP
->fx_r_type
== BFD_RELOC_CTOR
7030 || fixP
->fx_r_type
== BFD_RELOC_32_PCREL
))
7031 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
7032 _("data in executable section"));
7035 /* We are only able to convert some relocs to pc-relative. */
7036 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
7038 switch (fixP
->fx_r_type
)
7040 case BFD_RELOC_LO16
:
7041 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
7044 case BFD_RELOC_HI16
:
7045 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
7048 case BFD_RELOC_HI16_S
:
7049 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
7053 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7057 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7061 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7064 /* Some of course are already pc-relative. */
7065 case BFD_RELOC_LO16_PCREL
:
7066 case BFD_RELOC_HI16_PCREL
:
7067 case BFD_RELOC_HI16_S_PCREL
:
7068 case BFD_RELOC_64_PCREL
:
7069 case BFD_RELOC_32_PCREL
:
7070 case BFD_RELOC_16_PCREL
:
7071 case BFD_RELOC_PPC_B16
:
7072 case BFD_RELOC_PPC_B16_BRTAKEN
:
7073 case BFD_RELOC_PPC_B16_BRNTAKEN
:
7074 case BFD_RELOC_PPC_B26
:
7075 case BFD_RELOC_PPC_LOCAL24PC
:
7076 case BFD_RELOC_24_PLT_PCREL
:
7077 case BFD_RELOC_32_PLT_PCREL
:
7078 case BFD_RELOC_64_PLT_PCREL
:
7079 case BFD_RELOC_PPC_VLE_REL8
:
7080 case BFD_RELOC_PPC_VLE_REL15
:
7081 case BFD_RELOC_PPC_VLE_REL24
:
7090 /* Use expr_symbol_where to see if this is an
7091 expression symbol. */
7092 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
7093 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7094 _("unresolved expression that must"
7097 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7098 _("cannot emit PC relative %s relocation"
7100 bfd_get_reloc_code_name (fixP
->fx_r_type
),
7101 S_GET_NAME (fixP
->fx_addsy
));
7104 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7105 _("unable to resolve expression"));
7112 ppc_elf_validate_fix (fixP
, seg
);
7113 fixP
->fx_addnumber
= value
;
7115 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
7116 from the section contents. If we are going to be emitting a reloc
7117 then the section contents are immaterial, so don't warn if they
7118 happen to overflow. Leave such warnings to ld. */
7121 fixP
->fx_no_overflow
= 1;
7123 /* Arrange to emit .TOC. as a normal symbol if used in anything
7124 but .TOC.@tocbase. */
7126 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
7127 && fixP
->fx_addsy
!= NULL
7128 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
7129 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
7132 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
7133 fixP
->fx_addnumber
= 0;
7137 fixP
->fx_addnumber
= 0;
7139 /* We want to use the offset within the toc, not the actual VMA
7141 fixP
->fx_addnumber
=
7142 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
7143 - S_GET_VALUE (ppc_toc_csect
);
7144 /* Set *valP to avoid errors. */
7151 /* Generate a reloc for a fixup. */
7154 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
7158 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
7160 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
7161 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
7162 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
7163 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
7164 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
7166 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
7167 _("reloc %d not supported by object file format"),
7168 (int) fixp
->fx_r_type
);
7171 reloc
->addend
= fixp
->fx_addnumber
;
7177 ppc_cfi_frame_initial_instructions (void)
7179 cfi_add_CFA_def_cfa (1, 0);
7183 tc_ppc_regname_to_dw2regnum (char *regname
)
7185 unsigned int regnum
= -1;
7189 static struct { char *name
; int dw2regnum
; } regnames
[] =
7191 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7192 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7193 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7194 { "spe_acc", 111 }, { "spefscr", 112 }
7197 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7198 if (strcmp (regnames
[i
].name
, regname
) == 0)
7199 return regnames
[i
].dw2regnum
;
7201 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7203 p
= regname
+ 1 + (regname
[1] == '.');
7204 regnum
= strtoul (p
, &q
, 10);
7205 if (p
== q
|| *q
|| regnum
>= 32)
7207 if (regname
[0] == 'f')
7209 else if (regname
[0] == 'v')
7212 else if (regname
[0] == 'c' && regname
[1] == 'r')
7214 p
= regname
+ 2 + (regname
[2] == '.');
7215 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7217 regnum
= p
[0] - '0' + 68;