1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
7 This file is part of GAS, the GNU Assembler.
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "safe-ctype.h"
27 #include "dw2gencfi.h"
28 #include "opcode/ppc.h"
32 #include "dwarf2dbg.h"
40 #include "coff/xcoff.h"
44 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
46 /* Tell the main code what the endianness is. */
47 extern int target_big_endian
;
49 /* Whether or not, we've set target_big_endian. */
50 static int set_target_endian
= 0;
52 /* Whether to use user friendly register names. */
53 #ifndef TARGET_REG_NAMES_P
55 #define TARGET_REG_NAMES_P TRUE
57 #define TARGET_REG_NAMES_P FALSE
61 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
64 /* #lo(value) denotes the least significant 16 bits of the indicated. */
65 #define PPC_LO(v) ((v) & 0xffff)
67 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
68 #define PPC_HI(v) (((v) >> 16) & 0xffff)
70 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
71 the indicated value, compensating for #lo() being treated as a
73 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
75 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
76 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
78 /* #highera(value) denotes bits 32 through 47 of the indicated value,
79 compensating for #lo() being treated as a signed number. */
80 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
82 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
83 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
85 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
86 compensating for #lo being treated as a signed number. */
87 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
89 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
91 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
93 static void ppc_macro (char *, const struct powerpc_macro
*);
94 static void ppc_byte (int);
96 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
97 static void ppc_tc (int);
98 static void ppc_machine (int);
102 static void ppc_comm (int);
103 static void ppc_bb (int);
104 static void ppc_bc (int);
105 static void ppc_bf (int);
106 static void ppc_biei (int);
107 static void ppc_bs (int);
108 static void ppc_eb (int);
109 static void ppc_ec (int);
110 static void ppc_ef (int);
111 static void ppc_es (int);
112 static void ppc_csect (int);
113 static void ppc_dwsect (int);
114 static void ppc_change_csect (symbolS
*, offsetT
);
115 static void ppc_function (int);
116 static void ppc_extern (int);
117 static void ppc_lglobl (int);
118 static void ppc_ref (int);
119 static void ppc_section (int);
120 static void ppc_named_section (int);
121 static void ppc_stabx (int);
122 static void ppc_rename (int);
123 static void ppc_toc (int);
124 static void ppc_xcoff_cons (int);
125 static void ppc_vbyte (int);
129 static void ppc_elf_cons (int);
130 static void ppc_elf_rdata (int);
131 static void ppc_elf_lcomm (int);
135 static void ppc_previous (int);
136 static void ppc_pdata (int);
137 static void ppc_ydata (int);
138 static void ppc_reldata (int);
139 static void ppc_rdata (int);
140 static void ppc_ualong (int);
141 static void ppc_znop (int);
142 static void ppc_pe_comm (int);
143 static void ppc_pe_section (int);
144 static void ppc_pe_function (int);
145 static void ppc_pe_tocd (int);
148 /* Generic assembler global variables which must be defined by all
152 /* This string holds the chars that always start a comment. If the
153 pre-processor is disabled, these aren't very useful. The macro
154 tc_comment_chars points to this. We use this, rather than the
155 usual comment_chars, so that we can switch for Solaris conventions. */
156 static const char ppc_solaris_comment_chars
[] = "#!";
157 static const char ppc_eabi_comment_chars
[] = "#";
159 #ifdef TARGET_SOLARIS_COMMENT
160 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
162 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
165 const char comment_chars
[] = "#";
168 /* Characters which start a comment at the beginning of a line. */
169 const char line_comment_chars
[] = "#";
171 /* Characters which may be used to separate multiple commands on a
173 const char line_separator_chars
[] = ";";
175 /* Characters which are used to indicate an exponent in a floating
177 const char EXP_CHARS
[] = "eE";
179 /* Characters which mean that a number is a floating point constant,
181 const char FLT_CHARS
[] = "dD";
183 /* Anything that can start an operand needs to be mentioned here,
184 to stop the input scrubber eating whitespace. */
185 const char ppc_symbol_chars
[] = "%[";
187 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
188 int ppc_cie_data_alignment
;
190 /* More than this number of nops in an alignment op gets a branch
192 unsigned long nop_limit
= 4;
194 /* The type of processor we are assembling for. This is one or more
195 of the PPC_OPCODE flags defined in opcode/ppc.h. */
196 ppc_cpu_t ppc_cpu
= 0;
198 /* Flags set on encountering toc relocs. */
200 has_large_toc_reloc
= 1,
201 has_small_toc_reloc
= 2
204 /* The target specific pseudo-ops which we support. */
206 const pseudo_typeS md_pseudo_table
[] =
208 /* Pseudo-ops which must be overridden. */
209 { "byte", ppc_byte
, 0 },
212 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
213 legitimately belong in the obj-*.c file. However, XCOFF is based
214 on COFF, and is only implemented for the RS/6000. We just use
215 obj-coff.c, and add what we need here. */
216 { "comm", ppc_comm
, 0 },
217 { "lcomm", ppc_comm
, 1 },
221 { "bi", ppc_biei
, 0 },
223 { "csect", ppc_csect
, 0 },
224 { "dwsect", ppc_dwsect
, 0 },
225 { "data", ppc_section
, 'd' },
229 { "ei", ppc_biei
, 1 },
231 { "extern", ppc_extern
, 0 },
232 { "function", ppc_function
, 0 },
233 { "lglobl", ppc_lglobl
, 0 },
234 { "ref", ppc_ref
, 0 },
235 { "rename", ppc_rename
, 0 },
236 { "section", ppc_named_section
, 0 },
237 { "stabx", ppc_stabx
, 0 },
238 { "text", ppc_section
, 't' },
239 { "toc", ppc_toc
, 0 },
240 { "long", ppc_xcoff_cons
, 2 },
241 { "llong", ppc_xcoff_cons
, 3 },
242 { "word", ppc_xcoff_cons
, 1 },
243 { "short", ppc_xcoff_cons
, 1 },
244 { "vbyte", ppc_vbyte
, 0 },
248 { "llong", ppc_elf_cons
, 8 },
249 { "quad", ppc_elf_cons
, 8 },
250 { "long", ppc_elf_cons
, 4 },
251 { "word", ppc_elf_cons
, 2 },
252 { "short", ppc_elf_cons
, 2 },
253 { "rdata", ppc_elf_rdata
, 0 },
254 { "rodata", ppc_elf_rdata
, 0 },
255 { "lcomm", ppc_elf_lcomm
, 0 },
259 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
260 { "previous", ppc_previous
, 0 },
261 { "pdata", ppc_pdata
, 0 },
262 { "ydata", ppc_ydata
, 0 },
263 { "reldata", ppc_reldata
, 0 },
264 { "rdata", ppc_rdata
, 0 },
265 { "ualong", ppc_ualong
, 0 },
266 { "znop", ppc_znop
, 0 },
267 { "comm", ppc_pe_comm
, 0 },
268 { "lcomm", ppc_pe_comm
, 1 },
269 { "section", ppc_pe_section
, 0 },
270 { "function", ppc_pe_function
,0 },
271 { "tocd", ppc_pe_tocd
, 0 },
274 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
276 { "machine", ppc_machine
, 0 },
283 /* Predefined register names if -mregnames (or default for Windows NT).
284 In general, there are lots of them, in an attempt to be compatible
285 with a number of other Windows NT assemblers. */
287 /* Structure to hold information about predefined registers. */
294 /* List of registers that are pre-defined:
296 Each general register has predefined names of the form:
297 1. r<reg_num> which has the value <reg_num>.
298 2. r.<reg_num> which has the value <reg_num>.
300 Each floating point register has predefined names of the form:
301 1. f<reg_num> which has the value <reg_num>.
302 2. f.<reg_num> which has the value <reg_num>.
304 Each vector unit register has predefined names of the form:
305 1. v<reg_num> which has the value <reg_num>.
306 2. v.<reg_num> which has the value <reg_num>.
308 Each condition register has predefined names of the form:
309 1. cr<reg_num> which has the value <reg_num>.
310 2. cr.<reg_num> which has the value <reg_num>.
312 There are individual registers as well:
313 sp or r.sp has the value 1
314 rtoc or r.toc has the value 2
315 fpscr has the value 0
321 dsisr has the value 18
323 sdr1 has the value 25
324 srr0 has the value 26
325 srr1 has the value 27
327 The table is sorted. Suitable for searching by a binary search. */
329 static const struct pd_reg pre_defined_registers
[] =
331 { "cr.0", 0 }, /* Condition Registers */
351 { "dar", 19 }, /* Data Access Register */
352 { "dec", 22 }, /* Decrementer */
353 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
355 { "f.0", 0 }, /* Floating point registers */
382 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
448 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
489 /* Quantization registers used with pair single instructions. */
507 { "lr", 8 }, /* Link Register */
511 { "r.0", 0 }, /* General Purpose Registers */
544 { "r.sp", 1 }, /* Stack Pointer */
546 { "r.toc", 2 }, /* Pointer to the table of contents */
548 { "r0", 0 }, /* More general purpose registers */
581 { "rtoc", 2 }, /* Table of contents */
583 { "sdr1", 25 }, /* Storage Description Register 1 */
587 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
588 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
590 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
656 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
790 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
792 /* Given NAME, find the register number associated with that name, return
793 the integer value associated with the given name or -1 on failure. */
796 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
798 int middle
, low
, high
;
806 middle
= (low
+ high
) / 2;
807 cmp
= strcasecmp (name
, regs
[middle
].name
);
813 return regs
[middle
].value
;
821 * Summary of register_name.
823 * in: Input_line_pointer points to 1st char of operand.
825 * out: A expressionS.
826 * The operand may have been a register: in this case, X_op == O_register,
827 * X_add_number is set to the register number, and truth is returned.
828 * Input_line_pointer->(next non-blank) char after operand, or is in its
833 register_name (expressionS
*expressionP
)
840 /* Find the spelling of the operand. */
841 start
= name
= input_line_pointer
;
842 if (name
[0] == '%' && ISALPHA (name
[1]))
843 name
= ++input_line_pointer
;
845 else if (!reg_names_p
|| !ISALPHA (name
[0]))
848 c
= get_symbol_end ();
849 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
851 /* Put back the delimiting char. */
852 *input_line_pointer
= c
;
854 /* Look to see if it's in the register table. */
857 expressionP
->X_op
= O_register
;
858 expressionP
->X_add_number
= reg_number
;
860 /* Make the rest nice. */
861 expressionP
->X_add_symbol
= NULL
;
862 expressionP
->X_op_symbol
= NULL
;
866 /* Reset the line as if we had not done anything. */
867 input_line_pointer
= start
;
871 /* This function is called for each symbol seen in an expression. It
872 handles the special parsing which PowerPC assemblers are supposed
873 to use for condition codes. */
875 /* Whether to do the special parsing. */
876 static bfd_boolean cr_operand
;
878 /* Names to recognize in a condition code. This table is sorted. */
879 static const struct pd_reg cr_names
[] =
896 /* Parsing function. This returns non-zero if it recognized an
900 ppc_parse_name (const char *name
, expressionS
*exp
)
909 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
914 exp
->X_op
= O_constant
;
915 exp
->X_add_number
= val
;
920 /* Local variables. */
922 /* Whether to target xcoff64/elf64. */
923 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
925 /* Opcode hash table. */
926 static struct hash_control
*ppc_hash
;
928 /* Macro hash table. */
929 static struct hash_control
*ppc_macro_hash
;
932 /* What type of shared library support to use. */
933 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
935 /* Flags to set in the elf header. */
936 static flagword ppc_flags
= 0;
938 /* Whether this is Solaris or not. */
939 #ifdef TARGET_SOLARIS_COMMENT
940 #define SOLARIS_P TRUE
942 #define SOLARIS_P FALSE
945 static bfd_boolean msolaris
= SOLARIS_P
;
950 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
951 using a bunch of different sections. These assembler sections,
952 however, are all encompassed within the .text or .data sections of
953 the final output file. We handle this by using different
954 subsegments within these main segments. */
956 /* Next subsegment to allocate within the .text segment. */
957 static subsegT ppc_text_subsegment
= 2;
959 /* Linked list of csects in the text section. */
960 static symbolS
*ppc_text_csects
;
962 /* Next subsegment to allocate within the .data segment. */
963 static subsegT ppc_data_subsegment
= 2;
965 /* Linked list of csects in the data section. */
966 static symbolS
*ppc_data_csects
;
968 /* The current csect. */
969 static symbolS
*ppc_current_csect
;
971 /* The RS/6000 assembler uses a TOC which holds addresses of functions
972 and variables. Symbols are put in the TOC with the .tc pseudo-op.
973 A special relocation is used when accessing TOC entries. We handle
974 the TOC as a subsegment within the .data segment. We set it up if
975 we see a .toc pseudo-op, and save the csect symbol here. */
976 static symbolS
*ppc_toc_csect
;
978 /* The first frag in the TOC subsegment. */
979 static fragS
*ppc_toc_frag
;
981 /* The first frag in the first subsegment after the TOC in the .data
982 segment. NULL if there are no subsegments after the TOC. */
983 static fragS
*ppc_after_toc_frag
;
985 /* The current static block. */
986 static symbolS
*ppc_current_block
;
988 /* The COFF debugging section; set by md_begin. This is not the
989 .debug section, but is instead the secret BFD section which will
990 cause BFD to set the section number of a symbol to N_DEBUG. */
991 static asection
*ppc_coff_debug_section
;
993 /* Structure to set the length field of the dwarf sections. */
994 struct dw_subsection
{
995 /* Subsections are simply linked. */
996 struct dw_subsection
*link
;
998 /* The subsection number. */
1001 /* Expression to compute the length of the section. */
1002 expressionS end_exp
;
1005 static struct dw_section
{
1006 /* Corresponding section. */
1009 /* Simply linked list of subsections with a label. */
1010 struct dw_subsection
*list_subseg
;
1012 /* The anonymous subsection. */
1013 struct dw_subsection
*anon_subseg
;
1014 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1015 #endif /* OBJ_XCOFF */
1019 /* Various sections that we need for PE coff support. */
1020 static segT ydata_section
;
1021 static segT pdata_section
;
1022 static segT reldata_section
;
1023 static segT rdata_section
;
1024 static segT tocdata_section
;
1026 /* The current section and the previous section. See ppc_previous. */
1027 static segT ppc_previous_section
;
1028 static segT ppc_current_section
;
1033 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1034 #define PPC_APUINFO_ISEL 0x40
1035 #define PPC_APUINFO_PMR 0x41
1036 #define PPC_APUINFO_RFMCI 0x42
1037 #define PPC_APUINFO_CACHELCK 0x43
1038 #define PPC_APUINFO_SPE 0x100
1039 #define PPC_APUINFO_EFS 0x101
1040 #define PPC_APUINFO_BRLOCK 0x102
1043 * We keep a list of APUinfo
1045 unsigned long *ppc_apuinfo_list
;
1046 unsigned int ppc_apuinfo_num
;
1047 unsigned int ppc_apuinfo_num_alloc
;
1048 #endif /* OBJ_ELF */
1051 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1053 const char *const md_shortopts
= "um:";
1055 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1056 const struct option md_longopts
[] = {
1057 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1058 {NULL
, no_argument
, NULL
, 0}
1060 const size_t md_longopts_size
= sizeof (md_longopts
);
1063 md_parse_option (int c
, char *arg
)
1070 /* -u means that any undefined symbols should be treated as
1071 external, which is the default for gas anyhow. */
1076 /* Solaris as takes -le (presumably for little endian). For completeness
1077 sake, recognize -be also. */
1078 if (strcmp (arg
, "e") == 0)
1080 target_big_endian
= 0;
1081 set_target_endian
= 1;
1089 if (strcmp (arg
, "e") == 0)
1091 target_big_endian
= 1;
1092 set_target_endian
= 1;
1100 /* Recognize -K PIC. */
1101 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1104 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1112 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1114 if (strcmp (arg
, "64") == 0)
1119 as_fatal (_("%s unsupported"), "-a64");
1122 else if (strcmp (arg
, "32") == 0)
1129 if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, arg
)) != 0)
1132 else if (strcmp (arg
, "regnames") == 0)
1135 else if (strcmp (arg
, "no-regnames") == 0)
1136 reg_names_p
= FALSE
;
1139 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1140 that require relocation. */
1141 else if (strcmp (arg
, "relocatable") == 0)
1143 shlib
= SHLIB_MRELOCATABLE
;
1144 ppc_flags
|= EF_PPC_RELOCATABLE
;
1147 else if (strcmp (arg
, "relocatable-lib") == 0)
1149 shlib
= SHLIB_MRELOCATABLE
;
1150 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1153 /* -memb, set embedded bit. */
1154 else if (strcmp (arg
, "emb") == 0)
1155 ppc_flags
|= EF_PPC_EMB
;
1157 /* -mlittle/-mbig set the endianness. */
1158 else if (strcmp (arg
, "little") == 0
1159 || strcmp (arg
, "little-endian") == 0)
1161 target_big_endian
= 0;
1162 set_target_endian
= 1;
1165 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1167 target_big_endian
= 1;
1168 set_target_endian
= 1;
1171 else if (strcmp (arg
, "solaris") == 0)
1174 ppc_comment_chars
= ppc_solaris_comment_chars
;
1177 else if (strcmp (arg
, "no-solaris") == 0)
1180 ppc_comment_chars
= ppc_eabi_comment_chars
;
1185 as_bad (_("invalid switch -m%s"), arg
);
1191 /* -V: SVR4 argument to print version ID. */
1193 print_version_id ();
1196 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1197 should be emitted or not. FIXME: Not implemented. */
1201 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1202 rather than .stabs.excl, which is ignored by the linker.
1203 FIXME: Not implemented. */
1214 nop_limit
= strtoul (optarg
, &end
, 0);
1216 as_bad (_("--nops needs a numeric argument"));
1228 md_show_usage (FILE *stream
)
1230 fprintf (stream
, _("\
1232 -a32 generate ELF32/XCOFF32\n\
1233 -a64 generate ELF64/XCOFF64\n\
1235 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1236 -mpwr generate code for POWER (RIOS1)\n\
1237 -m601 generate code for PowerPC 601\n\
1238 -mppc, -mppc32, -m603, -m604\n\
1239 generate code for PowerPC 603/604\n\
1240 -m403 generate code for PowerPC 403\n\
1241 -m405 generate code for PowerPC 405\n\
1242 -m440 generate code for PowerPC 440\n\
1243 -m464 generate code for PowerPC 464\n\
1244 -m476 generate code for PowerPC 476\n\
1245 -m7400, -m7410, -m7450, -m7455\n\
1246 generate code for PowerPC 7400/7410/7450/7455\n\
1247 -m750cl generate code for PowerPC 750cl\n"));
1248 fprintf (stream
, _("\
1249 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1250 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1251 -mbooke generate code for 32-bit PowerPC BookE\n\
1252 -ma2 generate code for A2 architecture\n\
1253 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1254 -mpower5, -mpwr5, -mpwr5x\n\
1255 generate code for Power5 architecture\n\
1256 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1257 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1258 -mcell generate code for Cell Broadband Engine architecture\n\
1259 -mcom generate code Power/PowerPC common instructions\n\
1260 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1261 fprintf (stream
, _("\
1262 -maltivec generate code for AltiVec\n\
1263 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1264 -me300 generate code for PowerPC e300 family\n\
1265 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1266 -me500mc, generate code for Freescale e500mc core complex\n\
1267 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1268 -me5500, generate code for Freescale e5500 core complex\n\
1269 -me6500, generate code for Freescale e6500 core complex\n\
1270 -mspe generate code for Motorola SPE instructions\n\
1271 -mtitan generate code for AppliedMicro Titan core complex\n\
1272 -mregnames Allow symbolic names for registers\n\
1273 -mno-regnames Do not allow symbolic names for registers\n"));
1275 fprintf (stream
, _("\
1276 -mrelocatable support for GCC's -mrelocatble option\n\
1277 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1278 -memb set PPC_EMB bit in ELF flags\n\
1279 -mlittle, -mlittle-endian, -le\n\
1280 generate code for a little endian machine\n\
1281 -mbig, -mbig-endian, -be\n\
1282 generate code for a big endian machine\n\
1283 -msolaris generate code for Solaris\n\
1284 -mno-solaris do not generate code for Solaris\n\
1285 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1286 -V print assembler version number\n\
1287 -Qy, -Qn ignored\n"));
1289 fprintf (stream
, _("\
1290 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1293 /* Set ppc_cpu if it is not already set. */
1298 const char *default_os
= TARGET_OS
;
1299 const char *default_cpu
= TARGET_CPU
;
1301 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1304 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1305 else if (strncmp (default_os
, "aix", 3) == 0
1306 && default_os
[3] >= '4' && default_os
[3] <= '9')
1307 ppc_cpu
|= PPC_OPCODE_COMMON
;
1308 else if (strncmp (default_os
, "aix3", 4) == 0)
1309 ppc_cpu
|= PPC_OPCODE_POWER
;
1310 else if (strcmp (default_cpu
, "rs6000") == 0)
1311 ppc_cpu
|= PPC_OPCODE_POWER
;
1312 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1313 ppc_cpu
|= PPC_OPCODE_PPC
;
1315 as_fatal (_("Unknown default cpu = %s, os = %s"),
1316 default_cpu
, default_os
);
1320 /* Figure out the BFD architecture to use. This function and ppc_mach
1321 are called well before md_begin, when the output file is opened. */
1323 enum bfd_architecture
1326 const char *default_cpu
= TARGET_CPU
;
1329 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1330 return bfd_arch_powerpc
;
1331 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1332 return bfd_arch_rs6000
;
1333 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1335 if (strcmp (default_cpu
, "rs6000") == 0)
1336 return bfd_arch_rs6000
;
1337 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1338 return bfd_arch_powerpc
;
1341 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1342 return bfd_arch_unknown
;
1349 return bfd_mach_ppc64
;
1350 else if (ppc_arch () == bfd_arch_rs6000
)
1351 return bfd_mach_rs6k
;
1352 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1353 return bfd_mach_ppc_titan
;
1355 return bfd_mach_ppc
;
1359 ppc_target_format (void)
1363 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1365 return "xcoff-powermac";
1368 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1370 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1376 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1377 # elif defined (TE_VXWORKS)
1378 return "elf32-powerpc-vxworks";
1380 return (target_big_endian
1381 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1382 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1387 /* Insert opcodes and macros into hash tables. Called at startup and
1391 ppc_setup_opcodes (void)
1393 const struct powerpc_opcode
*op
;
1394 const struct powerpc_opcode
*op_end
;
1395 const struct powerpc_macro
*macro
;
1396 const struct powerpc_macro
*macro_end
;
1397 bfd_boolean bad_insn
= FALSE
;
1399 if (ppc_hash
!= NULL
)
1400 hash_die (ppc_hash
);
1401 if (ppc_macro_hash
!= NULL
)
1402 hash_die (ppc_macro_hash
);
1404 /* Insert the opcodes into a hash table. */
1405 ppc_hash
= hash_new ();
1407 if (ENABLE_CHECKING
)
1411 /* Check operand masks. Code here and in the disassembler assumes
1412 all the 1's in the mask are contiguous. */
1413 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1415 unsigned long mask
= powerpc_operands
[i
].bitm
;
1416 unsigned long right_bit
;
1419 right_bit
= mask
& -mask
;
1421 right_bit
= mask
& -mask
;
1422 if (mask
!= right_bit
)
1424 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1427 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1428 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1429 sizeof (powerpc_operands
[0])) == 0)
1431 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1438 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1439 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1441 if (ENABLE_CHECKING
)
1443 const unsigned char *o
;
1444 unsigned long omask
= op
->mask
;
1446 if (op
!= powerpc_opcodes
)
1448 /* The major opcodes had better be sorted. Code in the
1449 disassembler assumes the insns are sorted according to
1451 if (PPC_OP (op
[0].opcode
) < PPC_OP (op
[-1].opcode
))
1453 as_bad (_("major opcode is not sorted for %s"),
1458 /* Warn if the table isn't more strictly ordered.
1459 Unfortunately it doesn't seem possible to order the
1460 table on much more than the major opcode, which makes
1461 it difficult to implement a binary search in the
1462 disassembler. The problem is that we have multiple
1463 ways to disassemble instructions, and we usually want
1464 to choose a more specific form (with more bits set in
1465 the opcode) than a more general form. eg. all of the
1466 following are equivalent:
1467 bne label # opcode = 0x40820000, mask = 0xff830003
1468 bf 2,label # opcode = 0x40800000, mask = 0xff800003
1469 bc 4,2,label # opcode = 0x40000000, mask = 0xfc000003
1471 There are also cases where the table needs to be out
1472 of order to disassemble the correct instruction for
1473 processor variants. */
1476 unsigned long t1
= op
[0].opcode
;
1477 unsigned long t2
= op
[-1].opcode
;
1479 if (((t1
^ t2
) & 0xfc0007ff) == 0
1480 && (t1
& 0xfc0006df) == 0x7c000286)
1482 /* spr field is split. */
1483 t1
= ((t1
& ~0x1ff800)
1484 | ((t1
& 0xf800) << 5) | ((t1
& 0x1f0000) >> 5));
1485 t2
= ((t2
& ~0x1ff800)
1486 | ((t2
& 0xf800) << 5) | ((t2
& 0x1f0000) >> 5));
1489 as_warn (_("%s (%08lx %08lx) after %s (%08lx %08lx)"),
1490 op
[0].name
, op
[0].opcode
, op
[0].mask
,
1491 op
[-1].name
, op
[-1].opcode
, op
[-1].mask
);
1495 /* The mask had better not trim off opcode bits. */
1496 if ((op
->opcode
& omask
) != op
->opcode
)
1498 as_bad (_("mask trims opcode bits for %s"),
1503 /* The operands must not overlap the opcode or each other. */
1504 for (o
= op
->operands
; *o
; ++o
)
1505 if (*o
>= num_powerpc_operands
)
1507 as_bad (_("operand index error for %s"),
1513 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1514 if (operand
->shift
>= 0)
1516 unsigned long mask
= operand
->bitm
<< operand
->shift
;
1519 as_bad (_("operand %d overlap in %s"),
1520 (int) (o
- op
->operands
), op
->name
);
1528 if ((ppc_cpu
& op
->flags
) != 0
1529 && !(ppc_cpu
& op
->deprecated
))
1533 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1536 as_bad (_("duplicate instruction %s"),
1543 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1544 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1545 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1547 /* Insert the macros into a hash table. */
1548 ppc_macro_hash
= hash_new ();
1550 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1551 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1553 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1557 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1558 if (retval
!= (const char *) NULL
)
1560 as_bad (_("duplicate macro %s"), macro
->name
);
1570 /* This function is called when the assembler starts up. It is called
1571 after the options have been parsed and the output file has been
1579 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1582 /* Set the ELF flags if desired. */
1583 if (ppc_flags
&& !msolaris
)
1584 bfd_set_private_flags (stdoutput
, ppc_flags
);
1587 ppc_setup_opcodes ();
1589 /* Tell the main code what the endianness is if it is not overridden
1591 if (!set_target_endian
)
1593 set_target_endian
= 1;
1594 target_big_endian
= PPC_BIG_ENDIAN
;
1598 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1600 /* Create dummy symbols to serve as initial csects. This forces the
1601 text csects to precede the data csects. These symbols will not
1603 ppc_text_csects
= symbol_make ("dummy\001");
1604 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1605 ppc_data_csects
= symbol_make ("dummy\001");
1606 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1611 ppc_current_section
= text_section
;
1612 ppc_previous_section
= 0;
1621 if (ppc_apuinfo_list
== NULL
)
1624 /* Ok, so write the section info out. We have this layout:
1628 0 8 length of "APUinfo\0"
1629 4 (n*4) number of APU's (4 bytes each)
1632 20 APU#1 first APU's info
1633 24 APU#2 second APU's info
1638 asection
*seg
= now_seg
;
1639 subsegT subseg
= now_subseg
;
1640 asection
*apuinfo_secp
= (asection
*) NULL
;
1643 /* Create the .PPC.EMB.apuinfo section. */
1644 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1645 bfd_set_section_flags (stdoutput
,
1647 SEC_HAS_CONTENTS
| SEC_READONLY
);
1650 md_number_to_chars (p
, (valueT
) 8, 4);
1653 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1656 md_number_to_chars (p
, (valueT
) 2, 4);
1659 strcpy (p
, "APUinfo");
1661 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1664 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1667 frag_align (2, 0, 0);
1669 /* We probably can't restore the current segment, for there likely
1672 subseg_set (seg
, subseg
);
1677 /* Insert an operand value into an instruction. */
1679 static unsigned long
1680 ppc_insert_operand (unsigned long insn
,
1681 const struct powerpc_operand
*operand
,
1687 long min
, max
, right
;
1689 max
= operand
->bitm
;
1693 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1695 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1696 max
= (max
>> 1) & -right
;
1697 min
= ~max
& -right
;
1700 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1703 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1712 /* Some people write constants with the sign extension done by
1713 hand but only up to 32 bits. This shouldn't really be valid,
1714 but, to permit this code to assemble on a 64-bit host, we
1715 sign extend the 32-bit value to 64 bits if so doing makes the
1718 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1719 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1720 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1721 val
= val
- 0x80000000 - 0x80000000;
1723 /* Similarly, people write expressions like ~(1<<15), and expect
1724 this to be OK for a 32-bit unsigned value. */
1726 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1727 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1728 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1729 val
= val
+ 0x80000000 + 0x80000000;
1733 || (val
& (right
- 1)) != 0)
1734 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1737 if (operand
->insert
)
1742 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1743 if (errmsg
!= (const char *) NULL
)
1744 as_bad_where (file
, line
, "%s", errmsg
);
1747 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1754 /* Parse @got, etc. and return the desired relocation. */
1755 static bfd_reloc_code_real_type
1756 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1760 unsigned int length
: 8;
1761 unsigned int valid32
: 1;
1762 unsigned int valid64
: 1;
1771 const struct map_bfd
*ptr
;
1773 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1774 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1775 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1777 static const struct map_bfd mapping
[] = {
1778 MAP ("l", BFD_RELOC_LO16
),
1779 MAP ("h", BFD_RELOC_HI16
),
1780 MAP ("ha", BFD_RELOC_HI16_S
),
1781 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1782 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1783 MAP ("got", BFD_RELOC_16_GOTOFF
),
1784 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1785 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1786 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1787 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1788 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1789 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1790 MAP ("copy", BFD_RELOC_PPC_COPY
),
1791 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1792 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1793 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1794 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1795 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1796 MAP ("tls", BFD_RELOC_PPC_TLS
),
1797 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1798 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1799 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1800 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1801 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1802 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1803 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1804 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1805 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1806 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1807 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1808 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1809 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1810 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1811 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1812 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1813 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1814 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1815 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1816 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1817 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1818 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1819 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1820 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1821 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1822 MAP32 ("fixup", BFD_RELOC_CTOR
),
1823 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1824 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1825 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1826 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1827 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1828 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1829 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1830 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1831 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1832 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1833 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1834 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1835 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1836 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1837 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1838 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1839 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1840 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1841 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1842 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1843 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1844 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1845 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1846 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1847 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1848 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1849 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1850 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1851 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1852 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1853 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1854 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1855 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1856 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1857 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1858 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1859 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1860 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1861 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1862 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1863 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1867 return BFD_RELOC_UNUSED
;
1869 for (ch
= *str
, str2
= ident
;
1870 (str2
< ident
+ sizeof (ident
) - 1
1871 && (ISALNUM (ch
) || ch
== '@'));
1874 *str2
++ = TOLOWER (ch
);
1881 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1882 if (ch
== ptr
->string
[0]
1883 && len
== ptr
->length
1884 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1885 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1887 int reloc
= ptr
->reloc
;
1889 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1893 case BFD_RELOC_16_GOTOFF
:
1894 case BFD_RELOC_LO16_GOTOFF
:
1895 case BFD_RELOC_HI16_GOTOFF
:
1896 case BFD_RELOC_HI16_S_GOTOFF
:
1897 as_warn (_("identifier+constant@got means "
1898 "identifier@got+constant"));
1901 case BFD_RELOC_PPC_GOT_TLSGD16
:
1902 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
1903 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
1904 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
1905 case BFD_RELOC_PPC_GOT_TLSLD16
:
1906 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
1907 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
1908 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
1909 case BFD_RELOC_PPC_GOT_DTPREL16
:
1910 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
1911 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
1912 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
1913 case BFD_RELOC_PPC_GOT_TPREL16
:
1914 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
1915 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
1916 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
1917 as_bad (_("symbol+offset not supported for got tls"));
1922 /* Now check for identifier@suffix+constant. */
1923 if (*str
== '-' || *str
== '+')
1925 char *orig_line
= input_line_pointer
;
1926 expressionS new_exp
;
1928 input_line_pointer
= str
;
1929 expression (&new_exp
);
1930 if (new_exp
.X_op
== O_constant
)
1932 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1933 str
= input_line_pointer
;
1936 if (&input_line_pointer
!= str_p
)
1937 input_line_pointer
= orig_line
;
1941 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1942 && exp_p
->X_op
== O_symbol
1943 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
1945 /* Change the symbol so that the dummy .TOC. symbol can be
1946 omitted from the object file. */
1947 exp_p
->X_add_symbol
= &abs_symbol
;
1950 return (bfd_reloc_code_real_type
) reloc
;
1953 return BFD_RELOC_UNUSED
;
1956 /* Like normal .long/.short/.word, except support @got, etc.
1957 Clobbers input_line_pointer, checks end-of-line. */
1959 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
1962 bfd_reloc_code_real_type reloc
;
1964 if (is_it_end_of_statement ())
1966 demand_empty_rest_of_line ();
1973 if (exp
.X_op
== O_symbol
1974 && *input_line_pointer
== '@'
1975 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1976 &exp
)) != BFD_RELOC_UNUSED
)
1978 reloc_howto_type
*reloc_howto
;
1981 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1982 size
= bfd_get_reloc_size (reloc_howto
);
1986 as_bad (_("%s relocations do not fit in %d bytes\n"),
1987 reloc_howto
->name
, nbytes
);
1994 p
= frag_more (nbytes
);
1995 memset (p
, 0, nbytes
);
1997 if (target_big_endian
)
1998 offset
= nbytes
- size
;
1999 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2004 emit_expr (&exp
, (unsigned int) nbytes
);
2006 while (*input_line_pointer
++ == ',');
2008 /* Put terminator back into stream. */
2009 input_line_pointer
--;
2010 demand_empty_rest_of_line ();
2013 /* Solaris pseduo op to change to the .rodata section. */
2015 ppc_elf_rdata (int xxx
)
2017 char *save_line
= input_line_pointer
;
2018 static char section
[] = ".rodata\n";
2020 /* Just pretend this is .section .rodata */
2021 input_line_pointer
= section
;
2022 obj_elf_section (xxx
);
2024 input_line_pointer
= save_line
;
2027 /* Pseudo op to make file scope bss items. */
2029 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2042 name
= input_line_pointer
;
2043 c
= get_symbol_end ();
2045 /* just after name is now '\0'. */
2046 p
= input_line_pointer
;
2049 if (*input_line_pointer
!= ',')
2051 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
2052 ignore_rest_of_line ();
2056 input_line_pointer
++; /* skip ',' */
2057 if ((size
= get_absolute_expression ()) < 0)
2059 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2060 ignore_rest_of_line ();
2064 /* The third argument to .lcomm is the alignment. */
2065 if (*input_line_pointer
!= ',')
2069 ++input_line_pointer
;
2070 align
= get_absolute_expression ();
2073 as_warn (_("ignoring bad alignment"));
2079 symbolP
= symbol_find_or_make (name
);
2082 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2084 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2085 S_GET_NAME (symbolP
));
2086 ignore_rest_of_line ();
2090 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2092 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2093 S_GET_NAME (symbolP
),
2094 (long) S_GET_VALUE (symbolP
),
2097 ignore_rest_of_line ();
2103 old_subsec
= now_subseg
;
2106 /* Convert to a power of 2 alignment. */
2107 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2110 as_bad (_("Common alignment not a power of 2"));
2111 ignore_rest_of_line ();
2118 record_alignment (bss_section
, align2
);
2119 subseg_set (bss_section
, 0);
2121 frag_align (align2
, 0, 0);
2122 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2123 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2124 symbol_set_frag (symbolP
, frag_now
);
2125 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2128 S_SET_SIZE (symbolP
, size
);
2129 S_SET_SEGMENT (symbolP
, bss_section
);
2130 subseg_set (old_sec
, old_subsec
);
2131 demand_empty_rest_of_line ();
2134 /* Validate any relocations emitted for -mrelocatable, possibly adding
2135 fixups for word relocations in writable segments, so we can adjust
2138 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2140 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2149 case SHLIB_MRELOCATABLE
:
2150 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2151 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2152 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2153 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2154 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2155 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2156 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2157 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2158 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2159 && (seg
->flags
& SEC_LOAD
) != 0
2160 && strcmp (segment_name (seg
), ".got2") != 0
2161 && strcmp (segment_name (seg
), ".dtors") != 0
2162 && strcmp (segment_name (seg
), ".ctors") != 0
2163 && strcmp (segment_name (seg
), ".fixup") != 0
2164 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2165 && strcmp (segment_name (seg
), ".eh_frame") != 0
2166 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2168 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2169 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2171 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2172 _("Relocation cannot be done when using -mrelocatable"));
2179 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2180 function descriptor sym if the corresponding code sym is used. */
2183 ppc_frob_file_before_adjust (void)
2191 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2198 name
= S_GET_NAME (symp
);
2202 if (! S_IS_WEAK (symp
)
2203 || S_IS_DEFINED (symp
))
2206 len
= strlen (name
) + 1;
2207 dotname
= xmalloc (len
+ 1);
2209 memcpy (dotname
+ 1, name
, len
);
2210 dotsym
= symbol_find_noref (dotname
, 1);
2212 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2213 || symbol_used_in_reloc_p (dotsym
)))
2214 symbol_mark_used (symp
);
2218 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2220 && toc_reloc_types
!= has_large_toc_reloc
2221 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2222 as_warn (_("TOC section size exceeds 64k"));
2224 /* Don't emit .TOC. symbol. */
2225 symp
= symbol_find (".TOC.");
2227 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2229 #endif /* OBJ_ELF */
2234 * Summary of parse_toc_entry.
2236 * in: Input_line_pointer points to the '[' in one of:
2238 * [toc] [tocv] [toc32] [toc64]
2240 * Anything else is an error of one kind or another.
2243 * return value: success or failure
2244 * toc_kind: kind of toc reference
2245 * input_line_pointer:
2246 * success: first char after the ']'
2247 * failure: unchanged
2251 * [toc] - rv == success, toc_kind = default_toc
2252 * [tocv] - rv == success, toc_kind = data_in_toc
2253 * [toc32] - rv == success, toc_kind = must_be_32
2254 * [toc64] - rv == success, toc_kind = must_be_64
2258 enum toc_size_qualifier
2260 default_toc
, /* The toc cell constructed should be the system default size */
2261 data_in_toc
, /* This is a direct reference to a toc cell */
2262 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2263 must_be_64
/* The toc cell constructed must be 64 bits wide */
2267 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2272 enum toc_size_qualifier t
;
2274 /* Save the input_line_pointer. */
2275 start
= input_line_pointer
;
2277 /* Skip over the '[' , and whitespace. */
2278 ++input_line_pointer
;
2281 /* Find the spelling of the operand. */
2282 toc_spec
= input_line_pointer
;
2283 c
= get_symbol_end ();
2285 if (strcmp (toc_spec
, "toc") == 0)
2289 else if (strcmp (toc_spec
, "tocv") == 0)
2293 else if (strcmp (toc_spec
, "toc32") == 0)
2297 else if (strcmp (toc_spec
, "toc64") == 0)
2303 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2304 *input_line_pointer
= c
;
2305 input_line_pointer
= start
;
2309 /* Now find the ']'. */
2310 *input_line_pointer
= c
;
2312 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2313 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2317 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2318 input_line_pointer
= start
;
2329 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2331 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2335 /* Check we don't already exist. */
2336 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2337 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2340 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2342 if (ppc_apuinfo_num_alloc
== 0)
2344 ppc_apuinfo_num_alloc
= 4;
2345 ppc_apuinfo_list
= (unsigned long *)
2346 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2350 ppc_apuinfo_num_alloc
+= 4;
2351 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2352 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2355 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2361 /* We need to keep a list of fixups. We can't simply generate them as
2362 we go, because that would require us to first create the frag, and
2363 that would screw up references to ``.''. */
2369 bfd_reloc_code_real_type reloc
;
2372 #define MAX_INSN_FIXUPS (5)
2374 /* This routine is called for each instruction to be assembled. */
2377 md_assemble (char *str
)
2380 const struct powerpc_opcode
*opcode
;
2382 const unsigned char *opindex_ptr
;
2386 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2392 bfd_reloc_code_real_type reloc
;
2395 /* Get the opcode. */
2396 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2401 /* Look up the opcode in the hash table. */
2402 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2403 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2405 const struct powerpc_macro
*macro
;
2407 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2408 if (macro
== (const struct powerpc_macro
*) NULL
)
2409 as_bad (_("Unrecognized opcode: `%s'"), str
);
2411 ppc_macro (s
, macro
);
2416 insn
= opcode
->opcode
;
2419 while (ISSPACE (*str
))
2422 /* PowerPC operands are just expressions. The only real issue is
2423 that a few operand types are optional. All cases which might use
2424 an optional operand separate the operands only with commas (in some
2425 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2426 have optional operands). Most instructions with optional operands
2427 have only one. Those that have more than one optional operand can
2428 take either all their operands or none. So, before we start seriously
2429 parsing the operands, we check to see if we have optional operands,
2430 and if we do, we count the number of commas to see which operands
2431 have been omitted. */
2433 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2435 const struct powerpc_operand
*operand
;
2437 operand
= &powerpc_operands
[*opindex_ptr
];
2438 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2440 unsigned int opcount
;
2441 unsigned int num_operands_expected
;
2443 /* There is an optional operand. Count the number of
2444 commas in the input line. */
2451 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2458 /* Compute the number of expected operands.
2459 Do not count fake operands. */
2460 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2461 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2462 ++ num_operands_expected
;
2464 /* If there are fewer operands in the line then are called
2465 for by the instruction, we want to skip the optional
2467 if (opcount
< num_operands_expected
)
2474 /* Gather the operands. */
2478 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2480 const struct powerpc_operand
*operand
;
2486 if (next_opindex
== 0)
2487 operand
= &powerpc_operands
[*opindex_ptr
];
2490 operand
= &powerpc_operands
[next_opindex
];
2495 /* If this is a fake operand, then we do not expect anything
2497 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2499 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2500 if (errmsg
!= (const char *) NULL
)
2501 as_bad ("%s", errmsg
);
2505 /* If this is an optional operand, and we are skipping it, just
2507 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2510 if (operand
->insert
)
2512 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2513 if (errmsg
!= (const char *) NULL
)
2514 as_bad ("%s", errmsg
);
2516 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2517 next_opindex
= *opindex_ptr
+ 1;
2521 /* Gather the operand. */
2522 hold
= input_line_pointer
;
2523 input_line_pointer
= str
;
2526 if (*input_line_pointer
== '[')
2528 /* We are expecting something like the second argument here:
2530 * lwz r4,[toc].GS.0.static_int(rtoc)
2531 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2532 * The argument following the `]' must be a symbol name, and the
2533 * register must be the toc register: 'rtoc' or '2'
2535 * The effect is to 0 as the displacement field
2536 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2537 * the appropriate variation) reloc against it based on the symbol.
2538 * The linker will build the toc, and insert the resolved toc offset.
2541 * o The size of the toc entry is currently assumed to be
2542 * 32 bits. This should not be assumed to be a hard coded
2544 * o In an effort to cope with a change from 32 to 64 bits,
2545 * there are also toc entries that are specified to be
2546 * either 32 or 64 bits:
2547 * lwz r4,[toc32].GS.0.static_int(rtoc)
2548 * lwz r4,[toc64].GS.0.static_int(rtoc)
2549 * These demand toc entries of the specified size, and the
2550 * instruction probably requires it.
2554 enum toc_size_qualifier toc_kind
;
2555 bfd_reloc_code_real_type toc_reloc
;
2557 /* Go parse off the [tocXX] part. */
2558 valid_toc
= parse_toc_entry (&toc_kind
);
2562 /* Note: message has already been issued.
2563 FIXME: what sort of recovery should we do?
2564 demand_rest_of_line (); return; ? */
2567 /* Now get the symbol following the ']'. */
2573 /* In this case, we may not have seen the symbol yet,
2574 since it is allowed to appear on a .extern or .globl
2575 or just be a label in the .data section. */
2576 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2579 /* 1. The symbol must be defined and either in the toc
2580 section, or a global.
2581 2. The reloc generated must have the TOCDEFN flag set
2582 in upper bit mess of the reloc type.
2583 FIXME: It's a little confusing what the tocv
2584 qualifier can be used for. At the very least, I've
2585 seen three uses, only one of which I'm sure I can
2587 if (ex
.X_op
== O_symbol
)
2589 gas_assert (ex
.X_add_symbol
!= NULL
);
2590 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2593 as_bad (_("[tocv] symbol is not a toc symbol"));
2597 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2600 /* FIXME: these next two specifically specify 32/64 bit
2601 toc entries. We don't support them today. Is this
2602 the right way to say that? */
2603 toc_reloc
= BFD_RELOC_UNUSED
;
2604 as_bad (_("Unimplemented toc32 expression modifier"));
2607 /* FIXME: see above. */
2608 toc_reloc
= BFD_RELOC_UNUSED
;
2609 as_bad (_("Unimplemented toc64 expression modifier"));
2613 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2619 /* We need to generate a fixup for this expression. */
2620 if (fc
>= MAX_INSN_FIXUPS
)
2621 as_fatal (_("too many fixups"));
2623 fixups
[fc
].reloc
= toc_reloc
;
2624 fixups
[fc
].exp
= ex
;
2625 fixups
[fc
].opindex
= *opindex_ptr
;
2628 /* Ok. We've set up the fixup for the instruction. Now make it
2629 look like the constant 0 was found here. */
2631 ex
.X_op
= O_constant
;
2632 ex
.X_add_number
= 0;
2633 ex
.X_add_symbol
= NULL
;
2634 ex
.X_op_symbol
= NULL
;
2640 if ((reg_names_p
&& (operand
->flags
& PPC_OPERAND_CR
) != 0)
2641 || !register_name (&ex
))
2643 char save_lex
= lex_type
['%'];
2645 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2648 lex_type
['%'] |= LEX_BEGIN_NAME
;
2652 lex_type
['%'] = save_lex
;
2656 str
= input_line_pointer
;
2657 input_line_pointer
= hold
;
2659 if (ex
.X_op
== O_illegal
)
2660 as_bad (_("illegal operand"));
2661 else if (ex
.X_op
== O_absent
)
2662 as_bad (_("missing operand"));
2663 else if (ex
.X_op
== O_register
)
2665 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2666 ppc_cpu
, (char *) NULL
, 0);
2668 else if (ex
.X_op
== O_constant
)
2671 /* Allow @HA, @L, @H on constants. */
2672 char *orig_str
= str
;
2674 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2681 case BFD_RELOC_LO16
:
2682 /* X_unsigned is the default, so if the user has done
2683 something which cleared it, we always produce a
2685 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2686 ex
.X_add_number
&= 0xffff;
2688 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2691 case BFD_RELOC_HI16
:
2692 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2693 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2695 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2698 case BFD_RELOC_HI16_S
:
2699 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2700 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2702 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2705 case BFD_RELOC_PPC64_HIGHER
:
2706 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2707 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2709 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2712 case BFD_RELOC_PPC64_HIGHER_S
:
2713 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2714 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2716 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2719 case BFD_RELOC_PPC64_HIGHEST
:
2720 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2721 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2723 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2726 case BFD_RELOC_PPC64_HIGHEST_S
:
2727 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2728 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2730 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2733 #endif /* OBJ_ELF */
2734 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2735 ppc_cpu
, (char *) NULL
, 0);
2740 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2742 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2743 if (sym_name
[0] == '.')
2746 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2748 expressionS tls_exp
;
2750 hold
= input_line_pointer
;
2751 input_line_pointer
= str
+ 1;
2752 expression (&tls_exp
);
2753 if (tls_exp
.X_op
== O_symbol
)
2755 reloc
= BFD_RELOC_UNUSED
;
2756 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2758 reloc
= BFD_RELOC_PPC_TLSGD
;
2759 input_line_pointer
+= 7;
2761 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2763 reloc
= BFD_RELOC_PPC_TLSLD
;
2764 input_line_pointer
+= 7;
2766 if (reloc
!= BFD_RELOC_UNUSED
)
2769 str
= input_line_pointer
;
2771 if (fc
>= MAX_INSN_FIXUPS
)
2772 as_fatal (_("too many fixups"));
2773 fixups
[fc
].exp
= tls_exp
;
2774 fixups
[fc
].opindex
= *opindex_ptr
;
2775 fixups
[fc
].reloc
= reloc
;
2779 input_line_pointer
= hold
;
2783 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2785 /* Some TLS tweaks. */
2791 case BFD_RELOC_PPC_TLS
:
2792 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2793 as_bad (_("@tls may not be used with \"%s\" operands"),
2795 else if (operand
->shift
!= 11)
2796 as_bad (_("@tls may only be used in last operand"));
2798 insn
= ppc_insert_operand (insn
, operand
,
2800 ppc_cpu
, (char *) NULL
, 0);
2803 /* We'll only use the 32 (or 64) bit form of these relocations
2804 in constants. Instructions get the 16 bit form. */
2805 case BFD_RELOC_PPC_DTPREL
:
2806 reloc
= BFD_RELOC_PPC_DTPREL16
;
2808 case BFD_RELOC_PPC_TPREL
:
2809 reloc
= BFD_RELOC_PPC_TPREL16
;
2813 /* For the absolute forms of branches, convert the PC
2814 relative form back into the absolute. */
2815 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2819 case BFD_RELOC_PPC_B26
:
2820 reloc
= BFD_RELOC_PPC_BA26
;
2822 case BFD_RELOC_PPC_B16
:
2823 reloc
= BFD_RELOC_PPC_BA16
;
2825 case BFD_RELOC_PPC_B16_BRTAKEN
:
2826 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2828 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2829 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2838 case BFD_RELOC_PPC_TOC16
:
2839 toc_reloc_types
|= has_small_toc_reloc
;
2841 case BFD_RELOC_PPC64_TOC16_LO
:
2842 case BFD_RELOC_PPC64_TOC16_HI
:
2843 case BFD_RELOC_PPC64_TOC16_HA
:
2844 toc_reloc_types
|= has_large_toc_reloc
;
2851 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
2856 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2858 case BFD_RELOC_LO16
:
2859 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2861 case BFD_RELOC_16_GOTOFF
:
2862 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2864 case BFD_RELOC_LO16_GOTOFF
:
2865 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2867 case BFD_RELOC_LO16_PLTOFF
:
2868 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2870 case BFD_RELOC_16_BASEREL
:
2871 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2873 case BFD_RELOC_LO16_BASEREL
:
2874 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2876 case BFD_RELOC_PPC_TOC16
:
2877 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2879 case BFD_RELOC_PPC64_TOC16_LO
:
2880 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2882 case BFD_RELOC_PPC64_PLTGOT16
:
2883 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2885 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2886 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2888 case BFD_RELOC_PPC_DTPREL16
:
2889 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2891 case BFD_RELOC_PPC_DTPREL16_LO
:
2892 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2894 case BFD_RELOC_PPC_TPREL16
:
2895 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2897 case BFD_RELOC_PPC_TPREL16_LO
:
2898 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2900 case BFD_RELOC_PPC_GOT_DTPREL16
:
2901 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2902 case BFD_RELOC_PPC_GOT_TPREL16
:
2903 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2906 as_bad (_("unsupported relocation for DS offset field"));
2912 /* We need to generate a fixup for this expression. */
2913 if (fc
>= MAX_INSN_FIXUPS
)
2914 as_fatal (_("too many fixups"));
2915 fixups
[fc
].exp
= ex
;
2916 fixups
[fc
].opindex
= *opindex_ptr
;
2917 fixups
[fc
].reloc
= reloc
;
2923 /* We need to generate a fixup for this expression. */
2924 if (fc
>= MAX_INSN_FIXUPS
)
2925 as_fatal (_("too many fixups"));
2926 fixups
[fc
].exp
= ex
;
2927 fixups
[fc
].opindex
= *opindex_ptr
;
2928 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2931 #endif /* OBJ_ELF */
2937 /* If expecting more operands, then we want to see "),". */
2938 if (*str
== endc
&& opindex_ptr
[1] != 0)
2942 while (ISSPACE (*str
));
2946 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2954 /* The call to expression should have advanced str past any
2957 && (endc
!= ',' || *str
!= '\0'))
2960 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
2962 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
2970 while (ISSPACE (*str
))
2974 as_bad (_("junk at end of line: `%s'"), str
);
2977 /* Do we need/want a APUinfo section? */
2978 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
)) != 0)
2980 /* These are all version "1". */
2981 if (opcode
->flags
& PPC_OPCODE_SPE
)
2982 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2983 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2984 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2985 if (opcode
->flags
& PPC_OPCODE_EFS
)
2986 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2987 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2988 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2989 if (opcode
->flags
& PPC_OPCODE_PMR
)
2990 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2991 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2992 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2993 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2994 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2998 /* Write out the instruction. */
3000 addr_mod
= frag_now_fix () & 3;
3001 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3002 as_bad (_("instruction address is not a multiple of 4"));
3003 frag_now
->insn_addr
= addr_mod
;
3004 frag_now
->has_code
= 1;
3005 md_number_to_chars (f
, insn
, 4);
3008 dwarf2_emit_insn (4);
3011 /* Create any fixups. At this point we do not use a
3012 bfd_reloc_code_real_type, but instead just use the
3013 BFD_RELOC_UNUSED plus the operand index. This lets us easily
3014 handle fixups for any operand type, although that is admittedly
3015 not a very exciting feature. We pick a BFD reloc type in
3017 for (i
= 0; i
< fc
; i
++)
3019 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3021 reloc_howto_type
*reloc_howto
;
3026 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3030 size
= bfd_get_reloc_size (reloc_howto
);
3031 offset
= target_big_endian
? (4 - size
) : 0;
3033 if (size
< 1 || size
> 4)
3036 fixP
= fix_new_exp (frag_now
,
3037 f
- frag_now
->fr_literal
+ offset
,
3040 reloc_howto
->pc_relative
,
3043 /* Turn off complaints that the addend is too large for things like
3045 switch (fixups
[i
].reloc
)
3047 case BFD_RELOC_16_GOTOFF
:
3048 case BFD_RELOC_PPC_TOC16
:
3049 case BFD_RELOC_LO16
:
3050 case BFD_RELOC_HI16
:
3051 case BFD_RELOC_HI16_S
:
3053 case BFD_RELOC_PPC64_HIGHER
:
3054 case BFD_RELOC_PPC64_HIGHER_S
:
3055 case BFD_RELOC_PPC64_HIGHEST
:
3056 case BFD_RELOC_PPC64_HIGHEST_S
:
3058 fixP
->fx_no_overflow
= 1;
3066 const struct powerpc_operand
*operand
;
3068 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3069 fix_new_exp (frag_now
,
3070 f
- frag_now
->fr_literal
,
3073 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3074 ((bfd_reloc_code_real_type
)
3075 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
3080 /* Handle a macro. Gather all the operands, transform them as
3081 described by the macro, and call md_assemble recursively. All the
3082 operands are separated by commas; we don't accept parentheses
3083 around operands here. */
3086 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3097 /* Gather the users operands into the operands array. */
3102 if (count
>= sizeof operands
/ sizeof operands
[0])
3104 operands
[count
++] = s
;
3105 s
= strchr (s
, ',');
3106 if (s
== (char *) NULL
)
3111 if (count
!= macro
->operands
)
3113 as_bad (_("wrong number of operands"));
3117 /* Work out how large the string must be (the size is unbounded
3118 because it includes user input). */
3120 format
= macro
->format
;
3121 while (*format
!= '\0')
3130 arg
= strtol (format
+ 1, &send
, 10);
3131 know (send
!= format
&& arg
< count
);
3132 len
+= strlen (operands
[arg
]);
3137 /* Put the string together. */
3138 complete
= s
= (char *) alloca (len
+ 1);
3139 format
= macro
->format
;
3140 while (*format
!= '\0')
3146 arg
= strtol (format
+ 1, &send
, 10);
3147 strcpy (s
, operands
[arg
]);
3154 /* Assemble the constructed instruction. */
3155 md_assemble (complete
);
3159 /* For ELF, add support for SHT_ORDERED. */
3162 ppc_section_type (char *str
, size_t len
)
3164 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3171 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3173 if (type
== SHT_ORDERED
)
3174 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3178 #endif /* OBJ_ELF */
3181 /* Pseudo-op handling. */
3183 /* The .byte pseudo-op. This is similar to the normal .byte
3184 pseudo-op, but it can also take a single ASCII string. */
3187 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3189 if (*input_line_pointer
!= '\"')
3195 /* Gather characters. A real double quote is doubled. Unusual
3196 characters are not permitted. */
3197 ++input_line_pointer
;
3202 c
= *input_line_pointer
++;
3206 if (*input_line_pointer
!= '\"')
3208 ++input_line_pointer
;
3211 FRAG_APPEND_1_CHAR (c
);
3214 demand_empty_rest_of_line ();
3219 /* XCOFF specific pseudo-op handling. */
3221 /* This is set if we are creating a .stabx symbol, since we don't want
3222 to handle symbol suffixes for such symbols. */
3223 static bfd_boolean ppc_stab_symbol
;
3225 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3226 symbols in the .bss segment as though they were local common
3227 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3228 aligns .comm and .lcomm to 4 bytes. */
3231 ppc_comm (int lcomm
)
3233 asection
*current_seg
= now_seg
;
3234 subsegT current_subseg
= now_subseg
;
3240 symbolS
*lcomm_sym
= NULL
;
3244 name
= input_line_pointer
;
3245 endc
= get_symbol_end ();
3246 end_name
= input_line_pointer
;
3249 if (*input_line_pointer
!= ',')
3251 as_bad (_("missing size"));
3252 ignore_rest_of_line ();
3255 ++input_line_pointer
;
3257 size
= get_absolute_expression ();
3260 as_bad (_("negative size"));
3261 ignore_rest_of_line ();
3267 /* The third argument to .comm is the alignment. */
3268 if (*input_line_pointer
!= ',')
3272 ++input_line_pointer
;
3273 align
= get_absolute_expression ();
3276 as_warn (_("ignoring bad alignment"));
3291 /* The third argument to .lcomm appears to be the real local
3292 common symbol to create. References to the symbol named in
3293 the first argument are turned into references to the third
3295 if (*input_line_pointer
!= ',')
3297 as_bad (_("missing real symbol name"));
3298 ignore_rest_of_line ();
3301 ++input_line_pointer
;
3303 lcomm_name
= input_line_pointer
;
3304 lcomm_endc
= get_symbol_end ();
3306 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3308 *input_line_pointer
= lcomm_endc
;
3312 sym
= symbol_find_or_make (name
);
3315 if (S_IS_DEFINED (sym
)
3316 || S_GET_VALUE (sym
) != 0)
3318 as_bad (_("attempt to redefine symbol"));
3319 ignore_rest_of_line ();
3323 record_alignment (bss_section
, align
);
3326 || ! S_IS_DEFINED (lcomm_sym
))
3335 S_SET_EXTERNAL (sym
);
3339 symbol_get_tc (lcomm_sym
)->output
= 1;
3340 def_sym
= lcomm_sym
;
3344 subseg_set (bss_section
, 1);
3345 frag_align (align
, 0, 0);
3347 symbol_set_frag (def_sym
, frag_now
);
3348 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3349 def_size
, (char *) NULL
);
3351 S_SET_SEGMENT (def_sym
, bss_section
);
3352 symbol_get_tc (def_sym
)->align
= align
;
3356 /* Align the size of lcomm_sym. */
3357 symbol_get_frag (lcomm_sym
)->fr_offset
=
3358 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3359 &~ ((1 << align
) - 1));
3360 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3361 symbol_get_tc (lcomm_sym
)->align
= align
;
3366 /* Make sym an offset from lcomm_sym. */
3367 S_SET_SEGMENT (sym
, bss_section
);
3368 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3369 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3370 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3373 subseg_set (current_seg
, current_subseg
);
3375 demand_empty_rest_of_line ();
3378 /* The .csect pseudo-op. This switches us into a different
3379 subsegment. The first argument is a symbol whose value is the
3380 start of the .csect. In COFF, csect symbols get special aux
3381 entries defined by the x_csect field of union internal_auxent. The
3382 optional second argument is the alignment (the default is 2). */
3385 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3392 name
= input_line_pointer
;
3393 endc
= get_symbol_end ();
3395 sym
= symbol_find_or_make (name
);
3397 *input_line_pointer
= endc
;
3399 if (S_GET_NAME (sym
)[0] == '\0')
3401 /* An unnamed csect is assumed to be [PR]. */
3402 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3406 if (*input_line_pointer
== ',')
3408 ++input_line_pointer
;
3409 align
= get_absolute_expression ();
3412 ppc_change_csect (sym
, align
);
3414 demand_empty_rest_of_line ();
3417 /* Change to a different csect. */
3420 ppc_change_csect (symbolS
*sym
, offsetT align
)
3422 if (S_IS_DEFINED (sym
))
3423 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3433 /* This is a new csect. We need to look at the symbol class to
3434 figure out whether it should go in the text section or the
3438 switch (symbol_get_tc (sym
)->symbol_class
)
3448 S_SET_SEGMENT (sym
, text_section
);
3449 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3450 ++ppc_text_subsegment
;
3451 list_ptr
= &ppc_text_csects
;
3461 if (ppc_toc_csect
!= NULL
3462 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3463 == ppc_data_subsegment
))
3465 S_SET_SEGMENT (sym
, data_section
);
3466 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3467 ++ppc_data_subsegment
;
3468 list_ptr
= &ppc_data_csects
;
3474 /* We set the obstack chunk size to a small value before
3475 changing subsegments, so that we don't use a lot of memory
3476 space for what may be a small section. */
3477 hold_chunksize
= chunksize
;
3480 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3481 symbol_get_tc (sym
)->subseg
);
3483 chunksize
= hold_chunksize
;
3486 ppc_after_toc_frag
= frag_now
;
3488 record_alignment (sec
, align
);
3490 frag_align_code (align
, 0);
3492 frag_align (align
, 0, 0);
3494 symbol_set_frag (sym
, frag_now
);
3495 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3497 symbol_get_tc (sym
)->align
= align
;
3498 symbol_get_tc (sym
)->output
= 1;
3499 symbol_get_tc (sym
)->within
= sym
;
3501 for (list
= *list_ptr
;
3502 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3503 list
= symbol_get_tc (list
)->next
)
3505 symbol_get_tc (list
)->next
= sym
;
3507 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3508 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3512 ppc_current_csect
= sym
;
3516 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3520 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3522 sec
= subseg_new (dw
->name
, subseg
);
3523 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3524 if (oldflags
== SEC_NO_FLAGS
)
3526 /* Just created section. */
3527 gas_assert (dw_sections
[idx
].sect
== NULL
);
3529 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3530 bfd_set_section_alignment (stdoutput
, sec
, 0);
3531 dw_sections
[idx
].sect
= sec
;
3534 /* Not anymore in a csect. */
3535 ppc_current_csect
= NULL
;
3538 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3539 .dwsect flag [, opt-label ]
3543 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3547 const struct xcoff_dwsect_name
*dw
;
3548 struct dw_subsection
*subseg
;
3549 struct dw_section
*dws
;
3553 flag
= get_absolute_expression ();
3555 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3556 if (xcoff_dwsect_names
[i
].flag
== flag
)
3558 dw
= &xcoff_dwsect_names
[i
];
3562 /* Parse opt-label. */
3563 if (*input_line_pointer
== ',')
3568 ++input_line_pointer
;
3570 label
= input_line_pointer
;
3571 c
= get_symbol_end ();
3572 opt_label
= symbol_find_or_make (label
);
3573 *input_line_pointer
= c
;
3578 demand_empty_rest_of_line ();
3580 /* Return now in case of unknown subsection. */
3583 as_bad (_("No known dwarf XCOFF section for flag 0x%08x\n"),
3588 /* Find the subsection. */
3589 dws
= &dw_sections
[i
];
3591 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3593 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3594 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3596 as_bad (_("label %s was not defined in this dwarf section"),
3597 S_GET_NAME (opt_label
));
3598 subseg
= dws
->anon_subseg
;
3602 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3607 /* Switch to the subsection. */
3608 ppc_change_debug_section (i
, subseg
->subseg
);
3612 /* Create a new dw subsection. */
3613 subseg
= (struct dw_subsection
*)
3614 xmalloc (sizeof (struct dw_subsection
));
3616 if (opt_label
== NULL
)
3618 /* The anonymous one. */
3620 subseg
->link
= NULL
;
3621 dws
->anon_subseg
= subseg
;
3626 if (dws
->list_subseg
!= NULL
)
3627 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3631 subseg
->link
= dws
->list_subseg
;
3632 dws
->list_subseg
= subseg
;
3633 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3636 ppc_change_debug_section (i
, subseg
->subseg
);
3640 /* Add the length field. */
3641 expressionS
*exp
= &subseg
->end_exp
;
3644 if (opt_label
!= NULL
)
3645 symbol_set_value_now (opt_label
);
3647 /* Add the length field. Note that according to the AIX assembler
3648 manual, the size of the length field is 4 for powerpc32 but
3649 12 for powerpc64. */
3652 /* Write the 64bit marker. */
3653 md_number_to_chars (frag_more (4), -1, 4);
3656 exp
->X_op
= O_subtract
;
3657 exp
->X_op_symbol
= symbol_temp_new_now ();
3658 exp
->X_add_symbol
= symbol_temp_make ();
3660 sz
= ppc_obj64
? 8 : 4;
3661 exp
->X_add_number
= -sz
;
3662 emit_expr (exp
, sz
);
3667 /* This function handles the .text and .data pseudo-ops. These
3668 pseudo-ops aren't really used by XCOFF; we implement them for the
3669 convenience of people who aren't used to XCOFF. */
3672 ppc_section (int type
)
3679 else if (type
== 'd')
3684 sym
= symbol_find_or_make (name
);
3686 ppc_change_csect (sym
, 2);
3688 demand_empty_rest_of_line ();
3691 /* This function handles the .section pseudo-op. This is mostly to
3692 give an error, since XCOFF only supports .text, .data and .bss, but
3693 we do permit the user to name the text or data section. */
3696 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3699 const char *real_name
;
3703 user_name
= input_line_pointer
;
3704 c
= get_symbol_end ();
3706 if (strcmp (user_name
, ".text") == 0)
3707 real_name
= ".text[PR]";
3708 else if (strcmp (user_name
, ".data") == 0)
3709 real_name
= ".data[RW]";
3712 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3713 *input_line_pointer
= c
;
3714 ignore_rest_of_line ();
3718 *input_line_pointer
= c
;
3720 sym
= symbol_find_or_make (real_name
);
3722 ppc_change_csect (sym
, 2);
3724 demand_empty_rest_of_line ();
3727 /* The .extern pseudo-op. We create an undefined symbol. */
3730 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
3735 name
= input_line_pointer
;
3736 endc
= get_symbol_end ();
3738 (void) symbol_find_or_make (name
);
3740 *input_line_pointer
= endc
;
3742 demand_empty_rest_of_line ();
3745 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3748 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
3754 name
= input_line_pointer
;
3755 endc
= get_symbol_end ();
3757 sym
= symbol_find_or_make (name
);
3759 *input_line_pointer
= endc
;
3761 symbol_get_tc (sym
)->output
= 1;
3763 demand_empty_rest_of_line ();
3766 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
3767 relocations at the beginning of the current csect.
3769 (In principle, there's no reason why the relocations _have_ to be at
3770 the beginning. Anywhere in the csect would do. However, inserting
3771 at the beginning is what the native assmebler does, and it helps to
3772 deal with cases where the .ref statements follow the section contents.)
3774 ??? .refs don't work for empty .csects. However, the native assembler
3775 doesn't report an error in this case, and neither yet do we. */
3778 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
3783 if (ppc_current_csect
== NULL
)
3785 as_bad (_(".ref outside .csect"));
3786 ignore_rest_of_line ();
3792 name
= input_line_pointer
;
3793 c
= get_symbol_end ();
3795 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
3796 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
3798 *input_line_pointer
= c
;
3800 c
= *input_line_pointer
;
3803 input_line_pointer
++;
3805 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3807 as_bad (_("missing symbol name"));
3808 ignore_rest_of_line ();
3815 demand_empty_rest_of_line ();
3818 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3819 although I don't know why it bothers. */
3822 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
3829 name
= input_line_pointer
;
3830 endc
= get_symbol_end ();
3832 sym
= symbol_find_or_make (name
);
3834 *input_line_pointer
= endc
;
3836 if (*input_line_pointer
!= ',')
3838 as_bad (_("missing rename string"));
3839 ignore_rest_of_line ();
3842 ++input_line_pointer
;
3844 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3846 demand_empty_rest_of_line ();
3849 /* The .stabx pseudo-op. This is similar to a normal .stabs
3850 pseudo-op, but slightly different. A sample is
3851 .stabx "main:F-1",.main,142,0
3852 The first argument is the symbol name to create. The second is the
3853 value, and the third is the storage class. The fourth seems to be
3854 always zero, and I am assuming it is the type. */
3857 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
3864 name
= demand_copy_C_string (&len
);
3866 if (*input_line_pointer
!= ',')
3868 as_bad (_("missing value"));
3871 ++input_line_pointer
;
3873 ppc_stab_symbol
= TRUE
;
3874 sym
= symbol_make (name
);
3875 ppc_stab_symbol
= FALSE
;
3877 symbol_get_tc (sym
)->real_name
= name
;
3879 (void) expression (&exp
);
3886 as_bad (_("illegal .stabx expression; zero assumed"));
3887 exp
.X_add_number
= 0;
3890 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3891 symbol_set_frag (sym
, &zero_address_frag
);
3895 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3896 symbol_set_value_expression (sym
, &exp
);
3900 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3901 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3906 /* The value is some complex expression. This will probably
3907 fail at some later point, but this is probably the right
3908 thing to do here. */
3909 symbol_set_value_expression (sym
, &exp
);
3913 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3914 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3916 if (*input_line_pointer
!= ',')
3918 as_bad (_("missing class"));
3921 ++input_line_pointer
;
3923 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3925 if (*input_line_pointer
!= ',')
3927 as_bad (_("missing type"));
3930 ++input_line_pointer
;
3932 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3934 symbol_get_tc (sym
)->output
= 1;
3936 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
3941 .stabx "z",arrays_,133,0
3944 .comm arrays_,13768,3
3946 resolve_symbol_value will copy the exp's "within" into sym's when the
3947 offset is 0. Since this seems to be corner case problem,
3948 only do the correction for storage class C_STSYM. A better solution
3949 would be to have the tc field updated in ppc_symbol_new_hook. */
3951 if (exp
.X_op
== O_symbol
)
3953 if (ppc_current_block
== NULL
)
3954 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
3956 symbol_get_tc (sym
)->within
= ppc_current_block
;
3957 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3961 if (exp
.X_op
!= O_symbol
3962 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3963 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3964 ppc_frob_label (sym
);
3967 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3968 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3969 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3970 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3973 demand_empty_rest_of_line ();
3976 /* The .function pseudo-op. This takes several arguments. The first
3977 argument seems to be the external name of the symbol. The second
3978 argument seems to be the label for the start of the function. gcc
3979 uses the same name for both. I have no idea what the third and
3980 fourth arguments are meant to be. The optional fifth argument is
3981 an expression for the size of the function. In COFF this symbol
3982 gets an aux entry like that used for a csect. */
3985 ppc_function (int ignore ATTRIBUTE_UNUSED
)
3993 name
= input_line_pointer
;
3994 endc
= get_symbol_end ();
3996 /* Ignore any [PR] suffix. */
3997 name
= ppc_canonicalize_symbol_name (name
);
3998 s
= strchr (name
, '[');
3999 if (s
!= (char *) NULL
4000 && strcmp (s
+ 1, "PR]") == 0)
4003 ext_sym
= symbol_find_or_make (name
);
4005 *input_line_pointer
= endc
;
4007 if (*input_line_pointer
!= ',')
4009 as_bad (_("missing symbol name"));
4010 ignore_rest_of_line ();
4013 ++input_line_pointer
;
4015 name
= input_line_pointer
;
4016 endc
= get_symbol_end ();
4018 lab_sym
= symbol_find_or_make (name
);
4020 *input_line_pointer
= endc
;
4022 if (ext_sym
!= lab_sym
)
4026 exp
.X_op
= O_symbol
;
4027 exp
.X_add_symbol
= lab_sym
;
4028 exp
.X_op_symbol
= NULL
;
4029 exp
.X_add_number
= 0;
4031 symbol_set_value_expression (ext_sym
, &exp
);
4034 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4035 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4036 symbol_get_tc (ext_sym
)->output
= 1;
4038 if (*input_line_pointer
== ',')
4042 /* Ignore the third argument. */
4043 ++input_line_pointer
;
4045 if (*input_line_pointer
== ',')
4047 /* Ignore the fourth argument. */
4048 ++input_line_pointer
;
4050 if (*input_line_pointer
== ',')
4052 /* The fifth argument is the function size. */
4053 ++input_line_pointer
;
4054 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4055 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4056 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4061 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4062 SF_SET_FUNCTION (ext_sym
);
4063 SF_SET_PROCESS (ext_sym
);
4064 coff_add_linesym (ext_sym
);
4066 demand_empty_rest_of_line ();
4069 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4070 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4071 with the correct line number */
4073 static symbolS
*saved_bi_sym
= 0;
4076 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4080 sym
= symbol_make (".bf");
4081 S_SET_SEGMENT (sym
, text_section
);
4082 symbol_set_frag (sym
, frag_now
);
4083 S_SET_VALUE (sym
, frag_now_fix ());
4084 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4086 coff_line_base
= get_absolute_expression ();
4088 S_SET_NUMBER_AUXILIARY (sym
, 1);
4089 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4091 /* Line number for bi. */
4094 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4099 symbol_get_tc (sym
)->output
= 1;
4101 ppc_frob_label (sym
);
4103 demand_empty_rest_of_line ();
4106 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4107 ".ef", except that the line number is absolute, not relative to the
4108 most recent ".bf" symbol. */
4111 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4115 sym
= symbol_make (".ef");
4116 S_SET_SEGMENT (sym
, text_section
);
4117 symbol_set_frag (sym
, frag_now
);
4118 S_SET_VALUE (sym
, frag_now_fix ());
4119 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4120 S_SET_NUMBER_AUXILIARY (sym
, 1);
4121 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4122 symbol_get_tc (sym
)->output
= 1;
4124 ppc_frob_label (sym
);
4126 demand_empty_rest_of_line ();
4129 /* The .bi and .ei pseudo-ops. These take a string argument and
4130 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4131 the symbol list. The value of .bi will be know when the next .bf
4137 static symbolS
*last_biei
;
4144 name
= demand_copy_C_string (&len
);
4146 /* The value of these symbols is actually file offset. Here we set
4147 the value to the index into the line number entries. In
4148 ppc_frob_symbols we set the fix_line field, which will cause BFD
4149 to do the right thing. */
4151 sym
= symbol_make (name
);
4152 /* obj-coff.c currently only handles line numbers correctly in the
4154 S_SET_SEGMENT (sym
, text_section
);
4155 S_SET_VALUE (sym
, coff_n_line_nos
);
4156 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4158 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4159 symbol_get_tc (sym
)->output
= 1;
4167 for (look
= last_biei
? last_biei
: symbol_rootP
;
4168 (look
!= (symbolS
*) NULL
4169 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4170 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4171 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4172 look
= symbol_next (look
))
4174 if (look
!= (symbolS
*) NULL
)
4176 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4177 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4181 demand_empty_rest_of_line ();
4184 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4185 There is one argument, which is a csect symbol. The value of the
4186 .bs symbol is the index of this csect symbol. */
4189 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4196 if (ppc_current_block
!= NULL
)
4197 as_bad (_("nested .bs blocks"));
4199 name
= input_line_pointer
;
4200 endc
= get_symbol_end ();
4202 csect
= symbol_find_or_make (name
);
4204 *input_line_pointer
= endc
;
4206 sym
= symbol_make (".bs");
4207 S_SET_SEGMENT (sym
, now_seg
);
4208 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4209 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4210 symbol_get_tc (sym
)->output
= 1;
4212 symbol_get_tc (sym
)->within
= csect
;
4214 ppc_frob_label (sym
);
4216 ppc_current_block
= sym
;
4218 demand_empty_rest_of_line ();
4221 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4224 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4228 if (ppc_current_block
== NULL
)
4229 as_bad (_(".es without preceding .bs"));
4231 sym
= symbol_make (".es");
4232 S_SET_SEGMENT (sym
, now_seg
);
4233 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4234 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4235 symbol_get_tc (sym
)->output
= 1;
4237 ppc_frob_label (sym
);
4239 ppc_current_block
= NULL
;
4241 demand_empty_rest_of_line ();
4244 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4248 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4252 sym
= symbol_make (".bb");
4253 S_SET_SEGMENT (sym
, text_section
);
4254 symbol_set_frag (sym
, frag_now
);
4255 S_SET_VALUE (sym
, frag_now_fix ());
4256 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4258 S_SET_NUMBER_AUXILIARY (sym
, 1);
4259 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4261 symbol_get_tc (sym
)->output
= 1;
4263 SF_SET_PROCESS (sym
);
4265 ppc_frob_label (sym
);
4267 demand_empty_rest_of_line ();
4270 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4274 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4278 sym
= symbol_make (".eb");
4279 S_SET_SEGMENT (sym
, text_section
);
4280 symbol_set_frag (sym
, frag_now
);
4281 S_SET_VALUE (sym
, frag_now_fix ());
4282 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4283 S_SET_NUMBER_AUXILIARY (sym
, 1);
4284 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4285 symbol_get_tc (sym
)->output
= 1;
4287 SF_SET_PROCESS (sym
);
4289 ppc_frob_label (sym
);
4291 demand_empty_rest_of_line ();
4294 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4298 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4304 name
= demand_copy_C_string (&len
);
4305 sym
= symbol_make (name
);
4306 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4307 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4308 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4309 S_SET_VALUE (sym
, 0);
4310 symbol_get_tc (sym
)->output
= 1;
4312 ppc_frob_label (sym
);
4314 demand_empty_rest_of_line ();
4317 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4320 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4324 sym
= symbol_make (".ec");
4325 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4326 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4327 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4328 S_SET_VALUE (sym
, 0);
4329 symbol_get_tc (sym
)->output
= 1;
4331 ppc_frob_label (sym
);
4333 demand_empty_rest_of_line ();
4336 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4339 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4341 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4342 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4349 subseg
= ppc_data_subsegment
;
4350 ++ppc_data_subsegment
;
4352 subseg_new (segment_name (data_section
), subseg
);
4353 ppc_toc_frag
= frag_now
;
4355 sym
= symbol_find_or_make ("TOC[TC0]");
4356 symbol_set_frag (sym
, frag_now
);
4357 S_SET_SEGMENT (sym
, data_section
);
4358 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4359 symbol_get_tc (sym
)->subseg
= subseg
;
4360 symbol_get_tc (sym
)->output
= 1;
4361 symbol_get_tc (sym
)->within
= sym
;
4363 ppc_toc_csect
= sym
;
4365 for (list
= ppc_data_csects
;
4366 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4367 list
= symbol_get_tc (list
)->next
)
4369 symbol_get_tc (list
)->next
= sym
;
4371 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4372 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4376 ppc_current_csect
= ppc_toc_csect
;
4378 demand_empty_rest_of_line ();
4381 /* The AIX assembler automatically aligns the operands of a .long or
4382 .short pseudo-op, and we want to be compatible. */
4385 ppc_xcoff_cons (int log_size
)
4387 frag_align (log_size
, 0, 0);
4388 record_alignment (now_seg
, log_size
);
4389 cons (1 << log_size
);
4393 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4398 (void) expression (&exp
);
4400 if (exp
.X_op
!= O_constant
)
4402 as_bad (_("non-constant byte count"));
4406 byte_count
= exp
.X_add_number
;
4408 if (*input_line_pointer
!= ',')
4410 as_bad (_("missing value"));
4414 ++input_line_pointer
;
4419 ppc_xcoff_end (void)
4423 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4425 struct dw_section
*dws
= &dw_sections
[i
];
4426 struct dw_subsection
*dwss
;
4428 if (dws
->anon_subseg
)
4430 dwss
= dws
->anon_subseg
;
4431 dwss
->link
= dws
->list_subseg
;
4434 dwss
= dws
->list_subseg
;
4436 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4437 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4439 subseg_set (dws
->sect
, dwss
->subseg
);
4440 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4445 #endif /* OBJ_XCOFF */
4446 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4448 /* The .tc pseudo-op. This is used when generating either XCOFF or
4449 ELF. This takes two or more arguments.
4451 When generating XCOFF output, the first argument is the name to
4452 give to this location in the toc; this will be a symbol with class
4453 TC. The rest of the arguments are N-byte values to actually put at
4454 this location in the TOC; often there is just one more argument, a
4455 relocatable symbol reference. The size of the value to store
4456 depends on target word size. A 32-bit target uses 4-byte values, a
4457 64-bit target uses 8-byte values.
4459 When not generating XCOFF output, the arguments are the same, but
4460 the first argument is simply ignored. */
4463 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4467 /* Define the TOC symbol name. */
4473 if (ppc_toc_csect
== (symbolS
*) NULL
4474 || ppc_toc_csect
!= ppc_current_csect
)
4476 as_bad (_(".tc not in .toc section"));
4477 ignore_rest_of_line ();
4481 name
= input_line_pointer
;
4482 endc
= get_symbol_end ();
4484 sym
= symbol_find_or_make (name
);
4486 *input_line_pointer
= endc
;
4488 if (S_IS_DEFINED (sym
))
4492 label
= symbol_get_tc (ppc_current_csect
)->within
;
4493 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4495 as_bad (_(".tc with no label"));
4496 ignore_rest_of_line ();
4500 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4501 symbol_set_frag (label
, symbol_get_frag (sym
));
4502 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4504 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4505 ++input_line_pointer
;
4510 S_SET_SEGMENT (sym
, now_seg
);
4511 symbol_set_frag (sym
, frag_now
);
4512 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4513 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4514 symbol_get_tc (sym
)->output
= 1;
4516 ppc_frob_label (sym
);
4519 #endif /* OBJ_XCOFF */
4523 /* Skip the TOC symbol name. */
4524 while (is_part_of_name (*input_line_pointer
)
4525 || *input_line_pointer
== ' '
4526 || *input_line_pointer
== '['
4527 || *input_line_pointer
== ']'
4528 || *input_line_pointer
== '{'
4529 || *input_line_pointer
== '}')
4530 ++input_line_pointer
;
4532 /* Align to a four/eight byte boundary. */
4533 align
= ppc_obj64
? 3 : 2;
4534 frag_align (align
, 0, 0);
4535 record_alignment (now_seg
, align
);
4536 #endif /* OBJ_ELF */
4538 if (*input_line_pointer
!= ',')
4539 demand_empty_rest_of_line ();
4542 ++input_line_pointer
;
4543 cons (ppc_obj64
? 8 : 4);
4547 /* Pseudo-op .machine. */
4550 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4553 #define MAX_HISTORY 100
4554 static ppc_cpu_t
*cpu_history
;
4555 static int curr_hist
;
4559 if (*input_line_pointer
== '"')
4562 cpu_string
= demand_copy_C_string (&len
);
4567 cpu_string
= input_line_pointer
;
4568 c
= get_symbol_end ();
4569 cpu_string
= xstrdup (cpu_string
);
4570 *input_line_pointer
= c
;
4573 if (cpu_string
!= NULL
)
4575 ppc_cpu_t old_cpu
= ppc_cpu
;
4579 for (p
= cpu_string
; *p
!= 0; p
++)
4582 if (strcmp (cpu_string
, "push") == 0)
4584 if (cpu_history
== NULL
)
4585 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4587 if (curr_hist
>= MAX_HISTORY
)
4588 as_bad (_(".machine stack overflow"));
4590 cpu_history
[curr_hist
++] = ppc_cpu
;
4592 else if (strcmp (cpu_string
, "pop") == 0)
4595 as_bad (_(".machine stack underflow"));
4597 ppc_cpu
= cpu_history
[--curr_hist
];
4599 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, cpu_string
)) != 0)
4602 as_bad (_("invalid machine `%s'"), cpu_string
);
4604 if (ppc_cpu
!= old_cpu
)
4605 ppc_setup_opcodes ();
4608 demand_empty_rest_of_line ();
4611 /* See whether a symbol is in the TOC section. */
4614 ppc_is_toc_sym (symbolS
*sym
)
4617 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
4620 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4622 return strcmp (sname
, ".toc") == 0;
4624 return strcmp (sname
, ".got") == 0;
4627 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4631 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4633 /* Set the current section. */
4635 ppc_set_current_section (segT
new)
4637 ppc_previous_section
= ppc_current_section
;
4638 ppc_current_section
= new;
4641 /* pseudo-op: .previous
4642 behaviour: toggles the current section with the previous section.
4644 warnings: "No previous section" */
4647 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4651 if (ppc_previous_section
== NULL
)
4653 as_warn (_("No previous section to return to. Directive ignored."));
4657 subseg_set (ppc_previous_section
, 0);
4659 ppc_set_current_section (ppc_previous_section
);
4662 /* pseudo-op: .pdata
4663 behaviour: predefined read only data section
4667 initial: .section .pdata "adr3"
4668 a - don't know -- maybe a misprint
4669 d - initialized data
4671 3 - double word aligned (that would be 4 byte boundary)
4674 Tag index tables (also known as the function table) for exception
4675 handling, debugging, etc. */
4678 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4680 if (pdata_section
== 0)
4682 pdata_section
= subseg_new (".pdata", 0);
4684 bfd_set_section_flags (stdoutput
, pdata_section
,
4685 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4686 | SEC_READONLY
| SEC_DATA
));
4688 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4692 pdata_section
= subseg_new (".pdata", 0);
4694 ppc_set_current_section (pdata_section
);
4697 /* pseudo-op: .ydata
4698 behaviour: predefined read only data section
4702 initial: .section .ydata "drw3"
4703 a - don't know -- maybe a misprint
4704 d - initialized data
4706 3 - double word aligned (that would be 4 byte boundary)
4708 Tag tables (also known as the scope table) for exception handling,
4712 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4714 if (ydata_section
== 0)
4716 ydata_section
= subseg_new (".ydata", 0);
4717 bfd_set_section_flags (stdoutput
, ydata_section
,
4718 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4719 | SEC_READONLY
| SEC_DATA
));
4721 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4725 ydata_section
= subseg_new (".ydata", 0);
4727 ppc_set_current_section (ydata_section
);
4730 /* pseudo-op: .reldata
4731 behaviour: predefined read write data section
4732 double word aligned (4-byte)
4733 FIXME: relocation is applied to it
4734 FIXME: what's the difference between this and .data?
4737 initial: .section .reldata "drw3"
4738 d - initialized data
4741 3 - double word aligned (that would be 8 byte boundary)
4744 Like .data, but intended to hold data subject to relocation, such as
4745 function descriptors, etc. */
4748 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
4750 if (reldata_section
== 0)
4752 reldata_section
= subseg_new (".reldata", 0);
4754 bfd_set_section_flags (stdoutput
, reldata_section
,
4755 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4758 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4762 reldata_section
= subseg_new (".reldata", 0);
4764 ppc_set_current_section (reldata_section
);
4767 /* pseudo-op: .rdata
4768 behaviour: predefined read only data section
4772 initial: .section .rdata "dr3"
4773 d - initialized data
4775 3 - double word aligned (that would be 4 byte boundary) */
4778 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
4780 if (rdata_section
== 0)
4782 rdata_section
= subseg_new (".rdata", 0);
4783 bfd_set_section_flags (stdoutput
, rdata_section
,
4784 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4785 | SEC_READONLY
| SEC_DATA
));
4787 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4791 rdata_section
= subseg_new (".rdata", 0);
4793 ppc_set_current_section (rdata_section
);
4796 /* pseudo-op: .ualong
4797 behaviour: much like .int, with the exception that no alignment is
4799 FIXME: test the alignment statement
4804 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
4810 /* pseudo-op: .znop <symbol name>
4811 behaviour: Issue a nop instruction
4812 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4813 the supplied symbol name.
4815 warnings: Missing symbol name */
4818 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
4821 const struct powerpc_opcode
*opcode
;
4832 /* Strip out the symbol name. */
4833 symbol_name
= input_line_pointer
;
4834 c
= get_symbol_end ();
4836 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4837 strcpy (name
, symbol_name
);
4839 sym
= symbol_find_or_make (name
);
4841 *input_line_pointer
= c
;
4845 /* Look up the opcode in the hash table. */
4846 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4848 /* Stick in the nop. */
4849 insn
= opcode
->opcode
;
4851 /* Write out the instruction. */
4853 md_number_to_chars (f
, insn
, 4);
4855 f
- frag_now
->fr_literal
,
4860 BFD_RELOC_16_GOT_PCREL
);
4870 ppc_pe_comm (int lcomm
)
4879 name
= input_line_pointer
;
4880 c
= get_symbol_end ();
4882 /* just after name is now '\0'. */
4883 p
= input_line_pointer
;
4886 if (*input_line_pointer
!= ',')
4888 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4889 ignore_rest_of_line ();
4893 input_line_pointer
++; /* skip ',' */
4894 if ((temp
= get_absolute_expression ()) < 0)
4896 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4897 ignore_rest_of_line ();
4903 /* The third argument to .comm is the alignment. */
4904 if (*input_line_pointer
!= ',')
4908 ++input_line_pointer
;
4909 align
= get_absolute_expression ();
4912 as_warn (_("ignoring bad alignment"));
4919 symbolP
= symbol_find_or_make (name
);
4922 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4924 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4925 S_GET_NAME (symbolP
));
4926 ignore_rest_of_line ();
4930 if (S_GET_VALUE (symbolP
))
4932 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4933 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4934 S_GET_NAME (symbolP
),
4935 (long) S_GET_VALUE (symbolP
),
4940 S_SET_VALUE (symbolP
, (valueT
) temp
);
4941 S_SET_EXTERNAL (symbolP
);
4942 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
4945 demand_empty_rest_of_line ();
4949 * implement the .section pseudo op:
4950 * .section name {, "flags"}
4952 * | +--- optional flags: 'b' for bss
4954 * +-- section name 'l' for lib
4958 * 'd' (apparently m88k for data)
4960 * But if the argument is not a quoted string, treat it as a
4961 * subsegment number.
4963 * FIXME: this is a copy of the section processing from obj-coff.c, with
4964 * additions/changes for the moto-pas assembler support. There are three
4967 * FIXME: I just noticed this. This doesn't work at all really. It it
4968 * setting bits that bfd probably neither understands or uses. The
4969 * correct approach (?) will have to incorporate extra fields attached
4970 * to the section to hold the system specific stuff. (krk)
4973 * 'a' - unknown - referred to in documentation, but no definition supplied
4974 * 'c' - section has code
4975 * 'd' - section has initialized data
4976 * 'u' - section has uninitialized data
4977 * 'i' - section contains directives (info)
4978 * 'n' - section can be discarded
4979 * 'R' - remove section at link time
4981 * Section Protection:
4982 * 'r' - section is readable
4983 * 'w' - section is writeable
4984 * 'x' - section is executable
4985 * 's' - section is sharable
4987 * Section Alignment:
4988 * '0' - align to byte boundary
4989 * '1' - align to halfword undary
4990 * '2' - align to word boundary
4991 * '3' - align to doubleword boundary
4992 * '4' - align to quadword boundary
4993 * '5' - align to 32 byte boundary
4994 * '6' - align to 64 byte boundary
4999 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5001 /* Strip out the section name. */
5010 section_name
= input_line_pointer
;
5011 c
= get_symbol_end ();
5013 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5014 strcpy (name
, section_name
);
5016 *input_line_pointer
= c
;
5021 flags
= SEC_NO_FLAGS
;
5023 if (strcmp (name
, ".idata$2") == 0)
5027 else if (strcmp (name
, ".idata$3") == 0)
5031 else if (strcmp (name
, ".idata$4") == 0)
5035 else if (strcmp (name
, ".idata$5") == 0)
5039 else if (strcmp (name
, ".idata$6") == 0)
5044 /* Default alignment to 16 byte boundary. */
5047 if (*input_line_pointer
== ',')
5049 ++input_line_pointer
;
5051 if (*input_line_pointer
!= '"')
5052 exp
= get_absolute_expression ();
5055 ++input_line_pointer
;
5056 while (*input_line_pointer
!= '"'
5057 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5059 switch (*input_line_pointer
)
5061 /* Section Contents */
5062 case 'a': /* unknown */
5063 as_bad (_("Unsupported section attribute -- 'a'"));
5065 case 'c': /* code section */
5068 case 'd': /* section has initialized data */
5071 case 'u': /* section has uninitialized data */
5072 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5076 case 'i': /* section contains directives (info) */
5077 /* FIXME: This is IMAGE_SCN_LNK_INFO
5079 flags
|= SEC_HAS_CONTENTS
;
5081 case 'n': /* section can be discarded */
5084 case 'R': /* Remove section at link time */
5085 flags
|= SEC_NEVER_LOAD
;
5087 #if IFLICT_BRAIN_DAMAGE
5088 /* Section Protection */
5089 case 'r': /* section is readable */
5090 flags
|= IMAGE_SCN_MEM_READ
;
5092 case 'w': /* section is writeable */
5093 flags
|= IMAGE_SCN_MEM_WRITE
;
5095 case 'x': /* section is executable */
5096 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5098 case 's': /* section is sharable */
5099 flags
|= IMAGE_SCN_MEM_SHARED
;
5102 /* Section Alignment */
5103 case '0': /* align to byte boundary */
5104 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5107 case '1': /* align to halfword boundary */
5108 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5111 case '2': /* align to word boundary */
5112 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5115 case '3': /* align to doubleword boundary */
5116 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5119 case '4': /* align to quadword boundary */
5120 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5123 case '5': /* align to 32 byte boundary */
5124 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5127 case '6': /* align to 64 byte boundary */
5128 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5133 as_bad (_("unknown section attribute '%c'"),
5134 *input_line_pointer
);
5137 ++input_line_pointer
;
5139 if (*input_line_pointer
== '"')
5140 ++input_line_pointer
;
5144 sec
= subseg_new (name
, (subsegT
) exp
);
5146 ppc_set_current_section (sec
);
5148 if (flags
!= SEC_NO_FLAGS
)
5150 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5151 as_bad (_("error setting flags for \"%s\": %s"),
5152 bfd_section_name (stdoutput
, sec
),
5153 bfd_errmsg (bfd_get_error ()));
5156 bfd_set_section_alignment (stdoutput
, sec
, align
);
5160 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5166 name
= input_line_pointer
;
5167 endc
= get_symbol_end ();
5169 ext_sym
= symbol_find_or_make (name
);
5171 *input_line_pointer
= endc
;
5173 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5174 SF_SET_FUNCTION (ext_sym
);
5175 SF_SET_PROCESS (ext_sym
);
5176 coff_add_linesym (ext_sym
);
5178 demand_empty_rest_of_line ();
5182 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5184 if (tocdata_section
== 0)
5186 tocdata_section
= subseg_new (".tocd", 0);
5187 /* FIXME: section flags won't work. */
5188 bfd_set_section_flags (stdoutput
, tocdata_section
,
5189 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5190 | SEC_READONLY
| SEC_DATA
));
5192 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5196 rdata_section
= subseg_new (".tocd", 0);
5199 ppc_set_current_section (tocdata_section
);
5201 demand_empty_rest_of_line ();
5204 /* Don't adjust TOC relocs to use the section symbol. */
5207 ppc_pe_fix_adjustable (fixS
*fix
)
5209 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5216 /* XCOFF specific symbol and file handling. */
5218 /* Canonicalize the symbol name. We use the to force the suffix, if
5219 any, to use square brackets, and to be in upper case. */
5222 ppc_canonicalize_symbol_name (char *name
)
5226 if (ppc_stab_symbol
)
5229 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5243 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5246 if (*s
== '\0' || s
[1] != '\0')
5247 as_bad (_("bad symbol suffix"));
5255 /* Set the class of a symbol based on the suffix, if any. This is
5256 called whenever a new symbol is created. */
5259 ppc_symbol_new_hook (symbolS
*sym
)
5261 struct ppc_tc_sy
*tc
;
5264 tc
= symbol_get_tc (sym
);
5267 tc
->symbol_class
= -1;
5268 tc
->real_name
= NULL
;
5275 if (ppc_stab_symbol
)
5278 s
= strchr (S_GET_NAME (sym
), '[');
5279 if (s
== (const char *) NULL
)
5281 /* There is no suffix. */
5290 if (strcmp (s
, "BS]") == 0)
5291 tc
->symbol_class
= XMC_BS
;
5294 if (strcmp (s
, "DB]") == 0)
5295 tc
->symbol_class
= XMC_DB
;
5296 else if (strcmp (s
, "DS]") == 0)
5297 tc
->symbol_class
= XMC_DS
;
5300 if (strcmp (s
, "GL]") == 0)
5301 tc
->symbol_class
= XMC_GL
;
5304 if (strcmp (s
, "PR]") == 0)
5305 tc
->symbol_class
= XMC_PR
;
5308 if (strcmp (s
, "RO]") == 0)
5309 tc
->symbol_class
= XMC_RO
;
5310 else if (strcmp (s
, "RW]") == 0)
5311 tc
->symbol_class
= XMC_RW
;
5314 if (strcmp (s
, "SV]") == 0)
5315 tc
->symbol_class
= XMC_SV
;
5318 if (strcmp (s
, "TC]") == 0)
5319 tc
->symbol_class
= XMC_TC
;
5320 else if (strcmp (s
, "TI]") == 0)
5321 tc
->symbol_class
= XMC_TI
;
5322 else if (strcmp (s
, "TB]") == 0)
5323 tc
->symbol_class
= XMC_TB
;
5324 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5325 tc
->symbol_class
= XMC_TC0
;
5328 if (strcmp (s
, "UA]") == 0)
5329 tc
->symbol_class
= XMC_UA
;
5330 else if (strcmp (s
, "UC]") == 0)
5331 tc
->symbol_class
= XMC_UC
;
5334 if (strcmp (s
, "XO]") == 0)
5335 tc
->symbol_class
= XMC_XO
;
5339 if (tc
->symbol_class
== -1)
5340 as_bad (_("Unrecognized symbol suffix"));
5343 /* Set the class of a label based on where it is defined. This
5344 handles symbols without suffixes. Also, move the symbol so that it
5345 follows the csect symbol. */
5348 ppc_frob_label (symbolS
*sym
)
5350 if (ppc_current_csect
!= (symbolS
*) NULL
)
5352 if (symbol_get_tc (sym
)->symbol_class
== -1)
5353 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5355 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5356 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5357 &symbol_rootP
, &symbol_lastP
);
5358 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5359 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5363 dwarf2_emit_label (sym
);
5367 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5368 seen. It tells ppc_adjust_symtab whether it needs to look through
5371 static bfd_boolean ppc_saw_abs
;
5373 /* Change the name of a symbol just before writing it out. Set the
5374 real name if the .rename pseudo-op was used. Otherwise, remove any
5375 class suffix. Return 1 if the symbol should not be included in the
5379 ppc_frob_symbol (symbolS
*sym
)
5381 static symbolS
*ppc_last_function
;
5382 static symbolS
*set_end
;
5384 /* Discard symbols that should not be included in the output symbol
5386 if (! symbol_used_in_reloc_p (sym
)
5387 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5388 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5389 && ! symbol_get_tc (sym
)->output
5390 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5393 /* This one will disappear anyway. Don't make a csect sym for it. */
5394 if (sym
== abs_section_sym
)
5397 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5398 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5404 name
= S_GET_NAME (sym
);
5405 s
= strchr (name
, '[');
5406 if (s
!= (char *) NULL
)
5412 snew
= xmalloc (len
+ 1);
5413 memcpy (snew
, name
, len
);
5416 S_SET_NAME (sym
, snew
);
5420 if (set_end
!= (symbolS
*) NULL
)
5422 SA_SET_SYM_ENDNDX (set_end
, sym
);
5426 if (SF_GET_FUNCTION (sym
))
5428 if (ppc_last_function
!= (symbolS
*) NULL
)
5429 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5430 ppc_last_function
= sym
;
5431 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5433 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5434 SA_SET_SYM_FSIZE (sym
,
5435 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5438 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5439 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5441 if (ppc_last_function
== (symbolS
*) NULL
)
5442 as_bad (_(".ef with no preceding .function"));
5445 set_end
= ppc_last_function
;
5446 ppc_last_function
= NULL
;
5448 /* We don't have a C_EFCN symbol, but we need to force the
5449 COFF backend to believe that it has seen one. */
5450 coff_last_function
= NULL
;
5454 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5455 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5456 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5457 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5458 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5459 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5460 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5461 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5462 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5463 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5464 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5466 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5467 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5468 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5471 union internal_auxent
*a
;
5473 /* Create a csect aux. */
5474 i
= S_GET_NUMBER_AUXILIARY (sym
);
5475 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5476 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5477 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5479 /* This is the TOC table. */
5480 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5481 a
->x_csect
.x_scnlen
.l
= 0;
5482 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5484 else if (symbol_get_tc (sym
)->subseg
!= 0)
5486 /* This is a csect symbol. x_scnlen is the size of the
5488 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5489 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5490 S_GET_SEGMENT (sym
))
5491 - S_GET_VALUE (sym
));
5494 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5495 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5496 - S_GET_VALUE (sym
));
5498 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5500 else if (S_GET_SEGMENT (sym
) == bss_section
)
5502 /* This is a common symbol. */
5503 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5504 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5505 if (S_IS_EXTERNAL (sym
))
5506 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5508 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5510 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5512 /* This is an absolute symbol. The csect will be created by
5513 ppc_adjust_symtab. */
5515 a
->x_csect
.x_smtyp
= XTY_LD
;
5516 if (symbol_get_tc (sym
)->symbol_class
== -1)
5517 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5519 else if (! S_IS_DEFINED (sym
))
5521 /* This is an external symbol. */
5522 a
->x_csect
.x_scnlen
.l
= 0;
5523 a
->x_csect
.x_smtyp
= XTY_ER
;
5525 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5529 /* This is a TOC definition. x_scnlen is the size of the
5531 next
= symbol_next (sym
);
5532 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5533 next
= symbol_next (next
);
5534 if (next
== (symbolS
*) NULL
5535 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5537 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5538 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5540 - S_GET_VALUE (sym
));
5542 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5543 - S_GET_VALUE (sym
));
5547 resolve_symbol_value (next
);
5548 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5549 - S_GET_VALUE (sym
));
5551 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5557 /* This is a normal symbol definition. x_scnlen is the
5558 symbol index of the containing csect. */
5559 if (S_GET_SEGMENT (sym
) == text_section
)
5560 csect
= ppc_text_csects
;
5561 else if (S_GET_SEGMENT (sym
) == data_section
)
5562 csect
= ppc_data_csects
;
5566 /* Skip the initial dummy symbol. */
5567 csect
= symbol_get_tc (csect
)->next
;
5569 if (csect
== (symbolS
*) NULL
)
5571 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5572 a
->x_csect
.x_scnlen
.l
= 0;
5576 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5578 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5579 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5580 > S_GET_VALUE (sym
))
5582 csect
= symbol_get_tc (csect
)->next
;
5585 a
->x_csect
.x_scnlen
.p
=
5586 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5587 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5590 a
->x_csect
.x_smtyp
= XTY_LD
;
5593 a
->x_csect
.x_parmhash
= 0;
5594 a
->x_csect
.x_snhash
= 0;
5595 if (symbol_get_tc (sym
)->symbol_class
== -1)
5596 a
->x_csect
.x_smclas
= XMC_PR
;
5598 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5599 a
->x_csect
.x_stab
= 0;
5600 a
->x_csect
.x_snstab
= 0;
5602 /* Don't let the COFF backend resort these symbols. */
5603 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5605 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5607 /* We want the value to be the symbol index of the referenced
5608 csect symbol. BFD will do that for us if we set the right
5610 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5611 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5613 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5614 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5616 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5621 block
= symbol_get_tc (sym
)->within
;
5624 /* The value is the offset from the enclosing csect. */
5627 csect
= symbol_get_tc (block
)->within
;
5628 resolve_symbol_value (csect
);
5629 base
= S_GET_VALUE (csect
);
5634 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5636 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5637 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5639 /* We want the value to be a file offset into the line numbers.
5640 BFD will do that for us if we set the right flags. We have
5641 already set the value correctly. */
5642 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5648 /* Adjust the symbol table. This creates csect symbols for all
5649 absolute symbols. */
5652 ppc_adjust_symtab (void)
5659 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5663 union internal_auxent
*a
;
5665 if (S_GET_SEGMENT (sym
) != absolute_section
)
5668 csect
= symbol_create (".abs[XO]", absolute_section
,
5669 S_GET_VALUE (sym
), &zero_address_frag
);
5670 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5671 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5672 i
= S_GET_NUMBER_AUXILIARY (csect
);
5673 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5674 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5675 a
->x_csect
.x_scnlen
.l
= 0;
5676 a
->x_csect
.x_smtyp
= XTY_SD
;
5677 a
->x_csect
.x_parmhash
= 0;
5678 a
->x_csect
.x_snhash
= 0;
5679 a
->x_csect
.x_smclas
= XMC_XO
;
5680 a
->x_csect
.x_stab
= 0;
5681 a
->x_csect
.x_snstab
= 0;
5683 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5685 i
= S_GET_NUMBER_AUXILIARY (sym
);
5686 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5687 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5688 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5691 ppc_saw_abs
= FALSE
;
5694 /* Set the VMA for a section. This is called on all the sections in
5698 ppc_frob_section (asection
*sec
)
5700 static bfd_vma vma
= 0;
5702 /* Dwarf sections start at 0. */
5703 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5706 vma
= md_section_align (sec
, vma
);
5707 bfd_set_section_vma (stdoutput
, sec
, vma
);
5708 vma
+= bfd_section_size (stdoutput
, sec
);
5711 #endif /* OBJ_XCOFF */
5714 md_atof (int type
, char *litp
, int *sizep
)
5716 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5719 /* Write a value out to the object file, using the appropriate
5723 md_number_to_chars (char *buf
, valueT val
, int n
)
5725 if (target_big_endian
)
5726 number_to_chars_bigendian (buf
, val
, n
);
5728 number_to_chars_littleendian (buf
, val
, n
);
5731 /* Align a section (I don't know why this is machine dependent). */
5734 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5739 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5741 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5745 /* We don't have any form of relaxing. */
5748 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5749 asection
*seg ATTRIBUTE_UNUSED
)
5755 /* Convert a machine dependent frag. We never generate these. */
5758 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5759 asection
*sec ATTRIBUTE_UNUSED
,
5760 fragS
*fragp ATTRIBUTE_UNUSED
)
5765 /* We have no need to default values of symbols. */
5768 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
5773 /* Functions concerning relocs. */
5775 /* The location from which a PC relative jump should be calculated,
5776 given a PC relative reloc. */
5779 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
5781 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5786 /* This is called to see whether a fixup should be adjusted to use a
5787 section symbol. We take the opportunity to change a fixup against
5788 a symbol in the TOC subsegment into a reloc against the
5789 corresponding .tc symbol. */
5792 ppc_fix_adjustable (fixS
*fix
)
5794 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5795 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5796 TC_SYMFIELD_TYPE
*tc
;
5798 if (symseg
== absolute_section
)
5801 /* Always adjust symbols in debugging sections. */
5802 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
5805 if (ppc_toc_csect
!= (symbolS
*) NULL
5806 && fix
->fx_addsy
!= ppc_toc_csect
5807 && symseg
== data_section
5808 && val
>= ppc_toc_frag
->fr_address
5809 && (ppc_after_toc_frag
== (fragS
*) NULL
5810 || val
< ppc_after_toc_frag
->fr_address
))
5814 for (sy
= symbol_next (ppc_toc_csect
);
5815 sy
!= (symbolS
*) NULL
;
5816 sy
= symbol_next (sy
))
5818 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5820 if (sy_tc
->symbol_class
== XMC_TC0
)
5822 if (sy_tc
->symbol_class
!= XMC_TC
)
5824 if (val
== resolve_symbol_value (sy
))
5827 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5832 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5833 _("symbol in .toc does not match any .tc"));
5836 /* Possibly adjust the reloc to be against the csect. */
5837 tc
= symbol_get_tc (fix
->fx_addsy
);
5839 && tc
->symbol_class
!= XMC_TC0
5840 && tc
->symbol_class
!= XMC_TC
5841 && symseg
!= bss_section
5842 /* Don't adjust if this is a reloc in the toc section. */
5843 && (symseg
!= data_section
5844 || ppc_toc_csect
== NULL
5845 || val
< ppc_toc_frag
->fr_address
5846 || (ppc_after_toc_frag
!= NULL
5847 && val
>= ppc_after_toc_frag
->fr_address
)))
5849 symbolS
*csect
= tc
->within
;
5851 /* If the symbol was not declared by a label (eg: a section symbol),
5852 use the section instead of the csect. This doesn't happen in
5853 normal AIX assembly code. */
5855 csect
= seg_info (symseg
)->sym
;
5857 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5858 fix
->fx_addsy
= csect
;
5863 /* Adjust a reloc against a .lcomm symbol to be against the base
5865 if (symseg
== bss_section
5866 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5868 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5870 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5877 /* A reloc from one csect to another must be kept. The assembler
5878 will, of course, keep relocs between sections, and it will keep
5879 absolute relocs, but we need to force it to keep PC relative relocs
5880 between two csects in the same section. */
5883 ppc_force_relocation (fixS
*fix
)
5885 /* At this point fix->fx_addsy should already have been converted to
5886 a csect symbol. If the csect does not include the fragment, then
5887 we need to force the relocation. */
5889 && fix
->fx_addsy
!= NULL
5890 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5891 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5892 > fix
->fx_frag
->fr_address
)
5893 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5894 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5895 <= fix
->fx_frag
->fr_address
))))
5898 return generic_force_reloc (fix
);
5902 ppc_new_dot_label (symbolS
*sym
)
5904 /* Anchor this label to the current csect for relocations. */
5905 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5908 #endif /* OBJ_XCOFF */
5911 /* If this function returns non-zero, it guarantees that a relocation
5912 will be emitted for a fixup. */
5915 ppc_force_relocation (fixS
*fix
)
5917 /* Branch prediction relocations must force a relocation, as must
5918 the vtable description relocs. */
5919 switch (fix
->fx_r_type
)
5921 case BFD_RELOC_PPC_B16_BRTAKEN
:
5922 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5923 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5924 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5925 case BFD_RELOC_24_PLT_PCREL
:
5926 case BFD_RELOC_PPC64_TOC
:
5932 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5933 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5936 return generic_force_reloc (fix
);
5940 ppc_fix_adjustable (fixS
*fix
)
5942 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5943 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5944 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5945 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5946 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
5947 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
5948 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5949 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5950 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5951 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5952 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
5956 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
5957 rs_align_code frag. */
5960 ppc_handle_align (struct frag
*fragP
)
5962 valueT count
= (fragP
->fr_next
->fr_address
5963 - (fragP
->fr_address
+ fragP
->fr_fix
));
5965 if (count
!= 0 && (count
& 3) == 0)
5967 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
5971 if (count
> 4 * nop_limit
&& count
< 0x2000000)
5975 /* Make a branch, then follow with nops. Insert another
5976 frag to handle the nops. */
5977 md_number_to_chars (dest
, 0x48000000 + count
, 4);
5982 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
5983 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
5984 fragP
->fr_next
= rest
;
5986 rest
->fr_address
+= rest
->fr_fix
+ 4;
5988 /* If we leave the next frag as rs_align_code we'll come here
5989 again, resulting in a bunch of branches rather than a
5990 branch followed by nops. */
5991 rest
->fr_type
= rs_align
;
5992 dest
= rest
->fr_literal
;
5995 md_number_to_chars (dest
, 0x60000000, 4);
5997 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
5998 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6000 /* For power6 and power7, we want the last nop to be a group
6001 terminating one. Do this by inserting an rs_fill frag immediately
6002 after this one, with its address set to the last nop location.
6003 This will automatically reduce the number of nops in the current
6007 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6009 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6010 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6011 group_nop
->fr_fix
= 0;
6012 group_nop
->fr_offset
= 1;
6013 group_nop
->fr_type
= rs_fill
;
6014 fragP
->fr_next
= group_nop
;
6015 dest
= group_nop
->fr_literal
;
6018 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6020 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6021 /* e500mc group terminating nop: "ori 0,0,0". */
6022 md_number_to_chars (dest
, 0x60000000, 4);
6024 /* power7 group terminating nop: "ori 2,2,0". */
6025 md_number_to_chars (dest
, 0x60420000, 4);
6028 /* power6 group terminating nop: "ori 1,1,0". */
6029 md_number_to_chars (dest
, 0x60210000, 4);
6034 /* Apply a fixup to the object code. This is called for all the
6035 fixups we generated by the call to fix_new_exp, above. In the call
6036 above we used a reloc code which was the largest legal reloc code
6037 plus the operand index. Here we undo that to recover the operand
6038 index. At this point all symbol values should be fully resolved,
6039 and we attempt to completely resolve the reloc. If we can not do
6040 that, we determine the correct reloc code and put it back in the
6044 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6046 valueT value
= * valP
;
6049 if (fixP
->fx_addsy
!= NULL
)
6051 /* Hack around bfd_install_relocation brain damage. */
6053 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6058 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6059 the symbol values. If we are doing this relocation the code in
6060 write.c is going to call bfd_install_relocation, which is also
6061 going to use the symbol value. That means that if the reloc is
6062 fully resolved we want to use *valP since bfd_install_relocation is
6064 However, if the reloc is not fully resolved we do not want to
6065 use *valP, and must use fx_offset instead. If the relocation
6066 is PC-relative, we then need to re-apply md_pcrel_from_section
6067 to this new relocation value. */
6068 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6073 value
= fixP
->fx_offset
;
6075 value
-= md_pcrel_from_section (fixP
, seg
);
6079 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6081 /* We can't actually support subtracting a symbol. */
6082 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6085 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
6088 const struct powerpc_operand
*operand
;
6092 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
6094 operand
= &powerpc_operands
[opindex
];
6097 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6098 does not generate a reloc. It uses the offset of `sym' within its
6099 csect. Other usages, such as `.long sym', generate relocs. This
6100 is the documented behaviour of non-TOC symbols. */
6101 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6102 && (operand
->bitm
& 0xfff0) == 0xfff0
6103 && operand
->shift
== 0
6104 && (operand
->insert
== NULL
|| ppc_obj64
)
6105 && fixP
->fx_addsy
!= NULL
6106 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6107 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6108 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6109 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6111 value
= fixP
->fx_offset
;
6116 /* Fetch the instruction, insert the fully resolved operand
6117 value, and stuff the instruction back again. */
6118 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6119 if (target_big_endian
)
6120 insn
= bfd_getb32 ((unsigned char *) where
);
6122 insn
= bfd_getl32 ((unsigned char *) where
);
6123 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
6124 fixP
->tc_fix_data
.ppc_cpu
,
6125 fixP
->fx_file
, fixP
->fx_line
);
6126 if (target_big_endian
)
6127 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6129 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6132 /* Nothing else to do here. */
6135 gas_assert (fixP
->fx_addsy
!= NULL
);
6137 /* Determine a BFD reloc value based on the operand information.
6138 We are only prepared to turn a few of the operands into
6140 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6141 && operand
->bitm
== 0x3fffffc
6142 && operand
->shift
== 0)
6143 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
6144 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6145 && operand
->bitm
== 0xfffc
6146 && operand
->shift
== 0)
6148 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
6151 if (target_big_endian
)
6152 fixP
->fx_where
+= 2;
6155 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6156 && operand
->bitm
== 0x3fffffc
6157 && operand
->shift
== 0)
6158 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
6159 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6160 && operand
->bitm
== 0xfffc
6161 && operand
->shift
== 0)
6163 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
6166 if (target_big_endian
)
6167 fixP
->fx_where
+= 2;
6170 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
6171 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6172 && (operand
->bitm
& 0xfff0) == 0xfff0
6173 && operand
->shift
== 0)
6175 if (ppc_is_toc_sym (fixP
->fx_addsy
))
6177 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6180 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6181 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
6186 fixP
->fx_r_type
= BFD_RELOC_16
;
6189 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6190 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
6194 if (target_big_endian
)
6195 fixP
->fx_where
+= 2;
6197 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
6203 /* Use expr_symbol_where to see if this is an expression
6205 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6206 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6207 _("unresolved expression that must be resolved"));
6209 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6210 _("unsupported relocation against %s"),
6211 S_GET_NAME (fixP
->fx_addsy
));
6219 ppc_elf_validate_fix (fixP
, seg
);
6221 switch (fixP
->fx_r_type
)
6223 case BFD_RELOC_CTOR
:
6230 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6234 case BFD_RELOC_32_PCREL
:
6235 case BFD_RELOC_PPC_EMB_NADDR32
:
6236 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6243 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6246 case BFD_RELOC_64_PCREL
:
6247 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6251 case BFD_RELOC_GPREL16
:
6252 case BFD_RELOC_16_GOT_PCREL
:
6253 case BFD_RELOC_16_GOTOFF
:
6254 case BFD_RELOC_LO16_GOTOFF
:
6255 case BFD_RELOC_HI16_GOTOFF
:
6256 case BFD_RELOC_HI16_S_GOTOFF
:
6257 case BFD_RELOC_16_BASEREL
:
6258 case BFD_RELOC_LO16_BASEREL
:
6259 case BFD_RELOC_HI16_BASEREL
:
6260 case BFD_RELOC_HI16_S_BASEREL
:
6261 case BFD_RELOC_PPC_EMB_NADDR16
:
6262 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6263 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6264 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6265 case BFD_RELOC_PPC_EMB_SDAI16
:
6266 case BFD_RELOC_PPC_EMB_SDA2REL
:
6267 case BFD_RELOC_PPC_EMB_SDA2I16
:
6268 case BFD_RELOC_PPC_EMB_RELSEC16
:
6269 case BFD_RELOC_PPC_EMB_RELST_LO
:
6270 case BFD_RELOC_PPC_EMB_RELST_HI
:
6271 case BFD_RELOC_PPC_EMB_RELST_HA
:
6272 case BFD_RELOC_PPC_EMB_RELSDA
:
6273 case BFD_RELOC_PPC_TOC16
:
6275 case BFD_RELOC_PPC64_TOC16_LO
:
6276 case BFD_RELOC_PPC64_TOC16_HI
:
6277 case BFD_RELOC_PPC64_TOC16_HA
:
6281 if (fixP
->fx_addsy
!= NULL
)
6282 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6283 _("cannot emit PC relative %s relocation against %s"),
6284 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6285 S_GET_NAME (fixP
->fx_addsy
));
6287 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6288 _("cannot emit PC relative %s relocation"),
6289 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6292 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6298 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6301 case BFD_RELOC_16_PCREL
:
6302 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6306 case BFD_RELOC_LO16
:
6308 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6311 case BFD_RELOC_LO16_PCREL
:
6312 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6316 /* This case happens when you write, for example,
6318 where L1 and L2 are defined later. */
6319 case BFD_RELOC_HI16
:
6321 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6324 case BFD_RELOC_HI16_PCREL
:
6325 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6329 case BFD_RELOC_HI16_S
:
6331 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6334 case BFD_RELOC_HI16_S_PCREL
:
6335 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6340 case BFD_RELOC_NONE
:
6345 case BFD_RELOC_PPC64_HIGHER
:
6348 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6349 PPC_HIGHER (value
), 2);
6352 case BFD_RELOC_PPC64_HIGHER_S
:
6355 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6356 PPC_HIGHERA (value
), 2);
6359 case BFD_RELOC_PPC64_HIGHEST
:
6362 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6363 PPC_HIGHEST (value
), 2);
6366 case BFD_RELOC_PPC64_HIGHEST_S
:
6369 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6370 PPC_HIGHESTA (value
), 2);
6373 case BFD_RELOC_PPC64_ADDR16_DS
:
6374 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6375 case BFD_RELOC_PPC64_GOT16_DS
:
6376 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6377 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6378 case BFD_RELOC_PPC64_SECTOFF_DS
:
6379 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6380 case BFD_RELOC_PPC64_TOC16_DS
:
6381 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6382 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6383 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6387 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6388 unsigned long val
, mask
;
6390 if (target_big_endian
)
6391 val
= bfd_getb32 (where
- 2);
6393 val
= bfd_getl32 (where
);
6395 /* lq insns reserve the four lsbs. */
6396 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
6397 && (val
& (0x3f << 26)) == (56u << 26))
6399 val
|= value
& mask
;
6400 if (target_big_endian
)
6401 bfd_putb16 ((bfd_vma
) val
, where
);
6403 bfd_putl16 ((bfd_vma
) val
, where
);
6407 case BFD_RELOC_PPC_B16_BRTAKEN
:
6408 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6409 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6410 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6413 case BFD_RELOC_PPC_TLS
:
6414 case BFD_RELOC_PPC_TLSGD
:
6415 case BFD_RELOC_PPC_TLSLD
:
6418 case BFD_RELOC_PPC_DTPMOD
:
6419 case BFD_RELOC_PPC_TPREL16
:
6420 case BFD_RELOC_PPC_TPREL16_LO
:
6421 case BFD_RELOC_PPC_TPREL16_HI
:
6422 case BFD_RELOC_PPC_TPREL16_HA
:
6423 case BFD_RELOC_PPC_TPREL
:
6424 case BFD_RELOC_PPC_DTPREL16
:
6425 case BFD_RELOC_PPC_DTPREL16_LO
:
6426 case BFD_RELOC_PPC_DTPREL16_HI
:
6427 case BFD_RELOC_PPC_DTPREL16_HA
:
6428 case BFD_RELOC_PPC_DTPREL
:
6429 case BFD_RELOC_PPC_GOT_TLSGD16
:
6430 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6431 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6432 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6433 case BFD_RELOC_PPC_GOT_TLSLD16
:
6434 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6435 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6436 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6437 case BFD_RELOC_PPC_GOT_TPREL16
:
6438 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6439 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6440 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6441 case BFD_RELOC_PPC_GOT_DTPREL16
:
6442 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6443 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6444 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6445 case BFD_RELOC_PPC64_TPREL16_DS
:
6446 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6447 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6448 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6449 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6450 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6451 case BFD_RELOC_PPC64_DTPREL16_DS
:
6452 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6453 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6454 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6455 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6456 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6457 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6460 /* Because SDA21 modifies the register field, the size is set to 4
6461 bytes, rather than 2, so offset it here appropriately. */
6462 case BFD_RELOC_PPC_EMB_SDA21
:
6466 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
6467 + ((target_big_endian
) ? 2 : 0),
6474 /* This can occur if there is a bug in the input assembler, eg:
6475 ".byte <undefined_symbol> - ." */
6477 as_bad (_("Unable to handle reference to symbol %s"),
6478 S_GET_NAME (fixP
->fx_addsy
));
6480 as_bad (_("Unable to resolve expression"));
6484 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6488 case BFD_RELOC_24_PLT_PCREL
:
6489 case BFD_RELOC_PPC_LOCAL24PC
:
6490 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
6498 /* Fetch the instruction, insert the fully resolved operand
6499 value, and stuff the instruction back again. */
6500 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6501 if (target_big_endian
)
6502 insn
= bfd_getb32 ((unsigned char *) where
);
6504 insn
= bfd_getl32 ((unsigned char *) where
);
6505 if ((value
& 3) != 0)
6506 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6507 _("must branch to an address a multiple of 4"));
6508 if ((offsetT
) value
< -0x40000000
6509 || (offsetT
) value
>= 0x40000000)
6510 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6511 _("@local or @plt branch destination is too far away, %ld bytes"),
6513 insn
= insn
| (value
& 0x03fffffc);
6514 if (target_big_endian
)
6515 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6517 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6521 case BFD_RELOC_VTABLE_INHERIT
:
6524 && !S_IS_DEFINED (fixP
->fx_addsy
)
6525 && !S_IS_WEAK (fixP
->fx_addsy
))
6526 S_SET_WEAK (fixP
->fx_addsy
);
6529 case BFD_RELOC_VTABLE_ENTRY
:
6534 /* Generated by reference to `sym@tocbase'. The sym is
6535 ignored by the linker. */
6536 case BFD_RELOC_PPC64_TOC
:
6542 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6549 fixP
->fx_addnumber
= value
;
6551 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6552 from the section contents. If we are going to be emitting a reloc
6553 then the section contents are immaterial, so don't warn if they
6554 happen to overflow. Leave such warnings to ld. */
6556 fixP
->fx_no_overflow
= 1;
6558 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6559 fixP
->fx_addnumber
= 0;
6563 fixP
->fx_addnumber
= 0;
6565 /* We want to use the offset within the toc, not the actual VMA
6567 fixP
->fx_addnumber
=
6568 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6569 - S_GET_VALUE (ppc_toc_csect
);
6575 /* Generate a reloc for a fixup. */
6578 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6582 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6584 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6585 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6586 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6587 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6588 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6590 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6591 _("reloc %d not supported by object file format"),
6592 (int) fixp
->fx_r_type
);
6595 reloc
->addend
= fixp
->fx_addnumber
;
6601 ppc_cfi_frame_initial_instructions (void)
6603 cfi_add_CFA_def_cfa (1, 0);
6607 tc_ppc_regname_to_dw2regnum (char *regname
)
6609 unsigned int regnum
= -1;
6613 static struct { char *name
; int dw2regnum
; } regnames
[] =
6615 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6616 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6617 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6618 { "spe_acc", 111 }, { "spefscr", 112 }
6621 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6622 if (strcmp (regnames
[i
].name
, regname
) == 0)
6623 return regnames
[i
].dw2regnum
;
6625 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6627 p
= regname
+ 1 + (regname
[1] == '.');
6628 regnum
= strtoul (p
, &q
, 10);
6629 if (p
== q
|| *q
|| regnum
>= 32)
6631 if (regname
[0] == 'f')
6633 else if (regname
[0] == 'v')
6636 else if (regname
[0] == 'c' && regname
[1] == 'r')
6638 p
= regname
+ 2 + (regname
[2] == '.');
6639 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6641 regnum
= p
[0] - '0' + 68;