1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994-2016 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "safe-ctype.h"
25 #include "dw2gencfi.h"
26 #include "opcode/ppc.h"
30 #include "elf/ppc64.h"
31 #include "dwarf2dbg.h"
39 #include "coff/xcoff.h"
43 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
45 /* Tell the main code what the endianness is. */
46 extern int target_big_endian
;
48 /* Whether or not, we've set target_big_endian. */
49 static int set_target_endian
= 0;
51 /* Whether to use user friendly register names. */
52 #ifndef TARGET_REG_NAMES_P
54 #define TARGET_REG_NAMES_P TRUE
56 #define TARGET_REG_NAMES_P FALSE
60 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
63 /* #lo(value) denotes the least significant 16 bits of the indicated. */
64 #define PPC_LO(v) ((v) & 0xffff)
66 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
67 #define PPC_HI(v) (((v) >> 16) & 0xffff)
69 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
70 the indicated value, compensating for #lo() being treated as a
72 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
74 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
75 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
77 /* #highera(value) denotes bits 32 through 47 of the indicated value,
78 compensating for #lo() being treated as a signed number. */
79 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
81 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
82 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
84 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
85 compensating for #lo being treated as a signed number. */
86 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
88 #define SEX16(val) (((val) ^ 0x8000) - 0x8000)
90 /* For the time being on ppc64, don't report overflow on @h and @ha
91 applied to constants. */
92 #define REPORT_OVERFLOW_HI 0
94 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
96 static void ppc_macro (char *, const struct powerpc_macro
*);
97 static void ppc_byte (int);
99 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
100 static void ppc_tc (int);
101 static void ppc_machine (int);
105 static void ppc_comm (int);
106 static void ppc_bb (int);
107 static void ppc_bc (int);
108 static void ppc_bf (int);
109 static void ppc_biei (int);
110 static void ppc_bs (int);
111 static void ppc_eb (int);
112 static void ppc_ec (int);
113 static void ppc_ef (int);
114 static void ppc_es (int);
115 static void ppc_csect (int);
116 static void ppc_dwsect (int);
117 static void ppc_change_csect (symbolS
*, offsetT
);
118 static void ppc_function (int);
119 static void ppc_extern (int);
120 static void ppc_lglobl (int);
121 static void ppc_ref (int);
122 static void ppc_section (int);
123 static void ppc_named_section (int);
124 static void ppc_stabx (int);
125 static void ppc_rename (int);
126 static void ppc_toc (int);
127 static void ppc_xcoff_cons (int);
128 static void ppc_vbyte (int);
132 static void ppc_elf_rdata (int);
133 static void ppc_elf_lcomm (int);
134 static void ppc_elf_localentry (int);
135 static void ppc_elf_abiversion (int);
139 static void ppc_previous (int);
140 static void ppc_pdata (int);
141 static void ppc_ydata (int);
142 static void ppc_reldata (int);
143 static void ppc_rdata (int);
144 static void ppc_ualong (int);
145 static void ppc_znop (int);
146 static void ppc_pe_comm (int);
147 static void ppc_pe_section (int);
148 static void ppc_pe_function (int);
149 static void ppc_pe_tocd (int);
152 /* Generic assembler global variables which must be defined by all
156 /* This string holds the chars that always start a comment. If the
157 pre-processor is disabled, these aren't very useful. The macro
158 tc_comment_chars points to this. We use this, rather than the
159 usual comment_chars, so that we can switch for Solaris conventions. */
160 static const char ppc_solaris_comment_chars
[] = "#!";
161 static const char ppc_eabi_comment_chars
[] = "#";
163 #ifdef TARGET_SOLARIS_COMMENT
164 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
166 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
169 const char comment_chars
[] = "#";
172 /* Characters which start a comment at the beginning of a line. */
173 const char line_comment_chars
[] = "#";
175 /* Characters which may be used to separate multiple commands on a
177 const char line_separator_chars
[] = ";";
179 /* Characters which are used to indicate an exponent in a floating
181 const char EXP_CHARS
[] = "eE";
183 /* Characters which mean that a number is a floating point constant,
185 const char FLT_CHARS
[] = "dD";
187 /* Anything that can start an operand needs to be mentioned here,
188 to stop the input scrubber eating whitespace. */
189 const char ppc_symbol_chars
[] = "%[";
191 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
192 int ppc_cie_data_alignment
;
194 /* The dwarf2 minimum instruction length. */
195 int ppc_dwarf2_line_min_insn_length
;
197 /* More than this number of nops in an alignment op gets a branch
199 unsigned long nop_limit
= 4;
201 /* The type of processor we are assembling for. This is one or more
202 of the PPC_OPCODE flags defined in opcode/ppc.h. */
203 ppc_cpu_t ppc_cpu
= 0;
204 ppc_cpu_t sticky
= 0;
206 /* Value for ELF e_flags EF_PPC64_ABI. */
207 unsigned int ppc_abiversion
= 0;
210 /* Flags set on encountering toc relocs. */
212 has_large_toc_reloc
= 1,
213 has_small_toc_reloc
= 2
217 /* Warn on emitting data to code sections. */
219 unsigned long last_insn
;
223 /* The target specific pseudo-ops which we support. */
225 const pseudo_typeS md_pseudo_table
[] =
227 /* Pseudo-ops which must be overridden. */
228 { "byte", ppc_byte
, 0 },
231 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
232 legitimately belong in the obj-*.c file. However, XCOFF is based
233 on COFF, and is only implemented for the RS/6000. We just use
234 obj-coff.c, and add what we need here. */
235 { "comm", ppc_comm
, 0 },
236 { "lcomm", ppc_comm
, 1 },
240 { "bi", ppc_biei
, 0 },
242 { "csect", ppc_csect
, 0 },
243 { "dwsect", ppc_dwsect
, 0 },
244 { "data", ppc_section
, 'd' },
248 { "ei", ppc_biei
, 1 },
250 { "extern", ppc_extern
, 0 },
251 { "function", ppc_function
, 0 },
252 { "lglobl", ppc_lglobl
, 0 },
253 { "ref", ppc_ref
, 0 },
254 { "rename", ppc_rename
, 0 },
255 { "section", ppc_named_section
, 0 },
256 { "stabx", ppc_stabx
, 0 },
257 { "text", ppc_section
, 't' },
258 { "toc", ppc_toc
, 0 },
259 { "long", ppc_xcoff_cons
, 2 },
260 { "llong", ppc_xcoff_cons
, 3 },
261 { "word", ppc_xcoff_cons
, 1 },
262 { "short", ppc_xcoff_cons
, 1 },
263 { "vbyte", ppc_vbyte
, 0 },
267 { "llong", cons
, 8 },
268 { "rdata", ppc_elf_rdata
, 0 },
269 { "rodata", ppc_elf_rdata
, 0 },
270 { "lcomm", ppc_elf_lcomm
, 0 },
271 { "localentry", ppc_elf_localentry
, 0 },
272 { "abiversion", ppc_elf_abiversion
, 0 },
276 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
277 { "previous", ppc_previous
, 0 },
278 { "pdata", ppc_pdata
, 0 },
279 { "ydata", ppc_ydata
, 0 },
280 { "reldata", ppc_reldata
, 0 },
281 { "rdata", ppc_rdata
, 0 },
282 { "ualong", ppc_ualong
, 0 },
283 { "znop", ppc_znop
, 0 },
284 { "comm", ppc_pe_comm
, 0 },
285 { "lcomm", ppc_pe_comm
, 1 },
286 { "section", ppc_pe_section
, 0 },
287 { "function", ppc_pe_function
,0 },
288 { "tocd", ppc_pe_tocd
, 0 },
291 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
293 { "machine", ppc_machine
, 0 },
300 /* Predefined register names if -mregnames (or default for Windows NT).
301 In general, there are lots of them, in an attempt to be compatible
302 with a number of other Windows NT assemblers. */
304 /* Structure to hold information about predefined registers. */
311 /* List of registers that are pre-defined:
313 Each general register has predefined names of the form:
314 1. r<reg_num> which has the value <reg_num>.
315 2. r.<reg_num> which has the value <reg_num>.
317 Each floating point register has predefined names of the form:
318 1. f<reg_num> which has the value <reg_num>.
319 2. f.<reg_num> which has the value <reg_num>.
321 Each vector unit register has predefined names of the form:
322 1. v<reg_num> which has the value <reg_num>.
323 2. v.<reg_num> which has the value <reg_num>.
325 Each condition register has predefined names of the form:
326 1. cr<reg_num> which has the value <reg_num>.
327 2. cr.<reg_num> which has the value <reg_num>.
329 There are individual registers as well:
330 sp or r.sp has the value 1
331 rtoc or r.toc has the value 2
332 fpscr has the value 0
338 dsisr has the value 18
340 sdr1 has the value 25
341 srr0 has the value 26
342 srr1 has the value 27
344 The table is sorted. Suitable for searching by a binary search. */
346 static const struct pd_reg pre_defined_registers
[] =
348 { "cr.0", 0 }, /* Condition Registers */
368 { "dar", 19 }, /* Data Access Register */
369 { "dec", 22 }, /* Decrementer */
370 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
372 { "f.0", 0 }, /* Floating point registers */
399 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
465 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
506 /* Quantization registers used with pair single instructions. */
524 { "lr", 8 }, /* Link Register */
528 { "r.0", 0 }, /* General Purpose Registers */
561 { "r.sp", 1 }, /* Stack Pointer */
563 { "r.toc", 2 }, /* Pointer to the table of contents */
565 { "r0", 0 }, /* More general purpose registers */
598 { "rtoc", 2 }, /* Table of contents */
600 { "sdr1", 25 }, /* Storage Description Register 1 */
604 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
605 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
607 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
673 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
807 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
809 /* Given NAME, find the register number associated with that name, return
810 the integer value associated with the given name or -1 on failure. */
813 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
815 int middle
, low
, high
;
823 middle
= (low
+ high
) / 2;
824 cmp
= strcasecmp (name
, regs
[middle
].name
);
830 return regs
[middle
].value
;
838 * Summary of register_name.
840 * in: Input_line_pointer points to 1st char of operand.
842 * out: A expressionS.
843 * The operand may have been a register: in this case, X_op == O_register,
844 * X_add_number is set to the register number, and truth is returned.
845 * Input_line_pointer->(next non-blank) char after operand, or is in its
850 register_name (expressionS
*expressionP
)
857 /* Find the spelling of the operand. */
858 start
= name
= input_line_pointer
;
859 if (name
[0] == '%' && ISALPHA (name
[1]))
860 name
= ++input_line_pointer
;
862 else if (!reg_names_p
|| !ISALPHA (name
[0]))
865 c
= get_symbol_name (&name
);
866 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
868 /* Put back the delimiting char. */
869 *input_line_pointer
= c
;
871 /* Look to see if it's in the register table. */
874 expressionP
->X_op
= O_register
;
875 expressionP
->X_add_number
= reg_number
;
877 /* Make the rest nice. */
878 expressionP
->X_add_symbol
= NULL
;
879 expressionP
->X_op_symbol
= NULL
;
883 /* Reset the line as if we had not done anything. */
884 input_line_pointer
= start
;
888 /* This function is called for each symbol seen in an expression. It
889 handles the special parsing which PowerPC assemblers are supposed
890 to use for condition codes. */
892 /* Whether to do the special parsing. */
893 static bfd_boolean cr_operand
;
895 /* Names to recognize in a condition code. This table is sorted. */
896 static const struct pd_reg cr_names
[] =
913 /* Parsing function. This returns non-zero if it recognized an
917 ppc_parse_name (const char *name
, expressionS
*exp
)
926 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
931 exp
->X_op
= O_constant
;
932 exp
->X_add_number
= val
;
937 /* Local variables. */
939 /* Whether to target xcoff64/elf64. */
940 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
942 /* Opcode hash table. */
943 static struct hash_control
*ppc_hash
;
945 /* Macro hash table. */
946 static struct hash_control
*ppc_macro_hash
;
949 /* What type of shared library support to use. */
950 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
952 /* Flags to set in the elf header. */
953 static flagword ppc_flags
= 0;
955 /* Whether this is Solaris or not. */
956 #ifdef TARGET_SOLARIS_COMMENT
957 #define SOLARIS_P TRUE
959 #define SOLARIS_P FALSE
962 static bfd_boolean msolaris
= SOLARIS_P
;
967 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
968 using a bunch of different sections. These assembler sections,
969 however, are all encompassed within the .text or .data sections of
970 the final output file. We handle this by using different
971 subsegments within these main segments. */
973 /* Next subsegment to allocate within the .text segment. */
974 static subsegT ppc_text_subsegment
= 2;
976 /* Linked list of csects in the text section. */
977 static symbolS
*ppc_text_csects
;
979 /* Next subsegment to allocate within the .data segment. */
980 static subsegT ppc_data_subsegment
= 2;
982 /* Linked list of csects in the data section. */
983 static symbolS
*ppc_data_csects
;
985 /* The current csect. */
986 static symbolS
*ppc_current_csect
;
988 /* The RS/6000 assembler uses a TOC which holds addresses of functions
989 and variables. Symbols are put in the TOC with the .tc pseudo-op.
990 A special relocation is used when accessing TOC entries. We handle
991 the TOC as a subsegment within the .data segment. We set it up if
992 we see a .toc pseudo-op, and save the csect symbol here. */
993 static symbolS
*ppc_toc_csect
;
995 /* The first frag in the TOC subsegment. */
996 static fragS
*ppc_toc_frag
;
998 /* The first frag in the first subsegment after the TOC in the .data
999 segment. NULL if there are no subsegments after the TOC. */
1000 static fragS
*ppc_after_toc_frag
;
1002 /* The current static block. */
1003 static symbolS
*ppc_current_block
;
1005 /* The COFF debugging section; set by md_begin. This is not the
1006 .debug section, but is instead the secret BFD section which will
1007 cause BFD to set the section number of a symbol to N_DEBUG. */
1008 static asection
*ppc_coff_debug_section
;
1010 /* Structure to set the length field of the dwarf sections. */
1011 struct dw_subsection
{
1012 /* Subsections are simply linked. */
1013 struct dw_subsection
*link
;
1015 /* The subsection number. */
1018 /* Expression to compute the length of the section. */
1019 expressionS end_exp
;
1022 static struct dw_section
{
1023 /* Corresponding section. */
1026 /* Simply linked list of subsections with a label. */
1027 struct dw_subsection
*list_subseg
;
1029 /* The anonymous subsection. */
1030 struct dw_subsection
*anon_subseg
;
1031 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1032 #endif /* OBJ_XCOFF */
1036 /* Various sections that we need for PE coff support. */
1037 static segT ydata_section
;
1038 static segT pdata_section
;
1039 static segT reldata_section
;
1040 static segT rdata_section
;
1041 static segT tocdata_section
;
1043 /* The current section and the previous section. See ppc_previous. */
1044 static segT ppc_previous_section
;
1045 static segT ppc_current_section
;
1050 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1051 #define PPC_APUINFO_ISEL 0x40
1052 #define PPC_APUINFO_PMR 0x41
1053 #define PPC_APUINFO_RFMCI 0x42
1054 #define PPC_APUINFO_CACHELCK 0x43
1055 #define PPC_APUINFO_SPE 0x100
1056 #define PPC_APUINFO_EFS 0x101
1057 #define PPC_APUINFO_BRLOCK 0x102
1058 #define PPC_APUINFO_VLE 0x104
1061 * We keep a list of APUinfo
1063 unsigned long *ppc_apuinfo_list
;
1064 unsigned int ppc_apuinfo_num
;
1065 unsigned int ppc_apuinfo_num_alloc
;
1066 #endif /* OBJ_ELF */
1069 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1071 const char *const md_shortopts
= "um:";
1073 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1074 const struct option md_longopts
[] = {
1075 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1076 {"ppc476-workaround", no_argument
, &warn_476
, 1},
1077 {"no-ppc476-workaround", no_argument
, &warn_476
, 0},
1078 {NULL
, no_argument
, NULL
, 0}
1080 const size_t md_longopts_size
= sizeof (md_longopts
);
1083 md_parse_option (int c
, const char *arg
)
1090 /* -u means that any undefined symbols should be treated as
1091 external, which is the default for gas anyhow. */
1096 /* Solaris as takes -le (presumably for little endian). For completeness
1097 sake, recognize -be also. */
1098 if (strcmp (arg
, "e") == 0)
1100 target_big_endian
= 0;
1101 set_target_endian
= 1;
1102 if (ppc_cpu
& PPC_OPCODE_VLE
)
1103 as_bad (_("the use of -mvle requires big endian."));
1111 if (strcmp (arg
, "e") == 0)
1113 target_big_endian
= 1;
1114 set_target_endian
= 1;
1122 /* Recognize -K PIC. */
1123 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1126 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1134 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1136 if (strcmp (arg
, "64") == 0)
1140 if (ppc_cpu
& PPC_OPCODE_VLE
)
1141 as_bad (_("the use of -mvle requires -a32."));
1143 as_fatal (_("%s unsupported"), "-a64");
1146 else if (strcmp (arg
, "32") == 0)
1153 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1157 if (strcmp (arg
, "vle") == 0)
1159 if (set_target_endian
&& target_big_endian
== 0)
1160 as_bad (_("the use of -mvle requires big endian."));
1162 as_bad (_("the use of -mvle requires -a32."));
1166 else if (strcmp (arg
, "regnames") == 0)
1169 else if (strcmp (arg
, "no-regnames") == 0)
1170 reg_names_p
= FALSE
;
1173 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1174 that require relocation. */
1175 else if (strcmp (arg
, "relocatable") == 0)
1177 shlib
= SHLIB_MRELOCATABLE
;
1178 ppc_flags
|= EF_PPC_RELOCATABLE
;
1181 else if (strcmp (arg
, "relocatable-lib") == 0)
1183 shlib
= SHLIB_MRELOCATABLE
;
1184 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1187 /* -memb, set embedded bit. */
1188 else if (strcmp (arg
, "emb") == 0)
1189 ppc_flags
|= EF_PPC_EMB
;
1191 /* -mlittle/-mbig set the endianness. */
1192 else if (strcmp (arg
, "little") == 0
1193 || strcmp (arg
, "little-endian") == 0)
1195 target_big_endian
= 0;
1196 set_target_endian
= 1;
1197 if (ppc_cpu
& PPC_OPCODE_VLE
)
1198 as_bad (_("the use of -mvle requires big endian."));
1201 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1203 target_big_endian
= 1;
1204 set_target_endian
= 1;
1207 else if (strcmp (arg
, "solaris") == 0)
1210 ppc_comment_chars
= ppc_solaris_comment_chars
;
1213 else if (strcmp (arg
, "no-solaris") == 0)
1216 ppc_comment_chars
= ppc_eabi_comment_chars
;
1221 as_bad (_("invalid switch -m%s"), arg
);
1227 /* -V: SVR4 argument to print version ID. */
1229 print_version_id ();
1232 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1233 should be emitted or not. FIXME: Not implemented. */
1237 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1238 rather than .stabs.excl, which is ignored by the linker.
1239 FIXME: Not implemented. */
1250 nop_limit
= strtoul (optarg
, &end
, 0);
1252 as_bad (_("--nops needs a numeric argument"));
1267 md_show_usage (FILE *stream
)
1269 fprintf (stream
, _("\
1271 -a32 generate ELF32/XCOFF32\n\
1272 -a64 generate ELF64/XCOFF64\n\
1274 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1275 -mpwr generate code for POWER (RIOS1)\n\
1276 -m601 generate code for PowerPC 601\n\
1277 -mppc, -mppc32, -m603, -m604\n\
1278 generate code for PowerPC 603/604\n\
1279 -m403 generate code for PowerPC 403\n\
1280 -m405 generate code for PowerPC 405\n\
1281 -m440 generate code for PowerPC 440\n\
1282 -m464 generate code for PowerPC 464\n\
1283 -m476 generate code for PowerPC 476\n\
1284 -m7400, -m7410, -m7450, -m7455\n\
1285 generate code for PowerPC 7400/7410/7450/7455\n\
1286 -m750cl generate code for PowerPC 750cl\n\
1287 -m821, -m850, -m860 generate code for PowerPC 821/850/860\n"));
1288 fprintf (stream
, _("\
1289 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1290 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1291 -mbooke generate code for 32-bit PowerPC BookE\n\
1292 -ma2 generate code for A2 architecture\n\
1293 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1294 -mpower5, -mpwr5, -mpwr5x\n\
1295 generate code for Power5 architecture\n\
1296 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1297 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1298 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1299 -mpower9, -mpwr9 generate code for Power9 architecture\n\
1300 -mcell generate code for Cell Broadband Engine architecture\n\
1301 -mcom generate code Power/PowerPC common instructions\n\
1302 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1303 fprintf (stream
, _("\
1304 -maltivec generate code for AltiVec\n\
1305 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1306 -mhtm generate code for Hardware Transactional Memory\n\
1307 -me300 generate code for PowerPC e300 family\n\
1308 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1309 -me500mc, generate code for Freescale e500mc core complex\n\
1310 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1311 -me5500, generate code for Freescale e5500 core complex\n\
1312 -me6500, generate code for Freescale e6500 core complex\n\
1313 -mspe generate code for Motorola SPE instructions\n\
1314 -mvle generate code for Freescale VLE instructions\n\
1315 -mtitan generate code for AppliedMicro Titan core complex\n\
1316 -mregnames Allow symbolic names for registers\n\
1317 -mno-regnames Do not allow symbolic names for registers\n"));
1319 fprintf (stream
, _("\
1320 -mrelocatable support for GCC's -mrelocatble option\n\
1321 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1322 -memb set PPC_EMB bit in ELF flags\n\
1323 -mlittle, -mlittle-endian, -le\n\
1324 generate code for a little endian machine\n\
1325 -mbig, -mbig-endian, -be\n\
1326 generate code for a big endian machine\n\
1327 -msolaris generate code for Solaris\n\
1328 -mno-solaris do not generate code for Solaris\n\
1329 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1330 -V print assembler version number\n\
1331 -Qy, -Qn ignored\n"));
1333 fprintf (stream
, _("\
1334 -nops=count when aligning, more than COUNT nops uses a branch\n\
1335 -ppc476-workaround warn if emitting data to code sections\n"));
1338 /* Set ppc_cpu if it is not already set. */
1343 const char *default_os
= TARGET_OS
;
1344 const char *default_cpu
= TARGET_CPU
;
1346 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1349 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1350 else if (strncmp (default_os
, "aix", 3) == 0
1351 && default_os
[3] >= '4' && default_os
[3] <= '9')
1352 ppc_cpu
|= PPC_OPCODE_COMMON
;
1353 else if (strncmp (default_os
, "aix3", 4) == 0)
1354 ppc_cpu
|= PPC_OPCODE_POWER
;
1355 else if (strcmp (default_cpu
, "rs6000") == 0)
1356 ppc_cpu
|= PPC_OPCODE_POWER
;
1357 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1358 ppc_cpu
|= PPC_OPCODE_PPC
;
1360 as_fatal (_("unknown default cpu = %s, os = %s"),
1361 default_cpu
, default_os
);
1365 /* Figure out the BFD architecture to use. This function and ppc_mach
1366 are called well before md_begin, when the output file is opened. */
1368 enum bfd_architecture
1371 const char *default_cpu
= TARGET_CPU
;
1374 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1375 return bfd_arch_powerpc
;
1376 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1377 return bfd_arch_powerpc
;
1378 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1379 return bfd_arch_rs6000
;
1380 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1382 if (strcmp (default_cpu
, "rs6000") == 0)
1383 return bfd_arch_rs6000
;
1384 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1385 return bfd_arch_powerpc
;
1388 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1389 return bfd_arch_unknown
;
1396 return bfd_mach_ppc64
;
1397 else if (ppc_arch () == bfd_arch_rs6000
)
1398 return bfd_mach_rs6k
;
1399 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1400 return bfd_mach_ppc_titan
;
1401 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1402 return bfd_mach_ppc_vle
;
1404 return bfd_mach_ppc
;
1408 ppc_target_format (void)
1412 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1414 return "xcoff-powermac";
1417 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1419 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1425 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1426 # elif defined (TE_VXWORKS)
1427 return "elf32-powerpc-vxworks";
1429 return (target_big_endian
1430 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1431 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1436 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1437 Return TRUE if there's a problem, otherwise FALSE. */
1440 insn_validate (const struct powerpc_opcode
*op
)
1442 const unsigned char *o
;
1443 unsigned long omask
= op
->mask
;
1445 /* The mask had better not trim off opcode bits. */
1446 if ((op
->opcode
& omask
) != op
->opcode
)
1448 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1452 /* The operands must not overlap the opcode or each other. */
1453 for (o
= op
->operands
; *o
; ++o
)
1455 if (*o
>= num_powerpc_operands
)
1457 as_bad (_("operand index error for %s"), op
->name
);
1462 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1463 if (operand
->shift
!= (int) PPC_OPSHIFT_INV
)
1467 if (operand
->shift
>= 0)
1468 mask
= operand
->bitm
<< operand
->shift
;
1470 mask
= operand
->bitm
>> -operand
->shift
;
1473 as_bad (_("operand %d overlap in %s"),
1474 (int) (o
- op
->operands
), op
->name
);
1484 /* Insert opcodes and macros into hash tables. Called at startup and
1485 for .machine pseudo. */
1488 ppc_setup_opcodes (void)
1490 const struct powerpc_opcode
*op
;
1491 const struct powerpc_opcode
*op_end
;
1492 const struct powerpc_macro
*macro
;
1493 const struct powerpc_macro
*macro_end
;
1494 bfd_boolean bad_insn
= FALSE
;
1496 if (ppc_hash
!= NULL
)
1497 hash_die (ppc_hash
);
1498 if (ppc_macro_hash
!= NULL
)
1499 hash_die (ppc_macro_hash
);
1501 /* Insert the opcodes into a hash table. */
1502 ppc_hash
= hash_new ();
1504 if (ENABLE_CHECKING
)
1508 /* An index into powerpc_operands is stored in struct fix
1509 fx_pcrel_adjust which is 8 bits wide. */
1510 gas_assert (num_powerpc_operands
< 256);
1512 /* Check operand masks. Code here and in the disassembler assumes
1513 all the 1's in the mask are contiguous. */
1514 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1516 unsigned long mask
= powerpc_operands
[i
].bitm
;
1517 unsigned long right_bit
;
1520 right_bit
= mask
& -mask
;
1522 right_bit
= mask
& -mask
;
1523 if (mask
!= right_bit
)
1525 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1528 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1529 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1530 sizeof (powerpc_operands
[0])) == 0)
1532 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1539 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1540 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1542 if (ENABLE_CHECKING
)
1544 if (op
!= powerpc_opcodes
)
1546 int old_opcode
= PPC_OP (op
[-1].opcode
);
1547 int new_opcode
= PPC_OP (op
[0].opcode
);
1549 #ifdef PRINT_OPCODE_TABLE
1550 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1551 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1552 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1553 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1556 /* The major opcodes had better be sorted. Code in the
1557 disassembler assumes the insns are sorted according to
1559 if (new_opcode
< old_opcode
)
1561 as_bad (_("major opcode is not sorted for %s"),
1566 bad_insn
|= insn_validate (op
);
1569 if ((ppc_cpu
& op
->flags
) != 0
1570 && !(ppc_cpu
& op
->deprecated
))
1574 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1577 as_bad (_("duplicate instruction %s"),
1584 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1585 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1586 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1588 op_end
= vle_opcodes
+ vle_num_opcodes
;
1589 for (op
= vle_opcodes
; op
< op_end
; op
++)
1591 if (ENABLE_CHECKING
)
1593 if (op
!= vle_opcodes
)
1595 unsigned old_seg
, new_seg
;
1597 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1598 old_seg
= VLE_OP_TO_SEG (old_seg
);
1599 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1600 new_seg
= VLE_OP_TO_SEG (new_seg
);
1602 #ifdef PRINT_OPCODE_TABLE
1603 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1604 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1605 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1606 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1608 /* The major opcodes had better be sorted. Code in the
1609 disassembler assumes the insns are sorted according to
1611 if (new_seg
< old_seg
)
1613 as_bad (_("major opcode is not sorted for %s"),
1619 bad_insn
|= insn_validate (op
);
1622 if ((ppc_cpu
& op
->flags
) != 0
1623 && !(ppc_cpu
& op
->deprecated
))
1627 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1630 as_bad (_("duplicate instruction %s"),
1637 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1638 for (op
= vle_opcodes
; op
< op_end
; op
++)
1639 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1641 /* Insert the macros into a hash table. */
1642 ppc_macro_hash
= hash_new ();
1644 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1645 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1647 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1651 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1652 if (retval
!= (const char *) NULL
)
1654 as_bad (_("duplicate macro %s"), macro
->name
);
1664 /* This function is called when the assembler starts up. It is called
1665 after the options have been parsed and the output file has been
1673 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1674 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1677 /* Set the ELF flags if desired. */
1678 if (ppc_flags
&& !msolaris
)
1679 bfd_set_private_flags (stdoutput
, ppc_flags
);
1682 ppc_setup_opcodes ();
1684 /* Tell the main code what the endianness is if it is not overridden
1686 if (!set_target_endian
)
1688 set_target_endian
= 1;
1689 target_big_endian
= PPC_BIG_ENDIAN
;
1693 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1695 /* Create dummy symbols to serve as initial csects. This forces the
1696 text csects to precede the data csects. These symbols will not
1698 ppc_text_csects
= symbol_make ("dummy\001");
1699 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1700 ppc_data_csects
= symbol_make ("dummy\001");
1701 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1706 ppc_current_section
= text_section
;
1707 ppc_previous_section
= 0;
1716 if (ppc_apuinfo_list
== NULL
)
1719 /* Ok, so write the section info out. We have this layout:
1723 0 8 length of "APUinfo\0"
1724 4 (n*4) number of APU's (4 bytes each)
1727 20 APU#1 first APU's info
1728 24 APU#2 second APU's info
1733 asection
*seg
= now_seg
;
1734 subsegT subseg
= now_subseg
;
1735 asection
*apuinfo_secp
= (asection
*) NULL
;
1738 /* Create the .PPC.EMB.apuinfo section. */
1739 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1740 bfd_set_section_flags (stdoutput
,
1742 SEC_HAS_CONTENTS
| SEC_READONLY
);
1745 md_number_to_chars (p
, (valueT
) 8, 4);
1748 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1751 md_number_to_chars (p
, (valueT
) 2, 4);
1754 strcpy (p
, "APUinfo");
1756 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1759 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1762 frag_align (2, 0, 0);
1764 /* We probably can't restore the current segment, for there likely
1767 subseg_set (seg
, subseg
);
1772 /* Insert an operand value into an instruction. */
1774 static unsigned long
1775 ppc_insert_operand (unsigned long insn
,
1776 const struct powerpc_operand
*operand
,
1782 long min
, max
, right
;
1784 max
= operand
->bitm
;
1788 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1790 /* Extend the allowed range for addis to [-65536, 65535].
1791 Similarly for some VLE high part insns. For 64-bit it
1792 would be good to disable this for signed fields since the
1793 value is sign extended into the high 32 bits of the register.
1794 If the value is, say, an address, then we might care about
1795 the high bits. However, gcc as of 2014-06 uses unsigned
1796 values when loading the high part of 64-bit constants using
1798 Use the same extended range for cmpli, to allow at least
1800 min
= ~max
& -right
;
1802 else if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1804 max
= (max
>> 1) & -right
;
1805 min
= ~max
& -right
;
1808 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1811 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1820 /* Some people write constants with the sign extension done by
1821 hand but only up to 32 bits. This shouldn't really be valid,
1822 but, to permit this code to assemble on a 64-bit host, we
1823 sign extend the 32-bit value to 64 bits if so doing makes the
1826 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1827 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1828 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1829 val
= val
- 0x80000000 - 0x80000000;
1831 /* Similarly, people write expressions like ~(1<<15), and expect
1832 this to be OK for a 32-bit unsigned value. */
1834 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1835 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1836 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1837 val
= val
+ 0x80000000 + 0x80000000;
1841 || (val
& (right
- 1)) != 0)
1842 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1845 if (operand
->insert
)
1850 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1851 if (errmsg
!= (const char *) NULL
)
1852 as_bad_where (file
, line
, "%s", errmsg
);
1854 else if (operand
->shift
>= 0)
1855 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1857 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1864 /* Parse @got, etc. and return the desired relocation. */
1865 static bfd_reloc_code_real_type
1866 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1870 unsigned int length
: 8;
1871 unsigned int valid32
: 1;
1872 unsigned int valid64
: 1;
1881 const struct map_bfd
*ptr
;
1883 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1884 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1885 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1887 static const struct map_bfd mapping
[] = {
1888 MAP ("l", BFD_RELOC_LO16
),
1889 MAP ("h", BFD_RELOC_HI16
),
1890 MAP ("ha", BFD_RELOC_HI16_S
),
1891 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1892 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1893 MAP ("got", BFD_RELOC_16_GOTOFF
),
1894 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1895 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1896 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1897 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1898 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1899 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1900 MAP ("copy", BFD_RELOC_PPC_COPY
),
1901 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1902 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1903 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1904 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1905 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1906 MAP ("tls", BFD_RELOC_PPC_TLS
),
1907 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1908 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1909 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1910 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1911 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1912 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1913 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1914 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1915 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1916 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1917 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1918 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1919 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1920 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1921 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1922 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1923 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1924 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1925 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1926 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1927 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1928 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1929 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1930 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1931 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1932 MAP32 ("fixup", BFD_RELOC_CTOR
),
1933 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1934 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1935 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1936 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1937 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1938 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1939 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1940 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1941 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1942 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1943 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1944 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1945 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1946 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1947 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1948 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1949 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1950 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1951 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1952 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1953 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1954 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1955 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1956 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1957 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1958 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1959 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1960 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1961 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1962 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1963 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1964 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1965 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1966 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1967 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1968 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1969 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1970 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1971 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1972 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1973 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1974 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1975 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1976 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1977 MAP64 ("localentry", BFD_RELOC_PPC64_ADDR64_LOCAL
),
1978 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1979 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1980 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1981 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1982 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1983 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1984 { (char *) 0, 0, 0, 0, BFD_RELOC_NONE
}
1988 return BFD_RELOC_NONE
;
1990 for (ch
= *str
, str2
= ident
;
1991 (str2
< ident
+ sizeof (ident
) - 1
1992 && (ISALNUM (ch
) || ch
== '@'));
1995 *str2
++ = TOLOWER (ch
);
2002 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
2003 if (ch
== ptr
->string
[0]
2004 && len
== ptr
->length
2005 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
2006 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
2008 int reloc
= ptr
->reloc
;
2010 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
2014 case BFD_RELOC_16_GOTOFF
:
2015 case BFD_RELOC_LO16_GOTOFF
:
2016 case BFD_RELOC_HI16_GOTOFF
:
2017 case BFD_RELOC_HI16_S_GOTOFF
:
2018 as_warn (_("identifier+constant@got means "
2019 "identifier@got+constant"));
2022 case BFD_RELOC_PPC_GOT_TLSGD16
:
2023 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
2024 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
2025 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
2026 case BFD_RELOC_PPC_GOT_TLSLD16
:
2027 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
2028 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
2029 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
2030 case BFD_RELOC_PPC_GOT_DTPREL16
:
2031 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2032 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2033 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2034 case BFD_RELOC_PPC_GOT_TPREL16
:
2035 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2036 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2037 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2038 as_bad (_("symbol+offset not supported for got tls"));
2043 /* Now check for identifier@suffix+constant. */
2044 if (*str
== '-' || *str
== '+')
2046 char *orig_line
= input_line_pointer
;
2047 expressionS new_exp
;
2049 input_line_pointer
= str
;
2050 expression (&new_exp
);
2051 if (new_exp
.X_op
== O_constant
)
2053 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2054 str
= input_line_pointer
;
2057 if (&input_line_pointer
!= str_p
)
2058 input_line_pointer
= orig_line
;
2062 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2063 && exp_p
->X_op
== O_symbol
2064 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2066 /* Change the symbol so that the dummy .TOC. symbol can be
2067 omitted from the object file. */
2068 exp_p
->X_add_symbol
= &abs_symbol
;
2071 return (bfd_reloc_code_real_type
) reloc
;
2074 return BFD_RELOC_NONE
;
2077 /* Support @got, etc. on constants emitted via .short, .int etc. */
2079 bfd_reloc_code_real_type
2080 ppc_elf_parse_cons (expressionS
*exp
, unsigned int nbytes
)
2083 if (nbytes
>= 2 && *input_line_pointer
== '@')
2084 return ppc_elf_suffix (&input_line_pointer
, exp
);
2085 return BFD_RELOC_NONE
;
2088 /* Warn when emitting data to code sections, unless we are emitting
2089 a relocation that ld --ppc476-workaround uses to recognise data
2090 *and* there was an unconditional branch prior to the data. */
2093 ppc_elf_cons_fix_check (expressionS
*exp ATTRIBUTE_UNUSED
,
2094 unsigned int nbytes
, fixS
*fix
)
2097 && (now_seg
->flags
& SEC_CODE
) != 0
2100 || !(fix
->fx_r_type
== BFD_RELOC_32
2101 || fix
->fx_r_type
== BFD_RELOC_CTOR
2102 || fix
->fx_r_type
== BFD_RELOC_32_PCREL
)
2103 || !(last_seg
== now_seg
&& last_subseg
== now_subseg
)
2104 || !((last_insn
& (0x3f << 26)) == (18u << 26)
2105 || ((last_insn
& (0x3f << 26)) == (16u << 26)
2106 && (last_insn
& (0x14 << 21)) == (0x14 << 21))
2107 || ((last_insn
& (0x3f << 26)) == (19u << 26)
2108 && (last_insn
& (0x3ff << 1)) == (16u << 1)
2109 && (last_insn
& (0x14 << 21)) == (0x14 << 21)))))
2111 /* Flag that we've warned. */
2115 as_warn (_("data in executable section"));
2119 /* Solaris pseduo op to change to the .rodata section. */
2121 ppc_elf_rdata (int xxx
)
2123 char *save_line
= input_line_pointer
;
2124 static char section
[] = ".rodata\n";
2126 /* Just pretend this is .section .rodata */
2127 input_line_pointer
= section
;
2128 obj_elf_section (xxx
);
2130 input_line_pointer
= save_line
;
2133 /* Pseudo op to make file scope bss items. */
2135 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2148 c
= get_symbol_name (&name
);
2150 /* Just after name is now '\0'. */
2151 p
= input_line_pointer
;
2153 SKIP_WHITESPACE_AFTER_NAME ();
2154 if (*input_line_pointer
!= ',')
2156 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2157 ignore_rest_of_line ();
2161 input_line_pointer
++; /* skip ',' */
2162 if ((size
= get_absolute_expression ()) < 0)
2164 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2165 ignore_rest_of_line ();
2169 /* The third argument to .lcomm is the alignment. */
2170 if (*input_line_pointer
!= ',')
2174 ++input_line_pointer
;
2175 align
= get_absolute_expression ();
2178 as_warn (_("ignoring bad alignment"));
2184 symbolP
= symbol_find_or_make (name
);
2187 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2189 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2190 S_GET_NAME (symbolP
));
2191 ignore_rest_of_line ();
2195 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2197 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2198 S_GET_NAME (symbolP
),
2199 (long) S_GET_VALUE (symbolP
),
2202 ignore_rest_of_line ();
2208 old_subsec
= now_subseg
;
2211 /* Convert to a power of 2 alignment. */
2212 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2215 as_bad (_("common alignment not a power of 2"));
2216 ignore_rest_of_line ();
2223 record_alignment (bss_section
, align2
);
2224 subseg_set (bss_section
, 1);
2226 frag_align (align2
, 0, 0);
2227 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2228 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2229 symbol_set_frag (symbolP
, frag_now
);
2230 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2233 S_SET_SIZE (symbolP
, size
);
2234 S_SET_SEGMENT (symbolP
, bss_section
);
2235 subseg_set (old_sec
, old_subsec
);
2236 demand_empty_rest_of_line ();
2239 /* Pseudo op to set symbol local entry point. */
2241 ppc_elf_localentry (int ignore ATTRIBUTE_UNUSED
)
2244 char c
= get_symbol_name (&name
);
2249 elf_symbol_type
*elfsym
;
2251 p
= input_line_pointer
;
2253 SKIP_WHITESPACE_AFTER_NAME ();
2254 if (*input_line_pointer
!= ',')
2257 as_bad (_("expected comma after name `%s' in .localentry directive"),
2260 ignore_rest_of_line ();
2263 input_line_pointer
++;
2265 if (exp
.X_op
== O_absent
)
2267 as_bad (_("missing expression in .localentry directive"));
2268 exp
.X_op
= O_constant
;
2269 exp
.X_add_number
= 0;
2272 sym
= symbol_find_or_make (name
);
2275 if (resolve_expression (&exp
)
2276 && exp
.X_op
== O_constant
)
2278 unsigned char encoded
= PPC64_SET_LOCAL_ENTRY_OFFSET (exp
.X_add_number
);
2280 if (exp
.X_add_number
!= (offsetT
) PPC64_LOCAL_ENTRY_OFFSET (encoded
))
2281 as_bad (_(".localentry expression for `%s' "
2282 "is not a valid power of 2"), S_GET_NAME (sym
));
2285 bfdsym
= symbol_get_bfdsym (sym
);
2286 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
2287 gas_assert (elfsym
);
2288 elfsym
->internal_elf_sym
.st_other
&= ~STO_PPC64_LOCAL_MASK
;
2289 elfsym
->internal_elf_sym
.st_other
|= encoded
;
2290 if (ppc_abiversion
== 0)
2295 as_bad (_(".localentry expression for `%s' "
2296 "does not evaluate to a constant"), S_GET_NAME (sym
));
2298 demand_empty_rest_of_line ();
2301 /* Pseudo op to set ABI version. */
2303 ppc_elf_abiversion (int ignore ATTRIBUTE_UNUSED
)
2308 if (exp
.X_op
== O_absent
)
2310 as_bad (_("missing expression in .abiversion directive"));
2311 exp
.X_op
= O_constant
;
2312 exp
.X_add_number
= 0;
2315 if (resolve_expression (&exp
)
2316 && exp
.X_op
== O_constant
)
2317 ppc_abiversion
= exp
.X_add_number
;
2319 as_bad (_(".abiversion expression does not evaluate to a constant"));
2320 demand_empty_rest_of_line ();
2323 /* Set ABI version in output file. */
2327 if (ppc_obj64
&& ppc_abiversion
!= 0)
2329 elf_elfheader (stdoutput
)->e_flags
&= ~EF_PPC64_ABI
;
2330 elf_elfheader (stdoutput
)->e_flags
|= ppc_abiversion
& EF_PPC64_ABI
;
2334 /* Validate any relocations emitted for -mrelocatable, possibly adding
2335 fixups for word relocations in writable segments, so we can adjust
2338 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2340 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2349 case SHLIB_MRELOCATABLE
:
2350 if (fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2351 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2352 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2353 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2354 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2355 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2356 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2357 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2358 && (seg
->flags
& SEC_LOAD
) != 0
2359 && strcmp (segment_name (seg
), ".got2") != 0
2360 && strcmp (segment_name (seg
), ".dtors") != 0
2361 && strcmp (segment_name (seg
), ".ctors") != 0
2362 && strcmp (segment_name (seg
), ".fixup") != 0
2363 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2364 && strcmp (segment_name (seg
), ".eh_frame") != 0
2365 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2367 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2368 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2370 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2371 _("relocation cannot be done when using -mrelocatable"));
2378 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2379 function descriptor sym if the corresponding code sym is used. */
2382 ppc_frob_file_before_adjust (void)
2390 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2396 name
= S_GET_NAME (symp
);
2400 if (! S_IS_WEAK (symp
)
2401 || S_IS_DEFINED (symp
))
2404 dotname
= concat (".", name
, (char *) NULL
);
2405 dotsym
= symbol_find_noref (dotname
, 1);
2407 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2408 || symbol_used_in_reloc_p (dotsym
)))
2409 symbol_mark_used (symp
);
2413 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2415 && toc_reloc_types
!= has_large_toc_reloc
2416 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2417 as_warn (_("TOC section size exceeds 64k"));
2420 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2421 emitted. Other uses of .TOC. will cause the symbol to be marked
2422 with BSF_KEEP in md_apply_fix. */
2425 ppc_elf_adjust_symtab (void)
2430 symp
= symbol_find (".TOC.");
2433 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2434 if ((bsym
->flags
& BSF_KEEP
) == 0)
2435 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2439 #endif /* OBJ_ELF */
2444 * Summary of parse_toc_entry.
2446 * in: Input_line_pointer points to the '[' in one of:
2448 * [toc] [tocv] [toc32] [toc64]
2450 * Anything else is an error of one kind or another.
2453 * return value: success or failure
2454 * toc_kind: kind of toc reference
2455 * input_line_pointer:
2456 * success: first char after the ']'
2457 * failure: unchanged
2461 * [toc] - rv == success, toc_kind = default_toc
2462 * [tocv] - rv == success, toc_kind = data_in_toc
2463 * [toc32] - rv == success, toc_kind = must_be_32
2464 * [toc64] - rv == success, toc_kind = must_be_64
2468 enum toc_size_qualifier
2470 default_toc
, /* The toc cell constructed should be the system default size */
2471 data_in_toc
, /* This is a direct reference to a toc cell */
2472 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2473 must_be_64
/* The toc cell constructed must be 64 bits wide */
2477 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2482 enum toc_size_qualifier t
;
2484 /* Save the input_line_pointer. */
2485 start
= input_line_pointer
;
2487 /* Skip over the '[' , and whitespace. */
2488 ++input_line_pointer
;
2491 /* Find the spelling of the operand. */
2492 c
= get_symbol_name (&toc_spec
);
2494 if (strcmp (toc_spec
, "toc") == 0)
2498 else if (strcmp (toc_spec
, "tocv") == 0)
2502 else if (strcmp (toc_spec
, "toc32") == 0)
2506 else if (strcmp (toc_spec
, "toc64") == 0)
2512 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2513 *input_line_pointer
= c
;
2514 input_line_pointer
= start
;
2518 /* Now find the ']'. */
2519 *input_line_pointer
= c
;
2521 SKIP_WHITESPACE_AFTER_NAME (); /* leading whitespace could be there. */
2522 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2526 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2527 input_line_pointer
= start
;
2536 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2537 /* See whether a symbol is in the TOC section. */
2540 ppc_is_toc_sym (symbolS
*sym
)
2543 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2544 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2547 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2549 return strcmp (sname
, ".toc") == 0;
2551 return strcmp (sname
, ".got") == 0;
2554 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2558 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2560 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2564 /* Check we don't already exist. */
2565 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2566 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2569 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2571 if (ppc_apuinfo_num_alloc
== 0)
2573 ppc_apuinfo_num_alloc
= 4;
2574 ppc_apuinfo_list
= XNEWVEC (unsigned long, ppc_apuinfo_num_alloc
);
2578 ppc_apuinfo_num_alloc
+= 4;
2579 ppc_apuinfo_list
= XRESIZEVEC (unsigned long, ppc_apuinfo_list
,
2580 ppc_apuinfo_num_alloc
);
2583 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2589 /* We need to keep a list of fixups. We can't simply generate them as
2590 we go, because that would require us to first create the frag, and
2591 that would screw up references to ``.''. */
2597 bfd_reloc_code_real_type reloc
;
2600 #define MAX_INSN_FIXUPS (5)
2603 #define E_OR2I_INSN 0x7000C000
2604 #define E_AND2I_DOT_INSN 0x7000C800
2605 #define E_OR2IS_INSN 0x7000D000
2606 #define E_LIS_INSN 0x7000E000
2607 #define E_AND2IS_DOT_INSN 0x7000E800
2610 #define E_ADD2I_DOT_INSN 0x70008800
2611 #define E_ADD2IS_INSN 0x70009000
2612 #define E_CMP16I_INSN 0x70009800
2613 #define E_MULL2I_INSN 0x7000A000
2614 #define E_CMPL16I_INSN 0x7000A800
2615 #define E_CMPH16I_INSN 0x7000B000
2616 #define E_CMPHL16I_INSN 0x7000B800
2618 /* This routine is called for each instruction to be assembled. */
2621 md_assemble (char *str
)
2624 const struct powerpc_opcode
*opcode
;
2626 const unsigned char *opindex_ptr
;
2630 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2635 unsigned int insn_length
;
2637 /* Get the opcode. */
2638 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2643 /* Look up the opcode in the hash table. */
2644 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2645 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2647 const struct powerpc_macro
*macro
;
2649 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2650 if (macro
== (const struct powerpc_macro
*) NULL
)
2651 as_bad (_("unrecognized opcode: `%s'"), str
);
2653 ppc_macro (s
, macro
);
2658 insn
= opcode
->opcode
;
2661 while (ISSPACE (*str
))
2664 /* PowerPC operands are just expressions. The only real issue is
2665 that a few operand types are optional. All cases which might use
2666 an optional operand separate the operands only with commas (in some
2667 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2668 have optional operands). Most instructions with optional operands
2669 have only one. Those that have more than one optional operand can
2670 take either all their operands or none. So, before we start seriously
2671 parsing the operands, we check to see if we have optional operands,
2672 and if we do, we count the number of commas to see which operands
2673 have been omitted. */
2675 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2677 const struct powerpc_operand
*operand
;
2679 operand
= &powerpc_operands
[*opindex_ptr
];
2680 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2682 unsigned int opcount
;
2683 unsigned int num_operands_expected
;
2685 /* There is an optional operand. Count the number of
2686 commas in the input line. */
2693 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2700 /* Compute the number of expected operands.
2701 Do not count fake operands. */
2702 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2703 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2704 ++ num_operands_expected
;
2706 /* If there are fewer operands in the line then are called
2707 for by the instruction, we want to skip the optional
2709 if (opcount
< num_operands_expected
)
2716 /* Gather the operands. */
2720 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2722 const struct powerpc_operand
*operand
;
2728 if (next_opindex
== 0)
2729 operand
= &powerpc_operands
[*opindex_ptr
];
2732 operand
= &powerpc_operands
[next_opindex
];
2737 /* If this is a fake operand, then we do not expect anything
2739 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2741 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2742 if (errmsg
!= (const char *) NULL
)
2743 as_bad ("%s", errmsg
);
2747 /* If this is an optional operand, and we are skipping it, just
2749 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2752 long val
= ppc_optional_operand_value (operand
);
2753 if (operand
->insert
)
2755 insn
= (*operand
->insert
) (insn
, val
, ppc_cpu
, &errmsg
);
2756 if (errmsg
!= (const char *) NULL
)
2757 as_bad ("%s", errmsg
);
2759 else if (operand
->shift
>= 0)
2760 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
2762 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
2764 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2765 next_opindex
= *opindex_ptr
+ 1;
2769 /* Gather the operand. */
2770 hold
= input_line_pointer
;
2771 input_line_pointer
= str
;
2774 if (*input_line_pointer
== '[')
2776 /* We are expecting something like the second argument here:
2778 * lwz r4,[toc].GS.0.static_int(rtoc)
2779 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2780 * The argument following the `]' must be a symbol name, and the
2781 * register must be the toc register: 'rtoc' or '2'
2783 * The effect is to 0 as the displacement field
2784 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2785 * the appropriate variation) reloc against it based on the symbol.
2786 * The linker will build the toc, and insert the resolved toc offset.
2789 * o The size of the toc entry is currently assumed to be
2790 * 32 bits. This should not be assumed to be a hard coded
2792 * o In an effort to cope with a change from 32 to 64 bits,
2793 * there are also toc entries that are specified to be
2794 * either 32 or 64 bits:
2795 * lwz r4,[toc32].GS.0.static_int(rtoc)
2796 * lwz r4,[toc64].GS.0.static_int(rtoc)
2797 * These demand toc entries of the specified size, and the
2798 * instruction probably requires it.
2802 enum toc_size_qualifier toc_kind
;
2803 bfd_reloc_code_real_type toc_reloc
;
2805 /* Go parse off the [tocXX] part. */
2806 valid_toc
= parse_toc_entry (&toc_kind
);
2810 ignore_rest_of_line ();
2814 /* Now get the symbol following the ']'. */
2820 /* In this case, we may not have seen the symbol yet,
2821 since it is allowed to appear on a .extern or .globl
2822 or just be a label in the .data section. */
2823 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2826 /* 1. The symbol must be defined and either in the toc
2827 section, or a global.
2828 2. The reloc generated must have the TOCDEFN flag set
2829 in upper bit mess of the reloc type.
2830 FIXME: It's a little confusing what the tocv
2831 qualifier can be used for. At the very least, I've
2832 seen three uses, only one of which I'm sure I can
2834 if (ex
.X_op
== O_symbol
)
2836 gas_assert (ex
.X_add_symbol
!= NULL
);
2837 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2840 as_bad (_("[tocv] symbol is not a toc symbol"));
2844 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2847 /* FIXME: these next two specifically specify 32/64 bit
2848 toc entries. We don't support them today. Is this
2849 the right way to say that? */
2850 toc_reloc
= BFD_RELOC_NONE
;
2851 as_bad (_("unimplemented toc32 expression modifier"));
2854 /* FIXME: see above. */
2855 toc_reloc
= BFD_RELOC_NONE
;
2856 as_bad (_("unimplemented toc64 expression modifier"));
2860 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2866 /* We need to generate a fixup for this expression. */
2867 if (fc
>= MAX_INSN_FIXUPS
)
2868 as_fatal (_("too many fixups"));
2870 fixups
[fc
].reloc
= toc_reloc
;
2871 fixups
[fc
].exp
= ex
;
2872 fixups
[fc
].opindex
= *opindex_ptr
;
2875 /* Ok. We've set up the fixup for the instruction. Now make it
2876 look like the constant 0 was found here. */
2878 ex
.X_op
= O_constant
;
2879 ex
.X_add_number
= 0;
2880 ex
.X_add_symbol
= NULL
;
2881 ex
.X_op_symbol
= NULL
;
2888 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2889 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2890 || !register_name (&ex
))
2892 char save_lex
= lex_type
['%'];
2894 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2895 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2898 lex_type
['%'] |= LEX_BEGIN_NAME
;
2902 lex_type
['%'] = save_lex
;
2906 str
= input_line_pointer
;
2907 input_line_pointer
= hold
;
2909 if (ex
.X_op
== O_illegal
)
2910 as_bad (_("illegal operand"));
2911 else if (ex
.X_op
== O_absent
)
2912 as_bad (_("missing operand"));
2913 else if (ex
.X_op
== O_register
)
2915 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2916 ppc_cpu
, (char *) NULL
, 0);
2918 else if (ex
.X_op
== O_constant
)
2921 /* Allow @HA, @L, @H on constants. */
2922 bfd_reloc_code_real_type reloc
;
2923 char *orig_str
= str
;
2925 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
2932 case BFD_RELOC_LO16
:
2933 ex
.X_add_number
&= 0xffff;
2934 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2935 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2938 case BFD_RELOC_HI16
:
2939 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2941 /* PowerPC64 @h is tested for overflow. */
2942 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2943 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2945 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2947 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2953 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2954 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2955 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2956 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2959 case BFD_RELOC_HI16_S
:
2960 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2962 /* PowerPC64 @ha is tested for overflow. */
2964 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2965 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2967 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2969 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2975 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2976 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2977 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2978 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2981 case BFD_RELOC_PPC64_HIGHER
:
2982 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2983 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2984 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2987 case BFD_RELOC_PPC64_HIGHER_S
:
2988 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2989 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2990 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2993 case BFD_RELOC_PPC64_HIGHEST
:
2994 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2995 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2996 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2999 case BFD_RELOC_PPC64_HIGHEST_S
:
3000 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
3001 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
3002 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
3005 #endif /* OBJ_ELF */
3006 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
3007 ppc_cpu
, (char *) NULL
, 0);
3011 bfd_reloc_code_real_type reloc
= BFD_RELOC_NONE
;
3013 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
3015 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
3016 if (sym_name
[0] == '.')
3019 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
3021 expressionS tls_exp
;
3023 hold
= input_line_pointer
;
3024 input_line_pointer
= str
+ 1;
3025 expression (&tls_exp
);
3026 if (tls_exp
.X_op
== O_symbol
)
3028 reloc
= BFD_RELOC_NONE
;
3029 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
3031 reloc
= BFD_RELOC_PPC_TLSGD
;
3032 input_line_pointer
+= 7;
3034 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
3036 reloc
= BFD_RELOC_PPC_TLSLD
;
3037 input_line_pointer
+= 7;
3039 if (reloc
!= BFD_RELOC_NONE
)
3042 str
= input_line_pointer
;
3044 if (fc
>= MAX_INSN_FIXUPS
)
3045 as_fatal (_("too many fixups"));
3046 fixups
[fc
].exp
= tls_exp
;
3047 fixups
[fc
].opindex
= *opindex_ptr
;
3048 fixups
[fc
].reloc
= reloc
;
3052 input_line_pointer
= hold
;
3056 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_NONE
)
3058 /* Some TLS tweaks. */
3064 case BFD_RELOC_PPC_TLS
:
3065 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
3066 as_bad (_("@tls may not be used with \"%s\" operands"),
3068 else if (operand
->shift
!= 11)
3069 as_bad (_("@tls may only be used in last operand"));
3071 insn
= ppc_insert_operand (insn
, operand
,
3073 ppc_cpu
, (char *) NULL
, 0);
3076 /* We'll only use the 32 (or 64) bit form of these relocations
3077 in constants. Instructions get the 16 bit form. */
3078 case BFD_RELOC_PPC_DTPREL
:
3079 reloc
= BFD_RELOC_PPC_DTPREL16
;
3081 case BFD_RELOC_PPC_TPREL
:
3082 reloc
= BFD_RELOC_PPC_TPREL16
;
3087 if (opcode
->opcode
== (19 << 26) + (2 << 1)
3088 && reloc
== BFD_RELOC_HI16_S
)
3089 reloc
= BFD_RELOC_PPC_REL16DX_HA
;
3091 /* If VLE-mode convert LO/HI/HA relocations. */
3092 if (opcode
->flags
& PPC_OPCODE_VLE
)
3094 int tmp_insn
= insn
& opcode
->mask
;
3096 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
3097 || tmp_insn
== E_AND2I_DOT_INSN
3098 || tmp_insn
== E_OR2IS_INSN
3099 || tmp_insn
== E_LIS_INSN
3100 || tmp_insn
== E_AND2IS_DOT_INSN
);
3103 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
3104 || tmp_insn
== E_ADD2IS_INSN
3105 || tmp_insn
== E_CMP16I_INSN
3106 || tmp_insn
== E_MULL2I_INSN
3107 || tmp_insn
== E_CMPL16I_INSN
3108 || tmp_insn
== E_CMPH16I_INSN
3109 || tmp_insn
== E_CMPHL16I_INSN
);
3116 case BFD_RELOC_PPC_EMB_SDA21
:
3117 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3120 case BFD_RELOC_LO16
:
3122 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3123 else if (use_a_reloc
)
3124 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3127 case BFD_RELOC_HI16
:
3129 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3130 else if (use_a_reloc
)
3131 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3134 case BFD_RELOC_HI16_S
:
3136 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3137 else if (use_a_reloc
)
3138 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3141 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3143 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3146 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3148 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3151 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3153 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3158 #endif /* OBJ_ELF */
3160 if (reloc
!= BFD_RELOC_NONE
)
3162 /* Determine a BFD reloc value based on the operand information.
3163 We are only prepared to turn a few of the operands into
3165 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3166 | PPC_OPERAND_ABSOLUTE
)) != 0
3167 && operand
->bitm
== 0x3fffffc
3168 && operand
->shift
== 0)
3169 reloc
= BFD_RELOC_PPC_B26
;
3170 else if ((operand
->flags
& (PPC_OPERAND_RELATIVE
3171 | PPC_OPERAND_ABSOLUTE
)) != 0
3172 && operand
->bitm
== 0xfffc
3173 && operand
->shift
== 0)
3174 reloc
= BFD_RELOC_PPC_B16
;
3175 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3176 && operand
->bitm
== 0x1fe
3177 && operand
->shift
== -1)
3178 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3179 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3180 && operand
->bitm
== 0xfffe
3181 && operand
->shift
== 0)
3182 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3183 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3184 && operand
->bitm
== 0x1fffffe
3185 && operand
->shift
== 0)
3186 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3187 else if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) == 0
3188 && (operand
->bitm
& 0xfff0) == 0xfff0
3189 && operand
->shift
== 0)
3191 reloc
= BFD_RELOC_16
;
3192 #if defined OBJ_XCOFF || defined OBJ_ELF
3193 /* Note: the symbol may be not yet defined. */
3194 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3195 && ppc_is_toc_sym (ex
.X_add_symbol
))
3197 reloc
= BFD_RELOC_PPC_TOC16
;
3199 as_warn (_("assuming %s on symbol"),
3200 ppc_obj64
? "@toc" : "@xgot");
3206 /* For the absolute forms of branches, convert the PC
3207 relative form back into the absolute. */
3208 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3212 case BFD_RELOC_PPC_B26
:
3213 reloc
= BFD_RELOC_PPC_BA26
;
3215 case BFD_RELOC_PPC_B16
:
3216 reloc
= BFD_RELOC_PPC_BA16
;
3219 case BFD_RELOC_PPC_B16_BRTAKEN
:
3220 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3222 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3223 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3234 case BFD_RELOC_PPC_TOC16
:
3235 toc_reloc_types
|= has_small_toc_reloc
;
3237 case BFD_RELOC_PPC64_TOC16_LO
:
3238 case BFD_RELOC_PPC64_TOC16_HI
:
3239 case BFD_RELOC_PPC64_TOC16_HA
:
3240 toc_reloc_types
|= has_large_toc_reloc
;
3247 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3252 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3254 case BFD_RELOC_LO16
:
3255 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3257 case BFD_RELOC_16_GOTOFF
:
3258 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3260 case BFD_RELOC_LO16_GOTOFF
:
3261 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3263 case BFD_RELOC_LO16_PLTOFF
:
3264 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3266 case BFD_RELOC_16_BASEREL
:
3267 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3269 case BFD_RELOC_LO16_BASEREL
:
3270 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3272 case BFD_RELOC_PPC_TOC16
:
3273 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3275 case BFD_RELOC_PPC64_TOC16_LO
:
3276 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3278 case BFD_RELOC_PPC64_PLTGOT16
:
3279 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3281 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3282 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3284 case BFD_RELOC_PPC_DTPREL16
:
3285 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3287 case BFD_RELOC_PPC_DTPREL16_LO
:
3288 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3290 case BFD_RELOC_PPC_TPREL16
:
3291 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3293 case BFD_RELOC_PPC_TPREL16_LO
:
3294 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3296 case BFD_RELOC_PPC_GOT_DTPREL16
:
3297 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3298 case BFD_RELOC_PPC_GOT_TPREL16
:
3299 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3302 as_bad (_("unsupported relocation for DS offset field"));
3308 /* We need to generate a fixup for this expression. */
3309 if (fc
>= MAX_INSN_FIXUPS
)
3310 as_fatal (_("too many fixups"));
3311 fixups
[fc
].exp
= ex
;
3312 fixups
[fc
].opindex
= *opindex_ptr
;
3313 fixups
[fc
].reloc
= reloc
;
3321 /* If expecting more operands, then we want to see "),". */
3322 if (*str
== endc
&& opindex_ptr
[1] != 0)
3326 while (ISSPACE (*str
));
3330 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3338 /* The call to expression should have advanced str past any
3341 && (endc
!= ',' || *str
!= '\0'))
3344 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3346 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3354 while (ISSPACE (*str
))
3358 as_bad (_("junk at end of line: `%s'"), str
);
3361 /* Do we need/want an APUinfo section? */
3362 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3365 /* These are all version "1". */
3366 if (opcode
->flags
& PPC_OPCODE_SPE
)
3367 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3368 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3369 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3370 if (opcode
->flags
& PPC_OPCODE_EFS
)
3371 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3372 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3373 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3374 if (opcode
->flags
& PPC_OPCODE_PMR
)
3375 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3376 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3377 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3378 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3379 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3380 /* Only set the VLE flag if the instruction has been pulled via
3381 the VLE instruction set. This way the flag is guaranteed to
3382 be set for VLE-only instructions or for VLE-only processors,
3383 however it'll remain clear for dual-mode instructions on
3384 dual-mode and, more importantly, standard-mode processors. */
3385 if ((ppc_cpu
& opcode
->flags
) == PPC_OPCODE_VLE
)
3386 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3390 /* Write out the instruction. */
3391 /* Differentiate between two and four byte insns. */
3392 if (ppc_mach () == bfd_mach_ppc_vle
)
3394 if (PPC_OP_SE_VLE (insn
))
3398 addr_mod
= frag_now_fix () & 1;
3403 addr_mod
= frag_now_fix () & 3;
3405 /* All instructions can start on a 2 byte boundary for VLE. */
3406 f
= frag_more (insn_length
);
3407 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3409 if (ppc_mach() == bfd_mach_ppc_vle
)
3410 as_bad (_("instruction address is not a multiple of 2"));
3412 as_bad (_("instruction address is not a multiple of 4"));
3414 frag_now
->insn_addr
= addr_mod
;
3415 frag_now
->has_code
= 1;
3416 md_number_to_chars (f
, insn
, insn_length
);
3419 last_subseg
= now_subseg
;
3422 dwarf2_emit_insn (insn_length
);
3425 /* Create any fixups. */
3426 for (i
= 0; i
< fc
; i
++)
3429 if (fixups
[i
].reloc
!= BFD_RELOC_NONE
)
3431 reloc_howto_type
*reloc_howto
;
3435 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3439 size
= bfd_get_reloc_size (reloc_howto
);
3440 offset
= target_big_endian
? (insn_length
- size
) : 0;
3442 fixP
= fix_new_exp (frag_now
,
3443 f
- frag_now
->fr_literal
+ offset
,
3446 reloc_howto
->pc_relative
,
3451 const struct powerpc_operand
*operand
;
3453 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3454 fixP
= fix_new_exp (frag_now
,
3455 f
- frag_now
->fr_literal
,
3458 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3461 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3465 /* Handle a macro. Gather all the operands, transform them as
3466 described by the macro, and call md_assemble recursively. All the
3467 operands are separated by commas; we don't accept parentheses
3468 around operands here. */
3471 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3482 /* Gather the users operands into the operands array. */
3487 if (count
>= sizeof operands
/ sizeof operands
[0])
3489 operands
[count
++] = s
;
3490 s
= strchr (s
, ',');
3491 if (s
== (char *) NULL
)
3496 if (count
!= macro
->operands
)
3498 as_bad (_("wrong number of operands"));
3502 /* Work out how large the string must be (the size is unbounded
3503 because it includes user input). */
3505 format
= macro
->format
;
3506 while (*format
!= '\0')
3515 arg
= strtol (format
+ 1, &send
, 10);
3516 know (send
!= format
&& arg
< count
);
3517 len
+= strlen (operands
[arg
]);
3522 /* Put the string together. */
3523 complete
= s
= XNEWVEC (char, len
+ 1);
3524 format
= macro
->format
;
3525 while (*format
!= '\0')
3531 arg
= strtol (format
+ 1, &send
, 10);
3532 strcpy (s
, operands
[arg
]);
3539 /* Assemble the constructed instruction. */
3540 md_assemble (complete
);
3545 /* For ELF, add support for SHT_ORDERED. */
3548 ppc_section_type (char *str
, size_t len
)
3550 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3557 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3559 if (type
== SHT_ORDERED
)
3560 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3564 #endif /* OBJ_ELF */
3567 /* Pseudo-op handling. */
3569 /* The .byte pseudo-op. This is similar to the normal .byte
3570 pseudo-op, but it can also take a single ASCII string. */
3573 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3577 if (*input_line_pointer
!= '\"')
3583 /* Gather characters. A real double quote is doubled. Unusual
3584 characters are not permitted. */
3585 ++input_line_pointer
;
3590 c
= *input_line_pointer
++;
3594 if (*input_line_pointer
!= '\"')
3596 ++input_line_pointer
;
3599 FRAG_APPEND_1_CHAR (c
);
3603 if (warn_476
&& count
!= 0 && (now_seg
->flags
& SEC_CODE
) != 0)
3604 as_warn (_("data in executable section"));
3605 demand_empty_rest_of_line ();
3610 /* XCOFF specific pseudo-op handling. */
3612 /* This is set if we are creating a .stabx symbol, since we don't want
3613 to handle symbol suffixes for such symbols. */
3614 static bfd_boolean ppc_stab_symbol
;
3616 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3617 symbols in the .bss segment as though they were local common
3618 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3619 aligns .comm and .lcomm to 4 bytes. */
3622 ppc_comm (int lcomm
)
3624 asection
*current_seg
= now_seg
;
3625 subsegT current_subseg
= now_subseg
;
3631 symbolS
*lcomm_sym
= NULL
;
3635 endc
= get_symbol_name (&name
);
3636 end_name
= input_line_pointer
;
3637 (void) restore_line_pointer (endc
);
3639 if (*input_line_pointer
!= ',')
3641 as_bad (_("missing size"));
3642 ignore_rest_of_line ();
3645 ++input_line_pointer
;
3647 size
= get_absolute_expression ();
3650 as_bad (_("negative size"));
3651 ignore_rest_of_line ();
3657 /* The third argument to .comm is the alignment. */
3658 if (*input_line_pointer
!= ',')
3662 ++input_line_pointer
;
3663 align
= get_absolute_expression ();
3666 as_warn (_("ignoring bad alignment"));
3676 /* The third argument to .lcomm appears to be the real local
3677 common symbol to create. References to the symbol named in
3678 the first argument are turned into references to the third
3680 if (*input_line_pointer
!= ',')
3682 as_bad (_("missing real symbol name"));
3683 ignore_rest_of_line ();
3686 ++input_line_pointer
;
3688 lcomm_endc
= get_symbol_name (&lcomm_name
);
3690 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3692 (void) restore_line_pointer (lcomm_endc
);
3694 /* The fourth argument to .lcomm is the alignment. */
3695 if (*input_line_pointer
!= ',')
3704 ++input_line_pointer
;
3705 align
= get_absolute_expression ();
3708 as_warn (_("ignoring bad alignment"));
3715 sym
= symbol_find_or_make (name
);
3718 if (S_IS_DEFINED (sym
)
3719 || S_GET_VALUE (sym
) != 0)
3721 as_bad (_("attempt to redefine symbol"));
3722 ignore_rest_of_line ();
3726 record_alignment (bss_section
, align
);
3729 || ! S_IS_DEFINED (lcomm_sym
))
3738 S_SET_EXTERNAL (sym
);
3742 symbol_get_tc (lcomm_sym
)->output
= 1;
3743 def_sym
= lcomm_sym
;
3747 subseg_set (bss_section
, 1);
3748 frag_align (align
, 0, 0);
3750 symbol_set_frag (def_sym
, frag_now
);
3751 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3752 def_size
, (char *) NULL
);
3754 S_SET_SEGMENT (def_sym
, bss_section
);
3755 symbol_get_tc (def_sym
)->align
= align
;
3759 /* Align the size of lcomm_sym. */
3760 symbol_get_frag (lcomm_sym
)->fr_offset
=
3761 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3762 &~ ((1 << align
) - 1));
3763 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3764 symbol_get_tc (lcomm_sym
)->align
= align
;
3769 /* Make sym an offset from lcomm_sym. */
3770 S_SET_SEGMENT (sym
, bss_section
);
3771 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3772 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3773 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3776 subseg_set (current_seg
, current_subseg
);
3778 demand_empty_rest_of_line ();
3781 /* The .csect pseudo-op. This switches us into a different
3782 subsegment. The first argument is a symbol whose value is the
3783 start of the .csect. In COFF, csect symbols get special aux
3784 entries defined by the x_csect field of union internal_auxent. The
3785 optional second argument is the alignment (the default is 2). */
3788 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3795 endc
= get_symbol_name (&name
);
3797 sym
= symbol_find_or_make (name
);
3799 (void) restore_line_pointer (endc
);
3801 if (S_GET_NAME (sym
)[0] == '\0')
3803 /* An unnamed csect is assumed to be [PR]. */
3804 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3808 if (*input_line_pointer
== ',')
3810 ++input_line_pointer
;
3811 align
= get_absolute_expression ();
3814 ppc_change_csect (sym
, align
);
3816 demand_empty_rest_of_line ();
3819 /* Change to a different csect. */
3822 ppc_change_csect (symbolS
*sym
, offsetT align
)
3824 if (S_IS_DEFINED (sym
))
3825 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3835 /* This is a new csect. We need to look at the symbol class to
3836 figure out whether it should go in the text section or the
3840 switch (symbol_get_tc (sym
)->symbol_class
)
3850 S_SET_SEGMENT (sym
, text_section
);
3851 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3852 ++ppc_text_subsegment
;
3853 list_ptr
= &ppc_text_csects
;
3863 if (ppc_toc_csect
!= NULL
3864 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3865 == ppc_data_subsegment
))
3867 S_SET_SEGMENT (sym
, data_section
);
3868 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3869 ++ppc_data_subsegment
;
3870 list_ptr
= &ppc_data_csects
;
3876 /* We set the obstack chunk size to a small value before
3877 changing subsegments, so that we don't use a lot of memory
3878 space for what may be a small section. */
3879 hold_chunksize
= chunksize
;
3882 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3883 symbol_get_tc (sym
)->subseg
);
3885 chunksize
= hold_chunksize
;
3888 ppc_after_toc_frag
= frag_now
;
3890 record_alignment (sec
, align
);
3892 frag_align_code (align
, 0);
3894 frag_align (align
, 0, 0);
3896 symbol_set_frag (sym
, frag_now
);
3897 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3899 symbol_get_tc (sym
)->align
= align
;
3900 symbol_get_tc (sym
)->output
= 1;
3901 symbol_get_tc (sym
)->within
= sym
;
3903 for (list
= *list_ptr
;
3904 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3905 list
= symbol_get_tc (list
)->next
)
3907 symbol_get_tc (list
)->next
= sym
;
3909 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3910 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3914 ppc_current_csect
= sym
;
3918 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3922 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3924 sec
= subseg_new (dw
->name
, subseg
);
3925 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3926 if (oldflags
== SEC_NO_FLAGS
)
3928 /* Just created section. */
3929 gas_assert (dw_sections
[idx
].sect
== NULL
);
3931 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3932 bfd_set_section_alignment (stdoutput
, sec
, 0);
3933 dw_sections
[idx
].sect
= sec
;
3936 /* Not anymore in a csect. */
3937 ppc_current_csect
= NULL
;
3940 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3941 .dwsect flag [, opt-label ]
3945 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3949 const struct xcoff_dwsect_name
*dw
;
3950 struct dw_subsection
*subseg
;
3951 struct dw_section
*dws
;
3955 flag
= get_absolute_expression ();
3957 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3958 if (xcoff_dwsect_names
[i
].flag
== flag
)
3960 dw
= &xcoff_dwsect_names
[i
];
3964 /* Parse opt-label. */
3965 if (*input_line_pointer
== ',')
3970 ++input_line_pointer
;
3972 c
= get_symbol_name (&label
);
3973 opt_label
= symbol_find_or_make (label
);
3974 (void) restore_line_pointer (c
);
3979 demand_empty_rest_of_line ();
3981 /* Return now in case of unknown subsection. */
3984 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3989 /* Find the subsection. */
3990 dws
= &dw_sections
[i
];
3992 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3994 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3995 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3997 as_bad (_("label %s was not defined in this dwarf section"),
3998 S_GET_NAME (opt_label
));
3999 subseg
= dws
->anon_subseg
;
4003 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
4008 /* Switch to the subsection. */
4009 ppc_change_debug_section (i
, subseg
->subseg
);
4013 /* Create a new dw subsection. */
4014 subseg
= XNEW (struct dw_subsection
);
4016 if (opt_label
== NULL
)
4018 /* The anonymous one. */
4020 subseg
->link
= NULL
;
4021 dws
->anon_subseg
= subseg
;
4026 if (dws
->list_subseg
!= NULL
)
4027 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
4031 subseg
->link
= dws
->list_subseg
;
4032 dws
->list_subseg
= subseg
;
4033 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
4036 ppc_change_debug_section (i
, subseg
->subseg
);
4040 /* Add the length field. */
4041 expressionS
*exp
= &subseg
->end_exp
;
4044 if (opt_label
!= NULL
)
4045 symbol_set_value_now (opt_label
);
4047 /* Add the length field. Note that according to the AIX assembler
4048 manual, the size of the length field is 4 for powerpc32 but
4049 12 for powerpc64. */
4052 /* Write the 64bit marker. */
4053 md_number_to_chars (frag_more (4), -1, 4);
4056 exp
->X_op
= O_subtract
;
4057 exp
->X_op_symbol
= symbol_temp_new_now ();
4058 exp
->X_add_symbol
= symbol_temp_make ();
4060 sz
= ppc_obj64
? 8 : 4;
4061 exp
->X_add_number
= -sz
;
4062 emit_expr (exp
, sz
);
4067 /* This function handles the .text and .data pseudo-ops. These
4068 pseudo-ops aren't really used by XCOFF; we implement them for the
4069 convenience of people who aren't used to XCOFF. */
4072 ppc_section (int type
)
4079 else if (type
== 'd')
4084 sym
= symbol_find_or_make (name
);
4086 ppc_change_csect (sym
, 2);
4088 demand_empty_rest_of_line ();
4091 /* This function handles the .section pseudo-op. This is mostly to
4092 give an error, since XCOFF only supports .text, .data and .bss, but
4093 we do permit the user to name the text or data section. */
4096 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
4099 const char *real_name
;
4103 c
= get_symbol_name (&user_name
);
4105 if (strcmp (user_name
, ".text") == 0)
4106 real_name
= ".text[PR]";
4107 else if (strcmp (user_name
, ".data") == 0)
4108 real_name
= ".data[RW]";
4111 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4112 (void) restore_line_pointer (c
);
4113 ignore_rest_of_line ();
4117 (void) restore_line_pointer (c
);
4119 sym
= symbol_find_or_make (real_name
);
4121 ppc_change_csect (sym
, 2);
4123 demand_empty_rest_of_line ();
4126 /* The .extern pseudo-op. We create an undefined symbol. */
4129 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4134 endc
= get_symbol_name (&name
);
4136 (void) symbol_find_or_make (name
);
4138 (void) restore_line_pointer (endc
);
4140 demand_empty_rest_of_line ();
4143 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4146 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4152 endc
= get_symbol_name (&name
);
4154 sym
= symbol_find_or_make (name
);
4156 (void) restore_line_pointer (endc
);
4158 symbol_get_tc (sym
)->output
= 1;
4160 demand_empty_rest_of_line ();
4163 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4164 relocations at the beginning of the current csect.
4166 (In principle, there's no reason why the relocations _have_ to be at
4167 the beginning. Anywhere in the csect would do. However, inserting
4168 at the beginning is what the native assmebler does, and it helps to
4169 deal with cases where the .ref statements follow the section contents.)
4171 ??? .refs don't work for empty .csects. However, the native assembler
4172 doesn't report an error in this case, and neither yet do we. */
4175 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4180 if (ppc_current_csect
== NULL
)
4182 as_bad (_(".ref outside .csect"));
4183 ignore_rest_of_line ();
4189 c
= get_symbol_name (&name
);
4191 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4192 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4194 *input_line_pointer
= c
;
4195 SKIP_WHITESPACE_AFTER_NAME ();
4196 c
= *input_line_pointer
;
4199 input_line_pointer
++;
4201 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4203 as_bad (_("missing symbol name"));
4204 ignore_rest_of_line ();
4211 demand_empty_rest_of_line ();
4214 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4215 although I don't know why it bothers. */
4218 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4225 endc
= get_symbol_name (&name
);
4227 sym
= symbol_find_or_make (name
);
4229 (void) restore_line_pointer (endc
);
4231 if (*input_line_pointer
!= ',')
4233 as_bad (_("missing rename string"));
4234 ignore_rest_of_line ();
4237 ++input_line_pointer
;
4239 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4241 demand_empty_rest_of_line ();
4244 /* The .stabx pseudo-op. This is similar to a normal .stabs
4245 pseudo-op, but slightly different. A sample is
4246 .stabx "main:F-1",.main,142,0
4247 The first argument is the symbol name to create. The second is the
4248 value, and the third is the storage class. The fourth seems to be
4249 always zero, and I am assuming it is the type. */
4252 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4259 name
= demand_copy_C_string (&len
);
4261 if (*input_line_pointer
!= ',')
4263 as_bad (_("missing value"));
4266 ++input_line_pointer
;
4268 ppc_stab_symbol
= TRUE
;
4269 sym
= symbol_make (name
);
4270 ppc_stab_symbol
= FALSE
;
4272 symbol_get_tc (sym
)->real_name
= name
;
4274 (void) expression (&exp
);
4281 as_bad (_("illegal .stabx expression; zero assumed"));
4282 exp
.X_add_number
= 0;
4285 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4286 symbol_set_frag (sym
, &zero_address_frag
);
4290 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4291 symbol_set_value_expression (sym
, &exp
);
4295 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4296 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4301 /* The value is some complex expression. This will probably
4302 fail at some later point, but this is probably the right
4303 thing to do here. */
4304 symbol_set_value_expression (sym
, &exp
);
4308 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4309 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4311 if (*input_line_pointer
!= ',')
4313 as_bad (_("missing class"));
4316 ++input_line_pointer
;
4318 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4320 if (*input_line_pointer
!= ',')
4322 as_bad (_("missing type"));
4325 ++input_line_pointer
;
4327 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4329 symbol_get_tc (sym
)->output
= 1;
4331 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4336 .stabx "z",arrays_,133,0
4339 .comm arrays_,13768,3
4341 resolve_symbol_value will copy the exp's "within" into sym's when the
4342 offset is 0. Since this seems to be corner case problem,
4343 only do the correction for storage class C_STSYM. A better solution
4344 would be to have the tc field updated in ppc_symbol_new_hook. */
4346 if (exp
.X_op
== O_symbol
)
4348 if (ppc_current_block
== NULL
)
4349 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4351 symbol_get_tc (sym
)->within
= ppc_current_block
;
4352 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4356 if (exp
.X_op
!= O_symbol
4357 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4358 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4359 ppc_frob_label (sym
);
4362 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4363 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4364 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4365 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4368 demand_empty_rest_of_line ();
4371 /* The .function pseudo-op. This takes several arguments. The first
4372 argument seems to be the external name of the symbol. The second
4373 argument seems to be the label for the start of the function. gcc
4374 uses the same name for both. I have no idea what the third and
4375 fourth arguments are meant to be. The optional fifth argument is
4376 an expression for the size of the function. In COFF this symbol
4377 gets an aux entry like that used for a csect. */
4380 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4388 endc
= get_symbol_name (&name
);
4390 /* Ignore any [PR] suffix. */
4391 name
= ppc_canonicalize_symbol_name (name
);
4392 s
= strchr (name
, '[');
4393 if (s
!= (char *) NULL
4394 && strcmp (s
+ 1, "PR]") == 0)
4397 ext_sym
= symbol_find_or_make (name
);
4399 (void) restore_line_pointer (endc
);
4401 if (*input_line_pointer
!= ',')
4403 as_bad (_("missing symbol name"));
4404 ignore_rest_of_line ();
4407 ++input_line_pointer
;
4409 endc
= get_symbol_name (&name
);
4411 lab_sym
= symbol_find_or_make (name
);
4413 (void) restore_line_pointer (endc
);
4415 if (ext_sym
!= lab_sym
)
4419 exp
.X_op
= O_symbol
;
4420 exp
.X_add_symbol
= lab_sym
;
4421 exp
.X_op_symbol
= NULL
;
4422 exp
.X_add_number
= 0;
4424 symbol_set_value_expression (ext_sym
, &exp
);
4427 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4428 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4429 symbol_get_tc (ext_sym
)->output
= 1;
4431 if (*input_line_pointer
== ',')
4435 /* Ignore the third argument. */
4436 ++input_line_pointer
;
4438 if (*input_line_pointer
== ',')
4440 /* Ignore the fourth argument. */
4441 ++input_line_pointer
;
4443 if (*input_line_pointer
== ',')
4445 /* The fifth argument is the function size. */
4446 ++input_line_pointer
;
4447 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4448 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4449 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4454 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4455 SF_SET_FUNCTION (ext_sym
);
4456 SF_SET_PROCESS (ext_sym
);
4457 coff_add_linesym (ext_sym
);
4459 demand_empty_rest_of_line ();
4462 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4463 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4464 with the correct line number */
4466 static symbolS
*saved_bi_sym
= 0;
4469 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4473 sym
= symbol_make (".bf");
4474 S_SET_SEGMENT (sym
, text_section
);
4475 symbol_set_frag (sym
, frag_now
);
4476 S_SET_VALUE (sym
, frag_now_fix ());
4477 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4479 coff_line_base
= get_absolute_expression ();
4481 S_SET_NUMBER_AUXILIARY (sym
, 1);
4482 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4484 /* Line number for bi. */
4487 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4492 symbol_get_tc (sym
)->output
= 1;
4494 ppc_frob_label (sym
);
4496 demand_empty_rest_of_line ();
4499 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4500 ".ef", except that the line number is absolute, not relative to the
4501 most recent ".bf" symbol. */
4504 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4508 sym
= symbol_make (".ef");
4509 S_SET_SEGMENT (sym
, text_section
);
4510 symbol_set_frag (sym
, frag_now
);
4511 S_SET_VALUE (sym
, frag_now_fix ());
4512 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4513 S_SET_NUMBER_AUXILIARY (sym
, 1);
4514 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4515 symbol_get_tc (sym
)->output
= 1;
4517 ppc_frob_label (sym
);
4519 demand_empty_rest_of_line ();
4522 /* The .bi and .ei pseudo-ops. These take a string argument and
4523 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4524 the symbol list. The value of .bi will be know when the next .bf
4530 static symbolS
*last_biei
;
4537 name
= demand_copy_C_string (&len
);
4539 /* The value of these symbols is actually file offset. Here we set
4540 the value to the index into the line number entries. In
4541 ppc_frob_symbols we set the fix_line field, which will cause BFD
4542 to do the right thing. */
4544 sym
= symbol_make (name
);
4545 /* obj-coff.c currently only handles line numbers correctly in the
4547 S_SET_SEGMENT (sym
, text_section
);
4548 S_SET_VALUE (sym
, coff_n_line_nos
);
4549 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4551 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4552 symbol_get_tc (sym
)->output
= 1;
4560 for (look
= last_biei
? last_biei
: symbol_rootP
;
4561 (look
!= (symbolS
*) NULL
4562 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4563 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4564 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4565 look
= symbol_next (look
))
4567 if (look
!= (symbolS
*) NULL
)
4569 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4570 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4574 demand_empty_rest_of_line ();
4577 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4578 There is one argument, which is a csect symbol. The value of the
4579 .bs symbol is the index of this csect symbol. */
4582 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4589 if (ppc_current_block
!= NULL
)
4590 as_bad (_("nested .bs blocks"));
4592 endc
= get_symbol_name (&name
);
4594 csect
= symbol_find_or_make (name
);
4596 (void) restore_line_pointer (endc
);
4598 sym
= symbol_make (".bs");
4599 S_SET_SEGMENT (sym
, now_seg
);
4600 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4601 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4602 symbol_get_tc (sym
)->output
= 1;
4604 symbol_get_tc (sym
)->within
= csect
;
4606 ppc_frob_label (sym
);
4608 ppc_current_block
= sym
;
4610 demand_empty_rest_of_line ();
4613 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4616 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4620 if (ppc_current_block
== NULL
)
4621 as_bad (_(".es without preceding .bs"));
4623 sym
= symbol_make (".es");
4624 S_SET_SEGMENT (sym
, now_seg
);
4625 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4626 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4627 symbol_get_tc (sym
)->output
= 1;
4629 ppc_frob_label (sym
);
4631 ppc_current_block
= NULL
;
4633 demand_empty_rest_of_line ();
4636 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4640 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4644 sym
= symbol_make (".bb");
4645 S_SET_SEGMENT (sym
, text_section
);
4646 symbol_set_frag (sym
, frag_now
);
4647 S_SET_VALUE (sym
, frag_now_fix ());
4648 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4650 S_SET_NUMBER_AUXILIARY (sym
, 1);
4651 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4653 symbol_get_tc (sym
)->output
= 1;
4655 SF_SET_PROCESS (sym
);
4657 ppc_frob_label (sym
);
4659 demand_empty_rest_of_line ();
4662 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4666 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4670 sym
= symbol_make (".eb");
4671 S_SET_SEGMENT (sym
, text_section
);
4672 symbol_set_frag (sym
, frag_now
);
4673 S_SET_VALUE (sym
, frag_now_fix ());
4674 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4675 S_SET_NUMBER_AUXILIARY (sym
, 1);
4676 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4677 symbol_get_tc (sym
)->output
= 1;
4679 SF_SET_PROCESS (sym
);
4681 ppc_frob_label (sym
);
4683 demand_empty_rest_of_line ();
4686 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4690 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4696 name
= demand_copy_C_string (&len
);
4697 sym
= symbol_make (name
);
4698 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4699 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4700 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4701 S_SET_VALUE (sym
, 0);
4702 symbol_get_tc (sym
)->output
= 1;
4704 ppc_frob_label (sym
);
4706 demand_empty_rest_of_line ();
4709 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4712 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4716 sym
= symbol_make (".ec");
4717 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4718 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4719 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4720 S_SET_VALUE (sym
, 0);
4721 symbol_get_tc (sym
)->output
= 1;
4723 ppc_frob_label (sym
);
4725 demand_empty_rest_of_line ();
4728 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4731 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4733 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4734 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4741 subseg
= ppc_data_subsegment
;
4742 ++ppc_data_subsegment
;
4744 subseg_new (segment_name (data_section
), subseg
);
4745 ppc_toc_frag
= frag_now
;
4747 sym
= symbol_find_or_make ("TOC[TC0]");
4748 symbol_set_frag (sym
, frag_now
);
4749 S_SET_SEGMENT (sym
, data_section
);
4750 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4751 symbol_get_tc (sym
)->subseg
= subseg
;
4752 symbol_get_tc (sym
)->output
= 1;
4753 symbol_get_tc (sym
)->within
= sym
;
4755 ppc_toc_csect
= sym
;
4757 for (list
= ppc_data_csects
;
4758 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4759 list
= symbol_get_tc (list
)->next
)
4761 symbol_get_tc (list
)->next
= sym
;
4763 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4764 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4768 ppc_current_csect
= ppc_toc_csect
;
4770 demand_empty_rest_of_line ();
4773 /* The AIX assembler automatically aligns the operands of a .long or
4774 .short pseudo-op, and we want to be compatible. */
4777 ppc_xcoff_cons (int log_size
)
4779 frag_align (log_size
, 0, 0);
4780 record_alignment (now_seg
, log_size
);
4781 cons (1 << log_size
);
4785 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4790 (void) expression (&exp
);
4792 if (exp
.X_op
!= O_constant
)
4794 as_bad (_("non-constant byte count"));
4798 byte_count
= exp
.X_add_number
;
4800 if (*input_line_pointer
!= ',')
4802 as_bad (_("missing value"));
4806 ++input_line_pointer
;
4811 ppc_xcoff_end (void)
4815 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4817 struct dw_section
*dws
= &dw_sections
[i
];
4818 struct dw_subsection
*dwss
;
4820 if (dws
->anon_subseg
)
4822 dwss
= dws
->anon_subseg
;
4823 dwss
->link
= dws
->list_subseg
;
4826 dwss
= dws
->list_subseg
;
4828 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4829 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4831 subseg_set (dws
->sect
, dwss
->subseg
);
4832 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4837 #endif /* OBJ_XCOFF */
4838 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4840 /* The .tc pseudo-op. This is used when generating either XCOFF or
4841 ELF. This takes two or more arguments.
4843 When generating XCOFF output, the first argument is the name to
4844 give to this location in the toc; this will be a symbol with class
4845 TC. The rest of the arguments are N-byte values to actually put at
4846 this location in the TOC; often there is just one more argument, a
4847 relocatable symbol reference. The size of the value to store
4848 depends on target word size. A 32-bit target uses 4-byte values, a
4849 64-bit target uses 8-byte values.
4851 When not generating XCOFF output, the arguments are the same, but
4852 the first argument is simply ignored. */
4855 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4859 /* Define the TOC symbol name. */
4865 if (ppc_toc_csect
== (symbolS
*) NULL
4866 || ppc_toc_csect
!= ppc_current_csect
)
4868 as_bad (_(".tc not in .toc section"));
4869 ignore_rest_of_line ();
4873 endc
= get_symbol_name (&name
);
4875 sym
= symbol_find_or_make (name
);
4877 (void) restore_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
)
4945 #define MAX_HISTORY 100
4946 static ppc_cpu_t
*cpu_history
;
4947 static int curr_hist
;
4951 c
= get_symbol_name (&cpu_string
);
4952 cpu_string
= xstrdup (cpu_string
);
4953 (void) restore_line_pointer (c
);
4955 if (cpu_string
!= NULL
)
4957 ppc_cpu_t old_cpu
= ppc_cpu
;
4961 for (p
= cpu_string
; *p
!= 0; p
++)
4964 if (strcmp (cpu_string
, "push") == 0)
4966 if (cpu_history
== NULL
)
4967 cpu_history
= XNEWVEC (ppc_cpu_t
, MAX_HISTORY
);
4969 if (curr_hist
>= MAX_HISTORY
)
4970 as_bad (_(".machine stack overflow"));
4972 cpu_history
[curr_hist
++] = ppc_cpu
;
4974 else if (strcmp (cpu_string
, "pop") == 0)
4977 as_bad (_(".machine stack underflow"));
4979 ppc_cpu
= cpu_history
[--curr_hist
];
4981 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4984 as_bad (_("invalid machine `%s'"), cpu_string
);
4986 if (ppc_cpu
!= old_cpu
)
4987 ppc_setup_opcodes ();
4990 demand_empty_rest_of_line ();
4992 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4996 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4998 /* Set the current section. */
5000 ppc_set_current_section (segT
new)
5002 ppc_previous_section
= ppc_current_section
;
5003 ppc_current_section
= new;
5006 /* pseudo-op: .previous
5007 behaviour: toggles the current section with the previous section.
5009 warnings: "No previous section" */
5012 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
5014 if (ppc_previous_section
== NULL
)
5016 as_warn (_("no previous section to return to, ignored."));
5020 subseg_set (ppc_previous_section
, 0);
5022 ppc_set_current_section (ppc_previous_section
);
5025 /* pseudo-op: .pdata
5026 behaviour: predefined read only data section
5030 initial: .section .pdata "adr3"
5031 a - don't know -- maybe a misprint
5032 d - initialized data
5034 3 - double word aligned (that would be 4 byte boundary)
5037 Tag index tables (also known as the function table) for exception
5038 handling, debugging, etc. */
5041 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
5043 if (pdata_section
== 0)
5045 pdata_section
= subseg_new (".pdata", 0);
5047 bfd_set_section_flags (stdoutput
, pdata_section
,
5048 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5049 | SEC_READONLY
| SEC_DATA
));
5051 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
5055 pdata_section
= subseg_new (".pdata", 0);
5057 ppc_set_current_section (pdata_section
);
5060 /* pseudo-op: .ydata
5061 behaviour: predefined read only data section
5065 initial: .section .ydata "drw3"
5066 a - don't know -- maybe a misprint
5067 d - initialized data
5069 3 - double word aligned (that would be 4 byte boundary)
5071 Tag tables (also known as the scope table) for exception handling,
5075 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
5077 if (ydata_section
== 0)
5079 ydata_section
= subseg_new (".ydata", 0);
5080 bfd_set_section_flags (stdoutput
, ydata_section
,
5081 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5082 | SEC_READONLY
| SEC_DATA
));
5084 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
5088 ydata_section
= subseg_new (".ydata", 0);
5090 ppc_set_current_section (ydata_section
);
5093 /* pseudo-op: .reldata
5094 behaviour: predefined read write data section
5095 double word aligned (4-byte)
5096 FIXME: relocation is applied to it
5097 FIXME: what's the difference between this and .data?
5100 initial: .section .reldata "drw3"
5101 d - initialized data
5104 3 - double word aligned (that would be 8 byte boundary)
5107 Like .data, but intended to hold data subject to relocation, such as
5108 function descriptors, etc. */
5111 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5113 if (reldata_section
== 0)
5115 reldata_section
= subseg_new (".reldata", 0);
5117 bfd_set_section_flags (stdoutput
, reldata_section
,
5118 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5121 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5125 reldata_section
= subseg_new (".reldata", 0);
5127 ppc_set_current_section (reldata_section
);
5130 /* pseudo-op: .rdata
5131 behaviour: predefined read only data section
5135 initial: .section .rdata "dr3"
5136 d - initialized data
5138 3 - double word aligned (that would be 4 byte boundary) */
5141 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5143 if (rdata_section
== 0)
5145 rdata_section
= subseg_new (".rdata", 0);
5146 bfd_set_section_flags (stdoutput
, rdata_section
,
5147 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5148 | SEC_READONLY
| SEC_DATA
));
5150 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5154 rdata_section
= subseg_new (".rdata", 0);
5156 ppc_set_current_section (rdata_section
);
5159 /* pseudo-op: .ualong
5160 behaviour: much like .int, with the exception that no alignment is
5162 FIXME: test the alignment statement
5167 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5173 /* pseudo-op: .znop <symbol name>
5174 behaviour: Issue a nop instruction
5175 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5176 the supplied symbol name.
5178 warnings: Missing symbol name */
5181 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5184 const struct powerpc_opcode
*opcode
;
5191 /* Strip out the symbol name. */
5192 c
= get_symbol_name (&symbol_name
);
5194 name
= xstrdup (symbol_name
);
5196 sym
= symbol_find_or_make (name
);
5198 *input_line_pointer
= c
;
5200 SKIP_WHITESPACE_AFTER_NAME ();
5202 /* Look up the opcode in the hash table. */
5203 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5205 /* Stick in the nop. */
5206 insn
= opcode
->opcode
;
5208 /* Write out the instruction. */
5210 md_number_to_chars (f
, insn
, 4);
5212 f
- frag_now
->fr_literal
,
5217 BFD_RELOC_16_GOT_PCREL
);
5227 ppc_pe_comm (int lcomm
)
5236 c
= get_symbol_name (&name
);
5238 /* just after name is now '\0'. */
5239 p
= input_line_pointer
;
5241 SKIP_WHITESPACE_AFTER_NAME ();
5242 if (*input_line_pointer
!= ',')
5244 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5245 ignore_rest_of_line ();
5249 input_line_pointer
++; /* skip ',' */
5250 if ((temp
= get_absolute_expression ()) < 0)
5252 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5253 ignore_rest_of_line ();
5259 /* The third argument to .comm is the alignment. */
5260 if (*input_line_pointer
!= ',')
5264 ++input_line_pointer
;
5265 align
= get_absolute_expression ();
5268 as_warn (_("ignoring bad alignment"));
5275 symbolP
= symbol_find_or_make (name
);
5278 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5280 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5281 S_GET_NAME (symbolP
));
5282 ignore_rest_of_line ();
5286 if (S_GET_VALUE (symbolP
))
5288 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5289 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5290 S_GET_NAME (symbolP
),
5291 (long) S_GET_VALUE (symbolP
),
5296 S_SET_VALUE (symbolP
, (valueT
) temp
);
5297 S_SET_EXTERNAL (symbolP
);
5298 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5301 demand_empty_rest_of_line ();
5305 * implement the .section pseudo op:
5306 * .section name {, "flags"}
5308 * | +--- optional flags: 'b' for bss
5310 * +-- section name 'l' for lib
5314 * 'd' (apparently m88k for data)
5316 * But if the argument is not a quoted string, treat it as a
5317 * subsegment number.
5319 * FIXME: this is a copy of the section processing from obj-coff.c, with
5320 * additions/changes for the moto-pas assembler support. There are three
5323 * FIXME: I just noticed this. This doesn't work at all really. It it
5324 * setting bits that bfd probably neither understands or uses. The
5325 * correct approach (?) will have to incorporate extra fields attached
5326 * to the section to hold the system specific stuff. (krk)
5329 * 'a' - unknown - referred to in documentation, but no definition supplied
5330 * 'c' - section has code
5331 * 'd' - section has initialized data
5332 * 'u' - section has uninitialized data
5333 * 'i' - section contains directives (info)
5334 * 'n' - section can be discarded
5335 * 'R' - remove section at link time
5337 * Section Protection:
5338 * 'r' - section is readable
5339 * 'w' - section is writeable
5340 * 'x' - section is executable
5341 * 's' - section is sharable
5343 * Section Alignment:
5344 * '0' - align to byte boundary
5345 * '1' - align to halfword undary
5346 * '2' - align to word boundary
5347 * '3' - align to doubleword boundary
5348 * '4' - align to quadword boundary
5349 * '5' - align to 32 byte boundary
5350 * '6' - align to 64 byte boundary
5355 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5357 /* Strip out the section name. */
5366 c
= get_symbol_name (§ion_name
);
5368 name
= xstrdup (section_name
);
5370 *input_line_pointer
= c
;
5372 SKIP_WHITESPACE_AFTER_NAME ();
5375 flags
= SEC_NO_FLAGS
;
5377 if (strcmp (name
, ".idata$2") == 0)
5381 else if (strcmp (name
, ".idata$3") == 0)
5385 else if (strcmp (name
, ".idata$4") == 0)
5389 else if (strcmp (name
, ".idata$5") == 0)
5393 else if (strcmp (name
, ".idata$6") == 0)
5398 /* Default alignment to 16 byte boundary. */
5401 if (*input_line_pointer
== ',')
5403 ++input_line_pointer
;
5405 if (*input_line_pointer
!= '"')
5406 exp
= get_absolute_expression ();
5409 ++input_line_pointer
;
5410 while (*input_line_pointer
!= '"'
5411 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5413 switch (*input_line_pointer
)
5415 /* Section Contents */
5416 case 'a': /* unknown */
5417 as_bad (_("unsupported section attribute -- 'a'"));
5419 case 'c': /* code section */
5422 case 'd': /* section has initialized data */
5425 case 'u': /* section has uninitialized data */
5426 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5430 case 'i': /* section contains directives (info) */
5431 /* FIXME: This is IMAGE_SCN_LNK_INFO
5433 flags
|= SEC_HAS_CONTENTS
;
5435 case 'n': /* section can be discarded */
5438 case 'R': /* Remove section at link time */
5439 flags
|= SEC_NEVER_LOAD
;
5441 #if IFLICT_BRAIN_DAMAGE
5442 /* Section Protection */
5443 case 'r': /* section is readable */
5444 flags
|= IMAGE_SCN_MEM_READ
;
5446 case 'w': /* section is writeable */
5447 flags
|= IMAGE_SCN_MEM_WRITE
;
5449 case 'x': /* section is executable */
5450 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5452 case 's': /* section is sharable */
5453 flags
|= IMAGE_SCN_MEM_SHARED
;
5456 /* Section Alignment */
5457 case '0': /* align to byte boundary */
5458 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5461 case '1': /* align to halfword boundary */
5462 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5465 case '2': /* align to word boundary */
5466 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5469 case '3': /* align to doubleword boundary */
5470 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5473 case '4': /* align to quadword boundary */
5474 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5477 case '5': /* align to 32 byte boundary */
5478 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5481 case '6': /* align to 64 byte boundary */
5482 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5487 as_bad (_("unknown section attribute '%c'"),
5488 *input_line_pointer
);
5491 ++input_line_pointer
;
5493 if (*input_line_pointer
== '"')
5494 ++input_line_pointer
;
5498 sec
= subseg_new (name
, (subsegT
) exp
);
5500 ppc_set_current_section (sec
);
5502 if (flags
!= SEC_NO_FLAGS
)
5504 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5505 as_bad (_("error setting flags for \"%s\": %s"),
5506 bfd_section_name (stdoutput
, sec
),
5507 bfd_errmsg (bfd_get_error ()));
5510 bfd_set_section_alignment (stdoutput
, sec
, align
);
5514 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5520 endc
= get_symbol_name (&name
);
5522 ext_sym
= symbol_find_or_make (name
);
5524 (void) restore_line_pointer (endc
);
5526 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5527 SF_SET_FUNCTION (ext_sym
);
5528 SF_SET_PROCESS (ext_sym
);
5529 coff_add_linesym (ext_sym
);
5531 demand_empty_rest_of_line ();
5535 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5537 if (tocdata_section
== 0)
5539 tocdata_section
= subseg_new (".tocd", 0);
5540 /* FIXME: section flags won't work. */
5541 bfd_set_section_flags (stdoutput
, tocdata_section
,
5542 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5543 | SEC_READONLY
| SEC_DATA
));
5545 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5549 rdata_section
= subseg_new (".tocd", 0);
5552 ppc_set_current_section (tocdata_section
);
5554 demand_empty_rest_of_line ();
5557 /* Don't adjust TOC relocs to use the section symbol. */
5560 ppc_pe_fix_adjustable (fixS
*fix
)
5562 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5569 /* XCOFF specific symbol and file handling. */
5571 /* Canonicalize the symbol name. We use the to force the suffix, if
5572 any, to use square brackets, and to be in upper case. */
5575 ppc_canonicalize_symbol_name (char *name
)
5579 if (ppc_stab_symbol
)
5582 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5596 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5599 if (*s
== '\0' || s
[1] != '\0')
5600 as_bad (_("bad symbol suffix"));
5608 /* Set the class of a symbol based on the suffix, if any. This is
5609 called whenever a new symbol is created. */
5612 ppc_symbol_new_hook (symbolS
*sym
)
5614 struct ppc_tc_sy
*tc
;
5617 tc
= symbol_get_tc (sym
);
5620 tc
->symbol_class
= -1;
5621 tc
->real_name
= NULL
;
5628 if (ppc_stab_symbol
)
5631 s
= strchr (S_GET_NAME (sym
), '[');
5632 if (s
== (const char *) NULL
)
5634 /* There is no suffix. */
5643 if (strcmp (s
, "BS]") == 0)
5644 tc
->symbol_class
= XMC_BS
;
5647 if (strcmp (s
, "DB]") == 0)
5648 tc
->symbol_class
= XMC_DB
;
5649 else if (strcmp (s
, "DS]") == 0)
5650 tc
->symbol_class
= XMC_DS
;
5653 if (strcmp (s
, "GL]") == 0)
5654 tc
->symbol_class
= XMC_GL
;
5657 if (strcmp (s
, "PR]") == 0)
5658 tc
->symbol_class
= XMC_PR
;
5661 if (strcmp (s
, "RO]") == 0)
5662 tc
->symbol_class
= XMC_RO
;
5663 else if (strcmp (s
, "RW]") == 0)
5664 tc
->symbol_class
= XMC_RW
;
5667 if (strcmp (s
, "SV]") == 0)
5668 tc
->symbol_class
= XMC_SV
;
5671 if (strcmp (s
, "TC]") == 0)
5672 tc
->symbol_class
= XMC_TC
;
5673 else if (strcmp (s
, "TI]") == 0)
5674 tc
->symbol_class
= XMC_TI
;
5675 else if (strcmp (s
, "TB]") == 0)
5676 tc
->symbol_class
= XMC_TB
;
5677 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5678 tc
->symbol_class
= XMC_TC0
;
5681 if (strcmp (s
, "UA]") == 0)
5682 tc
->symbol_class
= XMC_UA
;
5683 else if (strcmp (s
, "UC]") == 0)
5684 tc
->symbol_class
= XMC_UC
;
5687 if (strcmp (s
, "XO]") == 0)
5688 tc
->symbol_class
= XMC_XO
;
5692 if (tc
->symbol_class
== -1)
5693 as_bad (_("unrecognized symbol suffix"));
5696 /* Set the class of a label based on where it is defined. This
5697 handles symbols without suffixes. Also, move the symbol so that it
5698 follows the csect symbol. */
5701 ppc_frob_label (symbolS
*sym
)
5703 if (ppc_current_csect
!= (symbolS
*) NULL
)
5705 if (symbol_get_tc (sym
)->symbol_class
== -1)
5706 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5708 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5709 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5710 &symbol_rootP
, &symbol_lastP
);
5711 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5712 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5716 dwarf2_emit_label (sym
);
5720 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5721 seen. It tells ppc_adjust_symtab whether it needs to look through
5724 static bfd_boolean ppc_saw_abs
;
5726 /* Change the name of a symbol just before writing it out. Set the
5727 real name if the .rename pseudo-op was used. Otherwise, remove any
5728 class suffix. Return 1 if the symbol should not be included in the
5732 ppc_frob_symbol (symbolS
*sym
)
5734 static symbolS
*ppc_last_function
;
5735 static symbolS
*set_end
;
5737 /* Discard symbols that should not be included in the output symbol
5739 if (! symbol_used_in_reloc_p (sym
)
5740 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5741 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5742 && ! symbol_get_tc (sym
)->output
5743 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5746 /* This one will disappear anyway. Don't make a csect sym for it. */
5747 if (sym
== abs_section_sym
)
5750 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5751 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5757 name
= S_GET_NAME (sym
);
5758 s
= strchr (name
, '[');
5759 if (s
!= (char *) NULL
)
5765 snew
= xstrndup (name
, len
);
5767 S_SET_NAME (sym
, snew
);
5771 if (set_end
!= (symbolS
*) NULL
)
5773 SA_SET_SYM_ENDNDX (set_end
, sym
);
5777 if (SF_GET_FUNCTION (sym
))
5779 if (ppc_last_function
!= (symbolS
*) NULL
)
5780 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5781 ppc_last_function
= sym
;
5782 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5784 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5785 SA_SET_SYM_FSIZE (sym
,
5786 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5789 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5790 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5792 if (ppc_last_function
== (symbolS
*) NULL
)
5793 as_bad (_(".ef with no preceding .function"));
5796 set_end
= ppc_last_function
;
5797 ppc_last_function
= NULL
;
5799 /* We don't have a C_EFCN symbol, but we need to force the
5800 COFF backend to believe that it has seen one. */
5801 coff_last_function
= NULL
;
5805 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5806 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5807 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5808 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5809 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5810 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5811 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5812 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5813 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5814 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5815 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5817 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5818 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5819 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5822 union internal_auxent
*a
;
5824 /* Create a csect aux. */
5825 i
= S_GET_NUMBER_AUXILIARY (sym
);
5826 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5827 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5828 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5830 /* This is the TOC table. */
5831 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5832 a
->x_csect
.x_scnlen
.l
= 0;
5833 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5835 else if (symbol_get_tc (sym
)->subseg
!= 0)
5837 /* This is a csect symbol. x_scnlen is the size of the
5839 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5840 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5841 S_GET_SEGMENT (sym
))
5842 - S_GET_VALUE (sym
));
5845 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5846 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5847 - S_GET_VALUE (sym
));
5849 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5851 else if (S_GET_SEGMENT (sym
) == bss_section
)
5853 /* This is a common symbol. */
5854 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5855 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5856 if (S_IS_EXTERNAL (sym
))
5857 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5859 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5861 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5863 /* This is an absolute symbol. The csect will be created by
5864 ppc_adjust_symtab. */
5866 a
->x_csect
.x_smtyp
= XTY_LD
;
5867 if (symbol_get_tc (sym
)->symbol_class
== -1)
5868 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5870 else if (! S_IS_DEFINED (sym
))
5872 /* This is an external symbol. */
5873 a
->x_csect
.x_scnlen
.l
= 0;
5874 a
->x_csect
.x_smtyp
= XTY_ER
;
5876 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5880 /* This is a TOC definition. x_scnlen is the size of the
5882 next
= symbol_next (sym
);
5883 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5884 next
= symbol_next (next
);
5885 if (next
== (symbolS
*) NULL
5886 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5888 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5889 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5891 - S_GET_VALUE (sym
));
5893 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5894 - S_GET_VALUE (sym
));
5898 resolve_symbol_value (next
);
5899 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5900 - S_GET_VALUE (sym
));
5902 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5908 /* This is a normal symbol definition. x_scnlen is the
5909 symbol index of the containing csect. */
5910 if (S_GET_SEGMENT (sym
) == text_section
)
5911 csect
= ppc_text_csects
;
5912 else if (S_GET_SEGMENT (sym
) == data_section
)
5913 csect
= ppc_data_csects
;
5917 /* Skip the initial dummy symbol. */
5918 csect
= symbol_get_tc (csect
)->next
;
5920 if (csect
== (symbolS
*) NULL
)
5922 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5923 a
->x_csect
.x_scnlen
.l
= 0;
5927 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5929 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5930 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5931 > S_GET_VALUE (sym
))
5933 csect
= symbol_get_tc (csect
)->next
;
5936 a
->x_csect
.x_scnlen
.p
=
5937 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5938 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5941 a
->x_csect
.x_smtyp
= XTY_LD
;
5944 a
->x_csect
.x_parmhash
= 0;
5945 a
->x_csect
.x_snhash
= 0;
5946 if (symbol_get_tc (sym
)->symbol_class
== -1)
5947 a
->x_csect
.x_smclas
= XMC_PR
;
5949 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5950 a
->x_csect
.x_stab
= 0;
5951 a
->x_csect
.x_snstab
= 0;
5953 /* Don't let the COFF backend resort these symbols. */
5954 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5956 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5958 /* We want the value to be the symbol index of the referenced
5959 csect symbol. BFD will do that for us if we set the right
5961 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5962 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5964 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5965 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5967 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5972 block
= symbol_get_tc (sym
)->within
;
5975 /* The value is the offset from the enclosing csect. */
5978 csect
= symbol_get_tc (block
)->within
;
5979 resolve_symbol_value (csect
);
5980 base
= S_GET_VALUE (csect
);
5985 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5987 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5988 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5990 /* We want the value to be a file offset into the line numbers.
5991 BFD will do that for us if we set the right flags. We have
5992 already set the value correctly. */
5993 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5999 /* Adjust the symbol table. This creates csect symbols for all
6000 absolute symbols. */
6003 ppc_adjust_symtab (void)
6010 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
6014 union internal_auxent
*a
;
6016 if (S_GET_SEGMENT (sym
) != absolute_section
)
6019 csect
= symbol_create (".abs[XO]", absolute_section
,
6020 S_GET_VALUE (sym
), &zero_address_frag
);
6021 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
6022 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
6023 i
= S_GET_NUMBER_AUXILIARY (csect
);
6024 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
6025 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
6026 a
->x_csect
.x_scnlen
.l
= 0;
6027 a
->x_csect
.x_smtyp
= XTY_SD
;
6028 a
->x_csect
.x_parmhash
= 0;
6029 a
->x_csect
.x_snhash
= 0;
6030 a
->x_csect
.x_smclas
= XMC_XO
;
6031 a
->x_csect
.x_stab
= 0;
6032 a
->x_csect
.x_snstab
= 0;
6034 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
6036 i
= S_GET_NUMBER_AUXILIARY (sym
);
6037 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
6038 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
6039 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
6042 ppc_saw_abs
= FALSE
;
6045 /* Set the VMA for a section. This is called on all the sections in
6049 ppc_frob_section (asection
*sec
)
6051 static bfd_vma vma
= 0;
6053 /* Dwarf sections start at 0. */
6054 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
6057 vma
= md_section_align (sec
, vma
);
6058 bfd_set_section_vma (stdoutput
, sec
, vma
);
6059 vma
+= bfd_section_size (stdoutput
, sec
);
6062 #endif /* OBJ_XCOFF */
6065 md_atof (int type
, char *litp
, int *sizep
)
6067 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
6070 /* Write a value out to the object file, using the appropriate
6074 md_number_to_chars (char *buf
, valueT val
, int n
)
6076 if (target_big_endian
)
6077 number_to_chars_bigendian (buf
, val
, n
);
6079 number_to_chars_littleendian (buf
, val
, n
);
6082 /* Align a section (I don't know why this is machine dependent). */
6085 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6090 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6092 return ((addr
+ (1 << align
) - 1) & -(1 << align
));
6096 /* We don't have any form of relaxing. */
6099 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6100 asection
*seg ATTRIBUTE_UNUSED
)
6106 /* Convert a machine dependent frag. We never generate these. */
6109 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6110 asection
*sec ATTRIBUTE_UNUSED
,
6111 fragS
*fragp ATTRIBUTE_UNUSED
)
6116 /* We have no need to default values of symbols. */
6119 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6124 /* Functions concerning relocs. */
6126 /* The location from which a PC relative jump should be calculated,
6127 given a PC relative reloc. */
6130 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6132 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6137 /* This is called to see whether a fixup should be adjusted to use a
6138 section symbol. We take the opportunity to change a fixup against
6139 a symbol in the TOC subsegment into a reloc against the
6140 corresponding .tc symbol. */
6143 ppc_fix_adjustable (fixS
*fix
)
6145 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6146 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6147 TC_SYMFIELD_TYPE
*tc
;
6149 if (symseg
== absolute_section
)
6152 /* Always adjust symbols in debugging sections. */
6153 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6156 if (ppc_toc_csect
!= (symbolS
*) NULL
6157 && fix
->fx_addsy
!= ppc_toc_csect
6158 && symseg
== data_section
6159 && val
>= ppc_toc_frag
->fr_address
6160 && (ppc_after_toc_frag
== (fragS
*) NULL
6161 || val
< ppc_after_toc_frag
->fr_address
))
6165 for (sy
= symbol_next (ppc_toc_csect
);
6166 sy
!= (symbolS
*) NULL
;
6167 sy
= symbol_next (sy
))
6169 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6171 if (sy_tc
->symbol_class
== XMC_TC0
)
6173 if (sy_tc
->symbol_class
!= XMC_TC
)
6175 if (val
== resolve_symbol_value (sy
))
6178 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6183 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6184 _("symbol in .toc does not match any .tc"));
6187 /* Possibly adjust the reloc to be against the csect. */
6188 tc
= symbol_get_tc (fix
->fx_addsy
);
6190 && tc
->symbol_class
!= XMC_TC0
6191 && tc
->symbol_class
!= XMC_TC
6192 && symseg
!= bss_section
6193 /* Don't adjust if this is a reloc in the toc section. */
6194 && (symseg
!= data_section
6195 || ppc_toc_csect
== NULL
6196 || val
< ppc_toc_frag
->fr_address
6197 || (ppc_after_toc_frag
!= NULL
6198 && val
>= ppc_after_toc_frag
->fr_address
)))
6200 symbolS
*csect
= tc
->within
;
6202 /* If the symbol was not declared by a label (eg: a section symbol),
6203 use the section instead of the csect. This doesn't happen in
6204 normal AIX assembly code. */
6206 csect
= seg_info (symseg
)->sym
;
6208 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6209 fix
->fx_addsy
= csect
;
6214 /* Adjust a reloc against a .lcomm symbol to be against the base
6216 if (symseg
== bss_section
6217 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6219 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6221 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6228 /* A reloc from one csect to another must be kept. The assembler
6229 will, of course, keep relocs between sections, and it will keep
6230 absolute relocs, but we need to force it to keep PC relative relocs
6231 between two csects in the same section. */
6234 ppc_force_relocation (fixS
*fix
)
6236 /* At this point fix->fx_addsy should already have been converted to
6237 a csect symbol. If the csect does not include the fragment, then
6238 we need to force the relocation. */
6240 && fix
->fx_addsy
!= NULL
6241 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6242 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6243 > fix
->fx_frag
->fr_address
)
6244 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6245 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6246 <= fix
->fx_frag
->fr_address
))))
6249 return generic_force_reloc (fix
);
6253 ppc_new_dot_label (symbolS
*sym
)
6255 /* Anchor this label to the current csect for relocations. */
6256 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6259 #endif /* OBJ_XCOFF */
6262 /* If this function returns non-zero, it guarantees that a relocation
6263 will be emitted for a fixup. */
6266 ppc_force_relocation (fixS
*fix
)
6268 /* Branch prediction relocations must force a relocation, as must
6269 the vtable description relocs. */
6270 switch (fix
->fx_r_type
)
6272 case BFD_RELOC_PPC_B16_BRTAKEN
:
6273 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6274 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6275 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6276 case BFD_RELOC_24_PLT_PCREL
:
6277 case BFD_RELOC_PPC64_TOC
:
6279 case BFD_RELOC_PPC_B26
:
6280 case BFD_RELOC_PPC_BA26
:
6281 case BFD_RELOC_PPC_B16
:
6282 case BFD_RELOC_PPC_BA16
:
6283 /* All branch fixups targeting a localentry symbol must
6284 force a relocation. */
6287 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6288 elf_symbol_type
*elfsym
6289 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6290 gas_assert (elfsym
);
6291 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6299 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6300 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6303 return generic_force_reloc (fix
);
6307 ppc_fix_adjustable (fixS
*fix
)
6309 switch (fix
->fx_r_type
)
6311 /* All branch fixups targeting a localentry symbol must
6312 continue using the symbol. */
6313 case BFD_RELOC_PPC_B26
:
6314 case BFD_RELOC_PPC_BA26
:
6315 case BFD_RELOC_PPC_B16
:
6316 case BFD_RELOC_PPC_BA16
:
6317 case BFD_RELOC_PPC_B16_BRTAKEN
:
6318 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6319 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6320 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6323 asymbol
*bfdsym
= symbol_get_bfdsym (fix
->fx_addsy
);
6324 elf_symbol_type
*elfsym
6325 = elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
6326 gas_assert (elfsym
);
6327 if ((STO_PPC64_LOCAL_MASK
& elfsym
->internal_elf_sym
.st_other
) != 0)
6335 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6336 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6337 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6338 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6339 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6340 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6341 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6342 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6343 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6344 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6345 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6350 ppc_frag_check (struct frag
*fragP
)
6352 if (!fragP
->has_code
)
6355 if (ppc_mach() == bfd_mach_ppc_vle
)
6357 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6358 as_bad (_("instruction address is not a multiple of 2"));
6362 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6363 as_bad (_("instruction address is not a multiple of 4"));
6367 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6368 rs_align_code frag. */
6371 ppc_handle_align (struct frag
*fragP
)
6373 valueT count
= (fragP
->fr_next
->fr_address
6374 - (fragP
->fr_address
+ fragP
->fr_fix
));
6376 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6378 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6381 md_number_to_chars (dest
, 0x4400, 2);
6383 else if (count
!= 0 && (count
& 3) == 0)
6385 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6389 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6393 /* Make a branch, then follow with nops. Insert another
6394 frag to handle the nops. */
6395 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6400 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6401 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6402 fragP
->fr_next
= rest
;
6404 rest
->fr_address
+= rest
->fr_fix
+ 4;
6406 /* If we leave the next frag as rs_align_code we'll come here
6407 again, resulting in a bunch of branches rather than a
6408 branch followed by nops. */
6409 rest
->fr_type
= rs_align
;
6410 dest
= rest
->fr_literal
;
6413 md_number_to_chars (dest
, 0x60000000, 4);
6415 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6416 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6417 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0
6418 || (ppc_cpu
& PPC_OPCODE_POWER9
) != 0)
6420 /* For power6, power7, power8 and power9, we want the last nop to be
6421 a group terminating one. Do this by inserting an rs_fill frag
6422 immediately after this one, with its address set to the last nop
6423 location. This will automatically reduce the number of nops in
6424 the current frag by one. */
6427 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6429 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6430 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6431 group_nop
->fr_fix
= 0;
6432 group_nop
->fr_offset
= 1;
6433 group_nop
->fr_type
= rs_fill
;
6434 fragP
->fr_next
= group_nop
;
6435 dest
= group_nop
->fr_literal
;
6438 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6439 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0
6440 || (ppc_cpu
& PPC_OPCODE_POWER9
) != 0)
6442 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6443 /* e500mc group terminating nop: "ori 0,0,0". */
6444 md_number_to_chars (dest
, 0x60000000, 4);
6446 /* power7/power8/power9 group terminating nop: "ori 2,2,0". */
6447 md_number_to_chars (dest
, 0x60420000, 4);
6450 /* power6 group terminating nop: "ori 1,1,0". */
6451 md_number_to_chars (dest
, 0x60210000, 4);
6456 /* Apply a fixup to the object code. This is called for all the
6457 fixups we generated by the calls to fix_new_exp, above. */
6460 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg
)
6462 valueT value
= * valP
;
6464 const struct powerpc_operand
*operand
;
6467 if (fixP
->fx_addsy
!= NULL
)
6469 /* Hack around bfd_install_relocation brain damage. */
6471 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6473 if (fixP
->fx_addsy
== abs_section_sym
)
6479 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6480 the symbol values. If we are doing this relocation the code in
6481 write.c is going to call bfd_install_relocation, which is also
6482 going to use the symbol value. That means that if the reloc is
6483 fully resolved we want to use *valP since bfd_install_relocation is
6485 However, if the reloc is not fully resolved we do not want to
6486 use *valP, and must use fx_offset instead. If the relocation
6487 is PC-relative, we then need to re-apply md_pcrel_from_section
6488 to this new relocation value. */
6489 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6494 value
= fixP
->fx_offset
;
6496 value
-= md_pcrel_from_section (fixP
, seg
);
6500 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6502 /* We can't actually support subtracting a symbol. */
6503 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6507 if (fixP
->fx_pcrel_adjust
!= 0)
6509 /* This is a fixup on an instruction. */
6510 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6512 operand
= &powerpc_operands
[opindex
];
6514 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6515 does not generate a reloc. It uses the offset of `sym' within its
6516 csect. Other usages, such as `.long sym', generate relocs. This
6517 is the documented behaviour of non-TOC symbols. */
6518 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6519 && (operand
->bitm
& 0xfff0) == 0xfff0
6520 && operand
->shift
== 0
6521 && (operand
->insert
== NULL
|| ppc_obj64
)
6522 && fixP
->fx_addsy
!= NULL
6523 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6524 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6525 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6526 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6528 value
= fixP
->fx_offset
;
6532 /* During parsing of instructions, a TOC16 reloc is generated for
6533 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6534 in the toc. But at parse time, SYM may be not yet defined, so
6535 check again here. */
6536 if (fixP
->fx_r_type
== BFD_RELOC_16
6537 && fixP
->fx_addsy
!= NULL
6538 && ppc_is_toc_sym (fixP
->fx_addsy
))
6539 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6543 /* Calculate value to be stored in field. */
6545 switch (fixP
->fx_r_type
)
6548 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6549 case BFD_RELOC_PPC_VLE_LO16A
:
6550 case BFD_RELOC_PPC_VLE_LO16D
:
6552 case BFD_RELOC_LO16
:
6553 case BFD_RELOC_LO16_PCREL
:
6554 fieldval
= value
& 0xffff;
6556 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6557 fieldval
= SEX16 (fieldval
);
6558 fixP
->fx_no_overflow
= 1;
6561 case BFD_RELOC_HI16
:
6562 case BFD_RELOC_HI16_PCREL
:
6564 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6566 fieldval
= value
>> 16;
6567 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6569 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6570 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6576 case BFD_RELOC_PPC_VLE_HI16A
:
6577 case BFD_RELOC_PPC_VLE_HI16D
:
6578 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6580 fieldval
= PPC_HI (value
);
6581 goto sign_extend_16
;
6583 case BFD_RELOC_HI16_S
:
6584 case BFD_RELOC_HI16_S_PCREL
:
6585 case BFD_RELOC_PPC_REL16DX_HA
:
6587 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6589 fieldval
= (value
+ 0x8000) >> 16;
6590 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6592 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6593 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6599 case BFD_RELOC_PPC_VLE_HA16A
:
6600 case BFD_RELOC_PPC_VLE_HA16D
:
6601 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6603 fieldval
= PPC_HA (value
);
6604 goto sign_extend_16
;
6607 case BFD_RELOC_PPC64_HIGHER
:
6608 fieldval
= PPC_HIGHER (value
);
6609 goto sign_extend_16
;
6611 case BFD_RELOC_PPC64_HIGHER_S
:
6612 fieldval
= PPC_HIGHERA (value
);
6613 goto sign_extend_16
;
6615 case BFD_RELOC_PPC64_HIGHEST
:
6616 fieldval
= PPC_HIGHEST (value
);
6617 goto sign_extend_16
;
6619 case BFD_RELOC_PPC64_HIGHEST_S
:
6620 fieldval
= PPC_HIGHESTA (value
);
6621 goto sign_extend_16
;
6628 if (operand
!= NULL
)
6630 /* Handle relocs in an insn. */
6631 switch (fixP
->fx_r_type
)
6634 /* The following relocs can't be calculated by the assembler.
6635 Leave the field zero. */
6636 case BFD_RELOC_PPC_TPREL16
:
6637 case BFD_RELOC_PPC_TPREL16_LO
:
6638 case BFD_RELOC_PPC_TPREL16_HI
:
6639 case BFD_RELOC_PPC_TPREL16_HA
:
6640 case BFD_RELOC_PPC_DTPREL16
:
6641 case BFD_RELOC_PPC_DTPREL16_LO
:
6642 case BFD_RELOC_PPC_DTPREL16_HI
:
6643 case BFD_RELOC_PPC_DTPREL16_HA
:
6644 case BFD_RELOC_PPC_GOT_TLSGD16
:
6645 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6646 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6647 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6648 case BFD_RELOC_PPC_GOT_TLSLD16
:
6649 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6650 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6651 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6652 case BFD_RELOC_PPC_GOT_TPREL16
:
6653 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6654 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6655 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6656 case BFD_RELOC_PPC_GOT_DTPREL16
:
6657 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6658 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6659 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6660 case BFD_RELOC_PPC64_TPREL16_DS
:
6661 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6662 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6663 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6664 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6665 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6666 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6667 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6668 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6669 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6670 case BFD_RELOC_PPC64_DTPREL16_DS
:
6671 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6672 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6673 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6674 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6675 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6676 gas_assert (fixP
->fx_addsy
!= NULL
);
6677 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6681 /* These also should leave the field zero for the same
6682 reason. Note that older versions of gas wrote values
6683 here. If we want to go back to the old behaviour, then
6684 all _LO and _LO_DS cases will need to be treated like
6685 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6686 case BFD_RELOC_16_GOTOFF
:
6687 case BFD_RELOC_LO16_GOTOFF
:
6688 case BFD_RELOC_HI16_GOTOFF
:
6689 case BFD_RELOC_HI16_S_GOTOFF
:
6690 case BFD_RELOC_LO16_PLTOFF
:
6691 case BFD_RELOC_HI16_PLTOFF
:
6692 case BFD_RELOC_HI16_S_PLTOFF
:
6693 case BFD_RELOC_GPREL16
:
6694 case BFD_RELOC_16_BASEREL
:
6695 case BFD_RELOC_LO16_BASEREL
:
6696 case BFD_RELOC_HI16_BASEREL
:
6697 case BFD_RELOC_HI16_S_BASEREL
:
6698 case BFD_RELOC_PPC_TOC16
:
6699 case BFD_RELOC_PPC64_TOC16_LO
:
6700 case BFD_RELOC_PPC64_TOC16_HI
:
6701 case BFD_RELOC_PPC64_TOC16_HA
:
6702 case BFD_RELOC_PPC64_PLTGOT16
:
6703 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6704 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6705 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6706 case BFD_RELOC_PPC64_GOT16_DS
:
6707 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6708 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6709 case BFD_RELOC_PPC64_SECTOFF_DS
:
6710 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6711 case BFD_RELOC_PPC64_TOC16_DS
:
6712 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6713 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6714 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6715 case BFD_RELOC_PPC_EMB_NADDR16
:
6716 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6717 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6718 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6719 case BFD_RELOC_PPC_EMB_SDAI16
:
6720 case BFD_RELOC_PPC_EMB_SDA2I16
:
6721 case BFD_RELOC_PPC_EMB_SDA2REL
:
6722 case BFD_RELOC_PPC_EMB_SDA21
:
6723 case BFD_RELOC_PPC_EMB_MRKREF
:
6724 case BFD_RELOC_PPC_EMB_RELSEC16
:
6725 case BFD_RELOC_PPC_EMB_RELST_LO
:
6726 case BFD_RELOC_PPC_EMB_RELST_HI
:
6727 case BFD_RELOC_PPC_EMB_RELST_HA
:
6728 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6729 case BFD_RELOC_PPC_EMB_RELSDA
:
6730 case BFD_RELOC_PPC_VLE_SDA21
:
6731 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6732 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6733 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6734 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6735 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6736 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6737 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6738 gas_assert (fixP
->fx_addsy
!= NULL
);
6741 case BFD_RELOC_PPC_TLS
:
6742 case BFD_RELOC_PPC_TLSGD
:
6743 case BFD_RELOC_PPC_TLSLD
:
6749 case BFD_RELOC_PPC_B16
:
6750 /* Adjust the offset to the instruction boundary. */
6755 case BFD_RELOC_VTABLE_INHERIT
:
6756 case BFD_RELOC_VTABLE_ENTRY
:
6757 case BFD_RELOC_PPC_DTPMOD
:
6758 case BFD_RELOC_PPC_TPREL
:
6759 case BFD_RELOC_PPC_DTPREL
:
6760 case BFD_RELOC_PPC_COPY
:
6761 case BFD_RELOC_PPC_GLOB_DAT
:
6762 case BFD_RELOC_32_PLT_PCREL
:
6763 case BFD_RELOC_PPC_EMB_NADDR32
:
6764 case BFD_RELOC_PPC64_TOC
:
6765 case BFD_RELOC_CTOR
:
6767 case BFD_RELOC_32_PCREL
:
6770 case BFD_RELOC_64_PCREL
:
6771 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6772 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6773 _("%s unsupported as instruction fixup"),
6774 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6783 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6784 contents can stay at zero. */
6785 #define APPLY_RELOC fixP->fx_done
6787 #define APPLY_RELOC 1
6789 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6792 unsigned char *where
;
6794 /* Fetch the instruction, insert the fully resolved operand
6795 value, and stuff the instruction back again. */
6796 where
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6797 if (target_big_endian
)
6799 if (fixP
->fx_size
== 4)
6800 insn
= bfd_getb32 (where
);
6802 insn
= bfd_getb16 (where
);
6806 if (fixP
->fx_size
== 4)
6807 insn
= bfd_getl32 (where
);
6809 insn
= bfd_getl16 (where
);
6811 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6812 fixP
->tc_fix_data
.ppc_cpu
,
6813 fixP
->fx_file
, fixP
->fx_line
);
6814 if (target_big_endian
)
6816 if (fixP
->fx_size
== 4)
6817 bfd_putb32 (insn
, where
);
6819 bfd_putb16 (insn
, where
);
6823 if (fixP
->fx_size
== 4)
6824 bfd_putl32 (insn
, where
);
6826 bfd_putl16 (insn
, where
);
6831 /* Nothing else to do here. */
6834 gas_assert (fixP
->fx_addsy
!= NULL
);
6835 if (fixP
->fx_r_type
== BFD_RELOC_NONE
)
6840 /* Use expr_symbol_where to see if this is an expression
6842 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6843 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6844 _("unresolved expression that must be resolved"));
6846 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6847 _("unsupported relocation against %s"),
6848 S_GET_NAME (fixP
->fx_addsy
));
6855 /* Handle relocs in data. */
6856 switch (fixP
->fx_r_type
)
6858 case BFD_RELOC_VTABLE_INHERIT
:
6860 && !S_IS_DEFINED (fixP
->fx_addsy
)
6861 && !S_IS_WEAK (fixP
->fx_addsy
))
6862 S_SET_WEAK (fixP
->fx_addsy
);
6865 case BFD_RELOC_VTABLE_ENTRY
:
6870 /* These can appear with @l etc. in data. */
6871 case BFD_RELOC_LO16
:
6872 case BFD_RELOC_LO16_PCREL
:
6873 case BFD_RELOC_HI16
:
6874 case BFD_RELOC_HI16_PCREL
:
6875 case BFD_RELOC_HI16_S
:
6876 case BFD_RELOC_HI16_S_PCREL
:
6877 case BFD_RELOC_PPC64_HIGHER
:
6878 case BFD_RELOC_PPC64_HIGHER_S
:
6879 case BFD_RELOC_PPC64_HIGHEST
:
6880 case BFD_RELOC_PPC64_HIGHEST_S
:
6881 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6882 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6883 case BFD_RELOC_PPC64_ADDR64_LOCAL
:
6886 case BFD_RELOC_PPC_DTPMOD
:
6887 case BFD_RELOC_PPC_TPREL
:
6888 case BFD_RELOC_PPC_DTPREL
:
6889 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6892 /* Just punt all of these to the linker. */
6893 case BFD_RELOC_PPC_B16_BRTAKEN
:
6894 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6895 case BFD_RELOC_16_GOTOFF
:
6896 case BFD_RELOC_LO16_GOTOFF
:
6897 case BFD_RELOC_HI16_GOTOFF
:
6898 case BFD_RELOC_HI16_S_GOTOFF
:
6899 case BFD_RELOC_LO16_PLTOFF
:
6900 case BFD_RELOC_HI16_PLTOFF
:
6901 case BFD_RELOC_HI16_S_PLTOFF
:
6902 case BFD_RELOC_PPC_COPY
:
6903 case BFD_RELOC_PPC_GLOB_DAT
:
6904 case BFD_RELOC_16_BASEREL
:
6905 case BFD_RELOC_LO16_BASEREL
:
6906 case BFD_RELOC_HI16_BASEREL
:
6907 case BFD_RELOC_HI16_S_BASEREL
:
6908 case BFD_RELOC_PPC_TLS
:
6909 case BFD_RELOC_PPC_DTPREL16_LO
:
6910 case BFD_RELOC_PPC_DTPREL16_HI
:
6911 case BFD_RELOC_PPC_DTPREL16_HA
:
6912 case BFD_RELOC_PPC_TPREL16_LO
:
6913 case BFD_RELOC_PPC_TPREL16_HI
:
6914 case BFD_RELOC_PPC_TPREL16_HA
:
6915 case BFD_RELOC_PPC_GOT_TLSGD16
:
6916 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6917 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6918 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6919 case BFD_RELOC_PPC_GOT_TLSLD16
:
6920 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6921 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6922 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6923 case BFD_RELOC_PPC_GOT_DTPREL16
:
6924 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6925 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6926 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6927 case BFD_RELOC_PPC_GOT_TPREL16
:
6928 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6929 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6930 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6931 case BFD_RELOC_24_PLT_PCREL
:
6932 case BFD_RELOC_PPC_LOCAL24PC
:
6933 case BFD_RELOC_32_PLT_PCREL
:
6934 case BFD_RELOC_GPREL16
:
6935 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6936 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6937 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6938 case BFD_RELOC_PPC_EMB_NADDR32
:
6939 case BFD_RELOC_PPC_EMB_NADDR16
:
6940 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6941 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6942 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6943 case BFD_RELOC_PPC_EMB_SDAI16
:
6944 case BFD_RELOC_PPC_EMB_SDA2REL
:
6945 case BFD_RELOC_PPC_EMB_SDA2I16
:
6946 case BFD_RELOC_PPC_EMB_SDA21
:
6947 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6948 case BFD_RELOC_PPC_EMB_MRKREF
:
6949 case BFD_RELOC_PPC_EMB_RELSEC16
:
6950 case BFD_RELOC_PPC_EMB_RELST_LO
:
6951 case BFD_RELOC_PPC_EMB_RELST_HI
:
6952 case BFD_RELOC_PPC_EMB_RELST_HA
:
6953 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6954 case BFD_RELOC_PPC_EMB_RELSDA
:
6955 case BFD_RELOC_PPC64_TOC
:
6956 case BFD_RELOC_PPC_TOC16
:
6957 case BFD_RELOC_PPC64_TOC16_LO
:
6958 case BFD_RELOC_PPC64_TOC16_HI
:
6959 case BFD_RELOC_PPC64_TOC16_HA
:
6960 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6961 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6962 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6963 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6964 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6965 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6966 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6967 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6968 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6969 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6970 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6971 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6977 case BFD_RELOC_NONE
:
6979 case BFD_RELOC_CTOR
:
6981 case BFD_RELOC_32_PCREL
:
6984 case BFD_RELOC_64_PCREL
:
6986 case BFD_RELOC_16_PCREL
:
6992 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6997 if (fixP
->fx_size
&& APPLY_RELOC
)
6998 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6999 fieldval
, fixP
->fx_size
);
7001 && (seg
->flags
& SEC_CODE
) != 0
7002 && fixP
->fx_size
== 4
7005 && (fixP
->fx_r_type
== BFD_RELOC_32
7006 || fixP
->fx_r_type
== BFD_RELOC_CTOR
7007 || fixP
->fx_r_type
== BFD_RELOC_32_PCREL
))
7008 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
7009 _("data in executable section"));
7012 /* We are only able to convert some relocs to pc-relative. */
7013 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
7015 switch (fixP
->fx_r_type
)
7017 case BFD_RELOC_LO16
:
7018 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
7021 case BFD_RELOC_HI16
:
7022 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
7025 case BFD_RELOC_HI16_S
:
7026 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
7030 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7034 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7038 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7041 /* Some of course are already pc-relative. */
7042 case BFD_RELOC_LO16_PCREL
:
7043 case BFD_RELOC_HI16_PCREL
:
7044 case BFD_RELOC_HI16_S_PCREL
:
7045 case BFD_RELOC_PPC_REL16DX_HA
:
7046 case BFD_RELOC_64_PCREL
:
7047 case BFD_RELOC_32_PCREL
:
7048 case BFD_RELOC_16_PCREL
:
7049 case BFD_RELOC_PPC_B16
:
7050 case BFD_RELOC_PPC_B16_BRTAKEN
:
7051 case BFD_RELOC_PPC_B16_BRNTAKEN
:
7052 case BFD_RELOC_PPC_B26
:
7053 case BFD_RELOC_PPC_LOCAL24PC
:
7054 case BFD_RELOC_24_PLT_PCREL
:
7055 case BFD_RELOC_32_PLT_PCREL
:
7056 case BFD_RELOC_64_PLT_PCREL
:
7057 case BFD_RELOC_PPC_VLE_REL8
:
7058 case BFD_RELOC_PPC_VLE_REL15
:
7059 case BFD_RELOC_PPC_VLE_REL24
:
7068 /* Use expr_symbol_where to see if this is an
7069 expression symbol. */
7070 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
7071 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7072 _("unresolved expression that must"
7075 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7076 _("cannot emit PC relative %s relocation"
7078 bfd_get_reloc_code_name (fixP
->fx_r_type
),
7079 S_GET_NAME (fixP
->fx_addsy
));
7082 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
7083 _("unable to resolve expression"));
7090 ppc_elf_validate_fix (fixP
, seg
);
7091 fixP
->fx_addnumber
= value
;
7093 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
7094 from the section contents. If we are going to be emitting a reloc
7095 then the section contents are immaterial, so don't warn if they
7096 happen to overflow. Leave such warnings to ld. */
7099 fixP
->fx_no_overflow
= 1;
7101 /* Arrange to emit .TOC. as a normal symbol if used in anything
7102 but .TOC.@tocbase. */
7104 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
7105 && fixP
->fx_addsy
!= NULL
7106 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
7107 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
7110 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
7111 fixP
->fx_addnumber
= 0;
7115 fixP
->fx_addnumber
= 0;
7117 /* We want to use the offset within the toc, not the actual VMA
7119 fixP
->fx_addnumber
=
7120 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
7121 - S_GET_VALUE (ppc_toc_csect
);
7122 /* Set *valP to avoid errors. */
7129 /* Generate a reloc for a fixup. */
7132 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
7136 reloc
= XNEW (arelent
);
7138 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
7139 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
7140 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
7141 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
7142 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
7144 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
7145 _("reloc %d not supported by object file format"),
7146 (int) fixp
->fx_r_type
);
7149 reloc
->addend
= fixp
->fx_addnumber
;
7155 ppc_cfi_frame_initial_instructions (void)
7157 cfi_add_CFA_def_cfa (1, 0);
7161 tc_ppc_regname_to_dw2regnum (char *regname
)
7163 unsigned int regnum
= -1;
7167 static struct { const char *name
; int dw2regnum
; } regnames
[] =
7169 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7170 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7171 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7172 { "spe_acc", 111 }, { "spefscr", 112 }
7175 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7176 if (strcmp (regnames
[i
].name
, regname
) == 0)
7177 return regnames
[i
].dw2regnum
;
7179 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7181 p
= regname
+ 1 + (regname
[1] == '.');
7182 regnum
= strtoul (p
, &q
, 10);
7183 if (p
== q
|| *q
|| regnum
>= 32)
7185 if (regname
[0] == 'f')
7187 else if (regname
[0] == 'v')
7190 else if (regname
[0] == 'c' && regname
[1] == 'r')
7192 p
= regname
+ 2 + (regname
[2] == '.');
7193 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7195 regnum
= p
[0] - '0' + 68;