1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
7 This file is part of GAS, the GNU Assembler.
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "safe-ctype.h"
27 #include "dw2gencfi.h"
28 #include "opcode/ppc.h"
32 #include "elf/ppc64.h"
33 #include "dwarf2dbg.h"
41 #include "coff/xcoff.h"
45 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
47 /* Tell the main code what the endianness is. */
48 extern int target_big_endian
;
50 /* Whether or not, we've set target_big_endian. */
51 static int set_target_endian
= 0;
53 /* Whether to use user friendly register names. */
54 #ifndef TARGET_REG_NAMES_P
56 #define TARGET_REG_NAMES_P TRUE
58 #define TARGET_REG_NAMES_P FALSE
62 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
65 /* #lo(value) denotes the least significant 16 bits of the indicated. */
66 #define PPC_LO(v) ((v) & 0xffff)
68 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
69 #define PPC_HI(v) (((v) >> 16) & 0xffff)
71 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
72 the indicated value, compensating for #lo() being treated as a
74 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
76 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
77 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
79 /* #highera(value) denotes bits 32 through 47 of the indicated value,
80 compensating for #lo() being treated as a signed number. */
81 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
83 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
84 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
86 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
87 compensating for #lo being treated as a signed number. */
88 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
90 #define SEX16(val) (((val) ^ 0x8000) - 0x8000)
92 /* For the time being on ppc64, don't report overflow on @h and @ha
93 applied to constants. */
94 #define REPORT_OVERFLOW_HI 0
96 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
98 static void ppc_macro (char *, const struct powerpc_macro
*);
99 static void ppc_byte (int);
101 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
102 static void ppc_tc (int);
103 static void ppc_machine (int);
107 static void ppc_comm (int);
108 static void ppc_bb (int);
109 static void ppc_bc (int);
110 static void ppc_bf (int);
111 static void ppc_biei (int);
112 static void ppc_bs (int);
113 static void ppc_eb (int);
114 static void ppc_ec (int);
115 static void ppc_ef (int);
116 static void ppc_es (int);
117 static void ppc_csect (int);
118 static void ppc_dwsect (int);
119 static void ppc_change_csect (symbolS
*, offsetT
);
120 static void ppc_function (int);
121 static void ppc_extern (int);
122 static void ppc_lglobl (int);
123 static void ppc_ref (int);
124 static void ppc_section (int);
125 static void ppc_named_section (int);
126 static void ppc_stabx (int);
127 static void ppc_rename (int);
128 static void ppc_toc (int);
129 static void ppc_xcoff_cons (int);
130 static void ppc_vbyte (int);
134 static void ppc_elf_cons (int);
135 static void ppc_elf_rdata (int);
136 static void ppc_elf_lcomm (int);
137 static void ppc_elf_localentry (int);
138 static void ppc_elf_abiversion (int);
142 static void ppc_previous (int);
143 static void ppc_pdata (int);
144 static void ppc_ydata (int);
145 static void ppc_reldata (int);
146 static void ppc_rdata (int);
147 static void ppc_ualong (int);
148 static void ppc_znop (int);
149 static void ppc_pe_comm (int);
150 static void ppc_pe_section (int);
151 static void ppc_pe_function (int);
152 static void ppc_pe_tocd (int);
155 /* Generic assembler global variables which must be defined by all
159 /* This string holds the chars that always start a comment. If the
160 pre-processor is disabled, these aren't very useful. The macro
161 tc_comment_chars points to this. We use this, rather than the
162 usual comment_chars, so that we can switch for Solaris conventions. */
163 static const char ppc_solaris_comment_chars
[] = "#!";
164 static const char ppc_eabi_comment_chars
[] = "#";
166 #ifdef TARGET_SOLARIS_COMMENT
167 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
169 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
172 const char comment_chars
[] = "#";
175 /* Characters which start a comment at the beginning of a line. */
176 const char line_comment_chars
[] = "#";
178 /* Characters which may be used to separate multiple commands on a
180 const char line_separator_chars
[] = ";";
182 /* Characters which are used to indicate an exponent in a floating
184 const char EXP_CHARS
[] = "eE";
186 /* Characters which mean that a number is a floating point constant,
188 const char FLT_CHARS
[] = "dD";
190 /* Anything that can start an operand needs to be mentioned here,
191 to stop the input scrubber eating whitespace. */
192 const char ppc_symbol_chars
[] = "%[";
194 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
195 int ppc_cie_data_alignment
;
197 /* The dwarf2 minimum instruction length. */
198 int ppc_dwarf2_line_min_insn_length
;
200 /* More than this number of nops in an alignment op gets a branch
202 unsigned long nop_limit
= 4;
204 /* The type of processor we are assembling for. This is one or more
205 of the PPC_OPCODE flags defined in opcode/ppc.h. */
206 ppc_cpu_t ppc_cpu
= 0;
207 ppc_cpu_t sticky
= 0;
209 /* Value for ELF e_flags EF_PPC64_ABI. */
210 unsigned int ppc_abiversion
= 0;
212 /* Flags set on encountering toc relocs. */
214 has_large_toc_reloc
= 1,
215 has_small_toc_reloc
= 2
218 /* The target specific pseudo-ops which we support. */
220 const pseudo_typeS md_pseudo_table
[] =
222 /* Pseudo-ops which must be overridden. */
223 { "byte", ppc_byte
, 0 },
226 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
227 legitimately belong in the obj-*.c file. However, XCOFF is based
228 on COFF, and is only implemented for the RS/6000. We just use
229 obj-coff.c, and add what we need here. */
230 { "comm", ppc_comm
, 0 },
231 { "lcomm", ppc_comm
, 1 },
235 { "bi", ppc_biei
, 0 },
237 { "csect", ppc_csect
, 0 },
238 { "dwsect", ppc_dwsect
, 0 },
239 { "data", ppc_section
, 'd' },
243 { "ei", ppc_biei
, 1 },
245 { "extern", ppc_extern
, 0 },
246 { "function", ppc_function
, 0 },
247 { "lglobl", ppc_lglobl
, 0 },
248 { "ref", ppc_ref
, 0 },
249 { "rename", ppc_rename
, 0 },
250 { "section", ppc_named_section
, 0 },
251 { "stabx", ppc_stabx
, 0 },
252 { "text", ppc_section
, 't' },
253 { "toc", ppc_toc
, 0 },
254 { "long", ppc_xcoff_cons
, 2 },
255 { "llong", ppc_xcoff_cons
, 3 },
256 { "word", ppc_xcoff_cons
, 1 },
257 { "short", ppc_xcoff_cons
, 1 },
258 { "vbyte", ppc_vbyte
, 0 },
262 { "llong", ppc_elf_cons
, 8 },
263 { "quad", ppc_elf_cons
, 8 },
264 { "long", ppc_elf_cons
, 4 },
265 { "word", ppc_elf_cons
, 2 },
266 { "short", ppc_elf_cons
, 2 },
267 { "rdata", ppc_elf_rdata
, 0 },
268 { "rodata", ppc_elf_rdata
, 0 },
269 { "lcomm", ppc_elf_lcomm
, 0 },
270 { "localentry", ppc_elf_localentry
, 0 },
271 { "abiversion", ppc_elf_abiversion
, 0 },
275 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
276 { "previous", ppc_previous
, 0 },
277 { "pdata", ppc_pdata
, 0 },
278 { "ydata", ppc_ydata
, 0 },
279 { "reldata", ppc_reldata
, 0 },
280 { "rdata", ppc_rdata
, 0 },
281 { "ualong", ppc_ualong
, 0 },
282 { "znop", ppc_znop
, 0 },
283 { "comm", ppc_pe_comm
, 0 },
284 { "lcomm", ppc_pe_comm
, 1 },
285 { "section", ppc_pe_section
, 0 },
286 { "function", ppc_pe_function
,0 },
287 { "tocd", ppc_pe_tocd
, 0 },
290 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
292 { "machine", ppc_machine
, 0 },
299 /* Predefined register names if -mregnames (or default for Windows NT).
300 In general, there are lots of them, in an attempt to be compatible
301 with a number of other Windows NT assemblers. */
303 /* Structure to hold information about predefined registers. */
310 /* List of registers that are pre-defined:
312 Each general register has predefined names of the form:
313 1. r<reg_num> which has the value <reg_num>.
314 2. r.<reg_num> which has the value <reg_num>.
316 Each floating point register has predefined names of the form:
317 1. f<reg_num> which has the value <reg_num>.
318 2. f.<reg_num> which has the value <reg_num>.
320 Each vector unit register has predefined names of the form:
321 1. v<reg_num> which has the value <reg_num>.
322 2. v.<reg_num> which has the value <reg_num>.
324 Each condition register has predefined names of the form:
325 1. cr<reg_num> which has the value <reg_num>.
326 2. cr.<reg_num> which has the value <reg_num>.
328 There are individual registers as well:
329 sp or r.sp has the value 1
330 rtoc or r.toc has the value 2
331 fpscr has the value 0
337 dsisr has the value 18
339 sdr1 has the value 25
340 srr0 has the value 26
341 srr1 has the value 27
343 The table is sorted. Suitable for searching by a binary search. */
345 static const struct pd_reg pre_defined_registers
[] =
347 { "cr.0", 0 }, /* Condition Registers */
367 { "dar", 19 }, /* Data Access Register */
368 { "dec", 22 }, /* Decrementer */
369 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
371 { "f.0", 0 }, /* Floating point registers */
398 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
464 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
505 /* Quantization registers used with pair single instructions. */
523 { "lr", 8 }, /* Link Register */
527 { "r.0", 0 }, /* General Purpose Registers */
560 { "r.sp", 1 }, /* Stack Pointer */
562 { "r.toc", 2 }, /* Pointer to the table of contents */
564 { "r0", 0 }, /* More general purpose registers */
597 { "rtoc", 2 }, /* Table of contents */
599 { "sdr1", 25 }, /* Storage Description Register 1 */
603 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
604 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
606 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
672 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
806 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
808 /* Given NAME, find the register number associated with that name, return
809 the integer value associated with the given name or -1 on failure. */
812 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
814 int middle
, low
, high
;
822 middle
= (low
+ high
) / 2;
823 cmp
= strcasecmp (name
, regs
[middle
].name
);
829 return regs
[middle
].value
;
837 * Summary of register_name.
839 * in: Input_line_pointer points to 1st char of operand.
841 * out: A expressionS.
842 * The operand may have been a register: in this case, X_op == O_register,
843 * X_add_number is set to the register number, and truth is returned.
844 * Input_line_pointer->(next non-blank) char after operand, or is in its
849 register_name (expressionS
*expressionP
)
856 /* Find the spelling of the operand. */
857 start
= name
= input_line_pointer
;
858 if (name
[0] == '%' && ISALPHA (name
[1]))
859 name
= ++input_line_pointer
;
861 else if (!reg_names_p
|| !ISALPHA (name
[0]))
864 c
= get_symbol_end ();
865 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
867 /* Put back the delimiting char. */
868 *input_line_pointer
= c
;
870 /* Look to see if it's in the register table. */
873 expressionP
->X_op
= O_register
;
874 expressionP
->X_add_number
= reg_number
;
876 /* Make the rest nice. */
877 expressionP
->X_add_symbol
= NULL
;
878 expressionP
->X_op_symbol
= NULL
;
882 /* Reset the line as if we had not done anything. */
883 input_line_pointer
= start
;
887 /* This function is called for each symbol seen in an expression. It
888 handles the special parsing which PowerPC assemblers are supposed
889 to use for condition codes. */
891 /* Whether to do the special parsing. */
892 static bfd_boolean cr_operand
;
894 /* Names to recognize in a condition code. This table is sorted. */
895 static const struct pd_reg cr_names
[] =
912 /* Parsing function. This returns non-zero if it recognized an
916 ppc_parse_name (const char *name
, expressionS
*exp
)
925 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
930 exp
->X_op
= O_constant
;
931 exp
->X_add_number
= val
;
936 /* Local variables. */
938 /* Whether to target xcoff64/elf64. */
939 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
941 /* Opcode hash table. */
942 static struct hash_control
*ppc_hash
;
944 /* Macro hash table. */
945 static struct hash_control
*ppc_macro_hash
;
948 /* What type of shared library support to use. */
949 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
951 /* Flags to set in the elf header. */
952 static flagword ppc_flags
= 0;
954 /* Whether this is Solaris or not. */
955 #ifdef TARGET_SOLARIS_COMMENT
956 #define SOLARIS_P TRUE
958 #define SOLARIS_P FALSE
961 static bfd_boolean msolaris
= SOLARIS_P
;
966 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
967 using a bunch of different sections. These assembler sections,
968 however, are all encompassed within the .text or .data sections of
969 the final output file. We handle this by using different
970 subsegments within these main segments. */
972 /* Next subsegment to allocate within the .text segment. */
973 static subsegT ppc_text_subsegment
= 2;
975 /* Linked list of csects in the text section. */
976 static symbolS
*ppc_text_csects
;
978 /* Next subsegment to allocate within the .data segment. */
979 static subsegT ppc_data_subsegment
= 2;
981 /* Linked list of csects in the data section. */
982 static symbolS
*ppc_data_csects
;
984 /* The current csect. */
985 static symbolS
*ppc_current_csect
;
987 /* The RS/6000 assembler uses a TOC which holds addresses of functions
988 and variables. Symbols are put in the TOC with the .tc pseudo-op.
989 A special relocation is used when accessing TOC entries. We handle
990 the TOC as a subsegment within the .data segment. We set it up if
991 we see a .toc pseudo-op, and save the csect symbol here. */
992 static symbolS
*ppc_toc_csect
;
994 /* The first frag in the TOC subsegment. */
995 static fragS
*ppc_toc_frag
;
997 /* The first frag in the first subsegment after the TOC in the .data
998 segment. NULL if there are no subsegments after the TOC. */
999 static fragS
*ppc_after_toc_frag
;
1001 /* The current static block. */
1002 static symbolS
*ppc_current_block
;
1004 /* The COFF debugging section; set by md_begin. This is not the
1005 .debug section, but is instead the secret BFD section which will
1006 cause BFD to set the section number of a symbol to N_DEBUG. */
1007 static asection
*ppc_coff_debug_section
;
1009 /* Structure to set the length field of the dwarf sections. */
1010 struct dw_subsection
{
1011 /* Subsections are simply linked. */
1012 struct dw_subsection
*link
;
1014 /* The subsection number. */
1017 /* Expression to compute the length of the section. */
1018 expressionS end_exp
;
1021 static struct dw_section
{
1022 /* Corresponding section. */
1025 /* Simply linked list of subsections with a label. */
1026 struct dw_subsection
*list_subseg
;
1028 /* The anonymous subsection. */
1029 struct dw_subsection
*anon_subseg
;
1030 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1031 #endif /* OBJ_XCOFF */
1035 /* Various sections that we need for PE coff support. */
1036 static segT ydata_section
;
1037 static segT pdata_section
;
1038 static segT reldata_section
;
1039 static segT rdata_section
;
1040 static segT tocdata_section
;
1042 /* The current section and the previous section. See ppc_previous. */
1043 static segT ppc_previous_section
;
1044 static segT ppc_current_section
;
1049 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1050 #define PPC_APUINFO_ISEL 0x40
1051 #define PPC_APUINFO_PMR 0x41
1052 #define PPC_APUINFO_RFMCI 0x42
1053 #define PPC_APUINFO_CACHELCK 0x43
1054 #define PPC_APUINFO_SPE 0x100
1055 #define PPC_APUINFO_EFS 0x101
1056 #define PPC_APUINFO_BRLOCK 0x102
1057 #define PPC_APUINFO_VLE 0x104
1060 * We keep a list of APUinfo
1062 unsigned long *ppc_apuinfo_list
;
1063 unsigned int ppc_apuinfo_num
;
1064 unsigned int ppc_apuinfo_num_alloc
;
1065 #endif /* OBJ_ELF */
1068 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1070 const char *const md_shortopts
= "um:";
1072 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1073 const struct option md_longopts
[] = {
1074 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1075 {NULL
, no_argument
, NULL
, 0}
1077 const size_t md_longopts_size
= sizeof (md_longopts
);
1080 md_parse_option (int c
, char *arg
)
1087 /* -u means that any undefined symbols should be treated as
1088 external, which is the default for gas anyhow. */
1093 /* Solaris as takes -le (presumably for little endian). For completeness
1094 sake, recognize -be also. */
1095 if (strcmp (arg
, "e") == 0)
1097 target_big_endian
= 0;
1098 set_target_endian
= 1;
1099 if (ppc_cpu
& PPC_OPCODE_VLE
)
1100 as_bad (_("the use of -mvle requires big endian."));
1108 if (strcmp (arg
, "e") == 0)
1110 target_big_endian
= 1;
1111 set_target_endian
= 1;
1119 /* Recognize -K PIC. */
1120 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1123 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1131 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1133 if (strcmp (arg
, "64") == 0)
1137 if (ppc_cpu
& PPC_OPCODE_VLE
)
1138 as_bad (_("the use of -mvle requires -a32."));
1140 as_fatal (_("%s unsupported"), "-a64");
1143 else if (strcmp (arg
, "32") == 0)
1150 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1154 if (strcmp (arg
, "vle") == 0)
1156 if (set_target_endian
&& target_big_endian
== 0)
1157 as_bad (_("the use of -mvle requires big endian."));
1159 as_bad (_("the use of -mvle requires -a32."));
1163 else if (strcmp (arg
, "regnames") == 0)
1166 else if (strcmp (arg
, "no-regnames") == 0)
1167 reg_names_p
= FALSE
;
1170 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1171 that require relocation. */
1172 else if (strcmp (arg
, "relocatable") == 0)
1174 shlib
= SHLIB_MRELOCATABLE
;
1175 ppc_flags
|= EF_PPC_RELOCATABLE
;
1178 else if (strcmp (arg
, "relocatable-lib") == 0)
1180 shlib
= SHLIB_MRELOCATABLE
;
1181 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1184 /* -memb, set embedded bit. */
1185 else if (strcmp (arg
, "emb") == 0)
1186 ppc_flags
|= EF_PPC_EMB
;
1188 /* -mlittle/-mbig set the endianness. */
1189 else if (strcmp (arg
, "little") == 0
1190 || strcmp (arg
, "little-endian") == 0)
1192 target_big_endian
= 0;
1193 set_target_endian
= 1;
1194 if (ppc_cpu
& PPC_OPCODE_VLE
)
1195 as_bad (_("the use of -mvle requires big endian."));
1198 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1200 target_big_endian
= 1;
1201 set_target_endian
= 1;
1204 else if (strcmp (arg
, "solaris") == 0)
1207 ppc_comment_chars
= ppc_solaris_comment_chars
;
1210 else if (strcmp (arg
, "no-solaris") == 0)
1213 ppc_comment_chars
= ppc_eabi_comment_chars
;
1218 as_bad (_("invalid switch -m%s"), arg
);
1224 /* -V: SVR4 argument to print version ID. */
1226 print_version_id ();
1229 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1230 should be emitted or not. FIXME: Not implemented. */
1234 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1235 rather than .stabs.excl, which is ignored by the linker.
1236 FIXME: Not implemented. */
1247 nop_limit
= strtoul (optarg
, &end
, 0);
1249 as_bad (_("--nops needs a numeric argument"));
1261 md_show_usage (FILE *stream
)
1263 fprintf (stream
, _("\
1265 -a32 generate ELF32/XCOFF32\n\
1266 -a64 generate ELF64/XCOFF64\n\
1268 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1269 -mpwr generate code for POWER (RIOS1)\n\
1270 -m601 generate code for PowerPC 601\n\
1271 -mppc, -mppc32, -m603, -m604\n\
1272 generate code for PowerPC 603/604\n\
1273 -m403 generate code for PowerPC 403\n\
1274 -m405 generate code for PowerPC 405\n\
1275 -m440 generate code for PowerPC 440\n\
1276 -m464 generate code for PowerPC 464\n\
1277 -m476 generate code for PowerPC 476\n\
1278 -m7400, -m7410, -m7450, -m7455\n\
1279 generate code for PowerPC 7400/7410/7450/7455\n\
1280 -m750cl generate code for PowerPC 750cl\n"));
1281 fprintf (stream
, _("\
1282 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1283 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1284 -mbooke generate code for 32-bit PowerPC BookE\n\
1285 -ma2 generate code for A2 architecture\n\
1286 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1287 -mpower5, -mpwr5, -mpwr5x\n\
1288 generate code for Power5 architecture\n\
1289 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1290 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1291 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1292 -mcell generate code for Cell Broadband Engine architecture\n\
1293 -mcom generate code Power/PowerPC common instructions\n\
1294 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1295 fprintf (stream
, _("\
1296 -maltivec generate code for AltiVec\n\
1297 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1298 -mhtm generate code for Hardware Transactional Memory\n\
1299 -me300 generate code for PowerPC e300 family\n\
1300 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1301 -me500mc, generate code for Freescale e500mc core complex\n\
1302 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1303 -me5500, generate code for Freescale e5500 core complex\n\
1304 -me6500, generate code for Freescale e6500 core complex\n\
1305 -mspe generate code for Motorola SPE instructions\n\
1306 -mvle generate code for Freescale VLE instructions\n\
1307 -mtitan generate code for AppliedMicro Titan core complex\n\
1308 -mregnames Allow symbolic names for registers\n\
1309 -mno-regnames Do not allow symbolic names for registers\n"));
1311 fprintf (stream
, _("\
1312 -mrelocatable support for GCC's -mrelocatble option\n\
1313 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1314 -memb set PPC_EMB bit in ELF flags\n\
1315 -mlittle, -mlittle-endian, -le\n\
1316 generate code for a little endian machine\n\
1317 -mbig, -mbig-endian, -be\n\
1318 generate code for a big endian machine\n\
1319 -msolaris generate code for Solaris\n\
1320 -mno-solaris do not generate code for Solaris\n\
1321 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1322 -V print assembler version number\n\
1323 -Qy, -Qn ignored\n"));
1325 fprintf (stream
, _("\
1326 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1329 /* Set ppc_cpu if it is not already set. */
1334 const char *default_os
= TARGET_OS
;
1335 const char *default_cpu
= TARGET_CPU
;
1337 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1340 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1341 else if (strncmp (default_os
, "aix", 3) == 0
1342 && default_os
[3] >= '4' && default_os
[3] <= '9')
1343 ppc_cpu
|= PPC_OPCODE_COMMON
;
1344 else if (strncmp (default_os
, "aix3", 4) == 0)
1345 ppc_cpu
|= PPC_OPCODE_POWER
;
1346 else if (strcmp (default_cpu
, "rs6000") == 0)
1347 ppc_cpu
|= PPC_OPCODE_POWER
;
1348 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1349 ppc_cpu
|= PPC_OPCODE_PPC
;
1351 as_fatal (_("unknown default cpu = %s, os = %s"),
1352 default_cpu
, default_os
);
1356 /* Figure out the BFD architecture to use. This function and ppc_mach
1357 are called well before md_begin, when the output file is opened. */
1359 enum bfd_architecture
1362 const char *default_cpu
= TARGET_CPU
;
1365 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1366 return bfd_arch_powerpc
;
1367 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1368 return bfd_arch_powerpc
;
1369 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1370 return bfd_arch_rs6000
;
1371 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1373 if (strcmp (default_cpu
, "rs6000") == 0)
1374 return bfd_arch_rs6000
;
1375 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1376 return bfd_arch_powerpc
;
1379 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1380 return bfd_arch_unknown
;
1387 return bfd_mach_ppc64
;
1388 else if (ppc_arch () == bfd_arch_rs6000
)
1389 return bfd_mach_rs6k
;
1390 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1391 return bfd_mach_ppc_titan
;
1392 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1393 return bfd_mach_ppc_vle
;
1395 return bfd_mach_ppc
;
1399 ppc_target_format (void)
1403 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1405 return "xcoff-powermac";
1408 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1410 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1416 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1417 # elif defined (TE_VXWORKS)
1418 return "elf32-powerpc-vxworks";
1420 return (target_big_endian
1421 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1422 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1427 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1428 Return TRUE if there's a problem, otherwise FALSE. */
1431 insn_validate (const struct powerpc_opcode
*op
)
1433 const unsigned char *o
;
1434 unsigned long omask
= op
->mask
;
1436 /* The mask had better not trim off opcode bits. */
1437 if ((op
->opcode
& omask
) != op
->opcode
)
1439 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1443 /* The operands must not overlap the opcode or each other. */
1444 for (o
= op
->operands
; *o
; ++o
)
1446 if (*o
>= num_powerpc_operands
)
1448 as_bad (_("operand index error for %s"), op
->name
);
1453 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1454 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1458 if (operand
->shift
>= 0)
1459 mask
= operand
->bitm
<< operand
->shift
;
1461 mask
= operand
->bitm
>> -operand
->shift
;
1464 as_bad (_("operand %d overlap in %s"),
1465 (int) (o
- op
->operands
), op
->name
);
1475 /* Insert opcodes and macros into hash tables. Called at startup and
1476 for .machine pseudo. */
1479 ppc_setup_opcodes (void)
1481 const struct powerpc_opcode
*op
;
1482 const struct powerpc_opcode
*op_end
;
1483 const struct powerpc_macro
*macro
;
1484 const struct powerpc_macro
*macro_end
;
1485 bfd_boolean bad_insn
= FALSE
;
1487 if (ppc_hash
!= NULL
)
1488 hash_die (ppc_hash
);
1489 if (ppc_macro_hash
!= NULL
)
1490 hash_die (ppc_macro_hash
);
1492 /* Insert the opcodes into a hash table. */
1493 ppc_hash
= hash_new ();
1495 if (ENABLE_CHECKING
)
1499 /* An index into powerpc_operands is stored in struct fix
1500 fx_pcrel_adjust which is 8 bits wide. */
1501 gas_assert (num_powerpc_operands
< 256);
1503 /* Check operand masks. Code here and in the disassembler assumes
1504 all the 1's in the mask are contiguous. */
1505 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1507 unsigned long mask
= powerpc_operands
[i
].bitm
;
1508 unsigned long right_bit
;
1511 right_bit
= mask
& -mask
;
1513 right_bit
= mask
& -mask
;
1514 if (mask
!= right_bit
)
1516 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1519 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1520 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1521 sizeof (powerpc_operands
[0])) == 0)
1523 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1530 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1531 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1533 if (ENABLE_CHECKING
)
1535 if (op
!= powerpc_opcodes
)
1537 int old_opcode
= PPC_OP (op
[-1].opcode
);
1538 int new_opcode
= PPC_OP (op
[0].opcode
);
1540 #ifdef PRINT_OPCODE_TABLE
1541 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1542 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1543 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1544 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1547 /* The major opcodes had better be sorted. Code in the
1548 disassembler assumes the insns are sorted according to
1550 if (new_opcode
< old_opcode
)
1552 as_bad (_("major opcode is not sorted for %s"),
1557 bad_insn
|= insn_validate (op
);
1560 if ((ppc_cpu
& op
->flags
) != 0
1561 && !(ppc_cpu
& op
->deprecated
))
1565 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1568 as_bad (_("duplicate instruction %s"),
1575 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1576 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1577 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1579 op_end
= vle_opcodes
+ vle_num_opcodes
;
1580 for (op
= vle_opcodes
; op
< op_end
; op
++)
1582 if (ENABLE_CHECKING
)
1584 if (op
!= vle_opcodes
)
1586 unsigned old_seg
, new_seg
;
1588 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1589 old_seg
= VLE_OP_TO_SEG (old_seg
);
1590 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1591 new_seg
= VLE_OP_TO_SEG (new_seg
);
1593 #ifdef PRINT_OPCODE_TABLE
1594 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1595 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1596 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1597 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1599 /* The major opcodes had better be sorted. Code in the
1600 disassembler assumes the insns are sorted according to
1602 if (new_seg
< old_seg
)
1604 as_bad (_("major opcode is not sorted for %s"),
1610 bad_insn
|= insn_validate (op
);
1613 if ((ppc_cpu
& op
->flags
) != 0
1614 && !(ppc_cpu
& op
->deprecated
))
1618 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1621 as_bad (_("duplicate instruction %s"),
1628 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1629 for (op
= vle_opcodes
; op
< op_end
; op
++)
1630 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1632 /* Insert the macros into a hash table. */
1633 ppc_macro_hash
= hash_new ();
1635 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1636 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1638 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1642 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1643 if (retval
!= (const char *) NULL
)
1645 as_bad (_("duplicate macro %s"), macro
->name
);
1655 /* This function is called when the assembler starts up. It is called
1656 after the options have been parsed and the output file has been
1664 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1665 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1668 /* Set the ELF flags if desired. */
1669 if (ppc_flags
&& !msolaris
)
1670 bfd_set_private_flags (stdoutput
, ppc_flags
);
1673 ppc_setup_opcodes ();
1675 /* Tell the main code what the endianness is if it is not overridden
1677 if (!set_target_endian
)
1679 set_target_endian
= 1;
1680 target_big_endian
= PPC_BIG_ENDIAN
;
1684 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1686 /* Create dummy symbols to serve as initial csects. This forces the
1687 text csects to precede the data csects. These symbols will not
1689 ppc_text_csects
= symbol_make ("dummy\001");
1690 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1691 ppc_data_csects
= symbol_make ("dummy\001");
1692 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1697 ppc_current_section
= text_section
;
1698 ppc_previous_section
= 0;
1707 if (ppc_apuinfo_list
== NULL
)
1710 /* Ok, so write the section info out. We have this layout:
1714 0 8 length of "APUinfo\0"
1715 4 (n*4) number of APU's (4 bytes each)
1718 20 APU#1 first APU's info
1719 24 APU#2 second APU's info
1724 asection
*seg
= now_seg
;
1725 subsegT subseg
= now_subseg
;
1726 asection
*apuinfo_secp
= (asection
*) NULL
;
1729 /* Create the .PPC.EMB.apuinfo section. */
1730 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1731 bfd_set_section_flags (stdoutput
,
1733 SEC_HAS_CONTENTS
| SEC_READONLY
);
1736 md_number_to_chars (p
, (valueT
) 8, 4);
1739 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1742 md_number_to_chars (p
, (valueT
) 2, 4);
1745 strcpy (p
, "APUinfo");
1747 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1750 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1753 frag_align (2, 0, 0);
1755 /* We probably can't restore the current segment, for there likely
1758 subseg_set (seg
, subseg
);
1763 /* Insert an operand value into an instruction. */
1765 static unsigned long
1766 ppc_insert_operand (unsigned long insn
,
1767 const struct powerpc_operand
*operand
,
1773 long min
, max
, right
;
1775 max
= operand
->bitm
;
1779 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1781 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1782 max
= (max
>> 1) & -right
;
1783 min
= ~max
& -right
;
1786 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1789 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1798 /* Some people write constants with the sign extension done by
1799 hand but only up to 32 bits. This shouldn't really be valid,
1800 but, to permit this code to assemble on a 64-bit host, we
1801 sign extend the 32-bit value to 64 bits if so doing makes the
1804 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1805 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1806 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1807 val
= val
- 0x80000000 - 0x80000000;
1809 /* Similarly, people write expressions like ~(1<<15), and expect
1810 this to be OK for a 32-bit unsigned value. */
1812 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1813 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1814 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1815 val
= val
+ 0x80000000 + 0x80000000;
1819 || (val
& (right
- 1)) != 0)
1820 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1823 if (operand
->insert
)
1828 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1829 if (errmsg
!= (const char *) NULL
)
1830 as_bad_where (file
, line
, "%s", errmsg
);
1832 else if (operand
->shift
>= 0)
1833 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1835 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1842 /* Parse @got, etc. and return the desired relocation. */
1843 static bfd_reloc_code_real_type
1844 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1848 unsigned int length
: 8;
1849 unsigned int valid32
: 1;
1850 unsigned int valid64
: 1;
1859 const struct map_bfd
*ptr
;
1861 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1862 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1863 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1865 static const struct map_bfd mapping
[] = {
1866 MAP ("l", BFD_RELOC_LO16
),
1867 MAP ("h", BFD_RELOC_HI16
),
1868 MAP ("ha", BFD_RELOC_HI16_S
),
1869 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1870 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1871 MAP ("got", BFD_RELOC_16_GOTOFF
),
1872 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1873 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1874 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1875 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1876 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1877 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1878 MAP ("copy", BFD_RELOC_PPC_COPY
),
1879 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1880 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1881 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1882 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1883 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1884 MAP ("tls", BFD_RELOC_PPC_TLS
),
1885 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1886 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1887 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1888 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1889 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1890 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1891 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1892 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1893 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1894 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1895 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1896 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1897 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1898 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1899 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1900 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1901 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1902 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1903 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1904 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1905 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1906 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1907 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1908 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1909 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1910 MAP32 ("fixup", BFD_RELOC_CTOR
),
1911 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1912 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1913 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1914 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1915 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1916 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1917 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1918 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1919 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1920 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1921 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1922 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1923 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1924 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1925 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1926 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1927 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1928 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1929 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1930 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1931 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1932 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1933 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1934 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1935 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1936 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1937 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1938 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1939 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1940 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1941 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1942 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1943 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1944 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1945 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1946 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1947 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1948 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1949 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1950 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1951 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1952 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1953 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1954 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1955 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1956 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1957 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1958 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1959 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1960 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1961 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1965 return BFD_RELOC_UNUSED
;
1967 for (ch
= *str
, str2
= ident
;
1968 (str2
< ident
+ sizeof (ident
) - 1
1969 && (ISALNUM (ch
) || ch
== '@'));
1972 *str2
++ = TOLOWER (ch
);
1979 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1980 if (ch
== ptr
->string
[0]
1981 && len
== ptr
->length
1982 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1983 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1985 int reloc
= ptr
->reloc
;
1987 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1991 case BFD_RELOC_16_GOTOFF
:
1992 case BFD_RELOC_LO16_GOTOFF
:
1993 case BFD_RELOC_HI16_GOTOFF
:
1994 case BFD_RELOC_HI16_S_GOTOFF
:
1995 as_warn (_("identifier+constant@got means "
1996 "identifier@got+constant"));
1999 case BFD_RELOC_PPC_GOT_TLSGD16
:
2000 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2001 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2002 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2003 case BFD_RELOC_PPC_GOT_TLSLD16
:
2004 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2005 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2006 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2007 case BFD_RELOC_PPC_GOT_DTPREL16
:
2008 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2009 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2010 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2011 case BFD_RELOC_PPC_GOT_TPREL16
:
2012 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2013 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2014 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2015 as_bad (_("symbol+offset not supported for got tls"));
2020 /* Now check for identifier@suffix+constant. */
2021 if (*str
== '-' || *str
== '+')
2023 char *orig_line
= input_line_pointer
;
2024 expressionS new_exp
;
2026 input_line_pointer
= str
;
2027 expression (&new_exp
);
2028 if (new_exp
.X_op
== O_constant
)
2030 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2031 str
= input_line_pointer
;
2034 if (&input_line_pointer
!= str_p
)
2035 input_line_pointer
= orig_line
;
2039 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2040 && exp_p
->X_op
== O_symbol
2041 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2043 /* Change the symbol so that the dummy .TOC. symbol can be
2044 omitted from the object file. */
2045 exp_p
->X_add_symbol
= &abs_symbol
;
2048 return (bfd_reloc_code_real_type
) reloc
;
2051 return BFD_RELOC_UNUSED
;
2054 /* Like normal .long/.short/.word, except support @got, etc.
2055 Clobbers input_line_pointer, checks end-of-line. */
2057 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2060 bfd_reloc_code_real_type reloc
;
2062 if (is_it_end_of_statement ())
2064 demand_empty_rest_of_line ();
2071 if (*input_line_pointer
== '@'
2072 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2073 &exp
)) != BFD_RELOC_UNUSED
)
2075 reloc_howto_type
*reloc_howto
;
2078 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2079 size
= bfd_get_reloc_size (reloc_howto
);
2083 as_bad (_("%s relocations do not fit in %d bytes\n"),
2084 reloc_howto
->name
, nbytes
);
2091 p
= frag_more (nbytes
);
2092 memset (p
, 0, nbytes
);
2094 if (target_big_endian
)
2095 offset
= nbytes
- size
;
2096 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2101 emit_expr (&exp
, (unsigned int) nbytes
);
2103 while (*input_line_pointer
++ == ',');
2105 /* Put terminator back into stream. */
2106 input_line_pointer
--;
2107 demand_empty_rest_of_line ();
2110 /* Solaris pseduo op to change to the .rodata section. */
2112 ppc_elf_rdata (int xxx
)
2114 char *save_line
= input_line_pointer
;
2115 static char section
[] = ".rodata\n";
2117 /* Just pretend this is .section .rodata */
2118 input_line_pointer
= section
;
2119 obj_elf_section (xxx
);
2121 input_line_pointer
= save_line
;
2124 /* Pseudo op to make file scope bss items. */
2126 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2139 name
= input_line_pointer
;
2140 c
= get_symbol_end ();
2142 /* just after name is now '\0'. */
2143 p
= input_line_pointer
;
2146 if (*input_line_pointer
!= ',')
2148 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2149 ignore_rest_of_line ();
2153 input_line_pointer
++; /* skip ',' */
2154 if ((size
= get_absolute_expression ()) < 0)
2156 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2157 ignore_rest_of_line ();
2161 /* The third argument to .lcomm is the alignment. */
2162 if (*input_line_pointer
!= ',')
2166 ++input_line_pointer
;
2167 align
= get_absolute_expression ();
2170 as_warn (_("ignoring bad alignment"));
2176 symbolP
= symbol_find_or_make (name
);
2179 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2181 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2182 S_GET_NAME (symbolP
));
2183 ignore_rest_of_line ();
2187 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2189 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2190 S_GET_NAME (symbolP
),
2191 (long) S_GET_VALUE (symbolP
),
2194 ignore_rest_of_line ();
2200 old_subsec
= now_subseg
;
2203 /* Convert to a power of 2 alignment. */
2204 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2207 as_bad (_("common alignment not a power of 2"));
2208 ignore_rest_of_line ();
2215 record_alignment (bss_section
, align2
);
2216 subseg_set (bss_section
, 1);
2218 frag_align (align2
, 0, 0);
2219 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2220 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2221 symbol_set_frag (symbolP
, frag_now
);
2222 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2225 S_SET_SIZE (symbolP
, size
);
2226 S_SET_SEGMENT (symbolP
, bss_section
);
2227 subseg_set (old_sec
, old_subsec
);
2228 demand_empty_rest_of_line ();
2231 /* Pseudo op to set symbol local entry point. */
2233 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED
)
2235 char *name
= input_line_pointer
;
2236 char c
= get_symbol_end ();
2241 elf_symbol_type
*elfsym
;
2243 p
= input_line_pointer
;
2246 if (*input_line_pointer
!= ',')
2249 as_bad (_("expected comma after name `%s' in .localentry directive"),
2252 ignore_rest_of_line ();
2255 input_line_pointer
++;
2257 if (exp
.X_op
== O_absent
)
2259 as_bad (_("missing expression in .localentry directive"));
2260 exp
.X_op
= O_constant
;
2261 exp
.X_add_number
= 0;
2264 sym
= symbol_find_or_make (name
);
2267 if (resolve_expression (&exp
)
2268 && exp
.X_op
== O_constant
)
2270 unsigned char encoded
= PPC64_SET_LOCAL_ENTRY_OFFSET (exp
.X_add_number
);
2272 if (exp
.X_add_number
!= (offsetT
) PPC64_LOCAL_ENTRY_OFFSET (encoded
))
2273 as_bad (_(".localentry expression for `%s' "
2274 "is not a valid power of 2"), S_GET_NAME (sym
));
2277 bfdsym
= symbol_get_bfdsym (sym
);
2278 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
2279 gas_assert (elfsym
);
2280 elfsym
->internal_elf_sym
.st_other
&= ~STO_PPC64_LOCAL_MASK
;
2281 elfsym
->internal_elf_sym
.st_other
|= encoded
;
2282 if (ppc_abiversion
== 0)
2287 as_bad (_(".localentry expression for `%s' "
2288 "does not evaluate to a constant"), S_GET_NAME (sym
));
2290 demand_empty_rest_of_line ();
2293 /* Pseudo op to set ABI version. */
2295 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2300 if (exp
.X_op
== O_absent
)
2302 as_bad (_("missing expression in .abiversion directive"));
2303 exp
.X_op
= O_constant
;
2304 exp
.X_add_number
= 0;
2307 if (resolve_expression (&exp
)
2308 && exp
.X_op
== O_constant
)
2309 ppc_abiversion
= exp
.X_add_number
;
2311 as_bad (_(".abiversion expression does not evaluate to a constant"));
2312 demand_empty_rest_of_line ();
2315 /* Set ABI version in output file. */
2319 if (ppc_obj64
&& ppc_abiversion
!= 0)
2321 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2322 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2326 /* Validate any relocations emitted for -mrelocatable, possibly adding
2327 fixups for word relocations in writable segments, so we can adjust
2330 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2332 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2341 case SHLIB_MRELOCATABLE
:
2342 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2343 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2344 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2345 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2346 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2347 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2348 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2349 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2350 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2351 && (seg
->flags
& SEC_LOAD
) != 0
2352 && strcmp (segment_name (seg
), ".got2") != 0
2353 && strcmp (segment_name (seg
), ".dtors") != 0
2354 && strcmp (segment_name (seg
), ".ctors") != 0
2355 && strcmp (segment_name (seg
), ".fixup") != 0
2356 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2357 && strcmp (segment_name (seg
), ".eh_frame") != 0
2358 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2360 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2361 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2363 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2364 _("relocation cannot be done when using -mrelocatable"));
2371 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2372 function descriptor sym if the corresponding code sym is used. */
2375 ppc_frob_file_before_adjust (void)
2383 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2390 name
= S_GET_NAME (symp
);
2394 if (! S_IS_WEAK (symp
)
2395 || S_IS_DEFINED (symp
))
2398 len
= strlen (name
) + 1;
2399 dotname
= xmalloc (len
+ 1);
2401 memcpy (dotname
+ 1, name
, len
);
2402 dotsym
= symbol_find_noref (dotname
, 1);
2404 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2405 || symbol_used_in_reloc_p (dotsym
)))
2406 symbol_mark_used (symp
);
2410 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2412 && toc_reloc_types
!= has_large_toc_reloc
2413 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2414 as_warn (_("TOC section size exceeds 64k"));
2417 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2418 emitted. Other uses of .TOC. will cause the symbol to be marked
2419 with BSF_KEEP in md_apply_fix. */
2422 ppc_elf_adjust_symtab (void)
2427 symp
= symbol_find (".TOC.");
2430 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2431 if ((bsym
->flags
& BSF_KEEP
) == 0)
2432 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2436 #endif /* OBJ_ELF */
2441 * Summary of parse_toc_entry.
2443 * in: Input_line_pointer points to the '[' in one of:
2445 * [toc] [tocv] [toc32] [toc64]
2447 * Anything else is an error of one kind or another.
2450 * return value: success or failure
2451 * toc_kind: kind of toc reference
2452 * input_line_pointer:
2453 * success: first char after the ']'
2454 * failure: unchanged
2458 * [toc] - rv == success, toc_kind = default_toc
2459 * [tocv] - rv == success, toc_kind = data_in_toc
2460 * [toc32] - rv == success, toc_kind = must_be_32
2461 * [toc64] - rv == success, toc_kind = must_be_64
2465 enum toc_size_qualifier
2467 default_toc
, /* The toc cell constructed should be the system default size */
2468 data_in_toc
, /* This is a direct reference to a toc cell */
2469 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2470 must_be_64
/* The toc cell constructed must be 64 bits wide */
2474 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2479 enum toc_size_qualifier t
;
2481 /* Save the input_line_pointer. */
2482 start
= input_line_pointer
;
2484 /* Skip over the '[' , and whitespace. */
2485 ++input_line_pointer
;
2488 /* Find the spelling of the operand. */
2489 toc_spec
= input_line_pointer
;
2490 c
= get_symbol_end ();
2492 if (strcmp (toc_spec
, "toc") == 0)
2496 else if (strcmp (toc_spec
, "tocv") == 0)
2500 else if (strcmp (toc_spec
, "toc32") == 0)
2504 else if (strcmp (toc_spec
, "toc64") == 0)
2510 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2511 *input_line_pointer
= c
;
2512 input_line_pointer
= start
;
2516 /* Now find the ']'. */
2517 *input_line_pointer
= c
;
2519 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2520 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2524 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2525 input_line_pointer
= start
;
2534 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2535 /* See whether a symbol is in the TOC section. */
2538 ppc_is_toc_sym (symbolS
*sym
)
2541 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2542 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2545 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2547 return strcmp (sname
, ".toc") == 0;
2549 return strcmp (sname
, ".got") == 0;
2552 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2556 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2558 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2562 /* Check we don't already exist. */
2563 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2564 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2567 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2569 if (ppc_apuinfo_num_alloc
== 0)
2571 ppc_apuinfo_num_alloc
= 4;
2572 ppc_apuinfo_list
= (unsigned long *)
2573 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2577 ppc_apuinfo_num_alloc
+= 4;
2578 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2579 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2582 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2588 /* We need to keep a list of fixups. We can't simply generate them as
2589 we go, because that would require us to first create the frag, and
2590 that would screw up references to ``.''. */
2596 bfd_reloc_code_real_type reloc
;
2599 #define MAX_INSN_FIXUPS (5)
2602 #define E_OR2I_INSN 0x7000C000
2603 #define E_AND2I_DOT_INSN 0x7000C800
2604 #define E_OR2IS_INSN 0x7000D000
2605 #define E_LIS_INSN 0x7000E000
2606 #define E_AND2IS_DOT_INSN 0x7000E800
2609 #define E_ADD2I_DOT_INSN 0x70008800
2610 #define E_ADD2IS_INSN 0x70009000
2611 #define E_CMP16I_INSN 0x70009800
2612 #define E_MULL2I_INSN 0x7000A000
2613 #define E_CMPL16I_INSN 0x7000A800
2614 #define E_CMPH16I_INSN 0x7000B000
2615 #define E_CMPHL16I_INSN 0x7000B800
2617 /* This routine is called for each instruction to be assembled. */
2620 md_assemble (char *str
)
2623 const struct powerpc_opcode
*opcode
;
2625 const unsigned char *opindex_ptr
;
2629 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2634 unsigned int insn_length
;
2636 /* Get the opcode. */
2637 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2642 /* Look up the opcode in the hash table. */
2643 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2644 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2646 const struct powerpc_macro
*macro
;
2648 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2649 if (macro
== (const struct powerpc_macro
*) NULL
)
2650 as_bad (_("unrecognized opcode: `%s'"), str
);
2652 ppc_macro (s
, macro
);
2657 insn
= opcode
->opcode
;
2660 while (ISSPACE (*str
))
2663 /* PowerPC operands are just expressions. The only real issue is
2664 that a few operand types are optional. All cases which might use
2665 an optional operand separate the operands only with commas (in some
2666 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2667 have optional operands). Most instructions with optional operands
2668 have only one. Those that have more than one optional operand can
2669 take either all their operands or none. So, before we start seriously
2670 parsing the operands, we check to see if we have optional operands,
2671 and if we do, we count the number of commas to see which operands
2672 have been omitted. */
2674 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2676 const struct powerpc_operand
*operand
;
2678 operand
= &powerpc_operands
[*opindex_ptr
];
2679 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2681 unsigned int opcount
;
2682 unsigned int num_operands_expected
;
2684 /* There is an optional operand. Count the number of
2685 commas in the input line. */
2692 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2699 /* Compute the number of expected operands.
2700 Do not count fake operands. */
2701 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2702 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2703 ++ num_operands_expected
;
2705 /* If there are fewer operands in the line then are called
2706 for by the instruction, we want to skip the optional
2708 if (opcount
< num_operands_expected
)
2715 /* Gather the operands. */
2719 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2721 const struct powerpc_operand
*operand
;
2727 if (next_opindex
== 0)
2728 operand
= &powerpc_operands
[*opindex_ptr
];
2731 operand
= &powerpc_operands
[next_opindex
];
2736 /* If this is a fake operand, then we do not expect anything
2738 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2740 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2741 if (errmsg
!= (const char *) NULL
)
2742 as_bad ("%s", errmsg
);
2746 /* If this is an optional operand, and we are skipping it, just
2748 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2751 if (operand
->insert
)
2753 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2754 if (errmsg
!= (const char *) NULL
)
2755 as_bad ("%s", errmsg
);
2757 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2758 next_opindex
= *opindex_ptr
+ 1;
2762 /* Gather the operand. */
2763 hold
= input_line_pointer
;
2764 input_line_pointer
= str
;
2767 if (*input_line_pointer
== '[')
2769 /* We are expecting something like the second argument here:
2771 * lwz r4,[toc].GS.0.static_int(rtoc)
2772 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2773 * The argument following the `]' must be a symbol name, and the
2774 * register must be the toc register: 'rtoc' or '2'
2776 * The effect is to 0 as the displacement field
2777 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2778 * the appropriate variation) reloc against it based on the symbol.
2779 * The linker will build the toc, and insert the resolved toc offset.
2782 * o The size of the toc entry is currently assumed to be
2783 * 32 bits. This should not be assumed to be a hard coded
2785 * o In an effort to cope with a change from 32 to 64 bits,
2786 * there are also toc entries that are specified to be
2787 * either 32 or 64 bits:
2788 * lwz r4,[toc32].GS.0.static_int(rtoc)
2789 * lwz r4,[toc64].GS.0.static_int(rtoc)
2790 * These demand toc entries of the specified size, and the
2791 * instruction probably requires it.
2795 enum toc_size_qualifier toc_kind
;
2796 bfd_reloc_code_real_type toc_reloc
;
2798 /* Go parse off the [tocXX] part. */
2799 valid_toc
= parse_toc_entry (&toc_kind
);
2803 ignore_rest_of_line ();
2807 /* Now get the symbol following the ']'. */
2813 /* In this case, we may not have seen the symbol yet,
2814 since it is allowed to appear on a .extern or .globl
2815 or just be a label in the .data section. */
2816 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2819 /* 1. The symbol must be defined and either in the toc
2820 section, or a global.
2821 2. The reloc generated must have the TOCDEFN flag set
2822 in upper bit mess of the reloc type.
2823 FIXME: It's a little confusing what the tocv
2824 qualifier can be used for. At the very least, I've
2825 seen three uses, only one of which I'm sure I can
2827 if (ex
.X_op
== O_symbol
)
2829 gas_assert (ex
.X_add_symbol
!= NULL
);
2830 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2833 as_bad (_("[tocv] symbol is not a toc symbol"));
2837 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2840 /* FIXME: these next two specifically specify 32/64 bit
2841 toc entries. We don't support them today. Is this
2842 the right way to say that? */
2843 toc_reloc
= BFD_RELOC_UNUSED
;
2844 as_bad (_("unimplemented toc32 expression modifier"));
2847 /* FIXME: see above. */
2848 toc_reloc
= BFD_RELOC_UNUSED
;
2849 as_bad (_("unimplemented toc64 expression modifier"));
2853 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2859 /* We need to generate a fixup for this expression. */
2860 if (fc
>= MAX_INSN_FIXUPS
)
2861 as_fatal (_("too many fixups"));
2863 fixups
[fc
].reloc
= toc_reloc
;
2864 fixups
[fc
].exp
= ex
;
2865 fixups
[fc
].opindex
= *opindex_ptr
;
2868 /* Ok. We've set up the fixup for the instruction. Now make it
2869 look like the constant 0 was found here. */
2871 ex
.X_op
= O_constant
;
2872 ex
.X_add_number
= 0;
2873 ex
.X_add_symbol
= NULL
;
2874 ex
.X_op_symbol
= NULL
;
2881 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2882 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2883 || !register_name (&ex
))
2885 char save_lex
= lex_type
['%'];
2887 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2888 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2891 lex_type
['%'] |= LEX_BEGIN_NAME
;
2895 lex_type
['%'] = save_lex
;
2899 str
= input_line_pointer
;
2900 input_line_pointer
= hold
;
2902 if (ex
.X_op
== O_illegal
)
2903 as_bad (_("illegal operand"));
2904 else if (ex
.X_op
== O_absent
)
2905 as_bad (_("missing operand"));
2906 else if (ex
.X_op
== O_register
)
2908 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2909 ppc_cpu
, (char *) NULL
, 0);
2911 else if (ex
.X_op
== O_constant
)
2914 /* Allow @HA, @L, @H on constants. */
2915 bfd_reloc_code_real_type reloc
;
2916 char *orig_str
= str
;
2918 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2925 case BFD_RELOC_LO16
:
2926 ex
.X_add_number
&= 0xffff;
2927 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2928 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2931 case BFD_RELOC_HI16
:
2932 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2934 /* PowerPC64 @h is tested for overflow. */
2935 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2936 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2938 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2940 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2946 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2947 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2948 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2949 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2952 case BFD_RELOC_HI16_S
:
2953 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2955 /* PowerPC64 @ha is tested for overflow. */
2957 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2958 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2960 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2962 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2968 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2969 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2970 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2971 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2974 case BFD_RELOC_PPC64_HIGHER
:
2975 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2976 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2977 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2980 case BFD_RELOC_PPC64_HIGHER_S
:
2981 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2982 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2983 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2986 case BFD_RELOC_PPC64_HIGHEST
:
2987 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2988 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2989 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2992 case BFD_RELOC_PPC64_HIGHEST_S
:
2993 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2994 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2995 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2998 #endif /* OBJ_ELF */
2999 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
3000 ppc_cpu
, (char *) NULL
, 0);
3004 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
3006 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
3008 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
3009 if (sym_name
[0] == '.')
3012 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
3014 expressionS tls_exp
;
3016 hold
= input_line_pointer
;
3017 input_line_pointer
= str
+ 1;
3018 expression (&tls_exp
);
3019 if (tls_exp
.X_op
== O_symbol
)
3021 reloc
= BFD_RELOC_UNUSED
;
3022 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
3024 reloc
= BFD_RELOC_PPC_TLSGD
;
3025 input_line_pointer
+= 7;
3027 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
3029 reloc
= BFD_RELOC_PPC_TLSLD
;
3030 input_line_pointer
+= 7;
3032 if (reloc
!= BFD_RELOC_UNUSED
)
3035 str
= input_line_pointer
;
3037 if (fc
>= MAX_INSN_FIXUPS
)
3038 as_fatal (_("too many fixups"));
3039 fixups
[fc
].exp
= tls_exp
;
3040 fixups
[fc
].opindex
= *opindex_ptr
;
3041 fixups
[fc
].reloc
= reloc
;
3045 input_line_pointer
= hold
;
3049 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
3051 /* Some TLS tweaks. */
3057 case BFD_RELOC_PPC_TLS
:
3058 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
3059 as_bad (_("@tls may not be used with \"%s\" operands"),
3061 else if (operand
->shift
!= 11)
3062 as_bad (_("@tls may only be used in last operand"));
3064 insn
= ppc_insert_operand (insn
, operand
,
3066 ppc_cpu
, (char *) NULL
, 0);
3069 /* We'll only use the 32 (or 64) bit form of these relocations
3070 in constants. Instructions get the 16 bit form. */
3071 case BFD_RELOC_PPC_DTPREL
:
3072 reloc
= BFD_RELOC_PPC_DTPREL16
;
3074 case BFD_RELOC_PPC_TPREL
:
3075 reloc
= BFD_RELOC_PPC_TPREL16
;
3079 /* If VLE-mode convert LO/HI/HA relocations. */
3080 if (opcode
->flags
& PPC_OPCODE_VLE
)
3082 int tmp_insn
= insn
& opcode
->mask
;
3084 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3085 || tmp_insn
== E_AND2I_DOT_INSN
3086 || tmp_insn
== E_OR2IS_INSN
3087 || tmp_insn
== E_LIS_INSN
3088 || tmp_insn
== E_AND2IS_DOT_INSN
);
3091 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3092 || tmp_insn
== E_ADD2IS_INSN
3093 || tmp_insn
== E_CMP16I_INSN
3094 || tmp_insn
== E_MULL2I_INSN
3095 || tmp_insn
== E_CMPL16I_INSN
3096 || tmp_insn
== E_CMPH16I_INSN
3097 || tmp_insn
== E_CMPHL16I_INSN
);
3104 case BFD_RELOC_PPC_EMB_SDA21
:
3105 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3108 case BFD_RELOC_LO16
:
3110 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3111 else if (use_a_reloc
)
3112 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3115 case BFD_RELOC_HI16
:
3117 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3118 else if (use_a_reloc
)
3119 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3122 case BFD_RELOC_HI16_S
:
3124 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3125 else if (use_a_reloc
)
3126 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3129 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3131 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3134 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3136 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3139 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3141 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3146 /* For the absolute forms of branches, convert the PC
3147 relative form back into the absolute. */
3148 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3152 case BFD_RELOC_PPC_B26
:
3153 reloc
= BFD_RELOC_PPC_BA26
;
3155 case BFD_RELOC_PPC_B16
:
3156 reloc
= BFD_RELOC_PPC_BA16
;
3158 case BFD_RELOC_PPC_B16_BRTAKEN
:
3159 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3161 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3162 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3171 case BFD_RELOC_PPC_TOC16
:
3172 toc_reloc_types
|= has_small_toc_reloc
;
3174 case BFD_RELOC_PPC64_TOC16_LO
:
3175 case BFD_RELOC_PPC64_TOC16_HI
:
3176 case BFD_RELOC_PPC64_TOC16_HA
:
3177 toc_reloc_types
|= has_large_toc_reloc
;
3183 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3188 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3190 case BFD_RELOC_LO16
:
3191 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3193 case BFD_RELOC_16_GOTOFF
:
3194 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3196 case BFD_RELOC_LO16_GOTOFF
:
3197 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3199 case BFD_RELOC_LO16_PLTOFF
:
3200 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3202 case BFD_RELOC_16_BASEREL
:
3203 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3205 case BFD_RELOC_LO16_BASEREL
:
3206 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3208 case BFD_RELOC_PPC_TOC16
:
3209 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3211 case BFD_RELOC_PPC64_TOC16_LO
:
3212 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3214 case BFD_RELOC_PPC64_PLTGOT16
:
3215 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3217 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3218 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3220 case BFD_RELOC_PPC_DTPREL16
:
3221 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3223 case BFD_RELOC_PPC_DTPREL16_LO
:
3224 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3226 case BFD_RELOC_PPC_TPREL16
:
3227 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3229 case BFD_RELOC_PPC_TPREL16_LO
:
3230 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3232 case BFD_RELOC_PPC_GOT_DTPREL16
:
3233 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3234 case BFD_RELOC_PPC_GOT_TPREL16
:
3235 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3238 as_bad (_("unsupported relocation for DS offset field"));
3243 #endif /* OBJ_ELF */
3245 if (reloc
!= BFD_RELOC_UNUSED
)
3247 /* Determine a BFD reloc value based on the operand information.
3248 We are only prepared to turn a few of the operands into
3250 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3251 && operand
->bitm
== 0x3fffffc
3252 && operand
->shift
== 0)
3253 reloc
= BFD_RELOC_PPC_B26
;
3254 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3255 && operand
->bitm
== 0xfffc
3256 && operand
->shift
== 0)
3257 reloc
= BFD_RELOC_PPC_B16
;
3258 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3259 && operand
->bitm
== 0x1fe
3260 && operand
->shift
== -1)
3261 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3262 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3263 && operand
->bitm
== 0xfffe
3264 && operand
->shift
== 0)
3265 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3266 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3267 && operand
->bitm
== 0x1fffffe
3268 && operand
->shift
== 0)
3269 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3270 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3271 && operand
->bitm
== 0x3fffffc
3272 && operand
->shift
== 0)
3273 reloc
= BFD_RELOC_PPC_BA26
;
3274 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3275 && operand
->bitm
== 0xfffc
3276 && operand
->shift
== 0)
3277 reloc
= BFD_RELOC_PPC_BA16
;
3278 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3279 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3280 && (operand
->bitm
& 0xfff0) == 0xfff0
3281 && operand
->shift
== 0)
3283 /* Note: the symbol may be not yet defined. */
3284 if (ppc_is_toc_sym (ex
.X_add_symbol
))
3286 reloc
= BFD_RELOC_PPC_TOC16
;
3289 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3290 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3295 reloc
= BFD_RELOC_16
;
3298 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3299 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3303 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3305 /* We need to generate a fixup for this expression. */
3306 if (fc
>= MAX_INSN_FIXUPS
)
3307 as_fatal (_("too many fixups"));
3308 fixups
[fc
].exp
= ex
;
3309 fixups
[fc
].opindex
= *opindex_ptr
;
3310 fixups
[fc
].reloc
= reloc
;
3318 /* If expecting more operands, then we want to see "),". */
3319 if (*str
== endc
&& opindex_ptr
[1] != 0)
3323 while (ISSPACE (*str
));
3327 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3335 /* The call to expression should have advanced str past any
3338 && (endc
!= ',' || *str
!= '\0'))
3341 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3343 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3351 while (ISSPACE (*str
))
3355 as_bad (_("junk at end of line: `%s'"), str
);
3358 /* Do we need/want an APUinfo section? */
3359 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3362 /* These are all version "1". */
3363 if (opcode
->flags
& PPC_OPCODE_SPE
)
3364 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3365 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3366 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3367 if (opcode
->flags
& PPC_OPCODE_EFS
)
3368 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3369 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3370 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3371 if (opcode
->flags
& PPC_OPCODE_PMR
)
3372 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3373 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3374 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3375 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3376 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3377 if (opcode
->flags
& PPC_OPCODE_VLE
)
3378 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3382 /* Write out the instruction. */
3383 /* Differentiate between two and four byte insns. */
3384 if (ppc_mach () == bfd_mach_ppc_vle
)
3386 if (PPC_OP_SE_VLE (insn
))
3390 addr_mod
= frag_now_fix () & 1;
3395 addr_mod
= frag_now_fix () & 3;
3397 /* All instructions can start on a 2 byte boundary for VLE. */
3398 f
= frag_more (insn_length
);
3399 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3401 if (ppc_mach() == bfd_mach_ppc_vle
)
3402 as_bad (_("instruction address is not a multiple of 2"));
3404 as_bad (_("instruction address is not a multiple of 4"));
3406 frag_now
->insn_addr
= addr_mod
;
3407 frag_now
->has_code
= 1;
3408 md_number_to_chars (f
, insn
, insn_length
);
3411 dwarf2_emit_insn (insn_length
);
3414 /* Create any fixups. */
3415 for (i
= 0; i
< fc
; i
++)
3418 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3420 reloc_howto_type
*reloc_howto
;
3424 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3428 size
= bfd_get_reloc_size (reloc_howto
);
3429 offset
= target_big_endian
? (insn_length
- size
) : 0;
3431 if (size
< 1 || size
> 4)
3434 fixP
= fix_new_exp (frag_now
,
3435 f
- frag_now
->fr_literal
+ offset
,
3438 reloc_howto
->pc_relative
,
3443 const struct powerpc_operand
*operand
;
3445 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3446 fixP
= fix_new_exp (frag_now
,
3447 f
- frag_now
->fr_literal
,
3450 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3453 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3457 /* Handle a macro. Gather all the operands, transform them as
3458 described by the macro, and call md_assemble recursively. All the
3459 operands are separated by commas; we don't accept parentheses
3460 around operands here. */
3463 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3474 /* Gather the users operands into the operands array. */
3479 if (count
>= sizeof operands
/ sizeof operands
[0])
3481 operands
[count
++] = s
;
3482 s
= strchr (s
, ',');
3483 if (s
== (char *) NULL
)
3488 if (count
!= macro
->operands
)
3490 as_bad (_("wrong number of operands"));
3494 /* Work out how large the string must be (the size is unbounded
3495 because it includes user input). */
3497 format
= macro
->format
;
3498 while (*format
!= '\0')
3507 arg
= strtol (format
+ 1, &send
, 10);
3508 know (send
!= format
&& arg
< count
);
3509 len
+= strlen (operands
[arg
]);
3514 /* Put the string together. */
3515 complete
= s
= (char *) alloca (len
+ 1);
3516 format
= macro
->format
;
3517 while (*format
!= '\0')
3523 arg
= strtol (format
+ 1, &send
, 10);
3524 strcpy (s
, operands
[arg
]);
3531 /* Assemble the constructed instruction. */
3532 md_assemble (complete
);
3536 /* For ELF, add support for SHT_ORDERED. */
3539 ppc_section_type (char *str
, size_t len
)
3541 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3548 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3550 if (type
== SHT_ORDERED
)
3551 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3555 #endif /* OBJ_ELF */
3558 /* Pseudo-op handling. */
3560 /* The .byte pseudo-op. This is similar to the normal .byte
3561 pseudo-op, but it can also take a single ASCII string. */
3564 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3566 if (*input_line_pointer
!= '\"')
3572 /* Gather characters. A real double quote is doubled. Unusual
3573 characters are not permitted. */
3574 ++input_line_pointer
;
3579 c
= *input_line_pointer
++;
3583 if (*input_line_pointer
!= '\"')
3585 ++input_line_pointer
;
3588 FRAG_APPEND_1_CHAR (c
);
3591 demand_empty_rest_of_line ();
3596 /* XCOFF specific pseudo-op handling. */
3598 /* This is set if we are creating a .stabx symbol, since we don't want
3599 to handle symbol suffixes for such symbols. */
3600 static bfd_boolean ppc_stab_symbol
;
3602 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3603 symbols in the .bss segment as though they were local common
3604 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3605 aligns .comm and .lcomm to 4 bytes. */
3608 ppc_comm (int lcomm
)
3610 asection
*current_seg
= now_seg
;
3611 subsegT current_subseg
= now_subseg
;
3617 symbolS
*lcomm_sym
= NULL
;
3621 name
= input_line_pointer
;
3622 endc
= get_symbol_end ();
3623 end_name
= input_line_pointer
;
3626 if (*input_line_pointer
!= ',')
3628 as_bad (_("missing size"));
3629 ignore_rest_of_line ();
3632 ++input_line_pointer
;
3634 size
= get_absolute_expression ();
3637 as_bad (_("negative size"));
3638 ignore_rest_of_line ();
3644 /* The third argument to .comm is the alignment. */
3645 if (*input_line_pointer
!= ',')
3649 ++input_line_pointer
;
3650 align
= get_absolute_expression ();
3653 as_warn (_("ignoring bad alignment"));
3663 /* The third argument to .lcomm appears to be the real local
3664 common symbol to create. References to the symbol named in
3665 the first argument are turned into references to the third
3667 if (*input_line_pointer
!= ',')
3669 as_bad (_("missing real symbol name"));
3670 ignore_rest_of_line ();
3673 ++input_line_pointer
;
3675 lcomm_name
= input_line_pointer
;
3676 lcomm_endc
= get_symbol_end ();
3678 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3680 *input_line_pointer
= lcomm_endc
;
3682 /* The fourth argument to .lcomm is the alignment. */
3683 if (*input_line_pointer
!= ',')
3692 ++input_line_pointer
;
3693 align
= get_absolute_expression ();
3696 as_warn (_("ignoring bad alignment"));
3703 sym
= symbol_find_or_make (name
);
3706 if (S_IS_DEFINED (sym
)
3707 || S_GET_VALUE (sym
) != 0)
3709 as_bad (_("attempt to redefine symbol"));
3710 ignore_rest_of_line ();
3714 record_alignment (bss_section
, align
);
3717 || ! S_IS_DEFINED (lcomm_sym
))
3726 S_SET_EXTERNAL (sym
);
3730 symbol_get_tc (lcomm_sym
)->output
= 1;
3731 def_sym
= lcomm_sym
;
3735 subseg_set (bss_section
, 1);
3736 frag_align (align
, 0, 0);
3738 symbol_set_frag (def_sym
, frag_now
);
3739 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3740 def_size
, (char *) NULL
);
3742 S_SET_SEGMENT (def_sym
, bss_section
);
3743 symbol_get_tc (def_sym
)->align
= align
;
3747 /* Align the size of lcomm_sym. */
3748 symbol_get_frag (lcomm_sym
)->fr_offset
=
3749 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3750 &~ ((1 << align
) - 1));
3751 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3752 symbol_get_tc (lcomm_sym
)->align
= align
;
3757 /* Make sym an offset from lcomm_sym. */
3758 S_SET_SEGMENT (sym
, bss_section
);
3759 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3760 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3761 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3764 subseg_set (current_seg
, current_subseg
);
3766 demand_empty_rest_of_line ();
3769 /* The .csect pseudo-op. This switches us into a different
3770 subsegment. The first argument is a symbol whose value is the
3771 start of the .csect. In COFF, csect symbols get special aux
3772 entries defined by the x_csect field of union internal_auxent. The
3773 optional second argument is the alignment (the default is 2). */
3776 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3783 name
= input_line_pointer
;
3784 endc
= get_symbol_end ();
3786 sym
= symbol_find_or_make (name
);
3788 *input_line_pointer
= endc
;
3790 if (S_GET_NAME (sym
)[0] == '\0')
3792 /* An unnamed csect is assumed to be [PR]. */
3793 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3797 if (*input_line_pointer
== ',')
3799 ++input_line_pointer
;
3800 align
= get_absolute_expression ();
3803 ppc_change_csect (sym
, align
);
3805 demand_empty_rest_of_line ();
3808 /* Change to a different csect. */
3811 ppc_change_csect (symbolS
*sym
, offsetT align
)
3813 if (S_IS_DEFINED (sym
))
3814 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3824 /* This is a new csect. We need to look at the symbol class to
3825 figure out whether it should go in the text section or the
3829 switch (symbol_get_tc (sym
)->symbol_class
)
3839 S_SET_SEGMENT (sym
, text_section
);
3840 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3841 ++ppc_text_subsegment
;
3842 list_ptr
= &ppc_text_csects
;
3852 if (ppc_toc_csect
!= NULL
3853 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3854 == ppc_data_subsegment
))
3856 S_SET_SEGMENT (sym
, data_section
);
3857 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3858 ++ppc_data_subsegment
;
3859 list_ptr
= &ppc_data_csects
;
3865 /* We set the obstack chunk size to a small value before
3866 changing subsegments, so that we don't use a lot of memory
3867 space for what may be a small section. */
3868 hold_chunksize
= chunksize
;
3871 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3872 symbol_get_tc (sym
)->subseg
);
3874 chunksize
= hold_chunksize
;
3877 ppc_after_toc_frag
= frag_now
;
3879 record_alignment (sec
, align
);
3881 frag_align_code (align
, 0);
3883 frag_align (align
, 0, 0);
3885 symbol_set_frag (sym
, frag_now
);
3886 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3888 symbol_get_tc (sym
)->align
= align
;
3889 symbol_get_tc (sym
)->output
= 1;
3890 symbol_get_tc (sym
)->within
= sym
;
3892 for (list
= *list_ptr
;
3893 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3894 list
= symbol_get_tc (list
)->next
)
3896 symbol_get_tc (list
)->next
= sym
;
3898 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3899 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3903 ppc_current_csect
= sym
;
3907 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3911 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3913 sec
= subseg_new (dw
->name
, subseg
);
3914 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3915 if (oldflags
== SEC_NO_FLAGS
)
3917 /* Just created section. */
3918 gas_assert (dw_sections
[idx
].sect
== NULL
);
3920 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3921 bfd_set_section_alignment (stdoutput
, sec
, 0);
3922 dw_sections
[idx
].sect
= sec
;
3925 /* Not anymore in a csect. */
3926 ppc_current_csect
= NULL
;
3929 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3930 .dwsect flag [, opt-label ]
3934 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3938 const struct xcoff_dwsect_name
*dw
;
3939 struct dw_subsection
*subseg
;
3940 struct dw_section
*dws
;
3944 flag
= get_absolute_expression ();
3946 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3947 if (xcoff_dwsect_names
[i
].flag
== flag
)
3949 dw
= &xcoff_dwsect_names
[i
];
3953 /* Parse opt-label. */
3954 if (*input_line_pointer
== ',')
3959 ++input_line_pointer
;
3961 label
= input_line_pointer
;
3962 c
= get_symbol_end ();
3963 opt_label
= symbol_find_or_make (label
);
3964 *input_line_pointer
= c
;
3969 demand_empty_rest_of_line ();
3971 /* Return now in case of unknown subsection. */
3974 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3979 /* Find the subsection. */
3980 dws
= &dw_sections
[i
];
3982 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3984 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3985 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3987 as_bad (_("label %s was not defined in this dwarf section"),
3988 S_GET_NAME (opt_label
));
3989 subseg
= dws
->anon_subseg
;
3993 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3998 /* Switch to the subsection. */
3999 ppc_change_debug_section (i
, subseg
->subseg
);
4003 /* Create a new dw subsection. */
4004 subseg
= (struct dw_subsection
*)
4005 xmalloc (sizeof (struct dw_subsection
));
4007 if (opt_label
== NULL
)
4009 /* The anonymous one. */
4011 subseg
->link
= NULL
;
4012 dws
->anon_subseg
= subseg
;
4017 if (dws
->list_subseg
!= NULL
)
4018 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
4022 subseg
->link
= dws
->list_subseg
;
4023 dws
->list_subseg
= subseg
;
4024 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
4027 ppc_change_debug_section (i
, subseg
->subseg
);
4031 /* Add the length field. */
4032 expressionS
*exp
= &subseg
->end_exp
;
4035 if (opt_label
!= NULL
)
4036 symbol_set_value_now (opt_label
);
4038 /* Add the length field. Note that according to the AIX assembler
4039 manual, the size of the length field is 4 for powerpc32 but
4040 12 for powerpc64. */
4043 /* Write the 64bit marker. */
4044 md_number_to_chars (frag_more (4), -1, 4);
4047 exp
->X_op
= O_subtract
;
4048 exp
->X_op_symbol
= symbol_temp_new_now ();
4049 exp
->X_add_symbol
= symbol_temp_make ();
4051 sz
= ppc_obj64
? 8 : 4;
4052 exp
->X_add_number
= -sz
;
4053 emit_expr (exp
, sz
);
4058 /* This function handles the .text and .data pseudo-ops. These
4059 pseudo-ops aren't really used by XCOFF; we implement them for the
4060 convenience of people who aren't used to XCOFF. */
4063 ppc_section (int type
)
4070 else if (type
== 'd')
4075 sym
= symbol_find_or_make (name
);
4077 ppc_change_csect (sym
, 2);
4079 demand_empty_rest_of_line ();
4082 /* This function handles the .section pseudo-op. This is mostly to
4083 give an error, since XCOFF only supports .text, .data and .bss, but
4084 we do permit the user to name the text or data section. */
4087 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4090 const char *real_name
;
4094 user_name
= input_line_pointer
;
4095 c
= get_symbol_end ();
4097 if (strcmp (user_name
, ".text") == 0)
4098 real_name
= ".text[PR]";
4099 else if (strcmp (user_name
, ".data") == 0)
4100 real_name
= ".data[RW]";
4103 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4104 *input_line_pointer
= c
;
4105 ignore_rest_of_line ();
4109 *input_line_pointer
= c
;
4111 sym
= symbol_find_or_make (real_name
);
4113 ppc_change_csect (sym
, 2);
4115 demand_empty_rest_of_line ();
4118 /* The .extern pseudo-op. We create an undefined symbol. */
4121 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4126 name
= input_line_pointer
;
4127 endc
= get_symbol_end ();
4129 (void) symbol_find_or_make (name
);
4131 *input_line_pointer
= endc
;
4133 demand_empty_rest_of_line ();
4136 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4139 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4145 name
= input_line_pointer
;
4146 endc
= get_symbol_end ();
4148 sym
= symbol_find_or_make (name
);
4150 *input_line_pointer
= endc
;
4152 symbol_get_tc (sym
)->output
= 1;
4154 demand_empty_rest_of_line ();
4157 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4158 relocations at the beginning of the current csect.
4160 (In principle, there's no reason why the relocations _have_ to be at
4161 the beginning. Anywhere in the csect would do. However, inserting
4162 at the beginning is what the native assmebler does, and it helps to
4163 deal with cases where the .ref statements follow the section contents.)
4165 ??? .refs don't work for empty .csects. However, the native assembler
4166 doesn't report an error in this case, and neither yet do we. */
4169 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4174 if (ppc_current_csect
== NULL
)
4176 as_bad (_(".ref outside .csect"));
4177 ignore_rest_of_line ();
4183 name
= input_line_pointer
;
4184 c
= get_symbol_end ();
4186 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4187 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4189 *input_line_pointer
= c
;
4191 c
= *input_line_pointer
;
4194 input_line_pointer
++;
4196 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4198 as_bad (_("missing symbol name"));
4199 ignore_rest_of_line ();
4206 demand_empty_rest_of_line ();
4209 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4210 although I don't know why it bothers. */
4213 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4220 name
= input_line_pointer
;
4221 endc
= get_symbol_end ();
4223 sym
= symbol_find_or_make (name
);
4225 *input_line_pointer
= endc
;
4227 if (*input_line_pointer
!= ',')
4229 as_bad (_("missing rename string"));
4230 ignore_rest_of_line ();
4233 ++input_line_pointer
;
4235 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4237 demand_empty_rest_of_line ();
4240 /* The .stabx pseudo-op. This is similar to a normal .stabs
4241 pseudo-op, but slightly different. A sample is
4242 .stabx "main:F-1",.main,142,0
4243 The first argument is the symbol name to create. The second is the
4244 value, and the third is the storage class. The fourth seems to be
4245 always zero, and I am assuming it is the type. */
4248 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4255 name
= demand_copy_C_string (&len
);
4257 if (*input_line_pointer
!= ',')
4259 as_bad (_("missing value"));
4262 ++input_line_pointer
;
4264 ppc_stab_symbol
= TRUE
;
4265 sym
= symbol_make (name
);
4266 ppc_stab_symbol
= FALSE
;
4268 symbol_get_tc (sym
)->real_name
= name
;
4270 (void) expression (&exp
);
4277 as_bad (_("illegal .stabx expression; zero assumed"));
4278 exp
.X_add_number
= 0;
4281 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4282 symbol_set_frag (sym
, &zero_address_frag
);
4286 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4287 symbol_set_value_expression (sym
, &exp
);
4291 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4292 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4297 /* The value is some complex expression. This will probably
4298 fail at some later point, but this is probably the right
4299 thing to do here. */
4300 symbol_set_value_expression (sym
, &exp
);
4304 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4305 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4307 if (*input_line_pointer
!= ',')
4309 as_bad (_("missing class"));
4312 ++input_line_pointer
;
4314 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4316 if (*input_line_pointer
!= ',')
4318 as_bad (_("missing type"));
4321 ++input_line_pointer
;
4323 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4325 symbol_get_tc (sym
)->output
= 1;
4327 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4332 .stabx "z",arrays_,133,0
4335 .comm arrays_,13768,3
4337 resolve_symbol_value will copy the exp's "within" into sym's when the
4338 offset is 0. Since this seems to be corner case problem,
4339 only do the correction for storage class C_STSYM. A better solution
4340 would be to have the tc field updated in ppc_symbol_new_hook. */
4342 if (exp
.X_op
== O_symbol
)
4344 if (ppc_current_block
== NULL
)
4345 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4347 symbol_get_tc (sym
)->within
= ppc_current_block
;
4348 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4352 if (exp
.X_op
!= O_symbol
4353 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4354 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4355 ppc_frob_label (sym
);
4358 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4359 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4360 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4361 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4364 demand_empty_rest_of_line ();
4367 /* The .function pseudo-op. This takes several arguments. The first
4368 argument seems to be the external name of the symbol. The second
4369 argument seems to be the label for the start of the function. gcc
4370 uses the same name for both. I have no idea what the third and
4371 fourth arguments are meant to be. The optional fifth argument is
4372 an expression for the size of the function. In COFF this symbol
4373 gets an aux entry like that used for a csect. */
4376 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4384 name
= input_line_pointer
;
4385 endc
= get_symbol_end ();
4387 /* Ignore any [PR] suffix. */
4388 name
= ppc_canonicalize_symbol_name (name
);
4389 s
= strchr (name
, '[');
4390 if (s
!= (char *) NULL
4391 && strcmp (s
+ 1, "PR]") == 0)
4394 ext_sym
= symbol_find_or_make (name
);
4396 *input_line_pointer
= endc
;
4398 if (*input_line_pointer
!= ',')
4400 as_bad (_("missing symbol name"));
4401 ignore_rest_of_line ();
4404 ++input_line_pointer
;
4406 name
= input_line_pointer
;
4407 endc
= get_symbol_end ();
4409 lab_sym
= symbol_find_or_make (name
);
4411 *input_line_pointer
= endc
;
4413 if (ext_sym
!= lab_sym
)
4417 exp
.X_op
= O_symbol
;
4418 exp
.X_add_symbol
= lab_sym
;
4419 exp
.X_op_symbol
= NULL
;
4420 exp
.X_add_number
= 0;
4422 symbol_set_value_expression (ext_sym
, &exp
);
4425 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4426 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4427 symbol_get_tc (ext_sym
)->output
= 1;
4429 if (*input_line_pointer
== ',')
4433 /* Ignore the third argument. */
4434 ++input_line_pointer
;
4436 if (*input_line_pointer
== ',')
4438 /* Ignore the fourth argument. */
4439 ++input_line_pointer
;
4441 if (*input_line_pointer
== ',')
4443 /* The fifth argument is the function size. */
4444 ++input_line_pointer
;
4445 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4446 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4447 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4452 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4453 SF_SET_FUNCTION (ext_sym
);
4454 SF_SET_PROCESS (ext_sym
);
4455 coff_add_linesym (ext_sym
);
4457 demand_empty_rest_of_line ();
4460 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4461 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4462 with the correct line number */
4464 static symbolS
*saved_bi_sym
= 0;
4467 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4471 sym
= symbol_make (".bf");
4472 S_SET_SEGMENT (sym
, text_section
);
4473 symbol_set_frag (sym
, frag_now
);
4474 S_SET_VALUE (sym
, frag_now_fix ());
4475 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4477 coff_line_base
= get_absolute_expression ();
4479 S_SET_NUMBER_AUXILIARY (sym
, 1);
4480 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4482 /* Line number for bi. */
4485 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4490 symbol_get_tc (sym
)->output
= 1;
4492 ppc_frob_label (sym
);
4494 demand_empty_rest_of_line ();
4497 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4498 ".ef", except that the line number is absolute, not relative to the
4499 most recent ".bf" symbol. */
4502 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4506 sym
= symbol_make (".ef");
4507 S_SET_SEGMENT (sym
, text_section
);
4508 symbol_set_frag (sym
, frag_now
);
4509 S_SET_VALUE (sym
, frag_now_fix ());
4510 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4511 S_SET_NUMBER_AUXILIARY (sym
, 1);
4512 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4513 symbol_get_tc (sym
)->output
= 1;
4515 ppc_frob_label (sym
);
4517 demand_empty_rest_of_line ();
4520 /* The .bi and .ei pseudo-ops. These take a string argument and
4521 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4522 the symbol list. The value of .bi will be know when the next .bf
4528 static symbolS
*last_biei
;
4535 name
= demand_copy_C_string (&len
);
4537 /* The value of these symbols is actually file offset. Here we set
4538 the value to the index into the line number entries. In
4539 ppc_frob_symbols we set the fix_line field, which will cause BFD
4540 to do the right thing. */
4542 sym
= symbol_make (name
);
4543 /* obj-coff.c currently only handles line numbers correctly in the
4545 S_SET_SEGMENT (sym
, text_section
);
4546 S_SET_VALUE (sym
, coff_n_line_nos
);
4547 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4549 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4550 symbol_get_tc (sym
)->output
= 1;
4558 for (look
= last_biei
? last_biei
: symbol_rootP
;
4559 (look
!= (symbolS
*) NULL
4560 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4561 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4562 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4563 look
= symbol_next (look
))
4565 if (look
!= (symbolS
*) NULL
)
4567 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4568 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4572 demand_empty_rest_of_line ();
4575 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4576 There is one argument, which is a csect symbol. The value of the
4577 .bs symbol is the index of this csect symbol. */
4580 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4587 if (ppc_current_block
!= NULL
)
4588 as_bad (_("nested .bs blocks"));
4590 name
= input_line_pointer
;
4591 endc
= get_symbol_end ();
4593 csect
= symbol_find_or_make (name
);
4595 *input_line_pointer
= endc
;
4597 sym
= symbol_make (".bs");
4598 S_SET_SEGMENT (sym
, now_seg
);
4599 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4600 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4601 symbol_get_tc (sym
)->output
= 1;
4603 symbol_get_tc (sym
)->within
= csect
;
4605 ppc_frob_label (sym
);
4607 ppc_current_block
= sym
;
4609 demand_empty_rest_of_line ();
4612 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4615 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4619 if (ppc_current_block
== NULL
)
4620 as_bad (_(".es without preceding .bs"));
4622 sym
= symbol_make (".es");
4623 S_SET_SEGMENT (sym
, now_seg
);
4624 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4625 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4626 symbol_get_tc (sym
)->output
= 1;
4628 ppc_frob_label (sym
);
4630 ppc_current_block
= NULL
;
4632 demand_empty_rest_of_line ();
4635 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4639 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4643 sym
= symbol_make (".bb");
4644 S_SET_SEGMENT (sym
, text_section
);
4645 symbol_set_frag (sym
, frag_now
);
4646 S_SET_VALUE (sym
, frag_now_fix ());
4647 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4649 S_SET_NUMBER_AUXILIARY (sym
, 1);
4650 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4652 symbol_get_tc (sym
)->output
= 1;
4654 SF_SET_PROCESS (sym
);
4656 ppc_frob_label (sym
);
4658 demand_empty_rest_of_line ();
4661 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4665 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4669 sym
= symbol_make (".eb");
4670 S_SET_SEGMENT (sym
, text_section
);
4671 symbol_set_frag (sym
, frag_now
);
4672 S_SET_VALUE (sym
, frag_now_fix ());
4673 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4674 S_SET_NUMBER_AUXILIARY (sym
, 1);
4675 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4676 symbol_get_tc (sym
)->output
= 1;
4678 SF_SET_PROCESS (sym
);
4680 ppc_frob_label (sym
);
4682 demand_empty_rest_of_line ();
4685 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4689 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4695 name
= demand_copy_C_string (&len
);
4696 sym
= symbol_make (name
);
4697 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4698 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4699 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4700 S_SET_VALUE (sym
, 0);
4701 symbol_get_tc (sym
)->output
= 1;
4703 ppc_frob_label (sym
);
4705 demand_empty_rest_of_line ();
4708 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4711 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4715 sym
= symbol_make (".ec");
4716 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4717 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4718 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4719 S_SET_VALUE (sym
, 0);
4720 symbol_get_tc (sym
)->output
= 1;
4722 ppc_frob_label (sym
);
4724 demand_empty_rest_of_line ();
4727 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4730 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4732 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4733 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4740 subseg
= ppc_data_subsegment
;
4741 ++ppc_data_subsegment
;
4743 subseg_new (segment_name (data_section
), subseg
);
4744 ppc_toc_frag
= frag_now
;
4746 sym
= symbol_find_or_make ("TOC[TC0]");
4747 symbol_set_frag (sym
, frag_now
);
4748 S_SET_SEGMENT (sym
, data_section
);
4749 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4750 symbol_get_tc (sym
)->subseg
= subseg
;
4751 symbol_get_tc (sym
)->output
= 1;
4752 symbol_get_tc (sym
)->within
= sym
;
4754 ppc_toc_csect
= sym
;
4756 for (list
= ppc_data_csects
;
4757 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4758 list
= symbol_get_tc (list
)->next
)
4760 symbol_get_tc (list
)->next
= sym
;
4762 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4763 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4767 ppc_current_csect
= ppc_toc_csect
;
4769 demand_empty_rest_of_line ();
4772 /* The AIX assembler automatically aligns the operands of a .long or
4773 .short pseudo-op, and we want to be compatible. */
4776 ppc_xcoff_cons (int log_size
)
4778 frag_align (log_size
, 0, 0);
4779 record_alignment (now_seg
, log_size
);
4780 cons (1 << log_size
);
4784 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4789 (void) expression (&exp
);
4791 if (exp
.X_op
!= O_constant
)
4793 as_bad (_("non-constant byte count"));
4797 byte_count
= exp
.X_add_number
;
4799 if (*input_line_pointer
!= ',')
4801 as_bad (_("missing value"));
4805 ++input_line_pointer
;
4810 ppc_xcoff_end (void)
4814 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4816 struct dw_section
*dws
= &dw_sections
[i
];
4817 struct dw_subsection
*dwss
;
4819 if (dws
->anon_subseg
)
4821 dwss
= dws
->anon_subseg
;
4822 dwss
->link
= dws
->list_subseg
;
4825 dwss
= dws
->list_subseg
;
4827 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4828 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4830 subseg_set (dws
->sect
, dwss
->subseg
);
4831 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4836 #endif /* OBJ_XCOFF */
4837 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4839 /* The .tc pseudo-op. This is used when generating either XCOFF or
4840 ELF. This takes two or more arguments.
4842 When generating XCOFF output, the first argument is the name to
4843 give to this location in the toc; this will be a symbol with class
4844 TC. The rest of the arguments are N-byte values to actually put at
4845 this location in the TOC; often there is just one more argument, a
4846 relocatable symbol reference. The size of the value to store
4847 depends on target word size. A 32-bit target uses 4-byte values, a
4848 64-bit target uses 8-byte values.
4850 When not generating XCOFF output, the arguments are the same, but
4851 the first argument is simply ignored. */
4854 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4858 /* Define the TOC symbol name. */
4864 if (ppc_toc_csect
== (symbolS
*) NULL
4865 || ppc_toc_csect
!= ppc_current_csect
)
4867 as_bad (_(".tc not in .toc section"));
4868 ignore_rest_of_line ();
4872 name
= input_line_pointer
;
4873 endc
= get_symbol_end ();
4875 sym
= symbol_find_or_make (name
);
4877 *input_line_pointer
= endc
;
4879 if (S_IS_DEFINED (sym
))
4883 label
= symbol_get_tc (ppc_current_csect
)->within
;
4884 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4886 as_bad (_(".tc with no label"));
4887 ignore_rest_of_line ();
4891 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4892 symbol_set_frag (label
, symbol_get_frag (sym
));
4893 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4895 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4896 ++input_line_pointer
;
4901 S_SET_SEGMENT (sym
, now_seg
);
4902 symbol_set_frag (sym
, frag_now
);
4903 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4904 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4905 symbol_get_tc (sym
)->output
= 1;
4907 ppc_frob_label (sym
);
4910 #endif /* OBJ_XCOFF */
4914 /* Skip the TOC symbol name. */
4915 while (is_part_of_name (*input_line_pointer
)
4916 || *input_line_pointer
== ' '
4917 || *input_line_pointer
== '['
4918 || *input_line_pointer
== ']'
4919 || *input_line_pointer
== '{'
4920 || *input_line_pointer
== '}')
4921 ++input_line_pointer
;
4923 /* Align to a four/eight byte boundary. */
4924 align
= ppc_obj64
? 3 : 2;
4925 frag_align (align
, 0, 0);
4926 record_alignment (now_seg
, align
);
4927 #endif /* OBJ_ELF */
4929 if (*input_line_pointer
!= ',')
4930 demand_empty_rest_of_line ();
4933 ++input_line_pointer
;
4934 cons (ppc_obj64
? 8 : 4);
4938 /* Pseudo-op .machine. */
4941 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4944 #define MAX_HISTORY 100
4945 static ppc_cpu_t
*cpu_history
;
4946 static int curr_hist
;
4950 if (*input_line_pointer
== '"')
4953 cpu_string
= demand_copy_C_string (&len
);
4958 cpu_string
= input_line_pointer
;
4959 c
= get_symbol_end ();
4960 cpu_string
= xstrdup (cpu_string
);
4961 *input_line_pointer
= c
;
4964 if (cpu_string
!= NULL
)
4966 ppc_cpu_t old_cpu
= ppc_cpu
;
4970 for (p
= cpu_string
; *p
!= 0; p
++)
4973 if (strcmp (cpu_string
, "push") == 0)
4975 if (cpu_history
== NULL
)
4976 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4978 if (curr_hist
>= MAX_HISTORY
)
4979 as_bad (_(".machine stack overflow"));
4981 cpu_history
[curr_hist
++] = ppc_cpu
;
4983 else if (strcmp (cpu_string
, "pop") == 0)
4986 as_bad (_(".machine stack underflow"));
4988 ppc_cpu
= cpu_history
[--curr_hist
];
4990 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4993 as_bad (_("invalid machine `%s'"), cpu_string
);
4995 if (ppc_cpu
!= old_cpu
)
4996 ppc_setup_opcodes ();
4999 demand_empty_rest_of_line ();
5001 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5005 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
5007 /* Set the current section. */
5009 ppc_set_current_section (segT
new)
5011 ppc_previous_section
= ppc_current_section
;
5012 ppc_current_section
= new;
5015 /* pseudo-op: .previous
5016 behaviour: toggles the current section with the previous section.
5018 warnings: "No previous section" */
5021 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
5023 if (ppc_previous_section
== NULL
)
5025 as_warn (_("no previous section to return to, ignored."));
5029 subseg_set (ppc_previous_section
, 0);
5031 ppc_set_current_section (ppc_previous_section
);
5034 /* pseudo-op: .pdata
5035 behaviour: predefined read only data section
5039 initial: .section .pdata "adr3"
5040 a - don't know -- maybe a misprint
5041 d - initialized data
5043 3 - double word aligned (that would be 4 byte boundary)
5046 Tag index tables (also known as the function table) for exception
5047 handling, debugging, etc. */
5050 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
5052 if (pdata_section
== 0)
5054 pdata_section
= subseg_new (".pdata", 0);
5056 bfd_set_section_flags (stdoutput
, pdata_section
,
5057 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5058 | SEC_READONLY
| SEC_DATA
));
5060 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5064 pdata_section
= subseg_new (".pdata", 0);
5066 ppc_set_current_section (pdata_section
);
5069 /* pseudo-op: .ydata
5070 behaviour: predefined read only data section
5074 initial: .section .ydata "drw3"
5075 a - don't know -- maybe a misprint
5076 d - initialized data
5078 3 - double word aligned (that would be 4 byte boundary)
5080 Tag tables (also known as the scope table) for exception handling,
5084 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5086 if (ydata_section
== 0)
5088 ydata_section
= subseg_new (".ydata", 0);
5089 bfd_set_section_flags (stdoutput
, ydata_section
,
5090 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5091 | SEC_READONLY
| SEC_DATA
));
5093 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5097 ydata_section
= subseg_new (".ydata", 0);
5099 ppc_set_current_section (ydata_section
);
5102 /* pseudo-op: .reldata
5103 behaviour: predefined read write data section
5104 double word aligned (4-byte)
5105 FIXME: relocation is applied to it
5106 FIXME: what's the difference between this and .data?
5109 initial: .section .reldata "drw3"
5110 d - initialized data
5113 3 - double word aligned (that would be 8 byte boundary)
5116 Like .data, but intended to hold data subject to relocation, such as
5117 function descriptors, etc. */
5120 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5122 if (reldata_section
== 0)
5124 reldata_section
= subseg_new (".reldata", 0);
5126 bfd_set_section_flags (stdoutput
, reldata_section
,
5127 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5130 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5134 reldata_section
= subseg_new (".reldata", 0);
5136 ppc_set_current_section (reldata_section
);
5139 /* pseudo-op: .rdata
5140 behaviour: predefined read only data section
5144 initial: .section .rdata "dr3"
5145 d - initialized data
5147 3 - double word aligned (that would be 4 byte boundary) */
5150 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5152 if (rdata_section
== 0)
5154 rdata_section
= subseg_new (".rdata", 0);
5155 bfd_set_section_flags (stdoutput
, rdata_section
,
5156 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5157 | SEC_READONLY
| SEC_DATA
));
5159 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5163 rdata_section
= subseg_new (".rdata", 0);
5165 ppc_set_current_section (rdata_section
);
5168 /* pseudo-op: .ualong
5169 behaviour: much like .int, with the exception that no alignment is
5171 FIXME: test the alignment statement
5176 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5182 /* pseudo-op: .znop <symbol name>
5183 behaviour: Issue a nop instruction
5184 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5185 the supplied symbol name.
5187 warnings: Missing symbol name */
5190 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5193 const struct powerpc_opcode
*opcode
;
5200 /* Strip out the symbol name. */
5201 symbol_name
= input_line_pointer
;
5202 c
= get_symbol_end ();
5204 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5205 strcpy (name
, symbol_name
);
5207 sym
= symbol_find_or_make (name
);
5209 *input_line_pointer
= c
;
5213 /* Look up the opcode in the hash table. */
5214 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5216 /* Stick in the nop. */
5217 insn
= opcode
->opcode
;
5219 /* Write out the instruction. */
5221 md_number_to_chars (f
, insn
, 4);
5223 f
- frag_now
->fr_literal
,
5228 BFD_RELOC_16_GOT_PCREL
);
5238 ppc_pe_comm (int lcomm
)
5247 name
= input_line_pointer
;
5248 c
= get_symbol_end ();
5250 /* just after name is now '\0'. */
5251 p
= input_line_pointer
;
5254 if (*input_line_pointer
!= ',')
5256 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5257 ignore_rest_of_line ();
5261 input_line_pointer
++; /* skip ',' */
5262 if ((temp
= get_absolute_expression ()) < 0)
5264 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5265 ignore_rest_of_line ();
5271 /* The third argument to .comm is the alignment. */
5272 if (*input_line_pointer
!= ',')
5276 ++input_line_pointer
;
5277 align
= get_absolute_expression ();
5280 as_warn (_("ignoring bad alignment"));
5287 symbolP
= symbol_find_or_make (name
);
5290 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5292 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5293 S_GET_NAME (symbolP
));
5294 ignore_rest_of_line ();
5298 if (S_GET_VALUE (symbolP
))
5300 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5301 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5302 S_GET_NAME (symbolP
),
5303 (long) S_GET_VALUE (symbolP
),
5308 S_SET_VALUE (symbolP
, (valueT
) temp
);
5309 S_SET_EXTERNAL (symbolP
);
5310 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5313 demand_empty_rest_of_line ();
5317 * implement the .section pseudo op:
5318 * .section name {, "flags"}
5320 * | +--- optional flags: 'b' for bss
5322 * +-- section name 'l' for lib
5326 * 'd' (apparently m88k for data)
5328 * But if the argument is not a quoted string, treat it as a
5329 * subsegment number.
5331 * FIXME: this is a copy of the section processing from obj-coff.c, with
5332 * additions/changes for the moto-pas assembler support. There are three
5335 * FIXME: I just noticed this. This doesn't work at all really. It it
5336 * setting bits that bfd probably neither understands or uses. The
5337 * correct approach (?) will have to incorporate extra fields attached
5338 * to the section to hold the system specific stuff. (krk)
5341 * 'a' - unknown - referred to in documentation, but no definition supplied
5342 * 'c' - section has code
5343 * 'd' - section has initialized data
5344 * 'u' - section has uninitialized data
5345 * 'i' - section contains directives (info)
5346 * 'n' - section can be discarded
5347 * 'R' - remove section at link time
5349 * Section Protection:
5350 * 'r' - section is readable
5351 * 'w' - section is writeable
5352 * 'x' - section is executable
5353 * 's' - section is sharable
5355 * Section Alignment:
5356 * '0' - align to byte boundary
5357 * '1' - align to halfword undary
5358 * '2' - align to word boundary
5359 * '3' - align to doubleword boundary
5360 * '4' - align to quadword boundary
5361 * '5' - align to 32 byte boundary
5362 * '6' - align to 64 byte boundary
5367 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5369 /* Strip out the section name. */
5378 section_name
= input_line_pointer
;
5379 c
= get_symbol_end ();
5381 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5382 strcpy (name
, section_name
);
5384 *input_line_pointer
= c
;
5389 flags
= SEC_NO_FLAGS
;
5391 if (strcmp (name
, ".idata$2") == 0)
5395 else if (strcmp (name
, ".idata$3") == 0)
5399 else if (strcmp (name
, ".idata$4") == 0)
5403 else if (strcmp (name
, ".idata$5") == 0)
5407 else if (strcmp (name
, ".idata$6") == 0)
5412 /* Default alignment to 16 byte boundary. */
5415 if (*input_line_pointer
== ',')
5417 ++input_line_pointer
;
5419 if (*input_line_pointer
!= '"')
5420 exp
= get_absolute_expression ();
5423 ++input_line_pointer
;
5424 while (*input_line_pointer
!= '"'
5425 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5427 switch (*input_line_pointer
)
5429 /* Section Contents */
5430 case 'a': /* unknown */
5431 as_bad (_("unsupported section attribute -- 'a'"));
5433 case 'c': /* code section */
5436 case 'd': /* section has initialized data */
5439 case 'u': /* section has uninitialized data */
5440 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5444 case 'i': /* section contains directives (info) */
5445 /* FIXME: This is IMAGE_SCN_LNK_INFO
5447 flags
|= SEC_HAS_CONTENTS
;
5449 case 'n': /* section can be discarded */
5452 case 'R': /* Remove section at link time */
5453 flags
|= SEC_NEVER_LOAD
;
5455 #if IFLICT_BRAIN_DAMAGE
5456 /* Section Protection */
5457 case 'r': /* section is readable */
5458 flags
|= IMAGE_SCN_MEM_READ
;
5460 case 'w': /* section is writeable */
5461 flags
|= IMAGE_SCN_MEM_WRITE
;
5463 case 'x': /* section is executable */
5464 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5466 case 's': /* section is sharable */
5467 flags
|= IMAGE_SCN_MEM_SHARED
;
5470 /* Section Alignment */
5471 case '0': /* align to byte boundary */
5472 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5475 case '1': /* align to halfword boundary */
5476 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5479 case '2': /* align to word boundary */
5480 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5483 case '3': /* align to doubleword boundary */
5484 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5487 case '4': /* align to quadword boundary */
5488 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5491 case '5': /* align to 32 byte boundary */
5492 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5495 case '6': /* align to 64 byte boundary */
5496 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5501 as_bad (_("unknown section attribute '%c'"),
5502 *input_line_pointer
);
5505 ++input_line_pointer
;
5507 if (*input_line_pointer
== '"')
5508 ++input_line_pointer
;
5512 sec
= subseg_new (name
, (subsegT
) exp
);
5514 ppc_set_current_section (sec
);
5516 if (flags
!= SEC_NO_FLAGS
)
5518 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5519 as_bad (_("error setting flags for \"%s\": %s"),
5520 bfd_section_name (stdoutput
, sec
),
5521 bfd_errmsg (bfd_get_error ()));
5524 bfd_set_section_alignment (stdoutput
, sec
, align
);
5528 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5534 name
= input_line_pointer
;
5535 endc
= get_symbol_end ();
5537 ext_sym
= symbol_find_or_make (name
);
5539 *input_line_pointer
= endc
;
5541 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5542 SF_SET_FUNCTION (ext_sym
);
5543 SF_SET_PROCESS (ext_sym
);
5544 coff_add_linesym (ext_sym
);
5546 demand_empty_rest_of_line ();
5550 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5552 if (tocdata_section
== 0)
5554 tocdata_section
= subseg_new (".tocd", 0);
5555 /* FIXME: section flags won't work. */
5556 bfd_set_section_flags (stdoutput
, tocdata_section
,
5557 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5558 | SEC_READONLY
| SEC_DATA
));
5560 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5564 rdata_section
= subseg_new (".tocd", 0);
5567 ppc_set_current_section (tocdata_section
);
5569 demand_empty_rest_of_line ();
5572 /* Don't adjust TOC relocs to use the section symbol. */
5575 ppc_pe_fix_adjustable (fixS
*fix
)
5577 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5584 /* XCOFF specific symbol and file handling. */
5586 /* Canonicalize the symbol name. We use the to force the suffix, if
5587 any, to use square brackets, and to be in upper case. */
5590 ppc_canonicalize_symbol_name (char *name
)
5594 if (ppc_stab_symbol
)
5597 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5611 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5614 if (*s
== '\0' || s
[1] != '\0')
5615 as_bad (_("bad symbol suffix"));
5623 /* Set the class of a symbol based on the suffix, if any. This is
5624 called whenever a new symbol is created. */
5627 ppc_symbol_new_hook (symbolS
*sym
)
5629 struct ppc_tc_sy
*tc
;
5632 tc
= symbol_get_tc (sym
);
5635 tc
->symbol_class
= -1;
5636 tc
->real_name
= NULL
;
5643 if (ppc_stab_symbol
)
5646 s
= strchr (S_GET_NAME (sym
), '[');
5647 if (s
== (const char *) NULL
)
5649 /* There is no suffix. */
5658 if (strcmp (s
, "BS]") == 0)
5659 tc
->symbol_class
= XMC_BS
;
5662 if (strcmp (s
, "DB]") == 0)
5663 tc
->symbol_class
= XMC_DB
;
5664 else if (strcmp (s
, "DS]") == 0)
5665 tc
->symbol_class
= XMC_DS
;
5668 if (strcmp (s
, "GL]") == 0)
5669 tc
->symbol_class
= XMC_GL
;
5672 if (strcmp (s
, "PR]") == 0)
5673 tc
->symbol_class
= XMC_PR
;
5676 if (strcmp (s
, "RO]") == 0)
5677 tc
->symbol_class
= XMC_RO
;
5678 else if (strcmp (s
, "RW]") == 0)
5679 tc
->symbol_class
= XMC_RW
;
5682 if (strcmp (s
, "SV]") == 0)
5683 tc
->symbol_class
= XMC_SV
;
5686 if (strcmp (s
, "TC]") == 0)
5687 tc
->symbol_class
= XMC_TC
;
5688 else if (strcmp (s
, "TI]") == 0)
5689 tc
->symbol_class
= XMC_TI
;
5690 else if (strcmp (s
, "TB]") == 0)
5691 tc
->symbol_class
= XMC_TB
;
5692 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5693 tc
->symbol_class
= XMC_TC0
;
5696 if (strcmp (s
, "UA]") == 0)
5697 tc
->symbol_class
= XMC_UA
;
5698 else if (strcmp (s
, "UC]") == 0)
5699 tc
->symbol_class
= XMC_UC
;
5702 if (strcmp (s
, "XO]") == 0)
5703 tc
->symbol_class
= XMC_XO
;
5707 if (tc
->symbol_class
== -1)
5708 as_bad (_("unrecognized symbol suffix"));
5711 /* Set the class of a label based on where it is defined. This
5712 handles symbols without suffixes. Also, move the symbol so that it
5713 follows the csect symbol. */
5716 ppc_frob_label (symbolS
*sym
)
5718 if (ppc_current_csect
!= (symbolS
*) NULL
)
5720 if (symbol_get_tc (sym
)->symbol_class
== -1)
5721 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5723 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5724 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5725 &symbol_rootP
, &symbol_lastP
);
5726 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5727 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5731 dwarf2_emit_label (sym
);
5735 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5736 seen. It tells ppc_adjust_symtab whether it needs to look through
5739 static bfd_boolean ppc_saw_abs
;
5741 /* Change the name of a symbol just before writing it out. Set the
5742 real name if the .rename pseudo-op was used. Otherwise, remove any
5743 class suffix. Return 1 if the symbol should not be included in the
5747 ppc_frob_symbol (symbolS
*sym
)
5749 static symbolS
*ppc_last_function
;
5750 static symbolS
*set_end
;
5752 /* Discard symbols that should not be included in the output symbol
5754 if (! symbol_used_in_reloc_p (sym
)
5755 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5756 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5757 && ! symbol_get_tc (sym
)->output
5758 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5761 /* This one will disappear anyway. Don't make a csect sym for it. */
5762 if (sym
== abs_section_sym
)
5765 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5766 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5772 name
= S_GET_NAME (sym
);
5773 s
= strchr (name
, '[');
5774 if (s
!= (char *) NULL
)
5780 snew
= xmalloc (len
+ 1);
5781 memcpy (snew
, name
, len
);
5784 S_SET_NAME (sym
, snew
);
5788 if (set_end
!= (symbolS
*) NULL
)
5790 SA_SET_SYM_ENDNDX (set_end
, sym
);
5794 if (SF_GET_FUNCTION (sym
))
5796 if (ppc_last_function
!= (symbolS
*) NULL
)
5797 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5798 ppc_last_function
= sym
;
5799 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5801 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5802 SA_SET_SYM_FSIZE (sym
,
5803 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5806 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5807 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5809 if (ppc_last_function
== (symbolS
*) NULL
)
5810 as_bad (_(".ef with no preceding .function"));
5813 set_end
= ppc_last_function
;
5814 ppc_last_function
= NULL
;
5816 /* We don't have a C_EFCN symbol, but we need to force the
5817 COFF backend to believe that it has seen one. */
5818 coff_last_function
= NULL
;
5822 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5823 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5824 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5825 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5826 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5827 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5828 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5829 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5830 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5831 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5832 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5834 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5835 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5836 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5839 union internal_auxent
*a
;
5841 /* Create a csect aux. */
5842 i
= S_GET_NUMBER_AUXILIARY (sym
);
5843 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5844 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5845 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5847 /* This is the TOC table. */
5848 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5849 a
->x_csect
.x_scnlen
.l
= 0;
5850 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5852 else if (symbol_get_tc (sym
)->subseg
!= 0)
5854 /* This is a csect symbol. x_scnlen is the size of the
5856 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5857 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5858 S_GET_SEGMENT (sym
))
5859 - S_GET_VALUE (sym
));
5862 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5863 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5864 - S_GET_VALUE (sym
));
5866 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5868 else if (S_GET_SEGMENT (sym
) == bss_section
)
5870 /* This is a common symbol. */
5871 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5872 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5873 if (S_IS_EXTERNAL (sym
))
5874 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5876 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5878 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5880 /* This is an absolute symbol. The csect will be created by
5881 ppc_adjust_symtab. */
5883 a
->x_csect
.x_smtyp
= XTY_LD
;
5884 if (symbol_get_tc (sym
)->symbol_class
== -1)
5885 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5887 else if (! S_IS_DEFINED (sym
))
5889 /* This is an external symbol. */
5890 a
->x_csect
.x_scnlen
.l
= 0;
5891 a
->x_csect
.x_smtyp
= XTY_ER
;
5893 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5897 /* This is a TOC definition. x_scnlen is the size of the
5899 next
= symbol_next (sym
);
5900 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5901 next
= symbol_next (next
);
5902 if (next
== (symbolS
*) NULL
5903 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5905 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5906 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5908 - S_GET_VALUE (sym
));
5910 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5911 - S_GET_VALUE (sym
));
5915 resolve_symbol_value (next
);
5916 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5917 - S_GET_VALUE (sym
));
5919 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5925 /* This is a normal symbol definition. x_scnlen is the
5926 symbol index of the containing csect. */
5927 if (S_GET_SEGMENT (sym
) == text_section
)
5928 csect
= ppc_text_csects
;
5929 else if (S_GET_SEGMENT (sym
) == data_section
)
5930 csect
= ppc_data_csects
;
5934 /* Skip the initial dummy symbol. */
5935 csect
= symbol_get_tc (csect
)->next
;
5937 if (csect
== (symbolS
*) NULL
)
5939 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5940 a
->x_csect
.x_scnlen
.l
= 0;
5944 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5946 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5947 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5948 > S_GET_VALUE (sym
))
5950 csect
= symbol_get_tc (csect
)->next
;
5953 a
->x_csect
.x_scnlen
.p
=
5954 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5955 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5958 a
->x_csect
.x_smtyp
= XTY_LD
;
5961 a
->x_csect
.x_parmhash
= 0;
5962 a
->x_csect
.x_snhash
= 0;
5963 if (symbol_get_tc (sym
)->symbol_class
== -1)
5964 a
->x_csect
.x_smclas
= XMC_PR
;
5966 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5967 a
->x_csect
.x_stab
= 0;
5968 a
->x_csect
.x_snstab
= 0;
5970 /* Don't let the COFF backend resort these symbols. */
5971 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5973 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5975 /* We want the value to be the symbol index of the referenced
5976 csect symbol. BFD will do that for us if we set the right
5978 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5979 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5981 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5982 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5984 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5989 block
= symbol_get_tc (sym
)->within
;
5992 /* The value is the offset from the enclosing csect. */
5995 csect
= symbol_get_tc (block
)->within
;
5996 resolve_symbol_value (csect
);
5997 base
= S_GET_VALUE (csect
);
6002 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
6004 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
6005 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
6007 /* We want the value to be a file offset into the line numbers.
6008 BFD will do that for us if we set the right flags. We have
6009 already set the value correctly. */
6010 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
6016 /* Adjust the symbol table. This creates csect symbols for all
6017 absolute symbols. */
6020 ppc_adjust_symtab (void)
6027 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
6031 union internal_auxent
*a
;
6033 if (S_GET_SEGMENT (sym
) != absolute_section
)
6036 csect
= symbol_create (".abs[XO]", absolute_section
,
6037 S_GET_VALUE (sym
), &zero_address_frag
);
6038 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
6039 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
6040 i
= S_GET_NUMBER_AUXILIARY (csect
);
6041 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
6042 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
6043 a
->x_csect
.x_scnlen
.l
= 0;
6044 a
->x_csect
.x_smtyp
= XTY_SD
;
6045 a
->x_csect
.x_parmhash
= 0;
6046 a
->x_csect
.x_snhash
= 0;
6047 a
->x_csect
.x_smclas
= XMC_XO
;
6048 a
->x_csect
.x_stab
= 0;
6049 a
->x_csect
.x_snstab
= 0;
6051 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
6053 i
= S_GET_NUMBER_AUXILIARY (sym
);
6054 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
6055 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
6056 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
6059 ppc_saw_abs
= FALSE
;
6062 /* Set the VMA for a section. This is called on all the sections in
6066 ppc_frob_section (asection
*sec
)
6068 static bfd_vma vma
= 0;
6070 /* Dwarf sections start at 0. */
6071 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6074 vma
= md_section_align (sec
, vma
);
6075 bfd_set_section_vma (stdoutput
, sec
, vma
);
6076 vma
+= bfd_section_size (stdoutput
, sec
);
6079 #endif /* OBJ_XCOFF */
6082 md_atof (int type
, char *litp
, int *sizep
)
6084 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6087 /* Write a value out to the object file, using the appropriate
6091 md_number_to_chars (char *buf
, valueT val
, int n
)
6093 if (target_big_endian
)
6094 number_to_chars_bigendian (buf
, val
, n
);
6096 number_to_chars_littleendian (buf
, val
, n
);
6099 /* Align a section (I don't know why this is machine dependent). */
6102 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6107 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6109 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
6113 /* We don't have any form of relaxing. */
6116 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6117 asection
*seg ATTRIBUTE_UNUSED
)
6123 /* Convert a machine dependent frag. We never generate these. */
6126 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6127 asection
*sec ATTRIBUTE_UNUSED
,
6128 fragS
*fragp ATTRIBUTE_UNUSED
)
6133 /* We have no need to default values of symbols. */
6136 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6141 /* Functions concerning relocs. */
6143 /* The location from which a PC relative jump should be calculated,
6144 given a PC relative reloc. */
6147 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6149 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6154 /* This is called to see whether a fixup should be adjusted to use a
6155 section symbol. We take the opportunity to change a fixup against
6156 a symbol in the TOC subsegment into a reloc against the
6157 corresponding .tc symbol. */
6160 ppc_fix_adjustable (fixS
*fix
)
6162 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6163 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6164 TC_SYMFIELD_TYPE
*tc
;
6166 if (symseg
== absolute_section
)
6169 /* Always adjust symbols in debugging sections. */
6170 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6173 if (ppc_toc_csect
!= (symbolS
*) NULL
6174 && fix
->fx_addsy
!= ppc_toc_csect
6175 && symseg
== data_section
6176 && val
>= ppc_toc_frag
->fr_address
6177 && (ppc_after_toc_frag
== (fragS
*) NULL
6178 || val
< ppc_after_toc_frag
->fr_address
))
6182 for (sy
= symbol_next (ppc_toc_csect
);
6183 sy
!= (symbolS
*) NULL
;
6184 sy
= symbol_next (sy
))
6186 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6188 if (sy_tc
->symbol_class
== XMC_TC0
)
6190 if (sy_tc
->symbol_class
!= XMC_TC
)
6192 if (val
== resolve_symbol_value (sy
))
6195 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6200 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6201 _("symbol in .toc does not match any .tc"));
6204 /* Possibly adjust the reloc to be against the csect. */
6205 tc
= symbol_get_tc (fix
->fx_addsy
);
6207 && tc
->symbol_class
!= XMC_TC0
6208 && tc
->symbol_class
!= XMC_TC
6209 && symseg
!= bss_section
6210 /* Don't adjust if this is a reloc in the toc section. */
6211 && (symseg
!= data_section
6212 || ppc_toc_csect
== NULL
6213 || val
< ppc_toc_frag
->fr_address
6214 || (ppc_after_toc_frag
!= NULL
6215 && val
>= ppc_after_toc_frag
->fr_address
)))
6217 symbolS
*csect
= tc
->within
;
6219 /* If the symbol was not declared by a label (eg: a section symbol),
6220 use the section instead of the csect. This doesn't happen in
6221 normal AIX assembly code. */
6223 csect
= seg_info (symseg
)->sym
;
6225 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6226 fix
->fx_addsy
= csect
;
6231 /* Adjust a reloc against a .lcomm symbol to be against the base
6233 if (symseg
== bss_section
6234 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6236 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6238 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6245 /* A reloc from one csect to another must be kept. The assembler
6246 will, of course, keep relocs between sections, and it will keep
6247 absolute relocs, but we need to force it to keep PC relative relocs
6248 between two csects in the same section. */
6251 ppc_force_relocation (fixS
*fix
)
6253 /* At this point fix->fx_addsy should already have been converted to
6254 a csect symbol. If the csect does not include the fragment, then
6255 we need to force the relocation. */
6257 && fix
->fx_addsy
!= NULL
6258 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6259 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6260 > fix
->fx_frag
->fr_address
)
6261 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6262 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6263 <= fix
->fx_frag
->fr_address
))))
6266 return generic_force_reloc (fix
);
6270 ppc_new_dot_label (symbolS
*sym
)
6272 /* Anchor this label to the current csect for relocations. */
6273 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6276 #endif /* OBJ_XCOFF */
6279 /* If this function returns non-zero, it guarantees that a relocation
6280 will be emitted for a fixup. */
6283 ppc_force_relocation (fixS
*fix
)
6285 /* Branch prediction relocations must force a relocation, as must
6286 the vtable description relocs. */
6287 switch (fix
->fx_r_type
)
6289 case BFD_RELOC_PPC_B16_BRTAKEN
:
6290 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6291 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6292 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6293 case BFD_RELOC_24_PLT_PCREL
:
6294 case BFD_RELOC_PPC64_TOC
:
6296 case BFD_RELOC_PPC_B26
:
6297 case BFD_RELOC_PPC_BA26
:
6298 case BFD_RELOC_PPC_B16
:
6299 case BFD_RELOC_PPC_BA16
:
6300 /* All branch fixups targeting a localentry symbol must
6301 force a relocation. */
6304 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6305 elf_symbol_type
*elfsym
6306 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6307 gas_assert (elfsym
);
6308 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6316 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6317 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6320 return generic_force_reloc (fix
);
6324 ppc_fix_adjustable (fixS
*fix
)
6326 switch (fix
->fx_r_type
)
6328 /* All branch fixups targeting a localentry symbol must
6329 continue using the symbol. */
6330 case BFD_RELOC_PPC_B26
:
6331 case BFD_RELOC_PPC_BA26
:
6332 case BFD_RELOC_PPC_B16
:
6333 case BFD_RELOC_PPC_BA16
:
6334 case BFD_RELOC_PPC_B16_BRTAKEN
:
6335 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6336 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6337 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6340 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6341 elf_symbol_type
*elfsym
6342 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6343 gas_assert (elfsym
);
6344 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6352 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6353 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6354 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6355 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6356 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6357 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6358 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6359 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6360 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6361 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6362 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6367 ppc_frag_check (struct frag
*fragP
)
6369 if (!fragP
->has_code
)
6372 if (ppc_mach() == bfd_mach_ppc_vle
)
6374 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6375 as_bad (_("instruction address is not a multiple of 2"));
6379 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6380 as_bad (_("instruction address is not a multiple of 4"));
6384 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6385 rs_align_code frag. */
6388 ppc_handle_align (struct frag
*fragP
)
6390 valueT count
= (fragP
->fr_next
->fr_address
6391 - (fragP
->fr_address
+ fragP
->fr_fix
));
6393 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6395 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6398 md_number_to_chars (dest
, 0x4400, 2);
6400 else if (count
!= 0 && (count
& 3) == 0)
6402 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6406 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6410 /* Make a branch, then follow with nops. Insert another
6411 frag to handle the nops. */
6412 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6417 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6418 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6419 fragP
->fr_next
= rest
;
6421 rest
->fr_address
+= rest
->fr_fix
+ 4;
6423 /* If we leave the next frag as rs_align_code we'll come here
6424 again, resulting in a bunch of branches rather than a
6425 branch followed by nops. */
6426 rest
->fr_type
= rs_align
;
6427 dest
= rest
->fr_literal
;
6430 md_number_to_chars (dest
, 0x60000000, 4);
6432 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6433 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6434 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6436 /* For power6, power7 and power8, we want the last nop to be a group
6437 terminating one. Do this by inserting an rs_fill frag immediately
6438 after this one, with its address set to the last nop location.
6439 This will automatically reduce the number of nops in the current
6443 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6445 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6446 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6447 group_nop
->fr_fix
= 0;
6448 group_nop
->fr_offset
= 1;
6449 group_nop
->fr_type
= rs_fill
;
6450 fragP
->fr_next
= group_nop
;
6451 dest
= group_nop
->fr_literal
;
6454 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6455 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6457 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6458 /* e500mc group terminating nop: "ori 0,0,0". */
6459 md_number_to_chars (dest
, 0x60000000, 4);
6461 /* power7/power8 group terminating nop: "ori 2,2,0". */
6462 md_number_to_chars (dest
, 0x60420000, 4);
6465 /* power6 group terminating nop: "ori 1,1,0". */
6466 md_number_to_chars (dest
, 0x60210000, 4);
6471 /* Apply a fixup to the object code. This is called for all the
6472 fixups we generated by the calls to fix_new_exp, above. */
6475 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6477 valueT value
= * valP
;
6479 const struct powerpc_operand
*operand
;
6482 if (fixP
->fx_addsy
!= NULL
)
6484 /* Hack around bfd_install_relocation brain damage. */
6486 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6491 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6492 the symbol values. If we are doing this relocation the code in
6493 write.c is going to call bfd_install_relocation, which is also
6494 going to use the symbol value. That means that if the reloc is
6495 fully resolved we want to use *valP since bfd_install_relocation is
6497 However, if the reloc is not fully resolved we do not want to
6498 use *valP, and must use fx_offset instead. If the relocation
6499 is PC-relative, we then need to re-apply md_pcrel_from_section
6500 to this new relocation value. */
6501 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6506 value
= fixP
->fx_offset
;
6508 value
-= md_pcrel_from_section (fixP
, seg
);
6512 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6514 /* We can't actually support subtracting a symbol. */
6515 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6519 if (fixP
->fx_pcrel_adjust
!= 0)
6521 /* This is a fixup on an instruction. */
6522 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6524 operand
= &powerpc_operands
[opindex
];
6526 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6527 does not generate a reloc. It uses the offset of `sym' within its
6528 csect. Other usages, such as `.long sym', generate relocs. This
6529 is the documented behaviour of non-TOC symbols. */
6530 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6531 && (operand
->bitm
& 0xfff0) == 0xfff0
6532 && operand
->shift
== 0
6533 && (operand
->insert
== NULL
|| ppc_obj64
)
6534 && fixP
->fx_addsy
!= NULL
6535 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6536 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6537 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6538 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6540 value
= fixP
->fx_offset
;
6544 /* During parsing of instructions, a TOC16 reloc is generated for
6545 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6546 in the toc. But at parse time, SYM may be not yet defined, so
6547 check again here. */
6548 if (fixP
->fx_r_type
== BFD_RELOC_16
6549 && fixP
->fx_addsy
!= NULL
6550 && ppc_is_toc_sym (fixP
->fx_addsy
))
6551 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6555 /* Calculate value to be stored in field. */
6557 switch (fixP
->fx_r_type
)
6560 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6561 case BFD_RELOC_PPC_VLE_LO16A
:
6562 case BFD_RELOC_PPC_VLE_LO16D
:
6564 case BFD_RELOC_LO16
:
6565 case BFD_RELOC_LO16_PCREL
:
6566 fieldval
= value
& 0xffff;
6568 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6569 fieldval
= SEX16 (fieldval
);
6570 fixP
->fx_no_overflow
= 1;
6573 case BFD_RELOC_HI16
:
6574 case BFD_RELOC_HI16_PCREL
:
6576 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6578 fieldval
= value
>> 16;
6579 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6581 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6582 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6588 case BFD_RELOC_PPC_VLE_HI16A
:
6589 case BFD_RELOC_PPC_VLE_HI16D
:
6590 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6592 fieldval
= PPC_HI (value
);
6593 goto sign_extend_16
;
6595 case BFD_RELOC_HI16_S
:
6596 case BFD_RELOC_HI16_S_PCREL
:
6598 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6600 fieldval
= (value
+ 0x8000) >> 16;
6601 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6603 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6604 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6610 case BFD_RELOC_PPC_VLE_HA16A
:
6611 case BFD_RELOC_PPC_VLE_HA16D
:
6612 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6614 fieldval
= PPC_HA (value
);
6615 goto sign_extend_16
;
6618 case BFD_RELOC_PPC64_HIGHER
:
6619 fieldval
= PPC_HIGHER (value
);
6620 goto sign_extend_16
;
6622 case BFD_RELOC_PPC64_HIGHER_S
:
6623 fieldval
= PPC_HIGHERA (value
);
6624 goto sign_extend_16
;
6626 case BFD_RELOC_PPC64_HIGHEST
:
6627 fieldval
= PPC_HIGHEST (value
);
6628 goto sign_extend_16
;
6630 case BFD_RELOC_PPC64_HIGHEST_S
:
6631 fieldval
= PPC_HIGHESTA (value
);
6632 goto sign_extend_16
;
6639 if (operand
!= NULL
)
6641 /* Handle relocs in an insn. */
6645 switch (fixP
->fx_r_type
)
6648 /* The following relocs can't be calculated by the assembler.
6649 Leave the field zero. */
6650 case BFD_RELOC_PPC_TPREL16
:
6651 case BFD_RELOC_PPC_TPREL16_LO
:
6652 case BFD_RELOC_PPC_TPREL16_HI
:
6653 case BFD_RELOC_PPC_TPREL16_HA
:
6654 case BFD_RELOC_PPC_DTPREL16
:
6655 case BFD_RELOC_PPC_DTPREL16_LO
:
6656 case BFD_RELOC_PPC_DTPREL16_HI
:
6657 case BFD_RELOC_PPC_DTPREL16_HA
:
6658 case BFD_RELOC_PPC_GOT_TLSGD16
:
6659 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6660 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6661 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6662 case BFD_RELOC_PPC_GOT_TLSLD16
:
6663 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6664 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6665 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6666 case BFD_RELOC_PPC_GOT_TPREL16
:
6667 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6668 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6669 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6670 case BFD_RELOC_PPC_GOT_DTPREL16
:
6671 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6672 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6673 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6674 case BFD_RELOC_PPC64_TPREL16_DS
:
6675 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6676 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6677 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6678 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6679 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6680 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6681 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6682 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6683 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6684 case BFD_RELOC_PPC64_DTPREL16_DS
:
6685 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6686 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6687 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6688 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6689 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6690 gas_assert (fixP
->fx_addsy
!= NULL
);
6691 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6695 /* These also should leave the field zero for the same
6696 reason. Note that older versions of gas wrote values
6697 here. If we want to go back to the old behaviour, then
6698 all _LO and _LO_DS cases will need to be treated like
6699 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6700 case BFD_RELOC_16_GOTOFF
:
6701 case BFD_RELOC_LO16_GOTOFF
:
6702 case BFD_RELOC_HI16_GOTOFF
:
6703 case BFD_RELOC_HI16_S_GOTOFF
:
6704 case BFD_RELOC_LO16_PLTOFF
:
6705 case BFD_RELOC_HI16_PLTOFF
:
6706 case BFD_RELOC_HI16_S_PLTOFF
:
6707 case BFD_RELOC_GPREL16
:
6708 case BFD_RELOC_16_BASEREL
:
6709 case BFD_RELOC_LO16_BASEREL
:
6710 case BFD_RELOC_HI16_BASEREL
:
6711 case BFD_RELOC_HI16_S_BASEREL
:
6712 case BFD_RELOC_PPC_TOC16
:
6713 case BFD_RELOC_PPC64_TOC16_LO
:
6714 case BFD_RELOC_PPC64_TOC16_HI
:
6715 case BFD_RELOC_PPC64_TOC16_HA
:
6716 case BFD_RELOC_PPC64_PLTGOT16
:
6717 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6718 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6719 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6720 case BFD_RELOC_PPC64_GOT16_DS
:
6721 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6722 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6723 case BFD_RELOC_PPC64_SECTOFF_DS
:
6724 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6725 case BFD_RELOC_PPC64_TOC16_DS
:
6726 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6727 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6728 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6729 case BFD_RELOC_PPC_EMB_NADDR16
:
6730 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6731 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6732 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6733 case BFD_RELOC_PPC_EMB_SDAI16
:
6734 case BFD_RELOC_PPC_EMB_SDA2I16
:
6735 case BFD_RELOC_PPC_EMB_SDA2REL
:
6736 case BFD_RELOC_PPC_EMB_SDA21
:
6737 case BFD_RELOC_PPC_EMB_MRKREF
:
6738 case BFD_RELOC_PPC_EMB_RELSEC16
:
6739 case BFD_RELOC_PPC_EMB_RELST_LO
:
6740 case BFD_RELOC_PPC_EMB_RELST_HI
:
6741 case BFD_RELOC_PPC_EMB_RELST_HA
:
6742 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6743 case BFD_RELOC_PPC_EMB_RELSDA
:
6744 case BFD_RELOC_PPC_VLE_SDA21
:
6745 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6746 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6747 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6748 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6749 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6750 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6751 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6752 gas_assert (fixP
->fx_addsy
!= NULL
);
6755 case BFD_RELOC_PPC_TLS
:
6756 case BFD_RELOC_PPC_TLSGD
:
6757 case BFD_RELOC_PPC_TLSLD
:
6763 case BFD_RELOC_PPC_B16
:
6764 /* Adjust the offset to the instruction boundary. */
6774 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6775 contents can stay at zero. */
6776 #define APPLY_RELOC fixP->fx_done
6778 #define APPLY_RELOC 1
6780 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6782 /* Fetch the instruction, insert the fully resolved operand
6783 value, and stuff the instruction back again. */
6784 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6785 if (target_big_endian
)
6787 if (fixP
->fx_size
== 4)
6788 insn
= bfd_getb32 ((unsigned char *) where
);
6790 insn
= bfd_getb16 ((unsigned char *) where
);
6794 if (fixP
->fx_size
== 4)
6795 insn
= bfd_getl32 ((unsigned char *) where
);
6797 insn
= bfd_getl16 ((unsigned char *) where
);
6799 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6800 fixP
->tc_fix_data
.ppc_cpu
,
6801 fixP
->fx_file
, fixP
->fx_line
);
6802 if (target_big_endian
)
6804 if (fixP
->fx_size
== 4)
6805 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6807 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6811 if (fixP
->fx_size
== 4)
6812 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6814 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6819 /* Nothing else to do here. */
6822 gas_assert (fixP
->fx_addsy
!= NULL
);
6823 if (fixP
->fx_r_type
== BFD_RELOC_UNUSED
)
6828 /* Use expr_symbol_where to see if this is an expression
6830 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6831 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6832 _("unresolved expression that must be resolved"));
6834 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6835 _("unsupported relocation against %s"),
6836 S_GET_NAME (fixP
->fx_addsy
));
6843 /* Handle relocs in data. */
6844 switch (fixP
->fx_r_type
)
6846 case BFD_RELOC_VTABLE_INHERIT
:
6848 && !S_IS_DEFINED (fixP
->fx_addsy
)
6849 && !S_IS_WEAK (fixP
->fx_addsy
))
6850 S_SET_WEAK (fixP
->fx_addsy
);
6853 case BFD_RELOC_VTABLE_ENTRY
:
6858 /* These can appear with @l etc. in data. */
6859 case BFD_RELOC_LO16
:
6860 case BFD_RELOC_LO16_PCREL
:
6861 case BFD_RELOC_HI16
:
6862 case BFD_RELOC_HI16_PCREL
:
6863 case BFD_RELOC_HI16_S
:
6864 case BFD_RELOC_HI16_S_PCREL
:
6865 case BFD_RELOC_PPC64_HIGHER
:
6866 case BFD_RELOC_PPC64_HIGHER_S
:
6867 case BFD_RELOC_PPC64_HIGHEST
:
6868 case BFD_RELOC_PPC64_HIGHEST_S
:
6869 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6870 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6873 case BFD_RELOC_PPC_DTPMOD
:
6874 case BFD_RELOC_PPC_TPREL
:
6875 case BFD_RELOC_PPC_DTPREL
:
6876 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6879 /* Just punt all of these to the linker. */
6880 case BFD_RELOC_PPC_B16_BRTAKEN
:
6881 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6882 case BFD_RELOC_16_GOTOFF
:
6883 case BFD_RELOC_LO16_GOTOFF
:
6884 case BFD_RELOC_HI16_GOTOFF
:
6885 case BFD_RELOC_HI16_S_GOTOFF
:
6886 case BFD_RELOC_LO16_PLTOFF
:
6887 case BFD_RELOC_HI16_PLTOFF
:
6888 case BFD_RELOC_HI16_S_PLTOFF
:
6889 case BFD_RELOC_PPC_COPY
:
6890 case BFD_RELOC_PPC_GLOB_DAT
:
6891 case BFD_RELOC_16_BASEREL
:
6892 case BFD_RELOC_LO16_BASEREL
:
6893 case BFD_RELOC_HI16_BASEREL
:
6894 case BFD_RELOC_HI16_S_BASEREL
:
6895 case BFD_RELOC_PPC_TLS
:
6896 case BFD_RELOC_PPC_DTPREL16_LO
:
6897 case BFD_RELOC_PPC_DTPREL16_HI
:
6898 case BFD_RELOC_PPC_DTPREL16_HA
:
6899 case BFD_RELOC_PPC_TPREL16_LO
:
6900 case BFD_RELOC_PPC_TPREL16_HI
:
6901 case BFD_RELOC_PPC_TPREL16_HA
:
6902 case BFD_RELOC_PPC_GOT_TLSGD16
:
6903 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6904 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6905 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6906 case BFD_RELOC_PPC_GOT_TLSLD16
:
6907 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6908 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6909 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6910 case BFD_RELOC_PPC_GOT_DTPREL16
:
6911 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6912 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6913 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6914 case BFD_RELOC_PPC_GOT_TPREL16
:
6915 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6916 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6917 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6918 case BFD_RELOC_24_PLT_PCREL
:
6919 case BFD_RELOC_PPC_LOCAL24PC
:
6920 case BFD_RELOC_32_PLT_PCREL
:
6921 case BFD_RELOC_GPREL16
:
6922 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6923 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6924 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6925 case BFD_RELOC_PPC_EMB_NADDR32
:
6926 case BFD_RELOC_PPC_EMB_NADDR16
:
6927 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6928 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6929 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6930 case BFD_RELOC_PPC_EMB_SDAI16
:
6931 case BFD_RELOC_PPC_EMB_SDA2REL
:
6932 case BFD_RELOC_PPC_EMB_SDA2I16
:
6933 case BFD_RELOC_PPC_EMB_SDA21
:
6934 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6935 case BFD_RELOC_PPC_EMB_MRKREF
:
6936 case BFD_RELOC_PPC_EMB_RELSEC16
:
6937 case BFD_RELOC_PPC_EMB_RELST_LO
:
6938 case BFD_RELOC_PPC_EMB_RELST_HI
:
6939 case BFD_RELOC_PPC_EMB_RELST_HA
:
6940 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6941 case BFD_RELOC_PPC_EMB_RELSDA
:
6942 case BFD_RELOC_PPC64_TOC
:
6943 case BFD_RELOC_PPC_TOC16
:
6944 case BFD_RELOC_PPC64_TOC16_LO
:
6945 case BFD_RELOC_PPC64_TOC16_HI
:
6946 case BFD_RELOC_PPC64_TOC16_HA
:
6947 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6948 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6949 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6950 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6951 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6952 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6953 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6954 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6955 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6956 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6957 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6958 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6964 case BFD_RELOC_NONE
:
6966 case BFD_RELOC_CTOR
:
6968 case BFD_RELOC_32_PCREL
:
6971 case BFD_RELOC_64_PCREL
:
6973 case BFD_RELOC_16_PCREL
:
6979 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6984 if (fixP
->fx_size
&& APPLY_RELOC
)
6985 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6986 fieldval
, fixP
->fx_size
);
6989 /* We are only able to convert some relocs to pc-relative. */
6990 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
6992 switch (fixP
->fx_r_type
)
6994 case BFD_RELOC_LO16
:
6995 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6998 case BFD_RELOC_HI16
:
6999 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
7002 case BFD_RELOC_HI16_S
:
7003 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
7007 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7011 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7015 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7018 /* Some of course are already pc-relative. */
7019 case BFD_RELOC_LO16_PCREL
:
7020 case BFD_RELOC_HI16_PCREL
:
7021 case BFD_RELOC_HI16_S_PCREL
:
7022 case BFD_RELOC_64_PCREL
:
7023 case BFD_RELOC_32_PCREL
:
7024 case BFD_RELOC_16_PCREL
:
7025 case BFD_RELOC_PPC_B16
:
7026 case BFD_RELOC_PPC_B16_BRTAKEN
:
7027 case BFD_RELOC_PPC_B16_BRNTAKEN
:
7028 case BFD_RELOC_PPC_B26
:
7029 case BFD_RELOC_PPC_LOCAL24PC
:
7030 case BFD_RELOC_24_PLT_PCREL
:
7031 case BFD_RELOC_32_PLT_PCREL
:
7032 case BFD_RELOC_64_PLT_PCREL
:
7033 case BFD_RELOC_PPC_VLE_REL8
:
7034 case BFD_RELOC_PPC_VLE_REL15
:
7035 case BFD_RELOC_PPC_VLE_REL24
:
7044 /* Use expr_symbol_where to see if this is an
7045 expression symbol. */
7046 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
7047 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7048 _("unresolved expression that must"
7051 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7052 _("cannot emit PC relative %s relocation"
7054 bfd_get_reloc_code_name (fixP
->fx_r_type
),
7055 S_GET_NAME (fixP
->fx_addsy
));
7058 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7059 _("unable to resolve expression"));
7066 ppc_elf_validate_fix (fixP
, seg
);
7067 fixP
->fx_addnumber
= value
;
7069 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
7070 from the section contents. If we are going to be emitting a reloc
7071 then the section contents are immaterial, so don't warn if they
7072 happen to overflow. Leave such warnings to ld. */
7075 fixP
->fx_no_overflow
= 1;
7077 /* Arrange to emit .TOC. as a normal symbol if used in anything
7078 but .TOC.@tocbase. */
7080 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
7081 && fixP
->fx_addsy
!= NULL
7082 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
7083 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
7086 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
7087 fixP
->fx_addnumber
= 0;
7091 fixP
->fx_addnumber
= 0;
7093 /* We want to use the offset within the toc, not the actual VMA
7095 fixP
->fx_addnumber
=
7096 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
7097 - S_GET_VALUE (ppc_toc_csect
);
7098 /* Set *valP to avoid errors. */
7105 /* Generate a reloc for a fixup. */
7108 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
7112 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
7114 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
7115 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
7116 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
7117 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
7118 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
7120 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
7121 _("reloc %d not supported by object file format"),
7122 (int) fixp
->fx_r_type
);
7125 reloc
->addend
= fixp
->fx_addnumber
;
7131 ppc_cfi_frame_initial_instructions (void)
7133 cfi_add_CFA_def_cfa (1, 0);
7137 tc_ppc_regname_to_dw2regnum (char *regname
)
7139 unsigned int regnum
= -1;
7143 static struct { char *name
; int dw2regnum
; } regnames
[] =
7145 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7146 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7147 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7148 { "spe_acc", 111 }, { "spefscr", 112 }
7151 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7152 if (strcmp (regnames
[i
].name
, regname
) == 0)
7153 return regnames
[i
].dw2regnum
;
7155 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7157 p
= regname
+ 1 + (regname
[1] == '.');
7158 regnum
= strtoul (p
, &q
, 10);
7159 if (p
== q
|| *q
|| regnum
>= 32)
7161 if (regname
[0] == 'f')
7163 else if (regname
[0] == 'v')
7166 else if (regname
[0] == 'c' && regname
[1] == 'r')
7168 p
= regname
+ 2 + (regname
[2] == '.');
7169 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7171 regnum
= p
[0] - '0' + 68;