1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994-2016 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);
136 static void ppc_elf_gnu_attribute (int);
140 static void ppc_previous (int);
141 static void ppc_pdata (int);
142 static void ppc_ydata (int);
143 static void ppc_reldata (int);
144 static void ppc_rdata (int);
145 static void ppc_ualong (int);
146 static void ppc_znop (int);
147 static void ppc_pe_comm (int);
148 static void ppc_pe_section (int);
149 static void ppc_pe_function (int);
150 static void ppc_pe_tocd (int);
153 /* Generic assembler global variables which must be defined by all
157 /* This string holds the chars that always start a comment. If the
158 pre-processor is disabled, these aren't very useful. The macro
159 tc_comment_chars points to this. We use this, rather than the
160 usual comment_chars, so that we can switch for Solaris conventions. */
161 static const char ppc_solaris_comment_chars
[] = "#!";
162 static const char ppc_eabi_comment_chars
[] = "#";
164 #ifdef TARGET_SOLARIS_COMMENT
165 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
167 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
170 const char comment_chars
[] = "#";
173 /* Characters which start a comment at the beginning of a line. */
174 const char line_comment_chars
[] = "#";
176 /* Characters which may be used to separate multiple commands on a
178 const char line_separator_chars
[] = ";";
180 /* Characters which are used to indicate an exponent in a floating
182 const char EXP_CHARS
[] = "eE";
184 /* Characters which mean that a number is a floating point constant,
186 const char FLT_CHARS
[] = "dD";
188 /* Anything that can start an operand needs to be mentioned here,
189 to stop the input scrubber eating whitespace. */
190 const char ppc_symbol_chars
[] = "%[";
192 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
193 int ppc_cie_data_alignment
;
195 /* The dwarf2 minimum instruction length. */
196 int ppc_dwarf2_line_min_insn_length
;
198 /* More than this number of nops in an alignment op gets a branch
200 unsigned long nop_limit
= 4;
202 /* The type of processor we are assembling for. This is one or more
203 of the PPC_OPCODE flags defined in opcode/ppc.h. */
204 ppc_cpu_t ppc_cpu
= 0;
205 ppc_cpu_t sticky
= 0;
207 /* Value for ELF e_flags EF_PPC64_ABI. */
208 unsigned int ppc_abiversion
= 0;
211 /* Flags set on encountering toc relocs. */
213 has_large_toc_reloc
= 1,
214 has_small_toc_reloc
= 2
218 /* Warn on emitting data to code sections. */
220 unsigned long last_insn
;
224 /* The target specific pseudo-ops which we support. */
226 const pseudo_typeS md_pseudo_table
[] =
228 /* Pseudo-ops which must be overridden. */
229 { "byte", ppc_byte
, 0 },
232 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
233 legitimately belong in the obj-*.c file. However, XCOFF is based
234 on COFF, and is only implemented for the RS/6000. We just use
235 obj-coff.c, and add what we need here. */
236 { "comm", ppc_comm
, 0 },
237 { "lcomm", ppc_comm
, 1 },
241 { "bi", ppc_biei
, 0 },
243 { "csect", ppc_csect
, 0 },
244 { "dwsect", ppc_dwsect
, 0 },
245 { "data", ppc_section
, 'd' },
249 { "ei", ppc_biei
, 1 },
251 { "extern", ppc_extern
, 0 },
252 { "function", ppc_function
, 0 },
253 { "lglobl", ppc_lglobl
, 0 },
254 { "ref", ppc_ref
, 0 },
255 { "rename", ppc_rename
, 0 },
256 { "section", ppc_named_section
, 0 },
257 { "stabx", ppc_stabx
, 0 },
258 { "text", ppc_section
, 't' },
259 { "toc", ppc_toc
, 0 },
260 { "long", ppc_xcoff_cons
, 2 },
261 { "llong", ppc_xcoff_cons
, 3 },
262 { "word", ppc_xcoff_cons
, 1 },
263 { "short", ppc_xcoff_cons
, 1 },
264 { "vbyte", ppc_vbyte
, 0 },
268 { "llong", cons
, 8 },
269 { "rdata", ppc_elf_rdata
, 0 },
270 { "rodata", ppc_elf_rdata
, 0 },
271 { "lcomm", ppc_elf_lcomm
, 0 },
272 { "localentry", ppc_elf_localentry
, 0 },
273 { "abiversion", ppc_elf_abiversion
, 0 },
274 { "gnu_attribute", ppc_elf_gnu_attribute
, 0},
278 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
279 { "previous", ppc_previous
, 0 },
280 { "pdata", ppc_pdata
, 0 },
281 { "ydata", ppc_ydata
, 0 },
282 { "reldata", ppc_reldata
, 0 },
283 { "rdata", ppc_rdata
, 0 },
284 { "ualong", ppc_ualong
, 0 },
285 { "znop", ppc_znop
, 0 },
286 { "comm", ppc_pe_comm
, 0 },
287 { "lcomm", ppc_pe_comm
, 1 },
288 { "section", ppc_pe_section
, 0 },
289 { "function", ppc_pe_function
,0 },
290 { "tocd", ppc_pe_tocd
, 0 },
293 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
295 { "machine", ppc_machine
, 0 },
302 /* Predefined register names if -mregnames (or default for Windows NT).
303 In general, there are lots of them, in an attempt to be compatible
304 with a number of other Windows NT assemblers. */
306 /* Structure to hold information about predefined registers. */
313 /* List of registers that are pre-defined:
315 Each general register has predefined names of the form:
316 1. r<reg_num> which has the value <reg_num>.
317 2. r.<reg_num> which has the value <reg_num>.
319 Each floating point register has predefined names of the form:
320 1. f<reg_num> which has the value <reg_num>.
321 2. f.<reg_num> which has the value <reg_num>.
323 Each vector unit register has predefined names of the form:
324 1. v<reg_num> which has the value <reg_num>.
325 2. v.<reg_num> which has the value <reg_num>.
327 Each condition register has predefined names of the form:
328 1. cr<reg_num> which has the value <reg_num>.
329 2. cr.<reg_num> which has the value <reg_num>.
331 There are individual registers as well:
332 sp or r.sp has the value 1
333 rtoc or r.toc has the value 2
334 fpscr has the value 0
340 dsisr has the value 18
342 sdr1 has the value 25
343 srr0 has the value 26
344 srr1 has the value 27
346 The table is sorted. Suitable for searching by a binary search. */
348 static const struct pd_reg pre_defined_registers
[] =
350 { "cr.0", 0 }, /* Condition Registers */
370 { "dar", 19 }, /* Data Access Register */
371 { "dec", 22 }, /* Decrementer */
372 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
374 { "f.0", 0 }, /* Floating point registers */
401 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
467 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
508 /* Quantization registers used with pair single instructions. */
526 { "lr", 8 }, /* Link Register */
530 { "r.0", 0 }, /* General Purpose Registers */
563 { "r.sp", 1 }, /* Stack Pointer */
565 { "r.toc", 2 }, /* Pointer to the table of contents */
567 { "r0", 0 }, /* More general purpose registers */
600 { "rtoc", 2 }, /* Table of contents */
602 { "sdr1", 25 }, /* Storage Description Register 1 */
606 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
607 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
609 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
675 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
809 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
811 /* Given NAME, find the register number associated with that name, return
812 the integer value associated with the given name or -1 on failure. */
815 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
817 int middle
, low
, high
;
825 middle
= (low
+ high
) / 2;
826 cmp
= strcasecmp (name
, regs
[middle
].name
);
832 return regs
[middle
].value
;
840 * Summary of register_name.
842 * in: Input_line_pointer points to 1st char of operand.
844 * out: A expressionS.
845 * The operand may have been a register: in this case, X_op == O_register,
846 * X_add_number is set to the register number, and truth is returned.
847 * Input_line_pointer->(next non-blank) char after operand, or is in its
852 register_name (expressionS
*expressionP
)
859 /* Find the spelling of the operand. */
860 start
= name
= input_line_pointer
;
861 if (name
[0] == '%' && ISALPHA (name
[1]))
862 name
= ++input_line_pointer
;
864 else if (!reg_names_p
|| !ISALPHA (name
[0]))
867 c
= get_symbol_name (&name
);
868 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
870 /* Put back the delimiting char. */
871 *input_line_pointer
= c
;
873 /* Look to see if it's in the register table. */
876 expressionP
->X_op
= O_register
;
877 expressionP
->X_add_number
= reg_number
;
879 /* Make the rest nice. */
880 expressionP
->X_add_symbol
= NULL
;
881 expressionP
->X_op_symbol
= NULL
;
885 /* Reset the line as if we had not done anything. */
886 input_line_pointer
= start
;
890 /* This function is called for each symbol seen in an expression. It
891 handles the special parsing which PowerPC assemblers are supposed
892 to use for condition codes. */
894 /* Whether to do the special parsing. */
895 static bfd_boolean cr_operand
;
897 /* Names to recognize in a condition code. This table is sorted. */
898 static const struct pd_reg cr_names
[] =
915 /* Parsing function. This returns non-zero if it recognized an
919 ppc_parse_name (const char *name
, expressionS
*exp
)
928 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
933 exp
->X_op
= O_constant
;
934 exp
->X_add_number
= val
;
939 /* Local variables. */
941 /* Whether to target xcoff64/elf64. */
942 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
944 /* Opcode hash table. */
945 static struct hash_control
*ppc_hash
;
947 /* Macro hash table. */
948 static struct hash_control
*ppc_macro_hash
;
951 /* What type of shared library support to use. */
952 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
954 /* Flags to set in the elf header. */
955 static flagword ppc_flags
= 0;
957 /* Whether this is Solaris or not. */
958 #ifdef TARGET_SOLARIS_COMMENT
959 #define SOLARIS_P TRUE
961 #define SOLARIS_P FALSE
964 static bfd_boolean msolaris
= SOLARIS_P
;
969 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
970 using a bunch of different sections. These assembler sections,
971 however, are all encompassed within the .text or .data sections of
972 the final output file. We handle this by using different
973 subsegments within these main segments. */
975 /* Next subsegment to allocate within the .text segment. */
976 static subsegT ppc_text_subsegment
= 2;
978 /* Linked list of csects in the text section. */
979 static symbolS
*ppc_text_csects
;
981 /* Next subsegment to allocate within the .data segment. */
982 static subsegT ppc_data_subsegment
= 2;
984 /* Linked list of csects in the data section. */
985 static symbolS
*ppc_data_csects
;
987 /* The current csect. */
988 static symbolS
*ppc_current_csect
;
990 /* The RS/6000 assembler uses a TOC which holds addresses of functions
991 and variables. Symbols are put in the TOC with the .tc pseudo-op.
992 A special relocation is used when accessing TOC entries. We handle
993 the TOC as a subsegment within the .data segment. We set it up if
994 we see a .toc pseudo-op, and save the csect symbol here. */
995 static symbolS
*ppc_toc_csect
;
997 /* The first frag in the TOC subsegment. */
998 static fragS
*ppc_toc_frag
;
1000 /* The first frag in the first subsegment after the TOC in the .data
1001 segment. NULL if there are no subsegments after the TOC. */
1002 static fragS
*ppc_after_toc_frag
;
1004 /* The current static block. */
1005 static symbolS
*ppc_current_block
;
1007 /* The COFF debugging section; set by md_begin. This is not the
1008 .debug section, but is instead the secret BFD section which will
1009 cause BFD to set the section number of a symbol to N_DEBUG. */
1010 static asection
*ppc_coff_debug_section
;
1012 /* Structure to set the length field of the dwarf sections. */
1013 struct dw_subsection
{
1014 /* Subsections are simply linked. */
1015 struct dw_subsection
*link
;
1017 /* The subsection number. */
1020 /* Expression to compute the length of the section. */
1021 expressionS end_exp
;
1024 static struct dw_section
{
1025 /* Corresponding section. */
1028 /* Simply linked list of subsections with a label. */
1029 struct dw_subsection
*list_subseg
;
1031 /* The anonymous subsection. */
1032 struct dw_subsection
*anon_subseg
;
1033 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1034 #endif /* OBJ_XCOFF */
1038 /* Various sections that we need for PE coff support. */
1039 static segT ydata_section
;
1040 static segT pdata_section
;
1041 static segT reldata_section
;
1042 static segT rdata_section
;
1043 static segT tocdata_section
;
1045 /* The current section and the previous section. See ppc_previous. */
1046 static segT ppc_previous_section
;
1047 static segT ppc_current_section
;
1052 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1053 unsigned long *ppc_apuinfo_list
;
1054 unsigned int ppc_apuinfo_num
;
1055 unsigned int ppc_apuinfo_num_alloc
;
1056 #endif /* OBJ_ELF */
1059 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1061 const char *const md_shortopts
= "um:";
1063 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1064 const struct option md_longopts
[] = {
1065 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1066 {"ppc476-workaround", no_argument
, &warn_476
, 1},
1067 {"no-ppc476-workaround", no_argument
, &warn_476
, 0},
1068 {NULL
, no_argument
, NULL
, 0}
1070 const size_t md_longopts_size
= sizeof (md_longopts
);
1073 md_parse_option (int c
, const char *arg
)
1080 /* -u means that any undefined symbols should be treated as
1081 external, which is the default for gas anyhow. */
1086 /* Solaris as takes -le (presumably for little endian). For completeness
1087 sake, recognize -be also. */
1088 if (strcmp (arg
, "e") == 0)
1090 target_big_endian
= 0;
1091 set_target_endian
= 1;
1092 if (ppc_cpu
& PPC_OPCODE_VLE
)
1093 as_bad (_("the use of -mvle requires big endian."));
1101 if (strcmp (arg
, "e") == 0)
1103 target_big_endian
= 1;
1104 set_target_endian
= 1;
1112 /* Recognize -K PIC. */
1113 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1116 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1124 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1126 if (strcmp (arg
, "64") == 0)
1130 if (ppc_cpu
& PPC_OPCODE_VLE
)
1131 as_bad (_("the use of -mvle requires -a32."));
1133 as_fatal (_("%s unsupported"), "-a64");
1136 else if (strcmp (arg
, "32") == 0)
1143 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1147 if (strcmp (arg
, "vle") == 0)
1149 if (set_target_endian
&& target_big_endian
== 0)
1150 as_bad (_("the use of -mvle requires big endian."));
1152 as_bad (_("the use of -mvle requires -a32."));
1156 else if (strcmp (arg
, "regnames") == 0)
1159 else if (strcmp (arg
, "no-regnames") == 0)
1160 reg_names_p
= FALSE
;
1163 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1164 that require relocation. */
1165 else if (strcmp (arg
, "relocatable") == 0)
1167 shlib
= SHLIB_MRELOCATABLE
;
1168 ppc_flags
|= EF_PPC_RELOCATABLE
;
1171 else if (strcmp (arg
, "relocatable-lib") == 0)
1173 shlib
= SHLIB_MRELOCATABLE
;
1174 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1177 /* -memb, set embedded bit. */
1178 else if (strcmp (arg
, "emb") == 0)
1179 ppc_flags
|= EF_PPC_EMB
;
1181 /* -mlittle/-mbig set the endianness. */
1182 else if (strcmp (arg
, "little") == 0
1183 || strcmp (arg
, "little-endian") == 0)
1185 target_big_endian
= 0;
1186 set_target_endian
= 1;
1187 if (ppc_cpu
& PPC_OPCODE_VLE
)
1188 as_bad (_("the use of -mvle requires big endian."));
1191 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1193 target_big_endian
= 1;
1194 set_target_endian
= 1;
1197 else if (strcmp (arg
, "solaris") == 0)
1200 ppc_comment_chars
= ppc_solaris_comment_chars
;
1203 else if (strcmp (arg
, "no-solaris") == 0)
1206 ppc_comment_chars
= ppc_eabi_comment_chars
;
1211 as_bad (_("invalid switch -m%s"), arg
);
1217 /* -V: SVR4 argument to print version ID. */
1219 print_version_id ();
1222 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1223 should be emitted or not. FIXME: Not implemented. */
1227 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1228 rather than .stabs.excl, which is ignored by the linker.
1229 FIXME: Not implemented. */
1240 nop_limit
= strtoul (optarg
, &end
, 0);
1242 as_bad (_("--nops needs a numeric argument"));
1257 md_show_usage (FILE *stream
)
1259 fprintf (stream
, _("\
1261 -a32 generate ELF32/XCOFF32\n\
1262 -a64 generate ELF64/XCOFF64\n\
1264 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1265 -mpwr generate code for POWER (RIOS1)\n\
1266 -m601 generate code for PowerPC 601\n\
1267 -mppc, -mppc32, -m603, -m604\n\
1268 generate code for PowerPC 603/604\n\
1269 -m403 generate code for PowerPC 403\n\
1270 -m405 generate code for PowerPC 405\n\
1271 -m440 generate code for PowerPC 440\n\
1272 -m464 generate code for PowerPC 464\n\
1273 -m476 generate code for PowerPC 476\n\
1274 -m7400, -m7410, -m7450, -m7455\n\
1275 generate code for PowerPC 7400/7410/7450/7455\n\
1276 -m750cl generate code for PowerPC 750cl\n\
1277 -m821, -m850, -m860 generate code for PowerPC 821/850/860\n"));
1278 fprintf (stream
, _("\
1279 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1280 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1281 -mbooke generate code for 32-bit PowerPC BookE\n\
1282 -ma2 generate code for A2 architecture\n\
1283 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1284 -mpower5, -mpwr5, -mpwr5x\n\
1285 generate code for Power5 architecture\n\
1286 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1287 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1288 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1289 -mpower9, -mpwr9 generate code for Power9 architecture\n\
1290 -mcell generate code for Cell Broadband Engine architecture\n\
1291 -mcom generate code Power/PowerPC common instructions\n\
1292 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1293 fprintf (stream
, _("\
1294 -maltivec generate code for AltiVec\n\
1295 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1296 -mhtm generate code for Hardware Transactional Memory\n\
1297 -me300 generate code for PowerPC e300 family\n\
1298 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1299 -me500mc, generate code for Freescale e500mc core complex\n\
1300 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1301 -me5500, generate code for Freescale e5500 core complex\n\
1302 -me6500, generate code for Freescale e6500 core complex\n\
1303 -mspe generate code for Motorola SPE instructions\n\
1304 -mvle generate code for Freescale VLE instructions\n\
1305 -mtitan generate code for AppliedMicro Titan core complex\n\
1306 -mregnames Allow symbolic names for registers\n\
1307 -mno-regnames Do not allow symbolic names for registers\n"));
1309 fprintf (stream
, _("\
1310 -mrelocatable support for GCC's -mrelocatble option\n\
1311 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1312 -memb set PPC_EMB bit in ELF flags\n\
1313 -mlittle, -mlittle-endian, -le\n\
1314 generate code for a little endian machine\n\
1315 -mbig, -mbig-endian, -be\n\
1316 generate code for a big endian machine\n\
1317 -msolaris generate code for Solaris\n\
1318 -mno-solaris do not generate code for Solaris\n\
1319 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1320 -V print assembler version number\n\
1321 -Qy, -Qn ignored\n"));
1323 fprintf (stream
, _("\
1324 -nops=count when aligning, more than COUNT nops uses a branch\n\
1325 -ppc476-workaround warn if emitting data to code sections\n"));
1328 /* Set ppc_cpu if it is not already set. */
1333 const char *default_os
= TARGET_OS
;
1334 const char *default_cpu
= TARGET_CPU
;
1336 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1339 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1340 else if (strncmp (default_os
, "aix", 3) == 0
1341 && default_os
[3] >= '4' && default_os
[3] <= '9')
1342 ppc_cpu
|= PPC_OPCODE_COMMON
;
1343 else if (strncmp (default_os
, "aix3", 4) == 0)
1344 ppc_cpu
|= PPC_OPCODE_POWER
;
1345 else if (strcmp (default_cpu
, "rs6000") == 0)
1346 ppc_cpu
|= PPC_OPCODE_POWER
;
1347 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1348 ppc_cpu
|= PPC_OPCODE_PPC
;
1350 as_fatal (_("unknown default cpu = %s, os = %s"),
1351 default_cpu
, default_os
);
1355 /* Figure out the BFD architecture to use. This function and ppc_mach
1356 are called well before md_begin, when the output file is opened. */
1358 enum bfd_architecture
1361 const char *default_cpu
= TARGET_CPU
;
1364 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1365 return bfd_arch_powerpc
;
1366 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1367 return bfd_arch_powerpc
;
1368 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1369 return bfd_arch_rs6000
;
1370 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1372 if (strcmp (default_cpu
, "rs6000") == 0)
1373 return bfd_arch_rs6000
;
1374 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1375 return bfd_arch_powerpc
;
1378 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1379 return bfd_arch_unknown
;
1386 return bfd_mach_ppc64
;
1387 else if (ppc_arch () == bfd_arch_rs6000
)
1388 return bfd_mach_rs6k
;
1389 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1390 return bfd_mach_ppc_titan
;
1391 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1392 return bfd_mach_ppc_vle
;
1394 return bfd_mach_ppc
;
1398 ppc_target_format (void)
1402 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1404 return "xcoff-powermac";
1407 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1409 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1415 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1416 # elif defined (TE_VXWORKS)
1417 return "elf32-powerpc-vxworks";
1419 return (target_big_endian
1420 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1421 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1426 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1427 Return TRUE if there's a problem, otherwise FALSE. */
1430 insn_validate (const struct powerpc_opcode
*op
)
1432 const unsigned char *o
;
1433 unsigned long omask
= op
->mask
;
1435 /* The mask had better not trim off opcode bits. */
1436 if ((op
->opcode
& omask
) != op
->opcode
)
1438 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1442 /* The operands must not overlap the opcode or each other. */
1443 for (o
= op
->operands
; *o
; ++o
)
1445 if (*o
>= num_powerpc_operands
)
1447 as_bad (_("operand index error for %s"), op
->name
);
1452 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1453 if (operand
->shift
!= (int) PPC_OPSHIFT_INV
)
1457 if (operand
->shift
>= 0)
1458 mask
= operand
->bitm
<< operand
->shift
;
1460 mask
= operand
->bitm
>> -operand
->shift
;
1463 as_bad (_("operand %d overlap in %s"),
1464 (int) (o
- op
->operands
), op
->name
);
1474 /* Insert opcodes and macros into hash tables. Called at startup and
1475 for .machine pseudo. */
1478 ppc_setup_opcodes (void)
1480 const struct powerpc_opcode
*op
;
1481 const struct powerpc_opcode
*op_end
;
1482 const struct powerpc_macro
*macro
;
1483 const struct powerpc_macro
*macro_end
;
1484 bfd_boolean bad_insn
= FALSE
;
1486 if (ppc_hash
!= NULL
)
1487 hash_die (ppc_hash
);
1488 if (ppc_macro_hash
!= NULL
)
1489 hash_die (ppc_macro_hash
);
1491 /* Insert the opcodes into a hash table. */
1492 ppc_hash
= hash_new ();
1494 if (ENABLE_CHECKING
)
1498 /* An index into powerpc_operands is stored in struct fix
1499 fx_pcrel_adjust which is 8 bits wide. */
1500 gas_assert (num_powerpc_operands
< 256);
1502 /* Check operand masks. Code here and in the disassembler assumes
1503 all the 1's in the mask are contiguous. */
1504 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1506 unsigned long mask
= powerpc_operands
[i
].bitm
;
1507 unsigned long right_bit
;
1510 right_bit
= mask
& -mask
;
1512 right_bit
= mask
& -mask
;
1513 if (mask
!= right_bit
)
1515 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1518 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1519 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1520 sizeof (powerpc_operands
[0])) == 0)
1522 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1529 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1530 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1532 if (ENABLE_CHECKING
)
1534 if (op
!= powerpc_opcodes
)
1536 int old_opcode
= PPC_OP (op
[-1].opcode
);
1537 int new_opcode
= PPC_OP (op
[0].opcode
);
1539 #ifdef PRINT_OPCODE_TABLE
1540 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1541 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1542 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1543 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1546 /* The major opcodes had better be sorted. Code in the
1547 disassembler assumes the insns are sorted according to
1549 if (new_opcode
< old_opcode
)
1551 as_bad (_("major opcode is not sorted for %s"),
1556 if ((op
->flags
& PPC_OPCODE_VLE
) != 0)
1558 as_bad (_("%s is enabled by vle flag"), op
->name
);
1561 if (PPC_OP (op
->opcode
) != 4
1562 && PPC_OP (op
->opcode
) != 31
1563 && (op
->deprecated
& PPC_OPCODE_VLE
) == 0)
1565 as_bad (_("%s not disabled by vle flag"), op
->name
);
1568 bad_insn
|= insn_validate (op
);
1571 if ((ppc_cpu
& op
->flags
) != 0
1572 && !(ppc_cpu
& op
->deprecated
))
1576 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1579 as_bad (_("duplicate instruction %s"),
1586 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1587 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1588 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1590 op_end
= vle_opcodes
+ vle_num_opcodes
;
1591 for (op
= vle_opcodes
; op
< op_end
; op
++)
1593 if (ENABLE_CHECKING
)
1595 if (op
!= vle_opcodes
)
1597 unsigned old_seg
, new_seg
;
1599 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1600 old_seg
= VLE_OP_TO_SEG (old_seg
);
1601 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1602 new_seg
= VLE_OP_TO_SEG (new_seg
);
1604 #ifdef PRINT_OPCODE_TABLE
1605 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1606 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1607 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1608 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1610 /* The major opcodes had better be sorted. Code in the
1611 disassembler assumes the insns are sorted according to
1613 if (new_seg
< old_seg
)
1615 as_bad (_("major opcode is not sorted for %s"),
1621 bad_insn
|= insn_validate (op
);
1624 if ((ppc_cpu
& op
->flags
) != 0
1625 && !(ppc_cpu
& op
->deprecated
))
1629 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1632 as_bad (_("duplicate instruction %s"),
1639 /* Insert the macros into a hash table. */
1640 ppc_macro_hash
= hash_new ();
1642 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1643 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1645 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1649 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1650 if (retval
!= (const char *) NULL
)
1652 as_bad (_("duplicate macro %s"), macro
->name
);
1662 /* This function is called when the assembler starts up. It is called
1663 after the options have been parsed and the output file has been
1671 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1672 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1675 /* Set the ELF flags if desired. */
1676 if (ppc_flags
&& !msolaris
)
1677 bfd_set_private_flags (stdoutput
, ppc_flags
);
1680 ppc_setup_opcodes ();
1682 /* Tell the main code what the endianness is if it is not overridden
1684 if (!set_target_endian
)
1686 set_target_endian
= 1;
1687 target_big_endian
= PPC_BIG_ENDIAN
;
1691 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1693 /* Create dummy symbols to serve as initial csects. This forces the
1694 text csects to precede the data csects. These symbols will not
1696 ppc_text_csects
= symbol_make ("dummy\001");
1697 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1698 ppc_data_csects
= symbol_make ("dummy\001");
1699 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1704 ppc_current_section
= text_section
;
1705 ppc_previous_section
= 0;
1714 if (ppc_apuinfo_list
== NULL
)
1717 /* Ok, so write the section info out. We have this layout:
1721 0 8 length of "APUinfo\0"
1722 4 (n*4) number of APU's (4 bytes each)
1725 20 APU#1 first APU's info
1726 24 APU#2 second APU's info
1731 asection
*seg
= now_seg
;
1732 subsegT subseg
= now_subseg
;
1733 asection
*apuinfo_secp
= (asection
*) NULL
;
1736 /* Create the .PPC.EMB.apuinfo section. */
1737 apuinfo_secp
= subseg_new (APUINFO_SECTION_NAME
, 0);
1738 bfd_set_section_flags (stdoutput
,
1740 SEC_HAS_CONTENTS
| SEC_READONLY
);
1743 md_number_to_chars (p
, (valueT
) 8, 4);
1746 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1749 md_number_to_chars (p
, (valueT
) 2, 4);
1752 strcpy (p
, APUINFO_LABEL
);
1754 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1757 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1760 frag_align (2, 0, 0);
1762 /* We probably can't restore the current segment, for there likely
1765 subseg_set (seg
, subseg
);
1770 /* Insert an operand value into an instruction. */
1772 static unsigned long
1773 ppc_insert_operand (unsigned long insn
,
1774 const struct powerpc_operand
*operand
,
1780 long min
, max
, right
;
1782 max
= operand
->bitm
;
1786 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1788 /* Extend the allowed range for addis to [-32768, 65535].
1789 Similarly for cmpli and some VLE high part insns. For 64-bit
1790 it would be good to disable this for signed fields since the
1791 value is sign extended into the high 32 bits of the register.
1792 If the value is, say, an address, then we might care about
1793 the high bits. However, gcc as of 2014-06 uses unsigned
1794 values when loading the high part of 64-bit constants using
1796 min
= ~(max
>> 1) & -right
;
1798 else if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1800 max
= (max
>> 1) & -right
;
1801 min
= ~max
& -right
;
1804 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1807 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1816 /* Some people write constants with the sign extension done by
1817 hand but only up to 32 bits. This shouldn't really be valid,
1818 but, to permit this code to assemble on a 64-bit host, we
1819 sign extend the 32-bit value to 64 bits if so doing makes the
1822 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1823 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1824 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1825 val
= val
- 0x80000000 - 0x80000000;
1827 /* Similarly, people write expressions like ~(1<<15), and expect
1828 this to be OK for a 32-bit unsigned value. */
1830 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1831 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1832 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1833 val
= val
+ 0x80000000 + 0x80000000;
1837 || (val
& (right
- 1)) != 0)
1838 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1841 if (operand
->insert
)
1846 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1847 if (errmsg
!= (const char *) NULL
)
1848 as_bad_where (file
, line
, "%s", errmsg
);
1850 else if (operand
->shift
>= 0)
1851 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1853 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1860 /* Parse @got, etc. and return the desired relocation. */
1861 static bfd_reloc_code_real_type
1862 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1866 unsigned int length
: 8;
1867 unsigned int valid32
: 1;
1868 unsigned int valid64
: 1;
1877 const struct map_bfd
*ptr
;
1879 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1880 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1881 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1883 static const struct map_bfd mapping
[] = {
1884 MAP ("l", BFD_RELOC_LO16
),
1885 MAP ("h", BFD_RELOC_HI16
),
1886 MAP ("ha", BFD_RELOC_HI16_S
),
1887 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1888 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1889 MAP ("got", BFD_RELOC_16_GOTOFF
),
1890 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1891 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1892 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1893 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1894 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1895 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1896 MAP ("copy", BFD_RELOC_PPC_COPY
),
1897 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1898 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1899 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1900 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1901 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1902 MAP ("tls", BFD_RELOC_PPC_TLS
),
1903 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1904 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1905 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1906 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1907 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1908 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1909 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1910 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1911 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1912 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1913 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1914 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1915 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1916 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1917 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1918 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1919 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1920 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1921 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1922 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1923 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1924 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1925 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1926 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1927 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1928 MAP32 ("fixup", BFD_RELOC_CTOR
),
1929 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1930 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1931 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1932 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1933 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1934 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1935 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1936 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1937 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1938 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1939 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1940 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1941 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1942 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1943 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1944 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1945 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1946 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1947 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1948 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1949 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1950 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1951 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1952 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1953 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1954 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1955 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1956 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1957 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1958 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1959 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1960 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1961 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1962 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1963 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1964 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1965 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1966 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1967 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1968 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1969 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1970 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1971 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1972 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1973 MAP64 ("localentry", BFD_RELOC_PPC64_ADDR64_LOCAL
),
1974 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1975 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1976 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1977 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1978 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1979 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1980 { (char *) 0, 0, 0, 0, BFD_RELOC_NONE
}
1984 return BFD_RELOC_NONE
;
1986 for (ch
= *str
, str2
= ident
;
1987 (str2
< ident
+ sizeof (ident
) - 1
1988 && (ISALNUM (ch
) || ch
== '@'));
1991 *str2
++ = TOLOWER (ch
);
1998 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1999 if (ch
== ptr
->string
[0]
2000 && len
== ptr
->length
2001 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
2002 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
2004 int reloc
= ptr
->reloc
;
2006 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
2010 case BFD_RELOC_16_GOTOFF
:
2011 case BFD_RELOC_LO16_GOTOFF
:
2012 case BFD_RELOC_HI16_GOTOFF
:
2013 case BFD_RELOC_HI16_S_GOTOFF
:
2014 as_warn (_("identifier+constant@got means "
2015 "identifier@got+constant"));
2018 case BFD_RELOC_PPC_GOT_TLSGD16
:
2019 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2020 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2021 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2022 case BFD_RELOC_PPC_GOT_TLSLD16
:
2023 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2024 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2025 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2026 case BFD_RELOC_PPC_GOT_DTPREL16
:
2027 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2028 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2029 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2030 case BFD_RELOC_PPC_GOT_TPREL16
:
2031 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2032 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2033 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2034 as_bad (_("symbol+offset not supported for got tls"));
2039 /* Now check for identifier@suffix+constant. */
2040 if (*str
== '-' || *str
== '+')
2042 char *orig_line
= input_line_pointer
;
2043 expressionS new_exp
;
2045 input_line_pointer
= str
;
2046 expression (&new_exp
);
2047 if (new_exp
.X_op
== O_constant
)
2049 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2050 str
= input_line_pointer
;
2053 if (&input_line_pointer
!= str_p
)
2054 input_line_pointer
= orig_line
;
2058 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2059 && exp_p
->X_op
== O_symbol
2060 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2062 /* Change the symbol so that the dummy .TOC. symbol can be
2063 omitted from the object file. */
2064 exp_p
->X_add_symbol
= &abs_symbol
;
2067 return (bfd_reloc_code_real_type
) reloc
;
2070 return BFD_RELOC_NONE
;
2073 /* Support @got, etc. on constants emitted via .short, .int etc. */
2075 bfd_reloc_code_real_type
2076 ppc_elf_parse_cons (expressionS
*exp
, unsigned int nbytes
)
2079 if (nbytes
>= 2 && *input_line_pointer
== '@')
2080 return ppc_elf_suffix (&input_line_pointer
, exp
);
2081 return BFD_RELOC_NONE
;
2084 /* Warn when emitting data to code sections, unless we are emitting
2085 a relocation that ld --ppc476-workaround uses to recognise data
2086 *and* there was an unconditional branch prior to the data. */
2089 ppc_elf_cons_fix_check (expressionS
*exp ATTRIBUTE_UNUSED
,
2090 unsigned int nbytes
, fixS
*fix
)
2093 && (now_seg
->flags
& SEC_CODE
) != 0
2096 || !(fix
->fx_r_type
== BFD_RELOC_32
2097 || fix
->fx_r_type
== BFD_RELOC_CTOR
2098 || fix
->fx_r_type
== BFD_RELOC_32_PCREL
)
2099 || !(last_seg
== now_seg
&& last_subseg
== now_subseg
)
2100 || !((last_insn
& (0x3f << 26)) == (18u << 26)
2101 || ((last_insn
& (0x3f << 26)) == (16u << 26)
2102 && (last_insn
& (0x14 << 21)) == (0x14 << 21))
2103 || ((last_insn
& (0x3f << 26)) == (19u << 26)
2104 && (last_insn
& (0x3ff << 1)) == (16u << 1)
2105 && (last_insn
& (0x14 << 21)) == (0x14 << 21)))))
2107 /* Flag that we've warned. */
2111 as_warn (_("data in executable section"));
2115 /* Solaris pseduo op to change to the .rodata section. */
2117 ppc_elf_rdata (int xxx
)
2119 char *save_line
= input_line_pointer
;
2120 static char section
[] = ".rodata\n";
2122 /* Just pretend this is .section .rodata */
2123 input_line_pointer
= section
;
2124 obj_elf_section (xxx
);
2126 input_line_pointer
= save_line
;
2129 /* Pseudo op to make file scope bss items. */
2131 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2144 c
= get_symbol_name (&name
);
2146 /* Just after name is now '\0'. */
2147 p
= input_line_pointer
;
2149 SKIP_WHITESPACE_AFTER_NAME ();
2150 if (*input_line_pointer
!= ',')
2152 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2153 ignore_rest_of_line ();
2157 input_line_pointer
++; /* skip ',' */
2158 if ((size
= get_absolute_expression ()) < 0)
2160 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2161 ignore_rest_of_line ();
2165 /* The third argument to .lcomm is the alignment. */
2166 if (*input_line_pointer
!= ',')
2170 ++input_line_pointer
;
2171 align
= get_absolute_expression ();
2174 as_warn (_("ignoring bad alignment"));
2180 symbolP
= symbol_find_or_make (name
);
2183 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2185 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2186 S_GET_NAME (symbolP
));
2187 ignore_rest_of_line ();
2191 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2193 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2194 S_GET_NAME (symbolP
),
2195 (long) S_GET_VALUE (symbolP
),
2198 ignore_rest_of_line ();
2204 old_subsec
= now_subseg
;
2207 /* Convert to a power of 2 alignment. */
2208 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2211 as_bad (_("common alignment not a power of 2"));
2212 ignore_rest_of_line ();
2219 record_alignment (bss_section
, align2
);
2220 subseg_set (bss_section
, 1);
2222 frag_align (align2
, 0, 0);
2223 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2224 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2225 symbol_set_frag (symbolP
, frag_now
);
2226 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2229 S_SET_SIZE (symbolP
, size
);
2230 S_SET_SEGMENT (symbolP
, bss_section
);
2231 subseg_set (old_sec
, old_subsec
);
2232 demand_empty_rest_of_line ();
2235 /* Pseudo op to set symbol local entry point. */
2237 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED
)
2240 char c
= get_symbol_name (&name
);
2245 elf_symbol_type
*elfsym
;
2247 p
= input_line_pointer
;
2249 SKIP_WHITESPACE_AFTER_NAME ();
2250 if (*input_line_pointer
!= ',')
2253 as_bad (_("expected comma after name `%s' in .localentry directive"),
2256 ignore_rest_of_line ();
2259 input_line_pointer
++;
2261 if (exp
.X_op
== O_absent
)
2263 as_bad (_("missing expression in .localentry directive"));
2264 exp
.X_op
= O_constant
;
2265 exp
.X_add_number
= 0;
2268 sym
= symbol_find_or_make (name
);
2271 if (resolve_expression (&exp
)
2272 && exp
.X_op
== O_constant
)
2274 unsigned char encoded
= PPC64_SET_LOCAL_ENTRY_OFFSET (exp
.X_add_number
);
2276 if (exp
.X_add_number
!= (offsetT
) PPC64_LOCAL_ENTRY_OFFSET (encoded
))
2277 as_bad (_(".localentry expression for `%s' "
2278 "is not a valid power of 2"), S_GET_NAME (sym
));
2281 bfdsym
= symbol_get_bfdsym (sym
);
2282 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
2283 gas_assert (elfsym
);
2284 elfsym
->internal_elf_sym
.st_other
&= ~STO_PPC64_LOCAL_MASK
;
2285 elfsym
->internal_elf_sym
.st_other
|= encoded
;
2286 if (ppc_abiversion
== 0)
2291 as_bad (_(".localentry expression for `%s' "
2292 "does not evaluate to a constant"), S_GET_NAME (sym
));
2294 demand_empty_rest_of_line ();
2297 /* Pseudo op to set ABI version. */
2299 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2304 if (exp
.X_op
== O_absent
)
2306 as_bad (_("missing expression in .abiversion directive"));
2307 exp
.X_op
= O_constant
;
2308 exp
.X_add_number
= 0;
2311 if (resolve_expression (&exp
)
2312 && exp
.X_op
== O_constant
)
2313 ppc_abiversion
= exp
.X_add_number
;
2315 as_bad (_(".abiversion expression does not evaluate to a constant"));
2316 demand_empty_rest_of_line ();
2319 /* Parse a .gnu_attribute directive. */
2321 ppc_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED
)
2323 int tag
= obj_elf_vendor_attribute (OBJ_ATTR_GNU
);
2325 /* Check validity of defined powerpc tags. */
2326 if (tag
== Tag_GNU_Power_ABI_FP
2327 || tag
== Tag_GNU_Power_ABI_Vector
2328 || tag
== Tag_GNU_Power_ABI_Struct_Return
)
2332 val
= bfd_elf_get_obj_attr_int (stdoutput
, OBJ_ATTR_GNU
, tag
);
2334 if ((tag
== Tag_GNU_Power_ABI_FP
&& val
> 15)
2335 || (tag
== Tag_GNU_Power_ABI_Vector
&& val
> 3)
2336 || (tag
== Tag_GNU_Power_ABI_Struct_Return
&& val
> 2))
2337 as_warn (_("unknown .gnu_attribute value"));
2341 /* Set ABI version in output file. */
2345 if (ppc_obj64
&& ppc_abiversion
!= 0)
2347 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2348 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2352 /* Validate any relocations emitted for -mrelocatable, possibly adding
2353 fixups for word relocations in writable segments, so we can adjust
2356 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2358 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2367 case SHLIB_MRELOCATABLE
:
2368 if (fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2369 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2370 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2371 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2372 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2373 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2374 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2375 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2376 && (seg
->flags
& SEC_LOAD
) != 0
2377 && strcmp (segment_name (seg
), ".got2") != 0
2378 && strcmp (segment_name (seg
), ".dtors") != 0
2379 && strcmp (segment_name (seg
), ".ctors") != 0
2380 && strcmp (segment_name (seg
), ".fixup") != 0
2381 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2382 && strcmp (segment_name (seg
), ".eh_frame") != 0
2383 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2385 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2386 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2388 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2389 _("relocation cannot be done when using -mrelocatable"));
2396 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2397 function descriptor sym if the corresponding code sym is used. */
2400 ppc_frob_file_before_adjust (void)
2408 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2414 name
= S_GET_NAME (symp
);
2418 if (! S_IS_WEAK (symp
)
2419 || S_IS_DEFINED (symp
))
2422 dotname
= concat (".", name
, (char *) NULL
);
2423 dotsym
= symbol_find_noref (dotname
, 1);
2425 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2426 || symbol_used_in_reloc_p (dotsym
)))
2427 symbol_mark_used (symp
);
2431 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2433 && toc_reloc_types
!= has_large_toc_reloc
2434 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2435 as_warn (_("TOC section size exceeds 64k"));
2438 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2439 emitted. Other uses of .TOC. will cause the symbol to be marked
2440 with BSF_KEEP in md_apply_fix. */
2443 ppc_elf_adjust_symtab (void)
2448 symp
= symbol_find (".TOC.");
2451 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2452 if ((bsym
->flags
& BSF_KEEP
) == 0)
2453 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2457 #endif /* OBJ_ELF */
2462 * Summary of parse_toc_entry.
2464 * in: Input_line_pointer points to the '[' in one of:
2466 * [toc] [tocv] [toc32] [toc64]
2468 * Anything else is an error of one kind or another.
2471 * return value: success or failure
2472 * toc_kind: kind of toc reference
2473 * input_line_pointer:
2474 * success: first char after the ']'
2475 * failure: unchanged
2479 * [toc] - rv == success, toc_kind = default_toc
2480 * [tocv] - rv == success, toc_kind = data_in_toc
2481 * [toc32] - rv == success, toc_kind = must_be_32
2482 * [toc64] - rv == success, toc_kind = must_be_64
2486 enum toc_size_qualifier
2488 default_toc
, /* The toc cell constructed should be the system default size */
2489 data_in_toc
, /* This is a direct reference to a toc cell */
2490 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2491 must_be_64
/* The toc cell constructed must be 64 bits wide */
2495 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2500 enum toc_size_qualifier t
;
2502 /* Save the input_line_pointer. */
2503 start
= input_line_pointer
;
2505 /* Skip over the '[' , and whitespace. */
2506 ++input_line_pointer
;
2509 /* Find the spelling of the operand. */
2510 c
= get_symbol_name (&toc_spec
);
2512 if (strcmp (toc_spec
, "toc") == 0)
2516 else if (strcmp (toc_spec
, "tocv") == 0)
2520 else if (strcmp (toc_spec
, "toc32") == 0)
2524 else if (strcmp (toc_spec
, "toc64") == 0)
2530 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2531 *input_line_pointer
= c
;
2532 input_line_pointer
= start
;
2536 /* Now find the ']'. */
2537 *input_line_pointer
= c
;
2539 SKIP_WHITESPACE_AFTER_NAME (); /* leading whitespace could be there. */
2540 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2544 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2545 input_line_pointer
= start
;
2554 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2555 /* See whether a symbol is in the TOC section. */
2558 ppc_is_toc_sym (symbolS
*sym
)
2561 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2562 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2565 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2567 return strcmp (sname
, ".toc") == 0;
2569 return strcmp (sname
, ".got") == 0;
2572 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2576 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2578 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2582 /* Check we don't already exist. */
2583 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2584 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2587 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2589 if (ppc_apuinfo_num_alloc
== 0)
2591 ppc_apuinfo_num_alloc
= 4;
2592 ppc_apuinfo_list
= XNEWVEC (unsigned long, ppc_apuinfo_num_alloc
);
2596 ppc_apuinfo_num_alloc
+= 4;
2597 ppc_apuinfo_list
= XRESIZEVEC (unsigned long, ppc_apuinfo_list
,
2598 ppc_apuinfo_num_alloc
);
2601 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2607 /* We need to keep a list of fixups. We can't simply generate them as
2608 we go, because that would require us to first create the frag, and
2609 that would screw up references to ``.''. */
2615 bfd_reloc_code_real_type reloc
;
2618 #define MAX_INSN_FIXUPS (5)
2621 #define E_OR2I_INSN 0x7000C000
2622 #define E_AND2I_DOT_INSN 0x7000C800
2623 #define E_OR2IS_INSN 0x7000D000
2624 #define E_LIS_INSN 0x7000E000
2625 #define E_AND2IS_DOT_INSN 0x7000E800
2628 #define E_ADD2I_DOT_INSN 0x70008800
2629 #define E_ADD2IS_INSN 0x70009000
2630 #define E_CMP16I_INSN 0x70009800
2631 #define E_MULL2I_INSN 0x7000A000
2632 #define E_CMPL16I_INSN 0x7000A800
2633 #define E_CMPH16I_INSN 0x7000B000
2634 #define E_CMPHL16I_INSN 0x7000B800
2636 /* This routine is called for each instruction to be assembled. */
2639 md_assemble (char *str
)
2642 const struct powerpc_opcode
*opcode
;
2644 const unsigned char *opindex_ptr
;
2648 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2653 unsigned int insn_length
;
2655 /* Get the opcode. */
2656 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2661 /* Look up the opcode in the hash table. */
2662 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2663 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2665 const struct powerpc_macro
*macro
;
2667 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2668 if (macro
== (const struct powerpc_macro
*) NULL
)
2669 as_bad (_("unrecognized opcode: `%s'"), str
);
2671 ppc_macro (s
, macro
);
2676 insn
= opcode
->opcode
;
2679 while (ISSPACE (*str
))
2682 /* PowerPC operands are just expressions. The only real issue is
2683 that a few operand types are optional. All cases which might use
2684 an optional operand separate the operands only with commas (in some
2685 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2686 have optional operands). Most instructions with optional operands
2687 have only one. Those that have more than one optional operand can
2688 take either all their operands or none. So, before we start seriously
2689 parsing the operands, we check to see if we have optional operands,
2690 and if we do, we count the number of commas to see which operands
2691 have been omitted. */
2693 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2695 const struct powerpc_operand
*operand
;
2697 operand
= &powerpc_operands
[*opindex_ptr
];
2698 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2700 unsigned int opcount
;
2701 unsigned int num_operands_expected
;
2703 /* There is an optional operand. Count the number of
2704 commas in the input line. */
2711 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2718 /* Compute the number of expected operands.
2719 Do not count fake operands. */
2720 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2721 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2722 ++ num_operands_expected
;
2724 /* If there are fewer operands in the line then are called
2725 for by the instruction, we want to skip the optional
2727 if (opcount
< num_operands_expected
)
2734 /* Gather the operands. */
2738 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2740 const struct powerpc_operand
*operand
;
2746 if (next_opindex
== 0)
2747 operand
= &powerpc_operands
[*opindex_ptr
];
2750 operand
= &powerpc_operands
[next_opindex
];
2755 /* If this is a fake operand, then we do not expect anything
2757 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2759 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2760 if (errmsg
!= (const char *) NULL
)
2761 as_bad ("%s", errmsg
);
2765 /* If this is an optional operand, and we are skipping it, just
2767 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2770 long val
= ppc_optional_operand_value (operand
);
2771 if (operand
->insert
)
2773 insn
= (*operand
->insert
) (insn
, val
, ppc_cpu
, &errmsg
);
2774 if (errmsg
!= (const char *) NULL
)
2775 as_bad ("%s", errmsg
);
2777 else if (operand
->shift
>= 0)
2778 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
2780 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
2782 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2783 next_opindex
= *opindex_ptr
+ 1;
2787 /* Gather the operand. */
2788 hold
= input_line_pointer
;
2789 input_line_pointer
= str
;
2792 if (*input_line_pointer
== '[')
2794 /* We are expecting something like the second argument here:
2796 * lwz r4,[toc].GS.0.static_int(rtoc)
2797 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2798 * The argument following the `]' must be a symbol name, and the
2799 * register must be the toc register: 'rtoc' or '2'
2801 * The effect is to 0 as the displacement field
2802 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2803 * the appropriate variation) reloc against it based on the symbol.
2804 * The linker will build the toc, and insert the resolved toc offset.
2807 * o The size of the toc entry is currently assumed to be
2808 * 32 bits. This should not be assumed to be a hard coded
2810 * o In an effort to cope with a change from 32 to 64 bits,
2811 * there are also toc entries that are specified to be
2812 * either 32 or 64 bits:
2813 * lwz r4,[toc32].GS.0.static_int(rtoc)
2814 * lwz r4,[toc64].GS.0.static_int(rtoc)
2815 * These demand toc entries of the specified size, and the
2816 * instruction probably requires it.
2820 enum toc_size_qualifier toc_kind
;
2821 bfd_reloc_code_real_type toc_reloc
;
2823 /* Go parse off the [tocXX] part. */
2824 valid_toc
= parse_toc_entry (&toc_kind
);
2828 ignore_rest_of_line ();
2832 /* Now get the symbol following the ']'. */
2838 /* In this case, we may not have seen the symbol yet,
2839 since it is allowed to appear on a .extern or .globl
2840 or just be a label in the .data section. */
2841 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2844 /* 1. The symbol must be defined and either in the toc
2845 section, or a global.
2846 2. The reloc generated must have the TOCDEFN flag set
2847 in upper bit mess of the reloc type.
2848 FIXME: It's a little confusing what the tocv
2849 qualifier can be used for. At the very least, I've
2850 seen three uses, only one of which I'm sure I can
2852 if (ex
.X_op
== O_symbol
)
2854 gas_assert (ex
.X_add_symbol
!= NULL
);
2855 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2858 as_bad (_("[tocv] symbol is not a toc symbol"));
2862 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2865 /* FIXME: these next two specifically specify 32/64 bit
2866 toc entries. We don't support them today. Is this
2867 the right way to say that? */
2868 toc_reloc
= BFD_RELOC_NONE
;
2869 as_bad (_("unimplemented toc32 expression modifier"));
2872 /* FIXME: see above. */
2873 toc_reloc
= BFD_RELOC_NONE
;
2874 as_bad (_("unimplemented toc64 expression modifier"));
2878 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2884 /* We need to generate a fixup for this expression. */
2885 if (fc
>= MAX_INSN_FIXUPS
)
2886 as_fatal (_("too many fixups"));
2888 fixups
[fc
].reloc
= toc_reloc
;
2889 fixups
[fc
].exp
= ex
;
2890 fixups
[fc
].opindex
= *opindex_ptr
;
2893 /* Ok. We've set up the fixup for the instruction. Now make it
2894 look like the constant 0 was found here. */
2896 ex
.X_op
= O_constant
;
2897 ex
.X_add_number
= 0;
2898 ex
.X_add_symbol
= NULL
;
2899 ex
.X_op_symbol
= NULL
;
2906 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2907 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2908 || !register_name (&ex
))
2910 char save_lex
= lex_type
['%'];
2912 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2913 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2916 lex_type
['%'] |= LEX_BEGIN_NAME
;
2920 lex_type
['%'] = save_lex
;
2924 str
= input_line_pointer
;
2925 input_line_pointer
= hold
;
2927 if (ex
.X_op
== O_illegal
)
2928 as_bad (_("illegal operand"));
2929 else if (ex
.X_op
== O_absent
)
2930 as_bad (_("missing operand"));
2931 else if (ex
.X_op
== O_register
)
2933 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2934 ppc_cpu
, (char *) NULL
, 0);
2936 else if (ex
.X_op
== O_constant
)
2939 /* Allow @HA, @L, @H on constants. */
2940 bfd_reloc_code_real_type reloc
;
2941 char *orig_str
= str
;
2943 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
2950 case BFD_RELOC_LO16
:
2951 ex
.X_add_number
&= 0xffff;
2952 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2953 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2956 case BFD_RELOC_HI16
:
2957 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2959 /* PowerPC64 @h is tested for overflow. */
2960 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2961 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2963 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2965 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2971 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2972 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2973 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2974 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2977 case BFD_RELOC_HI16_S
:
2978 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2980 /* PowerPC64 @ha is tested for overflow. */
2982 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2983 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2985 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2987 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2993 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2994 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2995 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2996 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2999 case BFD_RELOC_PPC64_HIGHER
:
3000 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
3001 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3002 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3005 case BFD_RELOC_PPC64_HIGHER_S
:
3006 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
3007 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3008 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3011 case BFD_RELOC_PPC64_HIGHEST
:
3012 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
3013 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3014 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3017 case BFD_RELOC_PPC64_HIGHEST_S
:
3018 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
3019 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3020 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3023 #endif /* OBJ_ELF */
3024 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
3025 ppc_cpu
, (char *) NULL
, 0);
3029 bfd_reloc_code_real_type reloc
= BFD_RELOC_NONE
;
3031 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
3033 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
3034 if (sym_name
[0] == '.')
3037 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
3039 expressionS tls_exp
;
3041 hold
= input_line_pointer
;
3042 input_line_pointer
= str
+ 1;
3043 expression (&tls_exp
);
3044 if (tls_exp
.X_op
== O_symbol
)
3046 reloc
= BFD_RELOC_NONE
;
3047 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
3049 reloc
= BFD_RELOC_PPC_TLSGD
;
3050 input_line_pointer
+= 7;
3052 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
3054 reloc
= BFD_RELOC_PPC_TLSLD
;
3055 input_line_pointer
+= 7;
3057 if (reloc
!= BFD_RELOC_NONE
)
3060 str
= input_line_pointer
;
3062 if (fc
>= MAX_INSN_FIXUPS
)
3063 as_fatal (_("too many fixups"));
3064 fixups
[fc
].exp
= tls_exp
;
3065 fixups
[fc
].opindex
= *opindex_ptr
;
3066 fixups
[fc
].reloc
= reloc
;
3070 input_line_pointer
= hold
;
3074 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
3076 /* Some TLS tweaks. */
3082 case BFD_RELOC_PPC_TLS
:
3083 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
3084 as_bad (_("@tls may not be used with \"%s\" operands"),
3086 else if (operand
->shift
!= 11)
3087 as_bad (_("@tls may only be used in last operand"));
3089 insn
= ppc_insert_operand (insn
, operand
,
3091 ppc_cpu
, (char *) NULL
, 0);
3094 /* We'll only use the 32 (or 64) bit form of these relocations
3095 in constants. Instructions get the 16 bit form. */
3096 case BFD_RELOC_PPC_DTPREL
:
3097 reloc
= BFD_RELOC_PPC_DTPREL16
;
3099 case BFD_RELOC_PPC_TPREL
:
3100 reloc
= BFD_RELOC_PPC_TPREL16
;
3105 if (opcode
->opcode
== (19 << 26) + (2 << 1)
3106 && reloc
== BFD_RELOC_HI16_S
)
3107 reloc
= BFD_RELOC_PPC_REL16DX_HA
;
3109 /* If VLE-mode convert LO/HI/HA relocations. */
3110 if (opcode
->flags
& PPC_OPCODE_VLE
)
3112 int tmp_insn
= insn
& opcode
->mask
;
3114 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3115 || tmp_insn
== E_AND2I_DOT_INSN
3116 || tmp_insn
== E_OR2IS_INSN
3117 || tmp_insn
== E_LIS_INSN
3118 || tmp_insn
== E_AND2IS_DOT_INSN
);
3121 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3122 || tmp_insn
== E_ADD2IS_INSN
3123 || tmp_insn
== E_CMP16I_INSN
3124 || tmp_insn
== E_MULL2I_INSN
3125 || tmp_insn
== E_CMPL16I_INSN
3126 || tmp_insn
== E_CMPH16I_INSN
3127 || tmp_insn
== E_CMPHL16I_INSN
);
3134 case BFD_RELOC_PPC_EMB_SDA21
:
3135 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3138 case BFD_RELOC_LO16
:
3140 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3141 else if (use_a_reloc
)
3142 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3145 case BFD_RELOC_HI16
:
3147 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3148 else if (use_a_reloc
)
3149 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3152 case BFD_RELOC_HI16_S
:
3154 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3155 else if (use_a_reloc
)
3156 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3159 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3161 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3164 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3166 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3169 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3171 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3176 #endif /* OBJ_ELF */
3178 if (reloc
!= BFD_RELOC_NONE
)
3180 /* Determine a BFD reloc value based on the operand information.
3181 We are only prepared to turn a few of the operands into
3183 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3184 | PPC_OPERAND_ABSOLUTE
)) != 0
3185 && operand
->bitm
== 0x3fffffc
3186 && operand
->shift
== 0)
3187 reloc
= BFD_RELOC_PPC_B26
;
3188 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3189 | PPC_OPERAND_ABSOLUTE
)) != 0
3190 && operand
->bitm
== 0xfffc
3191 && operand
->shift
== 0)
3192 reloc
= BFD_RELOC_PPC_B16
;
3193 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3194 && operand
->bitm
== 0x1fe
3195 && operand
->shift
== -1)
3196 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3197 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3198 && operand
->bitm
== 0xfffe
3199 && operand
->shift
== 0)
3200 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3201 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3202 && operand
->bitm
== 0x1fffffe
3203 && operand
->shift
== 0)
3204 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3205 else if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) == 0
3206 && (operand
->bitm
& 0xfff0) == 0xfff0
3207 && operand
->shift
== 0)
3209 reloc
= BFD_RELOC_16
;
3210 #if defined OBJ_XCOFF || defined OBJ_ELF
3211 /* Note: the symbol may be not yet defined. */
3212 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3213 && ppc_is_toc_sym (ex
.X_add_symbol
))
3215 reloc
= BFD_RELOC_PPC_TOC16
;
3217 as_warn (_("assuming %s on symbol"),
3218 ppc_obj64
? "@toc" : "@xgot");
3224 /* For the absolute forms of branches, convert the PC
3225 relative form back into the absolute. */
3226 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3230 case BFD_RELOC_PPC_B26
:
3231 reloc
= BFD_RELOC_PPC_BA26
;
3233 case BFD_RELOC_PPC_B16
:
3234 reloc
= BFD_RELOC_PPC_BA16
;
3237 case BFD_RELOC_PPC_B16_BRTAKEN
:
3238 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3240 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3241 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3252 case BFD_RELOC_PPC_TOC16
:
3253 toc_reloc_types
|= has_small_toc_reloc
;
3255 case BFD_RELOC_PPC64_TOC16_LO
:
3256 case BFD_RELOC_PPC64_TOC16_HI
:
3257 case BFD_RELOC_PPC64_TOC16_HA
:
3258 toc_reloc_types
|= has_large_toc_reloc
;
3265 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3270 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3272 case BFD_RELOC_LO16
:
3273 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3275 case BFD_RELOC_16_GOTOFF
:
3276 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3278 case BFD_RELOC_LO16_GOTOFF
:
3279 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3281 case BFD_RELOC_LO16_PLTOFF
:
3282 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3284 case BFD_RELOC_16_BASEREL
:
3285 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3287 case BFD_RELOC_LO16_BASEREL
:
3288 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3290 case BFD_RELOC_PPC_TOC16
:
3291 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3293 case BFD_RELOC_PPC64_TOC16_LO
:
3294 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3296 case BFD_RELOC_PPC64_PLTGOT16
:
3297 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3299 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3300 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3302 case BFD_RELOC_PPC_DTPREL16
:
3303 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3305 case BFD_RELOC_PPC_DTPREL16_LO
:
3306 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3308 case BFD_RELOC_PPC_TPREL16
:
3309 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3311 case BFD_RELOC_PPC_TPREL16_LO
:
3312 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3314 case BFD_RELOC_PPC_GOT_DTPREL16
:
3315 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3316 case BFD_RELOC_PPC_GOT_TPREL16
:
3317 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3320 as_bad (_("unsupported relocation for DS offset field"));
3326 /* We need to generate a fixup for this expression. */
3327 if (fc
>= MAX_INSN_FIXUPS
)
3328 as_fatal (_("too many fixups"));
3329 fixups
[fc
].exp
= ex
;
3330 fixups
[fc
].opindex
= *opindex_ptr
;
3331 fixups
[fc
].reloc
= reloc
;
3339 /* If expecting more operands, then we want to see "),". */
3340 if (*str
== endc
&& opindex_ptr
[1] != 0)
3344 while (ISSPACE (*str
));
3348 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3356 /* The call to expression should have advanced str past any
3359 && (endc
!= ',' || *str
!= '\0'))
3362 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3364 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3372 while (ISSPACE (*str
))
3376 as_bad (_("junk at end of line: `%s'"), str
);
3379 /* Do we need/want an APUinfo section? */
3380 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3383 /* These are all version "1". */
3384 if (opcode
->flags
& PPC_OPCODE_SPE
)
3385 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3386 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3387 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3388 if (opcode
->flags
& PPC_OPCODE_EFS
)
3389 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3390 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3391 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3392 if (opcode
->flags
& PPC_OPCODE_PMR
)
3393 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3394 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3395 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3396 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3397 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3398 /* Only set the VLE flag if the instruction has been pulled via
3399 the VLE instruction set. This way the flag is guaranteed to
3400 be set for VLE-only instructions or for VLE-only processors,
3401 however it'll remain clear for dual-mode instructions on
3402 dual-mode and, more importantly, standard-mode processors. */
3403 if ((ppc_cpu
& opcode
->flags
) == PPC_OPCODE_VLE
)
3405 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3406 if (elf_section_data (now_seg
) != NULL
)
3407 elf_section_data (now_seg
)->this_hdr
.sh_flags
|= SHF_PPC_VLE
;
3412 /* Write out the instruction. */
3413 /* Differentiate between two and four byte insns. */
3414 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
3416 if (PPC_OP_SE_VLE (insn
))
3420 addr_mod
= frag_now_fix () & 1;
3425 addr_mod
= frag_now_fix () & 3;
3427 /* All instructions can start on a 2 byte boundary for VLE. */
3428 f
= frag_more (insn_length
);
3429 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3431 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
3432 as_bad (_("instruction address is not a multiple of 2"));
3434 as_bad (_("instruction address is not a multiple of 4"));
3436 frag_now
->insn_addr
= addr_mod
;
3437 frag_now
->has_code
= 1;
3438 md_number_to_chars (f
, insn
, insn_length
);
3441 last_subseg
= now_subseg
;
3444 dwarf2_emit_insn (insn_length
);
3447 /* Create any fixups. */
3448 for (i
= 0; i
< fc
; i
++)
3451 if (fixups
[i
].reloc
!= BFD_RELOC_NONE
)
3453 reloc_howto_type
*reloc_howto
;
3457 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3461 size
= bfd_get_reloc_size (reloc_howto
);
3462 offset
= target_big_endian
? (insn_length
- size
) : 0;
3464 fixP
= fix_new_exp (frag_now
,
3465 f
- frag_now
->fr_literal
+ offset
,
3468 reloc_howto
->pc_relative
,
3473 const struct powerpc_operand
*operand
;
3475 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3476 fixP
= fix_new_exp (frag_now
,
3477 f
- frag_now
->fr_literal
,
3480 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3483 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3487 /* Handle a macro. Gather all the operands, transform them as
3488 described by the macro, and call md_assemble recursively. All the
3489 operands are separated by commas; we don't accept parentheses
3490 around operands here. */
3493 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3504 /* Gather the users operands into the operands array. */
3509 if (count
>= sizeof operands
/ sizeof operands
[0])
3511 operands
[count
++] = s
;
3512 s
= strchr (s
, ',');
3513 if (s
== (char *) NULL
)
3518 if (count
!= macro
->operands
)
3520 as_bad (_("wrong number of operands"));
3524 /* Work out how large the string must be (the size is unbounded
3525 because it includes user input). */
3527 format
= macro
->format
;
3528 while (*format
!= '\0')
3537 arg
= strtol (format
+ 1, &send
, 10);
3538 know (send
!= format
&& arg
< count
);
3539 len
+= strlen (operands
[arg
]);
3544 /* Put the string together. */
3545 complete
= s
= XNEWVEC (char, len
+ 1);
3546 format
= macro
->format
;
3547 while (*format
!= '\0')
3553 arg
= strtol (format
+ 1, &send
, 10);
3554 strcpy (s
, operands
[arg
]);
3561 /* Assemble the constructed instruction. */
3562 md_assemble (complete
);
3567 /* For ELF, add support for SHT_ORDERED. */
3570 ppc_section_type (char *str
, size_t len
)
3572 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3579 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3581 if (type
== SHT_ORDERED
)
3582 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3586 #endif /* OBJ_ELF */
3589 /* Pseudo-op handling. */
3591 /* The .byte pseudo-op. This is similar to the normal .byte
3592 pseudo-op, but it can also take a single ASCII string. */
3595 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3599 if (*input_line_pointer
!= '\"')
3605 /* Gather characters. A real double quote is doubled. Unusual
3606 characters are not permitted. */
3607 ++input_line_pointer
;
3612 c
= *input_line_pointer
++;
3616 if (*input_line_pointer
!= '\"')
3618 ++input_line_pointer
;
3621 FRAG_APPEND_1_CHAR (c
);
3625 if (warn_476
&& count
!= 0 && (now_seg
->flags
& SEC_CODE
) != 0)
3626 as_warn (_("data in executable section"));
3627 demand_empty_rest_of_line ();
3632 /* XCOFF specific pseudo-op handling. */
3634 /* This is set if we are creating a .stabx symbol, since we don't want
3635 to handle symbol suffixes for such symbols. */
3636 static bfd_boolean ppc_stab_symbol
;
3638 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3639 symbols in the .bss segment as though they were local common
3640 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3641 aligns .comm and .lcomm to 4 bytes. */
3644 ppc_comm (int lcomm
)
3646 asection
*current_seg
= now_seg
;
3647 subsegT current_subseg
= now_subseg
;
3653 symbolS
*lcomm_sym
= NULL
;
3657 endc
= get_symbol_name (&name
);
3658 end_name
= input_line_pointer
;
3659 (void) restore_line_pointer (endc
);
3661 if (*input_line_pointer
!= ',')
3663 as_bad (_("missing size"));
3664 ignore_rest_of_line ();
3667 ++input_line_pointer
;
3669 size
= get_absolute_expression ();
3672 as_bad (_("negative size"));
3673 ignore_rest_of_line ();
3679 /* The third argument to .comm is the alignment. */
3680 if (*input_line_pointer
!= ',')
3684 ++input_line_pointer
;
3685 align
= get_absolute_expression ();
3688 as_warn (_("ignoring bad alignment"));
3698 /* The third argument to .lcomm appears to be the real local
3699 common symbol to create. References to the symbol named in
3700 the first argument are turned into references to the third
3702 if (*input_line_pointer
!= ',')
3704 as_bad (_("missing real symbol name"));
3705 ignore_rest_of_line ();
3708 ++input_line_pointer
;
3710 lcomm_endc
= get_symbol_name (&lcomm_name
);
3712 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3714 (void) restore_line_pointer (lcomm_endc
);
3716 /* The fourth argument to .lcomm is the alignment. */
3717 if (*input_line_pointer
!= ',')
3726 ++input_line_pointer
;
3727 align
= get_absolute_expression ();
3730 as_warn (_("ignoring bad alignment"));
3737 sym
= symbol_find_or_make (name
);
3740 if (S_IS_DEFINED (sym
)
3741 || S_GET_VALUE (sym
) != 0)
3743 as_bad (_("attempt to redefine symbol"));
3744 ignore_rest_of_line ();
3748 record_alignment (bss_section
, align
);
3751 || ! S_IS_DEFINED (lcomm_sym
))
3760 S_SET_EXTERNAL (sym
);
3764 symbol_get_tc (lcomm_sym
)->output
= 1;
3765 def_sym
= lcomm_sym
;
3769 subseg_set (bss_section
, 1);
3770 frag_align (align
, 0, 0);
3772 symbol_set_frag (def_sym
, frag_now
);
3773 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3774 def_size
, (char *) NULL
);
3776 S_SET_SEGMENT (def_sym
, bss_section
);
3777 symbol_get_tc (def_sym
)->align
= align
;
3781 /* Align the size of lcomm_sym. */
3782 symbol_get_frag (lcomm_sym
)->fr_offset
=
3783 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3784 &~ ((1 << align
) - 1));
3785 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3786 symbol_get_tc (lcomm_sym
)->align
= align
;
3791 /* Make sym an offset from lcomm_sym. */
3792 S_SET_SEGMENT (sym
, bss_section
);
3793 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3794 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3795 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3798 subseg_set (current_seg
, current_subseg
);
3800 demand_empty_rest_of_line ();
3803 /* The .csect pseudo-op. This switches us into a different
3804 subsegment. The first argument is a symbol whose value is the
3805 start of the .csect. In COFF, csect symbols get special aux
3806 entries defined by the x_csect field of union internal_auxent. The
3807 optional second argument is the alignment (the default is 2). */
3810 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3817 endc
= get_symbol_name (&name
);
3819 sym
= symbol_find_or_make (name
);
3821 (void) restore_line_pointer (endc
);
3823 if (S_GET_NAME (sym
)[0] == '\0')
3825 /* An unnamed csect is assumed to be [PR]. */
3826 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3830 if (*input_line_pointer
== ',')
3832 ++input_line_pointer
;
3833 align
= get_absolute_expression ();
3836 ppc_change_csect (sym
, align
);
3838 demand_empty_rest_of_line ();
3841 /* Change to a different csect. */
3844 ppc_change_csect (symbolS
*sym
, offsetT align
)
3846 if (S_IS_DEFINED (sym
))
3847 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3857 /* This is a new csect. We need to look at the symbol class to
3858 figure out whether it should go in the text section or the
3862 switch (symbol_get_tc (sym
)->symbol_class
)
3872 S_SET_SEGMENT (sym
, text_section
);
3873 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3874 ++ppc_text_subsegment
;
3875 list_ptr
= &ppc_text_csects
;
3885 if (ppc_toc_csect
!= NULL
3886 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3887 == ppc_data_subsegment
))
3889 S_SET_SEGMENT (sym
, data_section
);
3890 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3891 ++ppc_data_subsegment
;
3892 list_ptr
= &ppc_data_csects
;
3898 /* We set the obstack chunk size to a small value before
3899 changing subsegments, so that we don't use a lot of memory
3900 space for what may be a small section. */
3901 hold_chunksize
= chunksize
;
3904 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3905 symbol_get_tc (sym
)->subseg
);
3907 chunksize
= hold_chunksize
;
3910 ppc_after_toc_frag
= frag_now
;
3912 record_alignment (sec
, align
);
3914 frag_align_code (align
, 0);
3916 frag_align (align
, 0, 0);
3918 symbol_set_frag (sym
, frag_now
);
3919 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3921 symbol_get_tc (sym
)->align
= align
;
3922 symbol_get_tc (sym
)->output
= 1;
3923 symbol_get_tc (sym
)->within
= sym
;
3925 for (list
= *list_ptr
;
3926 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3927 list
= symbol_get_tc (list
)->next
)
3929 symbol_get_tc (list
)->next
= sym
;
3931 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3932 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3936 ppc_current_csect
= sym
;
3940 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3944 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3946 sec
= subseg_new (dw
->name
, subseg
);
3947 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3948 if (oldflags
== SEC_NO_FLAGS
)
3950 /* Just created section. */
3951 gas_assert (dw_sections
[idx
].sect
== NULL
);
3953 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3954 bfd_set_section_alignment (stdoutput
, sec
, 0);
3955 dw_sections
[idx
].sect
= sec
;
3958 /* Not anymore in a csect. */
3959 ppc_current_csect
= NULL
;
3962 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3963 .dwsect flag [, opt-label ]
3967 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3971 const struct xcoff_dwsect_name
*dw
;
3972 struct dw_subsection
*subseg
;
3973 struct dw_section
*dws
;
3977 flag
= get_absolute_expression ();
3979 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3980 if (xcoff_dwsect_names
[i
].flag
== flag
)
3982 dw
= &xcoff_dwsect_names
[i
];
3986 /* Parse opt-label. */
3987 if (*input_line_pointer
== ',')
3992 ++input_line_pointer
;
3994 c
= get_symbol_name (&label
);
3995 opt_label
= symbol_find_or_make (label
);
3996 (void) restore_line_pointer (c
);
4001 demand_empty_rest_of_line ();
4003 /* Return now in case of unknown subsection. */
4006 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
4011 /* Find the subsection. */
4012 dws
= &dw_sections
[i
];
4014 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
4016 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
4017 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
4019 as_bad (_("label %s was not defined in this dwarf section"),
4020 S_GET_NAME (opt_label
));
4021 subseg
= dws
->anon_subseg
;
4025 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
4030 /* Switch to the subsection. */
4031 ppc_change_debug_section (i
, subseg
->subseg
);
4035 /* Create a new dw subsection. */
4036 subseg
= XNEW (struct dw_subsection
);
4038 if (opt_label
== NULL
)
4040 /* The anonymous one. */
4042 subseg
->link
= NULL
;
4043 dws
->anon_subseg
= subseg
;
4048 if (dws
->list_subseg
!= NULL
)
4049 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
4053 subseg
->link
= dws
->list_subseg
;
4054 dws
->list_subseg
= subseg
;
4055 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
4058 ppc_change_debug_section (i
, subseg
->subseg
);
4062 /* Add the length field. */
4063 expressionS
*exp
= &subseg
->end_exp
;
4066 if (opt_label
!= NULL
)
4067 symbol_set_value_now (opt_label
);
4069 /* Add the length field. Note that according to the AIX assembler
4070 manual, the size of the length field is 4 for powerpc32 but
4071 12 for powerpc64. */
4074 /* Write the 64bit marker. */
4075 md_number_to_chars (frag_more (4), -1, 4);
4078 exp
->X_op
= O_subtract
;
4079 exp
->X_op_symbol
= symbol_temp_new_now ();
4080 exp
->X_add_symbol
= symbol_temp_make ();
4082 sz
= ppc_obj64
? 8 : 4;
4083 exp
->X_add_number
= -sz
;
4084 emit_expr (exp
, sz
);
4089 /* This function handles the .text and .data pseudo-ops. These
4090 pseudo-ops aren't really used by XCOFF; we implement them for the
4091 convenience of people who aren't used to XCOFF. */
4094 ppc_section (int type
)
4101 else if (type
== 'd')
4106 sym
= symbol_find_or_make (name
);
4108 ppc_change_csect (sym
, 2);
4110 demand_empty_rest_of_line ();
4113 /* This function handles the .section pseudo-op. This is mostly to
4114 give an error, since XCOFF only supports .text, .data and .bss, but
4115 we do permit the user to name the text or data section. */
4118 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4121 const char *real_name
;
4125 c
= get_symbol_name (&user_name
);
4127 if (strcmp (user_name
, ".text") == 0)
4128 real_name
= ".text[PR]";
4129 else if (strcmp (user_name
, ".data") == 0)
4130 real_name
= ".data[RW]";
4133 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4134 (void) restore_line_pointer (c
);
4135 ignore_rest_of_line ();
4139 (void) restore_line_pointer (c
);
4141 sym
= symbol_find_or_make (real_name
);
4143 ppc_change_csect (sym
, 2);
4145 demand_empty_rest_of_line ();
4148 /* The .extern pseudo-op. We create an undefined symbol. */
4151 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4156 endc
= get_symbol_name (&name
);
4158 (void) symbol_find_or_make (name
);
4160 (void) restore_line_pointer (endc
);
4162 demand_empty_rest_of_line ();
4165 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4168 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4174 endc
= get_symbol_name (&name
);
4176 sym
= symbol_find_or_make (name
);
4178 (void) restore_line_pointer (endc
);
4180 symbol_get_tc (sym
)->output
= 1;
4182 demand_empty_rest_of_line ();
4185 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4186 relocations at the beginning of the current csect.
4188 (In principle, there's no reason why the relocations _have_ to be at
4189 the beginning. Anywhere in the csect would do. However, inserting
4190 at the beginning is what the native assmebler does, and it helps to
4191 deal with cases where the .ref statements follow the section contents.)
4193 ??? .refs don't work for empty .csects. However, the native assembler
4194 doesn't report an error in this case, and neither yet do we. */
4197 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4202 if (ppc_current_csect
== NULL
)
4204 as_bad (_(".ref outside .csect"));
4205 ignore_rest_of_line ();
4211 c
= get_symbol_name (&name
);
4213 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4214 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4216 *input_line_pointer
= c
;
4217 SKIP_WHITESPACE_AFTER_NAME ();
4218 c
= *input_line_pointer
;
4221 input_line_pointer
++;
4223 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4225 as_bad (_("missing symbol name"));
4226 ignore_rest_of_line ();
4233 demand_empty_rest_of_line ();
4236 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4237 although I don't know why it bothers. */
4240 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4247 endc
= get_symbol_name (&name
);
4249 sym
= symbol_find_or_make (name
);
4251 (void) restore_line_pointer (endc
);
4253 if (*input_line_pointer
!= ',')
4255 as_bad (_("missing rename string"));
4256 ignore_rest_of_line ();
4259 ++input_line_pointer
;
4261 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4263 demand_empty_rest_of_line ();
4266 /* The .stabx pseudo-op. This is similar to a normal .stabs
4267 pseudo-op, but slightly different. A sample is
4268 .stabx "main:F-1",.main,142,0
4269 The first argument is the symbol name to create. The second is the
4270 value, and the third is the storage class. The fourth seems to be
4271 always zero, and I am assuming it is the type. */
4274 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4281 name
= demand_copy_C_string (&len
);
4283 if (*input_line_pointer
!= ',')
4285 as_bad (_("missing value"));
4288 ++input_line_pointer
;
4290 ppc_stab_symbol
= TRUE
;
4291 sym
= symbol_make (name
);
4292 ppc_stab_symbol
= FALSE
;
4294 symbol_get_tc (sym
)->real_name
= name
;
4296 (void) expression (&exp
);
4303 as_bad (_("illegal .stabx expression; zero assumed"));
4304 exp
.X_add_number
= 0;
4307 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4308 symbol_set_frag (sym
, &zero_address_frag
);
4312 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4313 symbol_set_value_expression (sym
, &exp
);
4317 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4318 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4323 /* The value is some complex expression. This will probably
4324 fail at some later point, but this is probably the right
4325 thing to do here. */
4326 symbol_set_value_expression (sym
, &exp
);
4330 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4331 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4333 if (*input_line_pointer
!= ',')
4335 as_bad (_("missing class"));
4338 ++input_line_pointer
;
4340 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4342 if (*input_line_pointer
!= ',')
4344 as_bad (_("missing type"));
4347 ++input_line_pointer
;
4349 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4351 symbol_get_tc (sym
)->output
= 1;
4353 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4358 .stabx "z",arrays_,133,0
4361 .comm arrays_,13768,3
4363 resolve_symbol_value will copy the exp's "within" into sym's when the
4364 offset is 0. Since this seems to be corner case problem,
4365 only do the correction for storage class C_STSYM. A better solution
4366 would be to have the tc field updated in ppc_symbol_new_hook. */
4368 if (exp
.X_op
== O_symbol
)
4370 if (ppc_current_block
== NULL
)
4371 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4373 symbol_get_tc (sym
)->within
= ppc_current_block
;
4374 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4378 if (exp
.X_op
!= O_symbol
4379 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4380 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4381 ppc_frob_label (sym
);
4384 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4385 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4386 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4387 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4390 demand_empty_rest_of_line ();
4393 /* The .function pseudo-op. This takes several arguments. The first
4394 argument seems to be the external name of the symbol. The second
4395 argument seems to be the label for the start of the function. gcc
4396 uses the same name for both. I have no idea what the third and
4397 fourth arguments are meant to be. The optional fifth argument is
4398 an expression for the size of the function. In COFF this symbol
4399 gets an aux entry like that used for a csect. */
4402 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4410 endc
= get_symbol_name (&name
);
4412 /* Ignore any [PR] suffix. */
4413 name
= ppc_canonicalize_symbol_name (name
);
4414 s
= strchr (name
, '[');
4415 if (s
!= (char *) NULL
4416 && strcmp (s
+ 1, "PR]") == 0)
4419 ext_sym
= symbol_find_or_make (name
);
4421 (void) restore_line_pointer (endc
);
4423 if (*input_line_pointer
!= ',')
4425 as_bad (_("missing symbol name"));
4426 ignore_rest_of_line ();
4429 ++input_line_pointer
;
4431 endc
= get_symbol_name (&name
);
4433 lab_sym
= symbol_find_or_make (name
);
4435 (void) restore_line_pointer (endc
);
4437 if (ext_sym
!= lab_sym
)
4441 exp
.X_op
= O_symbol
;
4442 exp
.X_add_symbol
= lab_sym
;
4443 exp
.X_op_symbol
= NULL
;
4444 exp
.X_add_number
= 0;
4446 symbol_set_value_expression (ext_sym
, &exp
);
4449 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4450 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4451 symbol_get_tc (ext_sym
)->output
= 1;
4453 if (*input_line_pointer
== ',')
4457 /* Ignore the third argument. */
4458 ++input_line_pointer
;
4460 if (*input_line_pointer
== ',')
4462 /* Ignore the fourth argument. */
4463 ++input_line_pointer
;
4465 if (*input_line_pointer
== ',')
4467 /* The fifth argument is the function size. */
4468 ++input_line_pointer
;
4469 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4470 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4471 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4476 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4477 SF_SET_FUNCTION (ext_sym
);
4478 SF_SET_PROCESS (ext_sym
);
4479 coff_add_linesym (ext_sym
);
4481 demand_empty_rest_of_line ();
4484 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4485 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4486 with the correct line number */
4488 static symbolS
*saved_bi_sym
= 0;
4491 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4495 sym
= symbol_make (".bf");
4496 S_SET_SEGMENT (sym
, text_section
);
4497 symbol_set_frag (sym
, frag_now
);
4498 S_SET_VALUE (sym
, frag_now_fix ());
4499 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4501 coff_line_base
= get_absolute_expression ();
4503 S_SET_NUMBER_AUXILIARY (sym
, 1);
4504 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4506 /* Line number for bi. */
4509 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4514 symbol_get_tc (sym
)->output
= 1;
4516 ppc_frob_label (sym
);
4518 demand_empty_rest_of_line ();
4521 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4522 ".ef", except that the line number is absolute, not relative to the
4523 most recent ".bf" symbol. */
4526 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4530 sym
= symbol_make (".ef");
4531 S_SET_SEGMENT (sym
, text_section
);
4532 symbol_set_frag (sym
, frag_now
);
4533 S_SET_VALUE (sym
, frag_now_fix ());
4534 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4535 S_SET_NUMBER_AUXILIARY (sym
, 1);
4536 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4537 symbol_get_tc (sym
)->output
= 1;
4539 ppc_frob_label (sym
);
4541 demand_empty_rest_of_line ();
4544 /* The .bi and .ei pseudo-ops. These take a string argument and
4545 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4546 the symbol list. The value of .bi will be know when the next .bf
4552 static symbolS
*last_biei
;
4559 name
= demand_copy_C_string (&len
);
4561 /* The value of these symbols is actually file offset. Here we set
4562 the value to the index into the line number entries. In
4563 ppc_frob_symbols we set the fix_line field, which will cause BFD
4564 to do the right thing. */
4566 sym
= symbol_make (name
);
4567 /* obj-coff.c currently only handles line numbers correctly in the
4569 S_SET_SEGMENT (sym
, text_section
);
4570 S_SET_VALUE (sym
, coff_n_line_nos
);
4571 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4573 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4574 symbol_get_tc (sym
)->output
= 1;
4582 for (look
= last_biei
? last_biei
: symbol_rootP
;
4583 (look
!= (symbolS
*) NULL
4584 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4585 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4586 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4587 look
= symbol_next (look
))
4589 if (look
!= (symbolS
*) NULL
)
4591 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4592 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4596 demand_empty_rest_of_line ();
4599 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4600 There is one argument, which is a csect symbol. The value of the
4601 .bs symbol is the index of this csect symbol. */
4604 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4611 if (ppc_current_block
!= NULL
)
4612 as_bad (_("nested .bs blocks"));
4614 endc
= get_symbol_name (&name
);
4616 csect
= symbol_find_or_make (name
);
4618 (void) restore_line_pointer (endc
);
4620 sym
= symbol_make (".bs");
4621 S_SET_SEGMENT (sym
, now_seg
);
4622 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4623 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4624 symbol_get_tc (sym
)->output
= 1;
4626 symbol_get_tc (sym
)->within
= csect
;
4628 ppc_frob_label (sym
);
4630 ppc_current_block
= sym
;
4632 demand_empty_rest_of_line ();
4635 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4638 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4642 if (ppc_current_block
== NULL
)
4643 as_bad (_(".es without preceding .bs"));
4645 sym
= symbol_make (".es");
4646 S_SET_SEGMENT (sym
, now_seg
);
4647 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4648 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4649 symbol_get_tc (sym
)->output
= 1;
4651 ppc_frob_label (sym
);
4653 ppc_current_block
= NULL
;
4655 demand_empty_rest_of_line ();
4658 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4662 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4666 sym
= symbol_make (".bb");
4667 S_SET_SEGMENT (sym
, text_section
);
4668 symbol_set_frag (sym
, frag_now
);
4669 S_SET_VALUE (sym
, frag_now_fix ());
4670 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4672 S_SET_NUMBER_AUXILIARY (sym
, 1);
4673 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4675 symbol_get_tc (sym
)->output
= 1;
4677 SF_SET_PROCESS (sym
);
4679 ppc_frob_label (sym
);
4681 demand_empty_rest_of_line ();
4684 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4688 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4692 sym
= symbol_make (".eb");
4693 S_SET_SEGMENT (sym
, text_section
);
4694 symbol_set_frag (sym
, frag_now
);
4695 S_SET_VALUE (sym
, frag_now_fix ());
4696 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4697 S_SET_NUMBER_AUXILIARY (sym
, 1);
4698 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4699 symbol_get_tc (sym
)->output
= 1;
4701 SF_SET_PROCESS (sym
);
4703 ppc_frob_label (sym
);
4705 demand_empty_rest_of_line ();
4708 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4712 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4718 name
= demand_copy_C_string (&len
);
4719 sym
= symbol_make (name
);
4720 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4721 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4722 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4723 S_SET_VALUE (sym
, 0);
4724 symbol_get_tc (sym
)->output
= 1;
4726 ppc_frob_label (sym
);
4728 demand_empty_rest_of_line ();
4731 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4734 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4738 sym
= symbol_make (".ec");
4739 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4740 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4741 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4742 S_SET_VALUE (sym
, 0);
4743 symbol_get_tc (sym
)->output
= 1;
4745 ppc_frob_label (sym
);
4747 demand_empty_rest_of_line ();
4750 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4753 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4755 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4756 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4763 subseg
= ppc_data_subsegment
;
4764 ++ppc_data_subsegment
;
4766 subseg_new (segment_name (data_section
), subseg
);
4767 ppc_toc_frag
= frag_now
;
4769 sym
= symbol_find_or_make ("TOC[TC0]");
4770 symbol_set_frag (sym
, frag_now
);
4771 S_SET_SEGMENT (sym
, data_section
);
4772 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4773 symbol_get_tc (sym
)->subseg
= subseg
;
4774 symbol_get_tc (sym
)->output
= 1;
4775 symbol_get_tc (sym
)->within
= sym
;
4777 ppc_toc_csect
= sym
;
4779 for (list
= ppc_data_csects
;
4780 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4781 list
= symbol_get_tc (list
)->next
)
4783 symbol_get_tc (list
)->next
= sym
;
4785 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4786 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4790 ppc_current_csect
= ppc_toc_csect
;
4792 demand_empty_rest_of_line ();
4795 /* The AIX assembler automatically aligns the operands of a .long or
4796 .short pseudo-op, and we want to be compatible. */
4799 ppc_xcoff_cons (int log_size
)
4801 frag_align (log_size
, 0, 0);
4802 record_alignment (now_seg
, log_size
);
4803 cons (1 << log_size
);
4807 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4812 (void) expression (&exp
);
4814 if (exp
.X_op
!= O_constant
)
4816 as_bad (_("non-constant byte count"));
4820 byte_count
= exp
.X_add_number
;
4822 if (*input_line_pointer
!= ',')
4824 as_bad (_("missing value"));
4828 ++input_line_pointer
;
4833 ppc_xcoff_end (void)
4837 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4839 struct dw_section
*dws
= &dw_sections
[i
];
4840 struct dw_subsection
*dwss
;
4842 if (dws
->anon_subseg
)
4844 dwss
= dws
->anon_subseg
;
4845 dwss
->link
= dws
->list_subseg
;
4848 dwss
= dws
->list_subseg
;
4850 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4851 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4853 subseg_set (dws
->sect
, dwss
->subseg
);
4854 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4859 #endif /* OBJ_XCOFF */
4860 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4862 /* The .tc pseudo-op. This is used when generating either XCOFF or
4863 ELF. This takes two or more arguments.
4865 When generating XCOFF output, the first argument is the name to
4866 give to this location in the toc; this will be a symbol with class
4867 TC. The rest of the arguments are N-byte values to actually put at
4868 this location in the TOC; often there is just one more argument, a
4869 relocatable symbol reference. The size of the value to store
4870 depends on target word size. A 32-bit target uses 4-byte values, a
4871 64-bit target uses 8-byte values.
4873 When not generating XCOFF output, the arguments are the same, but
4874 the first argument is simply ignored. */
4877 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4881 /* Define the TOC symbol name. */
4887 if (ppc_toc_csect
== (symbolS
*) NULL
4888 || ppc_toc_csect
!= ppc_current_csect
)
4890 as_bad (_(".tc not in .toc section"));
4891 ignore_rest_of_line ();
4895 endc
= get_symbol_name (&name
);
4897 sym
= symbol_find_or_make (name
);
4899 (void) restore_line_pointer (endc
);
4901 if (S_IS_DEFINED (sym
))
4905 label
= symbol_get_tc (ppc_current_csect
)->within
;
4906 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4908 as_bad (_(".tc with no label"));
4909 ignore_rest_of_line ();
4913 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4914 symbol_set_frag (label
, symbol_get_frag (sym
));
4915 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4917 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4918 ++input_line_pointer
;
4923 S_SET_SEGMENT (sym
, now_seg
);
4924 symbol_set_frag (sym
, frag_now
);
4925 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4926 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4927 symbol_get_tc (sym
)->output
= 1;
4929 ppc_frob_label (sym
);
4932 #endif /* OBJ_XCOFF */
4936 /* Skip the TOC symbol name. */
4937 while (is_part_of_name (*input_line_pointer
)
4938 || *input_line_pointer
== ' '
4939 || *input_line_pointer
== '['
4940 || *input_line_pointer
== ']'
4941 || *input_line_pointer
== '{'
4942 || *input_line_pointer
== '}')
4943 ++input_line_pointer
;
4945 /* Align to a four/eight byte boundary. */
4946 align
= ppc_obj64
? 3 : 2;
4947 frag_align (align
, 0, 0);
4948 record_alignment (now_seg
, align
);
4949 #endif /* OBJ_ELF */
4951 if (*input_line_pointer
!= ',')
4952 demand_empty_rest_of_line ();
4955 ++input_line_pointer
;
4956 cons (ppc_obj64
? 8 : 4);
4960 /* Pseudo-op .machine. */
4963 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4967 #define MAX_HISTORY 100
4968 static ppc_cpu_t
*cpu_history
;
4969 static int curr_hist
;
4973 c
= get_symbol_name (&cpu_string
);
4974 cpu_string
= xstrdup (cpu_string
);
4975 (void) restore_line_pointer (c
);
4977 if (cpu_string
!= NULL
)
4979 ppc_cpu_t old_cpu
= ppc_cpu
;
4983 for (p
= cpu_string
; *p
!= 0; p
++)
4986 if (strcmp (cpu_string
, "push") == 0)
4988 if (cpu_history
== NULL
)
4989 cpu_history
= XNEWVEC (ppc_cpu_t
, MAX_HISTORY
);
4991 if (curr_hist
>= MAX_HISTORY
)
4992 as_bad (_(".machine stack overflow"));
4994 cpu_history
[curr_hist
++] = ppc_cpu
;
4996 else if (strcmp (cpu_string
, "pop") == 0)
4999 as_bad (_(".machine stack underflow"));
5001 ppc_cpu
= cpu_history
[--curr_hist
];
5003 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
5006 as_bad (_("invalid machine `%s'"), cpu_string
);
5008 if (ppc_cpu
!= old_cpu
)
5009 ppc_setup_opcodes ();
5012 demand_empty_rest_of_line ();
5014 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5018 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
5020 /* Set the current section. */
5022 ppc_set_current_section (segT
new)
5024 ppc_previous_section
= ppc_current_section
;
5025 ppc_current_section
= new;
5028 /* pseudo-op: .previous
5029 behaviour: toggles the current section with the previous section.
5031 warnings: "No previous section" */
5034 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
5036 if (ppc_previous_section
== NULL
)
5038 as_warn (_("no previous section to return to, ignored."));
5042 subseg_set (ppc_previous_section
, 0);
5044 ppc_set_current_section (ppc_previous_section
);
5047 /* pseudo-op: .pdata
5048 behaviour: predefined read only data section
5052 initial: .section .pdata "adr3"
5053 a - don't know -- maybe a misprint
5054 d - initialized data
5056 3 - double word aligned (that would be 4 byte boundary)
5059 Tag index tables (also known as the function table) for exception
5060 handling, debugging, etc. */
5063 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
5065 if (pdata_section
== 0)
5067 pdata_section
= subseg_new (".pdata", 0);
5069 bfd_set_section_flags (stdoutput
, pdata_section
,
5070 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5071 | SEC_READONLY
| SEC_DATA
));
5073 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5077 pdata_section
= subseg_new (".pdata", 0);
5079 ppc_set_current_section (pdata_section
);
5082 /* pseudo-op: .ydata
5083 behaviour: predefined read only data section
5087 initial: .section .ydata "drw3"
5088 a - don't know -- maybe a misprint
5089 d - initialized data
5091 3 - double word aligned (that would be 4 byte boundary)
5093 Tag tables (also known as the scope table) for exception handling,
5097 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5099 if (ydata_section
== 0)
5101 ydata_section
= subseg_new (".ydata", 0);
5102 bfd_set_section_flags (stdoutput
, ydata_section
,
5103 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5104 | SEC_READONLY
| SEC_DATA
));
5106 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5110 ydata_section
= subseg_new (".ydata", 0);
5112 ppc_set_current_section (ydata_section
);
5115 /* pseudo-op: .reldata
5116 behaviour: predefined read write data section
5117 double word aligned (4-byte)
5118 FIXME: relocation is applied to it
5119 FIXME: what's the difference between this and .data?
5122 initial: .section .reldata "drw3"
5123 d - initialized data
5126 3 - double word aligned (that would be 8 byte boundary)
5129 Like .data, but intended to hold data subject to relocation, such as
5130 function descriptors, etc. */
5133 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5135 if (reldata_section
== 0)
5137 reldata_section
= subseg_new (".reldata", 0);
5139 bfd_set_section_flags (stdoutput
, reldata_section
,
5140 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5143 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5147 reldata_section
= subseg_new (".reldata", 0);
5149 ppc_set_current_section (reldata_section
);
5152 /* pseudo-op: .rdata
5153 behaviour: predefined read only data section
5157 initial: .section .rdata "dr3"
5158 d - initialized data
5160 3 - double word aligned (that would be 4 byte boundary) */
5163 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5165 if (rdata_section
== 0)
5167 rdata_section
= subseg_new (".rdata", 0);
5168 bfd_set_section_flags (stdoutput
, rdata_section
,
5169 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5170 | SEC_READONLY
| SEC_DATA
));
5172 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5176 rdata_section
= subseg_new (".rdata", 0);
5178 ppc_set_current_section (rdata_section
);
5181 /* pseudo-op: .ualong
5182 behaviour: much like .int, with the exception that no alignment is
5184 FIXME: test the alignment statement
5189 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5195 /* pseudo-op: .znop <symbol name>
5196 behaviour: Issue a nop instruction
5197 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5198 the supplied symbol name.
5200 warnings: Missing symbol name */
5203 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5206 const struct powerpc_opcode
*opcode
;
5213 /* Strip out the symbol name. */
5214 c
= get_symbol_name (&symbol_name
);
5216 name
= xstrdup (symbol_name
);
5218 sym
= symbol_find_or_make (name
);
5220 *input_line_pointer
= c
;
5222 SKIP_WHITESPACE_AFTER_NAME ();
5224 /* Look up the opcode in the hash table. */
5225 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5227 /* Stick in the nop. */
5228 insn
= opcode
->opcode
;
5230 /* Write out the instruction. */
5232 md_number_to_chars (f
, insn
, 4);
5234 f
- frag_now
->fr_literal
,
5239 BFD_RELOC_16_GOT_PCREL
);
5249 ppc_pe_comm (int lcomm
)
5258 c
= get_symbol_name (&name
);
5260 /* just after name is now '\0'. */
5261 p
= input_line_pointer
;
5263 SKIP_WHITESPACE_AFTER_NAME ();
5264 if (*input_line_pointer
!= ',')
5266 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5267 ignore_rest_of_line ();
5271 input_line_pointer
++; /* skip ',' */
5272 if ((temp
= get_absolute_expression ()) < 0)
5274 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5275 ignore_rest_of_line ();
5281 /* The third argument to .comm is the alignment. */
5282 if (*input_line_pointer
!= ',')
5286 ++input_line_pointer
;
5287 align
= get_absolute_expression ();
5290 as_warn (_("ignoring bad alignment"));
5297 symbolP
= symbol_find_or_make (name
);
5300 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5302 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5303 S_GET_NAME (symbolP
));
5304 ignore_rest_of_line ();
5308 if (S_GET_VALUE (symbolP
))
5310 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5311 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5312 S_GET_NAME (symbolP
),
5313 (long) S_GET_VALUE (symbolP
),
5318 S_SET_VALUE (symbolP
, (valueT
) temp
);
5319 S_SET_EXTERNAL (symbolP
);
5320 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5323 demand_empty_rest_of_line ();
5327 * implement the .section pseudo op:
5328 * .section name {, "flags"}
5330 * | +--- optional flags: 'b' for bss
5332 * +-- section name 'l' for lib
5336 * 'd' (apparently m88k for data)
5338 * But if the argument is not a quoted string, treat it as a
5339 * subsegment number.
5341 * FIXME: this is a copy of the section processing from obj-coff.c, with
5342 * additions/changes for the moto-pas assembler support. There are three
5345 * FIXME: I just noticed this. This doesn't work at all really. It it
5346 * setting bits that bfd probably neither understands or uses. The
5347 * correct approach (?) will have to incorporate extra fields attached
5348 * to the section to hold the system specific stuff. (krk)
5351 * 'a' - unknown - referred to in documentation, but no definition supplied
5352 * 'c' - section has code
5353 * 'd' - section has initialized data
5354 * 'u' - section has uninitialized data
5355 * 'i' - section contains directives (info)
5356 * 'n' - section can be discarded
5357 * 'R' - remove section at link time
5359 * Section Protection:
5360 * 'r' - section is readable
5361 * 'w' - section is writeable
5362 * 'x' - section is executable
5363 * 's' - section is sharable
5365 * Section Alignment:
5366 * '0' - align to byte boundary
5367 * '1' - align to halfword undary
5368 * '2' - align to word boundary
5369 * '3' - align to doubleword boundary
5370 * '4' - align to quadword boundary
5371 * '5' - align to 32 byte boundary
5372 * '6' - align to 64 byte boundary
5377 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5379 /* Strip out the section name. */
5388 c
= get_symbol_name (§ion_name
);
5390 name
= xstrdup (section_name
);
5392 *input_line_pointer
= c
;
5394 SKIP_WHITESPACE_AFTER_NAME ();
5397 flags
= SEC_NO_FLAGS
;
5399 if (strcmp (name
, ".idata$2") == 0)
5403 else if (strcmp (name
, ".idata$3") == 0)
5407 else if (strcmp (name
, ".idata$4") == 0)
5411 else if (strcmp (name
, ".idata$5") == 0)
5415 else if (strcmp (name
, ".idata$6") == 0)
5420 /* Default alignment to 16 byte boundary. */
5423 if (*input_line_pointer
== ',')
5425 ++input_line_pointer
;
5427 if (*input_line_pointer
!= '"')
5428 exp
= get_absolute_expression ();
5431 ++input_line_pointer
;
5432 while (*input_line_pointer
!= '"'
5433 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5435 switch (*input_line_pointer
)
5437 /* Section Contents */
5438 case 'a': /* unknown */
5439 as_bad (_("unsupported section attribute -- 'a'"));
5441 case 'c': /* code section */
5444 case 'd': /* section has initialized data */
5447 case 'u': /* section has uninitialized data */
5448 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5452 case 'i': /* section contains directives (info) */
5453 /* FIXME: This is IMAGE_SCN_LNK_INFO
5455 flags
|= SEC_HAS_CONTENTS
;
5457 case 'n': /* section can be discarded */
5460 case 'R': /* Remove section at link time */
5461 flags
|= SEC_NEVER_LOAD
;
5463 #if IFLICT_BRAIN_DAMAGE
5464 /* Section Protection */
5465 case 'r': /* section is readable */
5466 flags
|= IMAGE_SCN_MEM_READ
;
5468 case 'w': /* section is writeable */
5469 flags
|= IMAGE_SCN_MEM_WRITE
;
5471 case 'x': /* section is executable */
5472 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5474 case 's': /* section is sharable */
5475 flags
|= IMAGE_SCN_MEM_SHARED
;
5478 /* Section Alignment */
5479 case '0': /* align to byte boundary */
5480 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5483 case '1': /* align to halfword boundary */
5484 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5487 case '2': /* align to word boundary */
5488 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5491 case '3': /* align to doubleword boundary */
5492 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5495 case '4': /* align to quadword boundary */
5496 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5499 case '5': /* align to 32 byte boundary */
5500 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5503 case '6': /* align to 64 byte boundary */
5504 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5509 as_bad (_("unknown section attribute '%c'"),
5510 *input_line_pointer
);
5513 ++input_line_pointer
;
5515 if (*input_line_pointer
== '"')
5516 ++input_line_pointer
;
5520 sec
= subseg_new (name
, (subsegT
) exp
);
5522 ppc_set_current_section (sec
);
5524 if (flags
!= SEC_NO_FLAGS
)
5526 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5527 as_bad (_("error setting flags for \"%s\": %s"),
5528 bfd_section_name (stdoutput
, sec
),
5529 bfd_errmsg (bfd_get_error ()));
5532 bfd_set_section_alignment (stdoutput
, sec
, align
);
5536 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5542 endc
= get_symbol_name (&name
);
5544 ext_sym
= symbol_find_or_make (name
);
5546 (void) restore_line_pointer (endc
);
5548 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5549 SF_SET_FUNCTION (ext_sym
);
5550 SF_SET_PROCESS (ext_sym
);
5551 coff_add_linesym (ext_sym
);
5553 demand_empty_rest_of_line ();
5557 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5559 if (tocdata_section
== 0)
5561 tocdata_section
= subseg_new (".tocd", 0);
5562 /* FIXME: section flags won't work. */
5563 bfd_set_section_flags (stdoutput
, tocdata_section
,
5564 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5565 | SEC_READONLY
| SEC_DATA
));
5567 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5571 rdata_section
= subseg_new (".tocd", 0);
5574 ppc_set_current_section (tocdata_section
);
5576 demand_empty_rest_of_line ();
5579 /* Don't adjust TOC relocs to use the section symbol. */
5582 ppc_pe_fix_adjustable (fixS
*fix
)
5584 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5591 /* XCOFF specific symbol and file handling. */
5593 /* Canonicalize the symbol name. We use the to force the suffix, if
5594 any, to use square brackets, and to be in upper case. */
5597 ppc_canonicalize_symbol_name (char *name
)
5601 if (ppc_stab_symbol
)
5604 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5618 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5621 if (*s
== '\0' || s
[1] != '\0')
5622 as_bad (_("bad symbol suffix"));
5630 /* Set the class of a symbol based on the suffix, if any. This is
5631 called whenever a new symbol is created. */
5634 ppc_symbol_new_hook (symbolS
*sym
)
5636 struct ppc_tc_sy
*tc
;
5639 tc
= symbol_get_tc (sym
);
5642 tc
->symbol_class
= -1;
5643 tc
->real_name
= NULL
;
5650 if (ppc_stab_symbol
)
5653 s
= strchr (S_GET_NAME (sym
), '[');
5654 if (s
== (const char *) NULL
)
5656 /* There is no suffix. */
5665 if (strcmp (s
, "BS]") == 0)
5666 tc
->symbol_class
= XMC_BS
;
5669 if (strcmp (s
, "DB]") == 0)
5670 tc
->symbol_class
= XMC_DB
;
5671 else if (strcmp (s
, "DS]") == 0)
5672 tc
->symbol_class
= XMC_DS
;
5675 if (strcmp (s
, "GL]") == 0)
5676 tc
->symbol_class
= XMC_GL
;
5679 if (strcmp (s
, "PR]") == 0)
5680 tc
->symbol_class
= XMC_PR
;
5683 if (strcmp (s
, "RO]") == 0)
5684 tc
->symbol_class
= XMC_RO
;
5685 else if (strcmp (s
, "RW]") == 0)
5686 tc
->symbol_class
= XMC_RW
;
5689 if (strcmp (s
, "SV]") == 0)
5690 tc
->symbol_class
= XMC_SV
;
5693 if (strcmp (s
, "TC]") == 0)
5694 tc
->symbol_class
= XMC_TC
;
5695 else if (strcmp (s
, "TI]") == 0)
5696 tc
->symbol_class
= XMC_TI
;
5697 else if (strcmp (s
, "TB]") == 0)
5698 tc
->symbol_class
= XMC_TB
;
5699 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5700 tc
->symbol_class
= XMC_TC0
;
5703 if (strcmp (s
, "UA]") == 0)
5704 tc
->symbol_class
= XMC_UA
;
5705 else if (strcmp (s
, "UC]") == 0)
5706 tc
->symbol_class
= XMC_UC
;
5709 if (strcmp (s
, "XO]") == 0)
5710 tc
->symbol_class
= XMC_XO
;
5714 if (tc
->symbol_class
== -1)
5715 as_bad (_("unrecognized symbol suffix"));
5718 /* Set the class of a label based on where it is defined. This
5719 handles symbols without suffixes. Also, move the symbol so that it
5720 follows the csect symbol. */
5723 ppc_frob_label (symbolS
*sym
)
5725 if (ppc_current_csect
!= (symbolS
*) NULL
)
5727 if (symbol_get_tc (sym
)->symbol_class
== -1)
5728 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5730 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5731 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5732 &symbol_rootP
, &symbol_lastP
);
5733 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5734 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5738 dwarf2_emit_label (sym
);
5742 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5743 seen. It tells ppc_adjust_symtab whether it needs to look through
5746 static bfd_boolean ppc_saw_abs
;
5748 /* Change the name of a symbol just before writing it out. Set the
5749 real name if the .rename pseudo-op was used. Otherwise, remove any
5750 class suffix. Return 1 if the symbol should not be included in the
5754 ppc_frob_symbol (symbolS
*sym
)
5756 static symbolS
*ppc_last_function
;
5757 static symbolS
*set_end
;
5759 /* Discard symbols that should not be included in the output symbol
5761 if (! symbol_used_in_reloc_p (sym
)
5762 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5763 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5764 && ! symbol_get_tc (sym
)->output
5765 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5768 /* This one will disappear anyway. Don't make a csect sym for it. */
5769 if (sym
== abs_section_sym
)
5772 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5773 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5779 name
= S_GET_NAME (sym
);
5780 s
= strchr (name
, '[');
5781 if (s
!= (char *) NULL
)
5787 snew
= xstrndup (name
, len
);
5789 S_SET_NAME (sym
, snew
);
5793 if (set_end
!= (symbolS
*) NULL
)
5795 SA_SET_SYM_ENDNDX (set_end
, sym
);
5799 if (SF_GET_FUNCTION (sym
))
5801 if (ppc_last_function
!= (symbolS
*) NULL
)
5802 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5803 ppc_last_function
= sym
;
5804 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5806 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5807 SA_SET_SYM_FSIZE (sym
,
5808 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5811 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5812 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5814 if (ppc_last_function
== (symbolS
*) NULL
)
5815 as_bad (_(".ef with no preceding .function"));
5818 set_end
= ppc_last_function
;
5819 ppc_last_function
= NULL
;
5821 /* We don't have a C_EFCN symbol, but we need to force the
5822 COFF backend to believe that it has seen one. */
5823 coff_last_function
= NULL
;
5827 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5828 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5829 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5830 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5831 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5832 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5833 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5834 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5835 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5836 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5837 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5839 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5840 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5841 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5844 union internal_auxent
*a
;
5846 /* Create a csect aux. */
5847 i
= S_GET_NUMBER_AUXILIARY (sym
);
5848 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5849 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5850 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5852 /* This is the TOC table. */
5853 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5854 a
->x_csect
.x_scnlen
.l
= 0;
5855 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5857 else if (symbol_get_tc (sym
)->subseg
!= 0)
5859 /* This is a csect symbol. x_scnlen is the size of the
5861 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5862 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5863 S_GET_SEGMENT (sym
))
5864 - S_GET_VALUE (sym
));
5867 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5868 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5869 - S_GET_VALUE (sym
));
5871 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5873 else if (S_GET_SEGMENT (sym
) == bss_section
)
5875 /* This is a common symbol. */
5876 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5877 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5878 if (S_IS_EXTERNAL (sym
))
5879 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5881 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5883 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5885 /* This is an absolute symbol. The csect will be created by
5886 ppc_adjust_symtab. */
5888 a
->x_csect
.x_smtyp
= XTY_LD
;
5889 if (symbol_get_tc (sym
)->symbol_class
== -1)
5890 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5892 else if (! S_IS_DEFINED (sym
))
5894 /* This is an external symbol. */
5895 a
->x_csect
.x_scnlen
.l
= 0;
5896 a
->x_csect
.x_smtyp
= XTY_ER
;
5898 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5902 /* This is a TOC definition. x_scnlen is the size of the
5904 next
= symbol_next (sym
);
5905 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5906 next
= symbol_next (next
);
5907 if (next
== (symbolS
*) NULL
5908 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5910 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5911 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5913 - S_GET_VALUE (sym
));
5915 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5916 - S_GET_VALUE (sym
));
5920 resolve_symbol_value (next
);
5921 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5922 - S_GET_VALUE (sym
));
5924 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5930 /* This is a normal symbol definition. x_scnlen is the
5931 symbol index of the containing csect. */
5932 if (S_GET_SEGMENT (sym
) == text_section
)
5933 csect
= ppc_text_csects
;
5934 else if (S_GET_SEGMENT (sym
) == data_section
)
5935 csect
= ppc_data_csects
;
5939 /* Skip the initial dummy symbol. */
5940 csect
= symbol_get_tc (csect
)->next
;
5942 if (csect
== (symbolS
*) NULL
)
5944 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5945 a
->x_csect
.x_scnlen
.l
= 0;
5949 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5951 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5952 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5953 > S_GET_VALUE (sym
))
5955 csect
= symbol_get_tc (csect
)->next
;
5958 a
->x_csect
.x_scnlen
.p
=
5959 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5960 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5963 a
->x_csect
.x_smtyp
= XTY_LD
;
5966 a
->x_csect
.x_parmhash
= 0;
5967 a
->x_csect
.x_snhash
= 0;
5968 if (symbol_get_tc (sym
)->symbol_class
== -1)
5969 a
->x_csect
.x_smclas
= XMC_PR
;
5971 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5972 a
->x_csect
.x_stab
= 0;
5973 a
->x_csect
.x_snstab
= 0;
5975 /* Don't let the COFF backend resort these symbols. */
5976 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5978 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5980 /* We want the value to be the symbol index of the referenced
5981 csect symbol. BFD will do that for us if we set the right
5983 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5984 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5986 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5987 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5989 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5994 block
= symbol_get_tc (sym
)->within
;
5997 /* The value is the offset from the enclosing csect. */
6000 csect
= symbol_get_tc (block
)->within
;
6001 resolve_symbol_value (csect
);
6002 base
= S_GET_VALUE (csect
);
6007 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
6009 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
6010 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
6012 /* We want the value to be a file offset into the line numbers.
6013 BFD will do that for us if we set the right flags. We have
6014 already set the value correctly. */
6015 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
6021 /* Adjust the symbol table. This creates csect symbols for all
6022 absolute symbols. */
6025 ppc_adjust_symtab (void)
6032 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
6036 union internal_auxent
*a
;
6038 if (S_GET_SEGMENT (sym
) != absolute_section
)
6041 csect
= symbol_create (".abs[XO]", absolute_section
,
6042 S_GET_VALUE (sym
), &zero_address_frag
);
6043 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
6044 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
6045 i
= S_GET_NUMBER_AUXILIARY (csect
);
6046 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
6047 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
6048 a
->x_csect
.x_scnlen
.l
= 0;
6049 a
->x_csect
.x_smtyp
= XTY_SD
;
6050 a
->x_csect
.x_parmhash
= 0;
6051 a
->x_csect
.x_snhash
= 0;
6052 a
->x_csect
.x_smclas
= XMC_XO
;
6053 a
->x_csect
.x_stab
= 0;
6054 a
->x_csect
.x_snstab
= 0;
6056 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
6058 i
= S_GET_NUMBER_AUXILIARY (sym
);
6059 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
6060 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
6061 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
6064 ppc_saw_abs
= FALSE
;
6067 /* Set the VMA for a section. This is called on all the sections in
6071 ppc_frob_section (asection
*sec
)
6073 static bfd_vma vma
= 0;
6075 /* Dwarf sections start at 0. */
6076 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6079 vma
= md_section_align (sec
, vma
);
6080 bfd_set_section_vma (stdoutput
, sec
, vma
);
6081 vma
+= bfd_section_size (stdoutput
, sec
);
6084 #endif /* OBJ_XCOFF */
6087 md_atof (int type
, char *litp
, int *sizep
)
6089 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6092 /* Write a value out to the object file, using the appropriate
6096 md_number_to_chars (char *buf
, valueT val
, int n
)
6098 if (target_big_endian
)
6099 number_to_chars_bigendian (buf
, val
, n
);
6101 number_to_chars_littleendian (buf
, val
, n
);
6104 /* Align a section (I don't know why this is machine dependent). */
6107 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6112 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6114 return ((addr
+ (1 << align
) - 1) & -(1 << align
));
6118 /* We don't have any form of relaxing. */
6121 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6122 asection
*seg ATTRIBUTE_UNUSED
)
6128 /* Convert a machine dependent frag. We never generate these. */
6131 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6132 asection
*sec ATTRIBUTE_UNUSED
,
6133 fragS
*fragp ATTRIBUTE_UNUSED
)
6138 /* We have no need to default values of symbols. */
6141 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6146 /* Functions concerning relocs. */
6148 /* The location from which a PC relative jump should be calculated,
6149 given a PC relative reloc. */
6152 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6154 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6159 /* This is called to see whether a fixup should be adjusted to use a
6160 section symbol. We take the opportunity to change a fixup against
6161 a symbol in the TOC subsegment into a reloc against the
6162 corresponding .tc symbol. */
6165 ppc_fix_adjustable (fixS
*fix
)
6167 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6168 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6169 TC_SYMFIELD_TYPE
*tc
;
6171 if (symseg
== absolute_section
)
6174 /* Always adjust symbols in debugging sections. */
6175 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6178 if (ppc_toc_csect
!= (symbolS
*) NULL
6179 && fix
->fx_addsy
!= ppc_toc_csect
6180 && symseg
== data_section
6181 && val
>= ppc_toc_frag
->fr_address
6182 && (ppc_after_toc_frag
== (fragS
*) NULL
6183 || val
< ppc_after_toc_frag
->fr_address
))
6187 for (sy
= symbol_next (ppc_toc_csect
);
6188 sy
!= (symbolS
*) NULL
;
6189 sy
= symbol_next (sy
))
6191 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6193 if (sy_tc
->symbol_class
== XMC_TC0
)
6195 if (sy_tc
->symbol_class
!= XMC_TC
)
6197 if (val
== resolve_symbol_value (sy
))
6200 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6205 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6206 _("symbol in .toc does not match any .tc"));
6209 /* Possibly adjust the reloc to be against the csect. */
6210 tc
= symbol_get_tc (fix
->fx_addsy
);
6212 && tc
->symbol_class
!= XMC_TC0
6213 && tc
->symbol_class
!= XMC_TC
6214 && symseg
!= bss_section
6215 /* Don't adjust if this is a reloc in the toc section. */
6216 && (symseg
!= data_section
6217 || ppc_toc_csect
== NULL
6218 || val
< ppc_toc_frag
->fr_address
6219 || (ppc_after_toc_frag
!= NULL
6220 && val
>= ppc_after_toc_frag
->fr_address
)))
6222 symbolS
*csect
= tc
->within
;
6224 /* If the symbol was not declared by a label (eg: a section symbol),
6225 use the section instead of the csect. This doesn't happen in
6226 normal AIX assembly code. */
6228 csect
= seg_info (symseg
)->sym
;
6230 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6231 fix
->fx_addsy
= csect
;
6236 /* Adjust a reloc against a .lcomm symbol to be against the base
6238 if (symseg
== bss_section
6239 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6241 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6243 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6250 /* A reloc from one csect to another must be kept. The assembler
6251 will, of course, keep relocs between sections, and it will keep
6252 absolute relocs, but we need to force it to keep PC relative relocs
6253 between two csects in the same section. */
6256 ppc_force_relocation (fixS
*fix
)
6258 /* At this point fix->fx_addsy should already have been converted to
6259 a csect symbol. If the csect does not include the fragment, then
6260 we need to force the relocation. */
6262 && fix
->fx_addsy
!= NULL
6263 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6264 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6265 > fix
->fx_frag
->fr_address
)
6266 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6267 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6268 <= fix
->fx_frag
->fr_address
))))
6271 return generic_force_reloc (fix
);
6275 ppc_new_dot_label (symbolS
*sym
)
6277 /* Anchor this label to the current csect for relocations. */
6278 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6281 #endif /* OBJ_XCOFF */
6284 /* If this function returns non-zero, it guarantees that a relocation
6285 will be emitted for a fixup. */
6288 ppc_force_relocation (fixS
*fix
)
6290 /* Branch prediction relocations must force a relocation, as must
6291 the vtable description relocs. */
6292 switch (fix
->fx_r_type
)
6294 case BFD_RELOC_PPC_B16_BRTAKEN
:
6295 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6296 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6297 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6298 case BFD_RELOC_24_PLT_PCREL
:
6299 case BFD_RELOC_PPC64_TOC
:
6301 case BFD_RELOC_PPC_B26
:
6302 case BFD_RELOC_PPC_BA26
:
6303 case BFD_RELOC_PPC_B16
:
6304 case BFD_RELOC_PPC_BA16
:
6305 /* All branch fixups targeting a localentry symbol must
6306 force a relocation. */
6309 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6310 elf_symbol_type
*elfsym
6311 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6312 gas_assert (elfsym
);
6313 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6321 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6322 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6325 return generic_force_reloc (fix
);
6329 ppc_fix_adjustable (fixS
*fix
)
6331 switch (fix
->fx_r_type
)
6333 /* All branch fixups targeting a localentry symbol must
6334 continue using the symbol. */
6335 case BFD_RELOC_PPC_B26
:
6336 case BFD_RELOC_PPC_BA26
:
6337 case BFD_RELOC_PPC_B16
:
6338 case BFD_RELOC_PPC_BA16
:
6339 case BFD_RELOC_PPC_B16_BRTAKEN
:
6340 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6341 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6342 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6345 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6346 elf_symbol_type
*elfsym
6347 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6348 gas_assert (elfsym
);
6349 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6357 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6358 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6359 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6360 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6361 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6362 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6363 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6364 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6365 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6366 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6367 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6372 ppc_frag_check (struct frag
*fragP
)
6374 if (!fragP
->has_code
)
6377 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
6379 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6380 as_bad (_("instruction address is not a multiple of 2"));
6384 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6385 as_bad (_("instruction address is not a multiple of 4"));
6389 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6390 rs_align_code frag. */
6393 ppc_handle_align (struct frag
*fragP
)
6395 valueT count
= (fragP
->fr_next
->fr_address
6396 - (fragP
->fr_address
+ fragP
->fr_fix
));
6398 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0 && count
!= 0 && (count
& 1) == 0)
6400 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6403 md_number_to_chars (dest
, 0x4400, 2);
6405 else if (count
!= 0 && (count
& 3) == 0)
6407 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6411 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6415 /* Make a branch, then follow with nops. Insert another
6416 frag to handle the nops. */
6417 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6422 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6423 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6424 fragP
->fr_next
= rest
;
6426 rest
->fr_address
+= rest
->fr_fix
+ 4;
6428 /* If we leave the next frag as rs_align_code we'll come here
6429 again, resulting in a bunch of branches rather than a
6430 branch followed by nops. */
6431 rest
->fr_type
= rs_align
;
6432 dest
= rest
->fr_literal
;
6435 md_number_to_chars (dest
, 0x60000000, 4);
6437 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6438 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6439 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0
6440 || (ppc_cpu
& PPC_OPCODE_POWER9
) != 0)
6442 /* For power6, power7, power8 and power9, we want the last nop to be
6443 a group terminating one. Do this by inserting an rs_fill frag
6444 immediately after this one, with its address set to the last nop
6445 location. This will automatically reduce the number of nops in
6446 the current frag by one. */
6449 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6451 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6452 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6453 group_nop
->fr_fix
= 0;
6454 group_nop
->fr_offset
= 1;
6455 group_nop
->fr_type
= rs_fill
;
6456 fragP
->fr_next
= group_nop
;
6457 dest
= group_nop
->fr_literal
;
6460 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6461 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0
6462 || (ppc_cpu
& PPC_OPCODE_POWER9
) != 0)
6464 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6465 /* e500mc group terminating nop: "ori 0,0,0". */
6466 md_number_to_chars (dest
, 0x60000000, 4);
6468 /* power7/power8/power9 group terminating nop: "ori 2,2,0". */
6469 md_number_to_chars (dest
, 0x60420000, 4);
6472 /* power6 group terminating nop: "ori 1,1,0". */
6473 md_number_to_chars (dest
, 0x60210000, 4);
6478 /* Apply a fixup to the object code. This is called for all the
6479 fixups we generated by the calls to fix_new_exp, above. */
6482 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg
)
6484 valueT value
= * valP
;
6486 const struct powerpc_operand
*operand
;
6489 if (fixP
->fx_addsy
!= NULL
)
6491 /* Hack around bfd_install_relocation brain damage. */
6493 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6495 if (fixP
->fx_addsy
== abs_section_sym
)
6501 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6502 the symbol values. If we are doing this relocation the code in
6503 write.c is going to call bfd_install_relocation, which is also
6504 going to use the symbol value. That means that if the reloc is
6505 fully resolved we want to use *valP since bfd_install_relocation is
6507 However, if the reloc is not fully resolved we do not want to
6508 use *valP, and must use fx_offset instead. If the relocation
6509 is PC-relative, we then need to re-apply md_pcrel_from_section
6510 to this new relocation value. */
6511 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6516 value
= fixP
->fx_offset
;
6518 value
-= md_pcrel_from_section (fixP
, seg
);
6522 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6524 /* We can't actually support subtracting a symbol. */
6525 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6529 if (fixP
->fx_pcrel_adjust
!= 0)
6531 /* This is a fixup on an instruction. */
6532 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6534 operand
= &powerpc_operands
[opindex
];
6536 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6537 does not generate a reloc. It uses the offset of `sym' within its
6538 csect. Other usages, such as `.long sym', generate relocs. This
6539 is the documented behaviour of non-TOC symbols. */
6540 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6541 && (operand
->bitm
& 0xfff0) == 0xfff0
6542 && operand
->shift
== 0
6543 && (operand
->insert
== NULL
|| ppc_obj64
)
6544 && fixP
->fx_addsy
!= NULL
6545 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6546 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6547 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6548 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6550 value
= fixP
->fx_offset
;
6554 /* During parsing of instructions, a TOC16 reloc is generated for
6555 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6556 in the toc. But at parse time, SYM may be not yet defined, so
6557 check again here. */
6558 if (fixP
->fx_r_type
== BFD_RELOC_16
6559 && fixP
->fx_addsy
!= NULL
6560 && ppc_is_toc_sym (fixP
->fx_addsy
))
6561 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6565 /* Calculate value to be stored in field. */
6567 switch (fixP
->fx_r_type
)
6570 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6571 case BFD_RELOC_PPC_VLE_LO16A
:
6572 case BFD_RELOC_PPC_VLE_LO16D
:
6574 case BFD_RELOC_LO16
:
6575 case BFD_RELOC_LO16_PCREL
:
6576 fieldval
= value
& 0xffff;
6578 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6579 fieldval
= SEX16 (fieldval
);
6580 fixP
->fx_no_overflow
= 1;
6583 case BFD_RELOC_HI16
:
6584 case BFD_RELOC_HI16_PCREL
:
6586 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6588 fieldval
= value
>> 16;
6589 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6591 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6592 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6598 case BFD_RELOC_PPC_VLE_HI16A
:
6599 case BFD_RELOC_PPC_VLE_HI16D
:
6600 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6602 fieldval
= PPC_HI (value
);
6603 goto sign_extend_16
;
6605 case BFD_RELOC_HI16_S
:
6606 case BFD_RELOC_HI16_S_PCREL
:
6607 case BFD_RELOC_PPC_REL16DX_HA
:
6609 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6611 fieldval
= (value
+ 0x8000) >> 16;
6612 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6614 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6615 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6621 case BFD_RELOC_PPC_VLE_HA16A
:
6622 case BFD_RELOC_PPC_VLE_HA16D
:
6623 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6625 fieldval
= PPC_HA (value
);
6626 goto sign_extend_16
;
6629 case BFD_RELOC_PPC64_HIGHER
:
6630 fieldval
= PPC_HIGHER (value
);
6631 goto sign_extend_16
;
6633 case BFD_RELOC_PPC64_HIGHER_S
:
6634 fieldval
= PPC_HIGHERA (value
);
6635 goto sign_extend_16
;
6637 case BFD_RELOC_PPC64_HIGHEST
:
6638 fieldval
= PPC_HIGHEST (value
);
6639 goto sign_extend_16
;
6641 case BFD_RELOC_PPC64_HIGHEST_S
:
6642 fieldval
= PPC_HIGHESTA (value
);
6643 goto sign_extend_16
;
6650 if (operand
!= NULL
)
6652 /* Handle relocs in an insn. */
6653 switch (fixP
->fx_r_type
)
6656 /* The following relocs can't be calculated by the assembler.
6657 Leave the field zero. */
6658 case BFD_RELOC_PPC_TPREL16
:
6659 case BFD_RELOC_PPC_TPREL16_LO
:
6660 case BFD_RELOC_PPC_TPREL16_HI
:
6661 case BFD_RELOC_PPC_TPREL16_HA
:
6662 case BFD_RELOC_PPC_DTPREL16
:
6663 case BFD_RELOC_PPC_DTPREL16_LO
:
6664 case BFD_RELOC_PPC_DTPREL16_HI
:
6665 case BFD_RELOC_PPC_DTPREL16_HA
:
6666 case BFD_RELOC_PPC_GOT_TLSGD16
:
6667 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6668 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6669 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6670 case BFD_RELOC_PPC_GOT_TLSLD16
:
6671 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6672 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6673 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6674 case BFD_RELOC_PPC_GOT_TPREL16
:
6675 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6676 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6677 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6678 case BFD_RELOC_PPC_GOT_DTPREL16
:
6679 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6680 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6681 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6682 case BFD_RELOC_PPC64_TPREL16_DS
:
6683 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6684 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6685 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6686 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6687 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6688 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6689 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6690 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6691 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6692 case BFD_RELOC_PPC64_DTPREL16_DS
:
6693 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6694 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6695 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6696 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6697 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6698 gas_assert (fixP
->fx_addsy
!= NULL
);
6699 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6703 /* These also should leave the field zero for the same
6704 reason. Note that older versions of gas wrote values
6705 here. If we want to go back to the old behaviour, then
6706 all _LO and _LO_DS cases will need to be treated like
6707 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6708 case BFD_RELOC_16_GOTOFF
:
6709 case BFD_RELOC_LO16_GOTOFF
:
6710 case BFD_RELOC_HI16_GOTOFF
:
6711 case BFD_RELOC_HI16_S_GOTOFF
:
6712 case BFD_RELOC_LO16_PLTOFF
:
6713 case BFD_RELOC_HI16_PLTOFF
:
6714 case BFD_RELOC_HI16_S_PLTOFF
:
6715 case BFD_RELOC_GPREL16
:
6716 case BFD_RELOC_16_BASEREL
:
6717 case BFD_RELOC_LO16_BASEREL
:
6718 case BFD_RELOC_HI16_BASEREL
:
6719 case BFD_RELOC_HI16_S_BASEREL
:
6720 case BFD_RELOC_PPC_TOC16
:
6721 case BFD_RELOC_PPC64_TOC16_LO
:
6722 case BFD_RELOC_PPC64_TOC16_HI
:
6723 case BFD_RELOC_PPC64_TOC16_HA
:
6724 case BFD_RELOC_PPC64_PLTGOT16
:
6725 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6726 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6727 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6728 case BFD_RELOC_PPC64_GOT16_DS
:
6729 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6730 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6731 case BFD_RELOC_PPC64_SECTOFF_DS
:
6732 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6733 case BFD_RELOC_PPC64_TOC16_DS
:
6734 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6735 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6736 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6737 case BFD_RELOC_PPC_EMB_NADDR16
:
6738 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6739 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6740 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6741 case BFD_RELOC_PPC_EMB_SDAI16
:
6742 case BFD_RELOC_PPC_EMB_SDA2I16
:
6743 case BFD_RELOC_PPC_EMB_SDA2REL
:
6744 case BFD_RELOC_PPC_EMB_SDA21
:
6745 case BFD_RELOC_PPC_EMB_MRKREF
:
6746 case BFD_RELOC_PPC_EMB_RELSEC16
:
6747 case BFD_RELOC_PPC_EMB_RELST_LO
:
6748 case BFD_RELOC_PPC_EMB_RELST_HI
:
6749 case BFD_RELOC_PPC_EMB_RELST_HA
:
6750 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6751 case BFD_RELOC_PPC_EMB_RELSDA
:
6752 case BFD_RELOC_PPC_VLE_SDA21
:
6753 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6754 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6755 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6756 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6757 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6758 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6759 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6760 gas_assert (fixP
->fx_addsy
!= NULL
);
6763 case BFD_RELOC_PPC_TLS
:
6764 case BFD_RELOC_PPC_TLSGD
:
6765 case BFD_RELOC_PPC_TLSLD
:
6771 case BFD_RELOC_PPC_B16
:
6772 /* Adjust the offset to the instruction boundary. */
6777 case BFD_RELOC_VTABLE_INHERIT
:
6778 case BFD_RELOC_VTABLE_ENTRY
:
6779 case BFD_RELOC_PPC_DTPMOD
:
6780 case BFD_RELOC_PPC_TPREL
:
6781 case BFD_RELOC_PPC_DTPREL
:
6782 case BFD_RELOC_PPC_COPY
:
6783 case BFD_RELOC_PPC_GLOB_DAT
:
6784 case BFD_RELOC_32_PLT_PCREL
:
6785 case BFD_RELOC_PPC_EMB_NADDR32
:
6786 case BFD_RELOC_PPC64_TOC
:
6787 case BFD_RELOC_CTOR
:
6789 case BFD_RELOC_32_PCREL
:
6792 case BFD_RELOC_64_PCREL
:
6793 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6794 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6795 _("%s unsupported as instruction fixup"),
6796 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6805 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6806 contents can stay at zero. */
6807 #define APPLY_RELOC fixP->fx_done
6809 #define APPLY_RELOC 1
6811 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6814 unsigned char *where
;
6816 /* Fetch the instruction, insert the fully resolved operand
6817 value, and stuff the instruction back again. */
6818 where
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6819 if (target_big_endian
)
6821 if (fixP
->fx_size
== 4)
6822 insn
= bfd_getb32 (where
);
6824 insn
= bfd_getb16 (where
);
6828 if (fixP
->fx_size
== 4)
6829 insn
= bfd_getl32 (where
);
6831 insn
= bfd_getl16 (where
);
6833 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6834 fixP
->tc_fix_data
.ppc_cpu
,
6835 fixP
->fx_file
, fixP
->fx_line
);
6836 if (target_big_endian
)
6838 if (fixP
->fx_size
== 4)
6839 bfd_putb32 (insn
, where
);
6841 bfd_putb16 (insn
, where
);
6845 if (fixP
->fx_size
== 4)
6846 bfd_putl32 (insn
, where
);
6848 bfd_putl16 (insn
, where
);
6853 /* Nothing else to do here. */
6856 gas_assert (fixP
->fx_addsy
!= NULL
);
6857 if (fixP
->fx_r_type
== BFD_RELOC_NONE
)
6862 /* Use expr_symbol_where to see if this is an expression
6864 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6865 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6866 _("unresolved expression that must be resolved"));
6868 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6869 _("unsupported relocation against %s"),
6870 S_GET_NAME (fixP
->fx_addsy
));
6877 /* Handle relocs in data. */
6878 switch (fixP
->fx_r_type
)
6880 case BFD_RELOC_VTABLE_INHERIT
:
6882 && !S_IS_DEFINED (fixP
->fx_addsy
)
6883 && !S_IS_WEAK (fixP
->fx_addsy
))
6884 S_SET_WEAK (fixP
->fx_addsy
);
6887 case BFD_RELOC_VTABLE_ENTRY
:
6892 /* These can appear with @l etc. in data. */
6893 case BFD_RELOC_LO16
:
6894 case BFD_RELOC_LO16_PCREL
:
6895 case BFD_RELOC_HI16
:
6896 case BFD_RELOC_HI16_PCREL
:
6897 case BFD_RELOC_HI16_S
:
6898 case BFD_RELOC_HI16_S_PCREL
:
6899 case BFD_RELOC_PPC64_HIGHER
:
6900 case BFD_RELOC_PPC64_HIGHER_S
:
6901 case BFD_RELOC_PPC64_HIGHEST
:
6902 case BFD_RELOC_PPC64_HIGHEST_S
:
6903 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6904 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6905 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6908 case BFD_RELOC_PPC_DTPMOD
:
6909 case BFD_RELOC_PPC_TPREL
:
6910 case BFD_RELOC_PPC_DTPREL
:
6911 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6914 /* Just punt all of these to the linker. */
6915 case BFD_RELOC_PPC_B16_BRTAKEN
:
6916 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6917 case BFD_RELOC_16_GOTOFF
:
6918 case BFD_RELOC_LO16_GOTOFF
:
6919 case BFD_RELOC_HI16_GOTOFF
:
6920 case BFD_RELOC_HI16_S_GOTOFF
:
6921 case BFD_RELOC_LO16_PLTOFF
:
6922 case BFD_RELOC_HI16_PLTOFF
:
6923 case BFD_RELOC_HI16_S_PLTOFF
:
6924 case BFD_RELOC_PPC_COPY
:
6925 case BFD_RELOC_PPC_GLOB_DAT
:
6926 case BFD_RELOC_16_BASEREL
:
6927 case BFD_RELOC_LO16_BASEREL
:
6928 case BFD_RELOC_HI16_BASEREL
:
6929 case BFD_RELOC_HI16_S_BASEREL
:
6930 case BFD_RELOC_PPC_TLS
:
6931 case BFD_RELOC_PPC_DTPREL16_LO
:
6932 case BFD_RELOC_PPC_DTPREL16_HI
:
6933 case BFD_RELOC_PPC_DTPREL16_HA
:
6934 case BFD_RELOC_PPC_TPREL16_LO
:
6935 case BFD_RELOC_PPC_TPREL16_HI
:
6936 case BFD_RELOC_PPC_TPREL16_HA
:
6937 case BFD_RELOC_PPC_GOT_TLSGD16
:
6938 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6939 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6940 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6941 case BFD_RELOC_PPC_GOT_TLSLD16
:
6942 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6943 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6944 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6945 case BFD_RELOC_PPC_GOT_DTPREL16
:
6946 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6947 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6948 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6949 case BFD_RELOC_PPC_GOT_TPREL16
:
6950 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6951 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6952 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6953 case BFD_RELOC_24_PLT_PCREL
:
6954 case BFD_RELOC_PPC_LOCAL24PC
:
6955 case BFD_RELOC_32_PLT_PCREL
:
6956 case BFD_RELOC_GPREL16
:
6957 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6958 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6959 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6960 case BFD_RELOC_PPC_EMB_NADDR32
:
6961 case BFD_RELOC_PPC_EMB_NADDR16
:
6962 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6963 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6964 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6965 case BFD_RELOC_PPC_EMB_SDAI16
:
6966 case BFD_RELOC_PPC_EMB_SDA2REL
:
6967 case BFD_RELOC_PPC_EMB_SDA2I16
:
6968 case BFD_RELOC_PPC_EMB_SDA21
:
6969 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6970 case BFD_RELOC_PPC_EMB_MRKREF
:
6971 case BFD_RELOC_PPC_EMB_RELSEC16
:
6972 case BFD_RELOC_PPC_EMB_RELST_LO
:
6973 case BFD_RELOC_PPC_EMB_RELST_HI
:
6974 case BFD_RELOC_PPC_EMB_RELST_HA
:
6975 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6976 case BFD_RELOC_PPC_EMB_RELSDA
:
6977 case BFD_RELOC_PPC64_TOC
:
6978 case BFD_RELOC_PPC_TOC16
:
6979 case BFD_RELOC_PPC64_TOC16_LO
:
6980 case BFD_RELOC_PPC64_TOC16_HI
:
6981 case BFD_RELOC_PPC64_TOC16_HA
:
6982 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6983 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6984 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6985 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6986 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6987 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6988 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6989 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6990 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6991 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6992 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6993 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6999 case BFD_RELOC_NONE
:
7001 case BFD_RELOC_CTOR
:
7003 case BFD_RELOC_32_PCREL
:
7006 case BFD_RELOC_64_PCREL
:
7008 case BFD_RELOC_16_PCREL
:
7014 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
7019 if (fixP
->fx_size
&& APPLY_RELOC
)
7020 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
7021 fieldval
, fixP
->fx_size
);
7023 && (seg
->flags
& SEC_CODE
) != 0
7024 && fixP
->fx_size
== 4
7027 && (fixP
->fx_r_type
== BFD_RELOC_32
7028 || fixP
->fx_r_type
== BFD_RELOC_CTOR
7029 || fixP
->fx_r_type
== BFD_RELOC_32_PCREL
))
7030 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
7031 _("data in executable section"));
7034 /* We are only able to convert some relocs to pc-relative. */
7035 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
7037 switch (fixP
->fx_r_type
)
7039 case BFD_RELOC_LO16
:
7040 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
7043 case BFD_RELOC_HI16
:
7044 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
7047 case BFD_RELOC_HI16_S
:
7048 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
7052 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7056 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7060 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7063 /* Some of course are already pc-relative. */
7064 case BFD_RELOC_LO16_PCREL
:
7065 case BFD_RELOC_HI16_PCREL
:
7066 case BFD_RELOC_HI16_S_PCREL
:
7067 case BFD_RELOC_PPC_REL16DX_HA
:
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
= XNEW (arelent
);
7160 reloc
->sym_ptr_ptr
= XNEW (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 { const 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;