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
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 -mspe generate code for Motorola SPE instructions\n\
1269 -mtitan generate code for AppliedMicro Titan core complex\n\
1270 -mregnames Allow symbolic names for registers\n\
1271 -mno-regnames Do not allow symbolic names for registers\n"));
1273 fprintf (stream
, _("\
1274 -mrelocatable support for GCC's -mrelocatble option\n\
1275 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1276 -memb set PPC_EMB bit in ELF flags\n\
1277 -mlittle, -mlittle-endian, -le\n\
1278 generate code for a little endian machine\n\
1279 -mbig, -mbig-endian, -be\n\
1280 generate code for a big endian machine\n\
1281 -msolaris generate code for Solaris\n\
1282 -mno-solaris do not generate code for Solaris\n\
1283 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1284 -V print assembler version number\n\
1285 -Qy, -Qn ignored\n"));
1287 fprintf (stream
, _("\
1288 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1291 /* Set ppc_cpu if it is not already set. */
1296 const char *default_os
= TARGET_OS
;
1297 const char *default_cpu
= TARGET_CPU
;
1299 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1302 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1303 else if (strncmp (default_os
, "aix", 3) == 0
1304 && default_os
[3] >= '4' && default_os
[3] <= '9')
1305 ppc_cpu
|= PPC_OPCODE_COMMON
;
1306 else if (strncmp (default_os
, "aix3", 4) == 0)
1307 ppc_cpu
|= PPC_OPCODE_POWER
;
1308 else if (strcmp (default_cpu
, "rs6000") == 0)
1309 ppc_cpu
|= PPC_OPCODE_POWER
;
1310 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1311 ppc_cpu
|= PPC_OPCODE_PPC
;
1313 as_fatal (_("Unknown default cpu = %s, os = %s"),
1314 default_cpu
, default_os
);
1318 /* Figure out the BFD architecture to use. This function and ppc_mach
1319 are called well before md_begin, when the output file is opened. */
1321 enum bfd_architecture
1324 const char *default_cpu
= TARGET_CPU
;
1327 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1328 return bfd_arch_powerpc
;
1329 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1330 return bfd_arch_rs6000
;
1331 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1333 if (strcmp (default_cpu
, "rs6000") == 0)
1334 return bfd_arch_rs6000
;
1335 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1336 return bfd_arch_powerpc
;
1339 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1340 return bfd_arch_unknown
;
1347 return bfd_mach_ppc64
;
1348 else if (ppc_arch () == bfd_arch_rs6000
)
1349 return bfd_mach_rs6k
;
1350 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1351 return bfd_mach_ppc_titan
;
1353 return bfd_mach_ppc
;
1357 ppc_target_format (void)
1361 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1363 return "xcoff-powermac";
1366 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1368 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1374 return "elf32-powerpc-vxworks";
1376 return (target_big_endian
1377 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1378 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1383 /* Insert opcodes and macros into hash tables. Called at startup and
1387 ppc_setup_opcodes (void)
1389 const struct powerpc_opcode
*op
;
1390 const struct powerpc_opcode
*op_end
;
1391 const struct powerpc_macro
*macro
;
1392 const struct powerpc_macro
*macro_end
;
1393 bfd_boolean bad_insn
= FALSE
;
1395 if (ppc_hash
!= NULL
)
1396 hash_die (ppc_hash
);
1397 if (ppc_macro_hash
!= NULL
)
1398 hash_die (ppc_macro_hash
);
1400 /* Insert the opcodes into a hash table. */
1401 ppc_hash
= hash_new ();
1403 if (ENABLE_CHECKING
)
1407 /* Check operand masks. Code here and in the disassembler assumes
1408 all the 1's in the mask are contiguous. */
1409 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1411 unsigned long mask
= powerpc_operands
[i
].bitm
;
1412 unsigned long right_bit
;
1415 right_bit
= mask
& -mask
;
1417 right_bit
= mask
& -mask
;
1418 if (mask
!= right_bit
)
1420 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1423 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1424 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1425 sizeof (powerpc_operands
[0])) == 0)
1427 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1434 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1435 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1437 if (ENABLE_CHECKING
)
1439 const unsigned char *o
;
1440 unsigned long omask
= op
->mask
;
1442 if (op
!= powerpc_opcodes
)
1444 /* The major opcodes had better be sorted. Code in the
1445 disassembler assumes the insns are sorted according to
1447 if (PPC_OP (op
[0].opcode
) < PPC_OP (op
[-1].opcode
))
1449 as_bad (_("major opcode is not sorted for %s"),
1454 /* Warn if the table isn't more strictly ordered.
1455 Unfortunately it doesn't seem possible to order the
1456 table on much more than the major opcode, which makes
1457 it difficult to implement a binary search in the
1458 disassembler. The problem is that we have multiple
1459 ways to disassemble instructions, and we usually want
1460 to choose a more specific form (with more bits set in
1461 the opcode) than a more general form. eg. all of the
1462 following are equivalent:
1463 bne label # opcode = 0x40820000, mask = 0xff830003
1464 bf 2,label # opcode = 0x40800000, mask = 0xff800003
1465 bc 4,2,label # opcode = 0x40000000, mask = 0xfc000003
1467 There are also cases where the table needs to be out
1468 of order to disassemble the correct instruction for
1469 processor variants. */
1472 unsigned long t1
= op
[0].opcode
;
1473 unsigned long t2
= op
[-1].opcode
;
1475 if (((t1
^ t2
) & 0xfc0007ff) == 0
1476 && (t1
& 0xfc0006df) == 0x7c000286)
1478 /* spr field is split. */
1479 t1
= ((t1
& ~0x1ff800)
1480 | ((t1
& 0xf800) << 5) | ((t1
& 0x1f0000) >> 5));
1481 t2
= ((t2
& ~0x1ff800)
1482 | ((t2
& 0xf800) << 5) | ((t2
& 0x1f0000) >> 5));
1485 as_warn (_("%s (%08lx %08lx) after %s (%08lx %08lx)"),
1486 op
[0].name
, op
[0].opcode
, op
[0].mask
,
1487 op
[-1].name
, op
[-1].opcode
, op
[-1].mask
);
1491 /* The mask had better not trim off opcode bits. */
1492 if ((op
->opcode
& omask
) != op
->opcode
)
1494 as_bad (_("mask trims opcode bits for %s"),
1499 /* The operands must not overlap the opcode or each other. */
1500 for (o
= op
->operands
; *o
; ++o
)
1501 if (*o
>= num_powerpc_operands
)
1503 as_bad (_("operand index error for %s"),
1509 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1510 if (operand
->shift
>= 0)
1512 unsigned long mask
= operand
->bitm
<< operand
->shift
;
1515 as_bad (_("operand %d overlap in %s"),
1516 (int) (o
- op
->operands
), op
->name
);
1524 if ((ppc_cpu
& op
->flags
) != 0
1525 && !(ppc_cpu
& op
->deprecated
))
1529 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1532 as_bad (_("duplicate instruction %s"),
1539 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1540 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1541 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1543 /* Insert the macros into a hash table. */
1544 ppc_macro_hash
= hash_new ();
1546 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1547 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1549 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1553 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1554 if (retval
!= (const char *) NULL
)
1556 as_bad (_("duplicate macro %s"), macro
->name
);
1566 /* This function is called when the assembler starts up. It is called
1567 after the options have been parsed and the output file has been
1575 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1578 /* Set the ELF flags if desired. */
1579 if (ppc_flags
&& !msolaris
)
1580 bfd_set_private_flags (stdoutput
, ppc_flags
);
1583 ppc_setup_opcodes ();
1585 /* Tell the main code what the endianness is if it is not overridden
1587 if (!set_target_endian
)
1589 set_target_endian
= 1;
1590 target_big_endian
= PPC_BIG_ENDIAN
;
1594 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1596 /* Create dummy symbols to serve as initial csects. This forces the
1597 text csects to precede the data csects. These symbols will not
1599 ppc_text_csects
= symbol_make ("dummy\001");
1600 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1601 ppc_data_csects
= symbol_make ("dummy\001");
1602 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1607 ppc_current_section
= text_section
;
1608 ppc_previous_section
= 0;
1617 if (ppc_apuinfo_list
== NULL
)
1620 /* Ok, so write the section info out. We have this layout:
1624 0 8 length of "APUinfo\0"
1625 4 (n*4) number of APU's (4 bytes each)
1628 20 APU#1 first APU's info
1629 24 APU#2 second APU's info
1634 asection
*seg
= now_seg
;
1635 subsegT subseg
= now_subseg
;
1636 asection
*apuinfo_secp
= (asection
*) NULL
;
1639 /* Create the .PPC.EMB.apuinfo section. */
1640 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1641 bfd_set_section_flags (stdoutput
,
1643 SEC_HAS_CONTENTS
| SEC_READONLY
);
1646 md_number_to_chars (p
, (valueT
) 8, 4);
1649 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1652 md_number_to_chars (p
, (valueT
) 2, 4);
1655 strcpy (p
, "APUinfo");
1657 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1660 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1663 frag_align (2, 0, 0);
1665 /* We probably can't restore the current segment, for there likely
1668 subseg_set (seg
, subseg
);
1673 /* Insert an operand value into an instruction. */
1675 static unsigned long
1676 ppc_insert_operand (unsigned long insn
,
1677 const struct powerpc_operand
*operand
,
1683 long min
, max
, right
;
1685 max
= operand
->bitm
;
1689 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1691 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1692 max
= (max
>> 1) & -right
;
1693 min
= ~max
& -right
;
1696 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1699 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1708 /* Some people write constants with the sign extension done by
1709 hand but only up to 32 bits. This shouldn't really be valid,
1710 but, to permit this code to assemble on a 64-bit host, we
1711 sign extend the 32-bit value to 64 bits if so doing makes the
1714 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1715 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1716 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1717 val
= val
- 0x80000000 - 0x80000000;
1719 /* Similarly, people write expressions like ~(1<<15), and expect
1720 this to be OK for a 32-bit unsigned value. */
1722 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1723 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1724 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1725 val
= val
+ 0x80000000 + 0x80000000;
1729 || (val
& (right
- 1)) != 0)
1730 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1733 if (operand
->insert
)
1738 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1739 if (errmsg
!= (const char *) NULL
)
1740 as_bad_where (file
, line
, "%s", errmsg
);
1743 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1750 /* Parse @got, etc. and return the desired relocation. */
1751 static bfd_reloc_code_real_type
1752 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1756 unsigned int length
: 8;
1757 unsigned int valid32
: 1;
1758 unsigned int valid64
: 1;
1767 const struct map_bfd
*ptr
;
1769 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1770 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1771 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1773 static const struct map_bfd mapping
[] = {
1774 MAP ("l", BFD_RELOC_LO16
),
1775 MAP ("h", BFD_RELOC_HI16
),
1776 MAP ("ha", BFD_RELOC_HI16_S
),
1777 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1778 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1779 MAP ("got", BFD_RELOC_16_GOTOFF
),
1780 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1781 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1782 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1783 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1784 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1785 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1786 MAP ("copy", BFD_RELOC_PPC_COPY
),
1787 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1788 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1789 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1790 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1791 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1792 MAP ("tls", BFD_RELOC_PPC_TLS
),
1793 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1794 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1795 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1796 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1797 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1798 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1799 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1800 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1801 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1802 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1803 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1804 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1805 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1806 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1807 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1808 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1809 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1810 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1811 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1812 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1813 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1814 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1815 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1816 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1817 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1818 MAP32 ("fixup", BFD_RELOC_CTOR
),
1819 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1820 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1821 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1822 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1823 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1824 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1825 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1826 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1827 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1828 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1829 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1830 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1831 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1832 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1833 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1834 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1835 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1836 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1837 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1838 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1839 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1840 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1841 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1842 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1843 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1844 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1845 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1846 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1847 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1848 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1849 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1850 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1851 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1852 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1853 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1854 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1855 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1856 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1857 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1858 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1859 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1863 return BFD_RELOC_UNUSED
;
1865 for (ch
= *str
, str2
= ident
;
1866 (str2
< ident
+ sizeof (ident
) - 1
1867 && (ISALNUM (ch
) || ch
== '@'));
1870 *str2
++ = TOLOWER (ch
);
1877 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1878 if (ch
== ptr
->string
[0]
1879 && len
== ptr
->length
1880 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1881 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1883 int reloc
= ptr
->reloc
;
1885 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1889 case BFD_RELOC_16_GOTOFF
:
1890 case BFD_RELOC_LO16_GOTOFF
:
1891 case BFD_RELOC_HI16_GOTOFF
:
1892 case BFD_RELOC_HI16_S_GOTOFF
:
1893 as_warn (_("identifier+constant@got means "
1894 "identifier@got+constant"));
1897 case BFD_RELOC_PPC_GOT_TLSGD16
:
1898 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
1899 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
1900 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
1901 case BFD_RELOC_PPC_GOT_TLSLD16
:
1902 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
1903 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
1904 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
1905 case BFD_RELOC_PPC_GOT_DTPREL16
:
1906 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
1907 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
1908 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
1909 case BFD_RELOC_PPC_GOT_TPREL16
:
1910 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
1911 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
1912 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
1913 as_bad (_("symbol+offset not supported for got tls"));
1918 /* Now check for identifier@suffix+constant. */
1919 if (*str
== '-' || *str
== '+')
1921 char *orig_line
= input_line_pointer
;
1922 expressionS new_exp
;
1924 input_line_pointer
= str
;
1925 expression (&new_exp
);
1926 if (new_exp
.X_op
== O_constant
)
1928 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1929 str
= input_line_pointer
;
1932 if (&input_line_pointer
!= str_p
)
1933 input_line_pointer
= orig_line
;
1937 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1938 && exp_p
->X_op
== O_symbol
1939 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
1941 /* Change the symbol so that the dummy .TOC. symbol can be
1942 omitted from the object file. */
1943 exp_p
->X_add_symbol
= &abs_symbol
;
1946 return (bfd_reloc_code_real_type
) reloc
;
1949 return BFD_RELOC_UNUSED
;
1952 /* Like normal .long/.short/.word, except support @got, etc.
1953 Clobbers input_line_pointer, checks end-of-line. */
1955 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
1958 bfd_reloc_code_real_type reloc
;
1960 if (is_it_end_of_statement ())
1962 demand_empty_rest_of_line ();
1969 if (exp
.X_op
== O_symbol
1970 && *input_line_pointer
== '@'
1971 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1972 &exp
)) != BFD_RELOC_UNUSED
)
1974 reloc_howto_type
*reloc_howto
;
1977 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1978 size
= bfd_get_reloc_size (reloc_howto
);
1982 as_bad (_("%s relocations do not fit in %d bytes\n"),
1983 reloc_howto
->name
, nbytes
);
1990 p
= frag_more (nbytes
);
1991 memset (p
, 0, nbytes
);
1993 if (target_big_endian
)
1994 offset
= nbytes
- size
;
1995 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2000 emit_expr (&exp
, (unsigned int) nbytes
);
2002 while (*input_line_pointer
++ == ',');
2004 /* Put terminator back into stream. */
2005 input_line_pointer
--;
2006 demand_empty_rest_of_line ();
2009 /* Solaris pseduo op to change to the .rodata section. */
2011 ppc_elf_rdata (int xxx
)
2013 char *save_line
= input_line_pointer
;
2014 static char section
[] = ".rodata\n";
2016 /* Just pretend this is .section .rodata */
2017 input_line_pointer
= section
;
2018 obj_elf_section (xxx
);
2020 input_line_pointer
= save_line
;
2023 /* Pseudo op to make file scope bss items. */
2025 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2038 name
= input_line_pointer
;
2039 c
= get_symbol_end ();
2041 /* just after name is now '\0'. */
2042 p
= input_line_pointer
;
2045 if (*input_line_pointer
!= ',')
2047 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
2048 ignore_rest_of_line ();
2052 input_line_pointer
++; /* skip ',' */
2053 if ((size
= get_absolute_expression ()) < 0)
2055 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2056 ignore_rest_of_line ();
2060 /* The third argument to .lcomm is the alignment. */
2061 if (*input_line_pointer
!= ',')
2065 ++input_line_pointer
;
2066 align
= get_absolute_expression ();
2069 as_warn (_("ignoring bad alignment"));
2075 symbolP
= symbol_find_or_make (name
);
2078 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2080 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2081 S_GET_NAME (symbolP
));
2082 ignore_rest_of_line ();
2086 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2088 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2089 S_GET_NAME (symbolP
),
2090 (long) S_GET_VALUE (symbolP
),
2093 ignore_rest_of_line ();
2099 old_subsec
= now_subseg
;
2102 /* Convert to a power of 2 alignment. */
2103 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2106 as_bad (_("Common alignment not a power of 2"));
2107 ignore_rest_of_line ();
2114 record_alignment (bss_section
, align2
);
2115 subseg_set (bss_section
, 0);
2117 frag_align (align2
, 0, 0);
2118 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2119 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2120 symbol_set_frag (symbolP
, frag_now
);
2121 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2124 S_SET_SIZE (symbolP
, size
);
2125 S_SET_SEGMENT (symbolP
, bss_section
);
2126 subseg_set (old_sec
, old_subsec
);
2127 demand_empty_rest_of_line ();
2130 /* Validate any relocations emitted for -mrelocatable, possibly adding
2131 fixups for word relocations in writable segments, so we can adjust
2134 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2136 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2145 case SHLIB_MRELOCATABLE
:
2146 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2147 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2148 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2149 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2150 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2151 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2152 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2153 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2154 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2155 && (seg
->flags
& SEC_LOAD
) != 0
2156 && strcmp (segment_name (seg
), ".got2") != 0
2157 && strcmp (segment_name (seg
), ".dtors") != 0
2158 && strcmp (segment_name (seg
), ".ctors") != 0
2159 && strcmp (segment_name (seg
), ".fixup") != 0
2160 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2161 && strcmp (segment_name (seg
), ".eh_frame") != 0
2162 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2164 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2165 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2167 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2168 _("Relocation cannot be done when using -mrelocatable"));
2175 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2176 function descriptor sym if the corresponding code sym is used. */
2179 ppc_frob_file_before_adjust (void)
2187 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2194 name
= S_GET_NAME (symp
);
2198 if (! S_IS_WEAK (symp
)
2199 || S_IS_DEFINED (symp
))
2202 len
= strlen (name
) + 1;
2203 dotname
= xmalloc (len
+ 1);
2205 memcpy (dotname
+ 1, name
, len
);
2206 dotsym
= symbol_find_noref (dotname
, 1);
2208 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2209 || symbol_used_in_reloc_p (dotsym
)))
2210 symbol_mark_used (symp
);
2214 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2216 && toc_reloc_types
!= has_large_toc_reloc
2217 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2218 as_warn (_("TOC section size exceeds 64k"));
2220 /* Don't emit .TOC. symbol. */
2221 symp
= symbol_find (".TOC.");
2223 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2225 #endif /* OBJ_ELF */
2230 * Summary of parse_toc_entry.
2232 * in: Input_line_pointer points to the '[' in one of:
2234 * [toc] [tocv] [toc32] [toc64]
2236 * Anything else is an error of one kind or another.
2239 * return value: success or failure
2240 * toc_kind: kind of toc reference
2241 * input_line_pointer:
2242 * success: first char after the ']'
2243 * failure: unchanged
2247 * [toc] - rv == success, toc_kind = default_toc
2248 * [tocv] - rv == success, toc_kind = data_in_toc
2249 * [toc32] - rv == success, toc_kind = must_be_32
2250 * [toc64] - rv == success, toc_kind = must_be_64
2254 enum toc_size_qualifier
2256 default_toc
, /* The toc cell constructed should be the system default size */
2257 data_in_toc
, /* This is a direct reference to a toc cell */
2258 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2259 must_be_64
/* The toc cell constructed must be 64 bits wide */
2263 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2268 enum toc_size_qualifier t
;
2270 /* Save the input_line_pointer. */
2271 start
= input_line_pointer
;
2273 /* Skip over the '[' , and whitespace. */
2274 ++input_line_pointer
;
2277 /* Find the spelling of the operand. */
2278 toc_spec
= input_line_pointer
;
2279 c
= get_symbol_end ();
2281 if (strcmp (toc_spec
, "toc") == 0)
2285 else if (strcmp (toc_spec
, "tocv") == 0)
2289 else if (strcmp (toc_spec
, "toc32") == 0)
2293 else if (strcmp (toc_spec
, "toc64") == 0)
2299 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2300 *input_line_pointer
= c
;
2301 input_line_pointer
= start
;
2305 /* Now find the ']'. */
2306 *input_line_pointer
= c
;
2308 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2309 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2313 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2314 input_line_pointer
= start
;
2325 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2327 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2331 /* Check we don't already exist. */
2332 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2333 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2336 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2338 if (ppc_apuinfo_num_alloc
== 0)
2340 ppc_apuinfo_num_alloc
= 4;
2341 ppc_apuinfo_list
= (unsigned long *)
2342 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2346 ppc_apuinfo_num_alloc
+= 4;
2347 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2348 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2351 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2357 /* We need to keep a list of fixups. We can't simply generate them as
2358 we go, because that would require us to first create the frag, and
2359 that would screw up references to ``.''. */
2365 bfd_reloc_code_real_type reloc
;
2368 #define MAX_INSN_FIXUPS (5)
2370 /* This routine is called for each instruction to be assembled. */
2373 md_assemble (char *str
)
2376 const struct powerpc_opcode
*opcode
;
2378 const unsigned char *opindex_ptr
;
2382 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2388 bfd_reloc_code_real_type reloc
;
2391 /* Get the opcode. */
2392 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2397 /* Look up the opcode in the hash table. */
2398 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2399 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2401 const struct powerpc_macro
*macro
;
2403 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2404 if (macro
== (const struct powerpc_macro
*) NULL
)
2405 as_bad (_("Unrecognized opcode: `%s'"), str
);
2407 ppc_macro (s
, macro
);
2412 insn
= opcode
->opcode
;
2415 while (ISSPACE (*str
))
2418 /* PowerPC operands are just expressions. The only real issue is
2419 that a few operand types are optional. All cases which might use
2420 an optional operand separate the operands only with commas (in some
2421 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2422 have optional operands). Most instructions with optional operands
2423 have only one. Those that have more than one optional operand can
2424 take either all their operands or none. So, before we start seriously
2425 parsing the operands, we check to see if we have optional operands,
2426 and if we do, we count the number of commas to see which operands
2427 have been omitted. */
2429 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2431 const struct powerpc_operand
*operand
;
2433 operand
= &powerpc_operands
[*opindex_ptr
];
2434 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2436 unsigned int opcount
;
2437 unsigned int num_operands_expected
;
2439 /* There is an optional operand. Count the number of
2440 commas in the input line. */
2447 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2454 /* Compute the number of expected operands.
2455 Do not count fake operands. */
2456 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2457 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2458 ++ num_operands_expected
;
2460 /* If there are fewer operands in the line then are called
2461 for by the instruction, we want to skip the optional
2463 if (opcount
< num_operands_expected
)
2470 /* Gather the operands. */
2474 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2476 const struct powerpc_operand
*operand
;
2482 if (next_opindex
== 0)
2483 operand
= &powerpc_operands
[*opindex_ptr
];
2486 operand
= &powerpc_operands
[next_opindex
];
2491 /* If this is a fake operand, then we do not expect anything
2493 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2495 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2496 if (errmsg
!= (const char *) NULL
)
2497 as_bad ("%s", errmsg
);
2501 /* If this is an optional operand, and we are skipping it, just
2503 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2506 if (operand
->insert
)
2508 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2509 if (errmsg
!= (const char *) NULL
)
2510 as_bad ("%s", errmsg
);
2512 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2513 next_opindex
= *opindex_ptr
+ 1;
2517 /* Gather the operand. */
2518 hold
= input_line_pointer
;
2519 input_line_pointer
= str
;
2522 if (*input_line_pointer
== '[')
2524 /* We are expecting something like the second argument here:
2526 * lwz r4,[toc].GS.0.static_int(rtoc)
2527 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2528 * The argument following the `]' must be a symbol name, and the
2529 * register must be the toc register: 'rtoc' or '2'
2531 * The effect is to 0 as the displacement field
2532 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2533 * the appropriate variation) reloc against it based on the symbol.
2534 * The linker will build the toc, and insert the resolved toc offset.
2537 * o The size of the toc entry is currently assumed to be
2538 * 32 bits. This should not be assumed to be a hard coded
2540 * o In an effort to cope with a change from 32 to 64 bits,
2541 * there are also toc entries that are specified to be
2542 * either 32 or 64 bits:
2543 * lwz r4,[toc32].GS.0.static_int(rtoc)
2544 * lwz r4,[toc64].GS.0.static_int(rtoc)
2545 * These demand toc entries of the specified size, and the
2546 * instruction probably requires it.
2550 enum toc_size_qualifier toc_kind
;
2551 bfd_reloc_code_real_type toc_reloc
;
2553 /* Go parse off the [tocXX] part. */
2554 valid_toc
= parse_toc_entry (&toc_kind
);
2558 /* Note: message has already been issued.
2559 FIXME: what sort of recovery should we do?
2560 demand_rest_of_line (); return; ? */
2563 /* Now get the symbol following the ']'. */
2569 /* In this case, we may not have seen the symbol yet,
2570 since it is allowed to appear on a .extern or .globl
2571 or just be a label in the .data section. */
2572 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2575 /* 1. The symbol must be defined and either in the toc
2576 section, or a global.
2577 2. The reloc generated must have the TOCDEFN flag set
2578 in upper bit mess of the reloc type.
2579 FIXME: It's a little confusing what the tocv
2580 qualifier can be used for. At the very least, I've
2581 seen three uses, only one of which I'm sure I can
2583 if (ex
.X_op
== O_symbol
)
2585 gas_assert (ex
.X_add_symbol
!= NULL
);
2586 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2589 as_bad (_("[tocv] symbol is not a toc symbol"));
2593 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2596 /* FIXME: these next two specifically specify 32/64 bit
2597 toc entries. We don't support them today. Is this
2598 the right way to say that? */
2599 toc_reloc
= BFD_RELOC_UNUSED
;
2600 as_bad (_("Unimplemented toc32 expression modifier"));
2603 /* FIXME: see above. */
2604 toc_reloc
= BFD_RELOC_UNUSED
;
2605 as_bad (_("Unimplemented toc64 expression modifier"));
2609 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2615 /* We need to generate a fixup for this expression. */
2616 if (fc
>= MAX_INSN_FIXUPS
)
2617 as_fatal (_("too many fixups"));
2619 fixups
[fc
].reloc
= toc_reloc
;
2620 fixups
[fc
].exp
= ex
;
2621 fixups
[fc
].opindex
= *opindex_ptr
;
2624 /* Ok. We've set up the fixup for the instruction. Now make it
2625 look like the constant 0 was found here. */
2627 ex
.X_op
= O_constant
;
2628 ex
.X_add_number
= 0;
2629 ex
.X_add_symbol
= NULL
;
2630 ex
.X_op_symbol
= NULL
;
2636 if ((reg_names_p
&& (operand
->flags
& PPC_OPERAND_CR
) != 0)
2637 || !register_name (&ex
))
2639 char save_lex
= lex_type
['%'];
2641 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2644 lex_type
['%'] |= LEX_BEGIN_NAME
;
2648 lex_type
['%'] = save_lex
;
2652 str
= input_line_pointer
;
2653 input_line_pointer
= hold
;
2655 if (ex
.X_op
== O_illegal
)
2656 as_bad (_("illegal operand"));
2657 else if (ex
.X_op
== O_absent
)
2658 as_bad (_("missing operand"));
2659 else if (ex
.X_op
== O_register
)
2661 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2662 ppc_cpu
, (char *) NULL
, 0);
2664 else if (ex
.X_op
== O_constant
)
2667 /* Allow @HA, @L, @H on constants. */
2668 char *orig_str
= str
;
2670 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2677 case BFD_RELOC_LO16
:
2678 /* X_unsigned is the default, so if the user has done
2679 something which cleared it, we always produce a
2681 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2682 ex
.X_add_number
&= 0xffff;
2684 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2687 case BFD_RELOC_HI16
:
2688 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2689 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2691 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2694 case BFD_RELOC_HI16_S
:
2695 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2696 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2698 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2701 case BFD_RELOC_PPC64_HIGHER
:
2702 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2703 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2705 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2708 case BFD_RELOC_PPC64_HIGHER_S
:
2709 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2710 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2712 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2715 case BFD_RELOC_PPC64_HIGHEST
:
2716 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2717 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2719 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2722 case BFD_RELOC_PPC64_HIGHEST_S
:
2723 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2724 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2726 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2729 #endif /* OBJ_ELF */
2730 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2731 ppc_cpu
, (char *) NULL
, 0);
2736 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2738 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2739 if (sym_name
[0] == '.')
2742 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2744 expressionS tls_exp
;
2746 hold
= input_line_pointer
;
2747 input_line_pointer
= str
+ 1;
2748 expression (&tls_exp
);
2749 if (tls_exp
.X_op
== O_symbol
)
2751 reloc
= BFD_RELOC_UNUSED
;
2752 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2754 reloc
= BFD_RELOC_PPC_TLSGD
;
2755 input_line_pointer
+= 7;
2757 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2759 reloc
= BFD_RELOC_PPC_TLSLD
;
2760 input_line_pointer
+= 7;
2762 if (reloc
!= BFD_RELOC_UNUSED
)
2765 str
= input_line_pointer
;
2767 if (fc
>= MAX_INSN_FIXUPS
)
2768 as_fatal (_("too many fixups"));
2769 fixups
[fc
].exp
= tls_exp
;
2770 fixups
[fc
].opindex
= *opindex_ptr
;
2771 fixups
[fc
].reloc
= reloc
;
2775 input_line_pointer
= hold
;
2779 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2781 /* Some TLS tweaks. */
2787 case BFD_RELOC_PPC_TLS
:
2788 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2789 as_bad (_("@tls may not be used with \"%s\" operands"),
2791 else if (operand
->shift
!= 11)
2792 as_bad (_("@tls may only be used in last operand"));
2794 insn
= ppc_insert_operand (insn
, operand
,
2796 ppc_cpu
, (char *) NULL
, 0);
2799 /* We'll only use the 32 (or 64) bit form of these relocations
2800 in constants. Instructions get the 16 bit form. */
2801 case BFD_RELOC_PPC_DTPREL
:
2802 reloc
= BFD_RELOC_PPC_DTPREL16
;
2804 case BFD_RELOC_PPC_TPREL
:
2805 reloc
= BFD_RELOC_PPC_TPREL16
;
2809 /* For the absolute forms of branches, convert the PC
2810 relative form back into the absolute. */
2811 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2815 case BFD_RELOC_PPC_B26
:
2816 reloc
= BFD_RELOC_PPC_BA26
;
2818 case BFD_RELOC_PPC_B16
:
2819 reloc
= BFD_RELOC_PPC_BA16
;
2821 case BFD_RELOC_PPC_B16_BRTAKEN
:
2822 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2824 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2825 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2834 case BFD_RELOC_PPC_TOC16
:
2835 toc_reloc_types
|= has_small_toc_reloc
;
2837 case BFD_RELOC_PPC64_TOC16_LO
:
2838 case BFD_RELOC_PPC64_TOC16_HI
:
2839 case BFD_RELOC_PPC64_TOC16_HA
:
2840 toc_reloc_types
|= has_large_toc_reloc
;
2847 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
2852 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2854 case BFD_RELOC_LO16
:
2855 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2857 case BFD_RELOC_16_GOTOFF
:
2858 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2860 case BFD_RELOC_LO16_GOTOFF
:
2861 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2863 case BFD_RELOC_LO16_PLTOFF
:
2864 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2866 case BFD_RELOC_16_BASEREL
:
2867 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2869 case BFD_RELOC_LO16_BASEREL
:
2870 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2872 case BFD_RELOC_PPC_TOC16
:
2873 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2875 case BFD_RELOC_PPC64_TOC16_LO
:
2876 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2878 case BFD_RELOC_PPC64_PLTGOT16
:
2879 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2881 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2882 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2884 case BFD_RELOC_PPC_DTPREL16
:
2885 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2887 case BFD_RELOC_PPC_DTPREL16_LO
:
2888 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2890 case BFD_RELOC_PPC_TPREL16
:
2891 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2893 case BFD_RELOC_PPC_TPREL16_LO
:
2894 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2896 case BFD_RELOC_PPC_GOT_DTPREL16
:
2897 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2898 case BFD_RELOC_PPC_GOT_TPREL16
:
2899 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2902 as_bad (_("unsupported relocation for DS offset field"));
2908 /* We need to generate a fixup for this expression. */
2909 if (fc
>= MAX_INSN_FIXUPS
)
2910 as_fatal (_("too many fixups"));
2911 fixups
[fc
].exp
= ex
;
2912 fixups
[fc
].opindex
= *opindex_ptr
;
2913 fixups
[fc
].reloc
= reloc
;
2919 /* We need to generate a fixup for this expression. */
2920 if (fc
>= MAX_INSN_FIXUPS
)
2921 as_fatal (_("too many fixups"));
2922 fixups
[fc
].exp
= ex
;
2923 fixups
[fc
].opindex
= *opindex_ptr
;
2924 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2927 #endif /* OBJ_ELF */
2933 /* If expecting more operands, then we want to see "),". */
2934 if (*str
== endc
&& opindex_ptr
[1] != 0)
2938 while (ISSPACE (*str
));
2942 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2950 /* The call to expression should have advanced str past any
2953 && (endc
!= ',' || *str
!= '\0'))
2956 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
2958 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
2966 while (ISSPACE (*str
))
2970 as_bad (_("junk at end of line: `%s'"), str
);
2973 /* Do we need/want a APUinfo section? */
2974 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
)) != 0)
2976 /* These are all version "1". */
2977 if (opcode
->flags
& PPC_OPCODE_SPE
)
2978 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2979 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2980 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2981 if (opcode
->flags
& PPC_OPCODE_EFS
)
2982 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2983 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2984 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2985 if (opcode
->flags
& PPC_OPCODE_PMR
)
2986 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2987 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2988 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2989 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2990 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2994 /* Write out the instruction. */
2996 addr_mod
= frag_now_fix () & 3;
2997 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
2998 as_bad (_("instruction address is not a multiple of 4"));
2999 frag_now
->insn_addr
= addr_mod
;
3000 frag_now
->has_code
= 1;
3001 md_number_to_chars (f
, insn
, 4);
3004 dwarf2_emit_insn (4);
3007 /* Create any fixups. At this point we do not use a
3008 bfd_reloc_code_real_type, but instead just use the
3009 BFD_RELOC_UNUSED plus the operand index. This lets us easily
3010 handle fixups for any operand type, although that is admittedly
3011 not a very exciting feature. We pick a BFD reloc type in
3013 for (i
= 0; i
< fc
; i
++)
3015 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3017 reloc_howto_type
*reloc_howto
;
3022 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3026 size
= bfd_get_reloc_size (reloc_howto
);
3027 offset
= target_big_endian
? (4 - size
) : 0;
3029 if (size
< 1 || size
> 4)
3032 fixP
= fix_new_exp (frag_now
,
3033 f
- frag_now
->fr_literal
+ offset
,
3036 reloc_howto
->pc_relative
,
3039 /* Turn off complaints that the addend is too large for things like
3041 switch (fixups
[i
].reloc
)
3043 case BFD_RELOC_16_GOTOFF
:
3044 case BFD_RELOC_PPC_TOC16
:
3045 case BFD_RELOC_LO16
:
3046 case BFD_RELOC_HI16
:
3047 case BFD_RELOC_HI16_S
:
3049 case BFD_RELOC_PPC64_HIGHER
:
3050 case BFD_RELOC_PPC64_HIGHER_S
:
3051 case BFD_RELOC_PPC64_HIGHEST
:
3052 case BFD_RELOC_PPC64_HIGHEST_S
:
3054 fixP
->fx_no_overflow
= 1;
3062 const struct powerpc_operand
*operand
;
3064 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3065 fix_new_exp (frag_now
,
3066 f
- frag_now
->fr_literal
,
3069 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3070 ((bfd_reloc_code_real_type
)
3071 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
3076 /* Handle a macro. Gather all the operands, transform them as
3077 described by the macro, and call md_assemble recursively. All the
3078 operands are separated by commas; we don't accept parentheses
3079 around operands here. */
3082 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3093 /* Gather the users operands into the operands array. */
3098 if (count
>= sizeof operands
/ sizeof operands
[0])
3100 operands
[count
++] = s
;
3101 s
= strchr (s
, ',');
3102 if (s
== (char *) NULL
)
3107 if (count
!= macro
->operands
)
3109 as_bad (_("wrong number of operands"));
3113 /* Work out how large the string must be (the size is unbounded
3114 because it includes user input). */
3116 format
= macro
->format
;
3117 while (*format
!= '\0')
3126 arg
= strtol (format
+ 1, &send
, 10);
3127 know (send
!= format
&& arg
< count
);
3128 len
+= strlen (operands
[arg
]);
3133 /* Put the string together. */
3134 complete
= s
= (char *) alloca (len
+ 1);
3135 format
= macro
->format
;
3136 while (*format
!= '\0')
3142 arg
= strtol (format
+ 1, &send
, 10);
3143 strcpy (s
, operands
[arg
]);
3150 /* Assemble the constructed instruction. */
3151 md_assemble (complete
);
3155 /* For ELF, add support for SHT_ORDERED. */
3158 ppc_section_type (char *str
, size_t len
)
3160 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3167 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3169 if (type
== SHT_ORDERED
)
3170 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3174 #endif /* OBJ_ELF */
3177 /* Pseudo-op handling. */
3179 /* The .byte pseudo-op. This is similar to the normal .byte
3180 pseudo-op, but it can also take a single ASCII string. */
3183 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3185 if (*input_line_pointer
!= '\"')
3191 /* Gather characters. A real double quote is doubled. Unusual
3192 characters are not permitted. */
3193 ++input_line_pointer
;
3198 c
= *input_line_pointer
++;
3202 if (*input_line_pointer
!= '\"')
3204 ++input_line_pointer
;
3207 FRAG_APPEND_1_CHAR (c
);
3210 demand_empty_rest_of_line ();
3215 /* XCOFF specific pseudo-op handling. */
3217 /* This is set if we are creating a .stabx symbol, since we don't want
3218 to handle symbol suffixes for such symbols. */
3219 static bfd_boolean ppc_stab_symbol
;
3221 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3222 symbols in the .bss segment as though they were local common
3223 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3224 aligns .comm and .lcomm to 4 bytes. */
3227 ppc_comm (int lcomm
)
3229 asection
*current_seg
= now_seg
;
3230 subsegT current_subseg
= now_subseg
;
3236 symbolS
*lcomm_sym
= NULL
;
3240 name
= input_line_pointer
;
3241 endc
= get_symbol_end ();
3242 end_name
= input_line_pointer
;
3245 if (*input_line_pointer
!= ',')
3247 as_bad (_("missing size"));
3248 ignore_rest_of_line ();
3251 ++input_line_pointer
;
3253 size
= get_absolute_expression ();
3256 as_bad (_("negative size"));
3257 ignore_rest_of_line ();
3263 /* The third argument to .comm is the alignment. */
3264 if (*input_line_pointer
!= ',')
3268 ++input_line_pointer
;
3269 align
= get_absolute_expression ();
3272 as_warn (_("ignoring bad alignment"));
3287 /* The third argument to .lcomm appears to be the real local
3288 common symbol to create. References to the symbol named in
3289 the first argument are turned into references to the third
3291 if (*input_line_pointer
!= ',')
3293 as_bad (_("missing real symbol name"));
3294 ignore_rest_of_line ();
3297 ++input_line_pointer
;
3299 lcomm_name
= input_line_pointer
;
3300 lcomm_endc
= get_symbol_end ();
3302 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3304 *input_line_pointer
= lcomm_endc
;
3308 sym
= symbol_find_or_make (name
);
3311 if (S_IS_DEFINED (sym
)
3312 || S_GET_VALUE (sym
) != 0)
3314 as_bad (_("attempt to redefine symbol"));
3315 ignore_rest_of_line ();
3319 record_alignment (bss_section
, align
);
3322 || ! S_IS_DEFINED (lcomm_sym
))
3331 S_SET_EXTERNAL (sym
);
3335 symbol_get_tc (lcomm_sym
)->output
= 1;
3336 def_sym
= lcomm_sym
;
3340 subseg_set (bss_section
, 1);
3341 frag_align (align
, 0, 0);
3343 symbol_set_frag (def_sym
, frag_now
);
3344 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3345 def_size
, (char *) NULL
);
3347 S_SET_SEGMENT (def_sym
, bss_section
);
3348 symbol_get_tc (def_sym
)->align
= align
;
3352 /* Align the size of lcomm_sym. */
3353 symbol_get_frag (lcomm_sym
)->fr_offset
=
3354 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3355 &~ ((1 << align
) - 1));
3356 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3357 symbol_get_tc (lcomm_sym
)->align
= align
;
3362 /* Make sym an offset from lcomm_sym. */
3363 S_SET_SEGMENT (sym
, bss_section
);
3364 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3365 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3366 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3369 subseg_set (current_seg
, current_subseg
);
3371 demand_empty_rest_of_line ();
3374 /* The .csect pseudo-op. This switches us into a different
3375 subsegment. The first argument is a symbol whose value is the
3376 start of the .csect. In COFF, csect symbols get special aux
3377 entries defined by the x_csect field of union internal_auxent. The
3378 optional second argument is the alignment (the default is 2). */
3381 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3388 name
= input_line_pointer
;
3389 endc
= get_symbol_end ();
3391 sym
= symbol_find_or_make (name
);
3393 *input_line_pointer
= endc
;
3395 if (S_GET_NAME (sym
)[0] == '\0')
3397 /* An unnamed csect is assumed to be [PR]. */
3398 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3402 if (*input_line_pointer
== ',')
3404 ++input_line_pointer
;
3405 align
= get_absolute_expression ();
3408 ppc_change_csect (sym
, align
);
3410 demand_empty_rest_of_line ();
3413 /* Change to a different csect. */
3416 ppc_change_csect (symbolS
*sym
, offsetT align
)
3418 if (S_IS_DEFINED (sym
))
3419 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3429 /* This is a new csect. We need to look at the symbol class to
3430 figure out whether it should go in the text section or the
3434 switch (symbol_get_tc (sym
)->symbol_class
)
3444 S_SET_SEGMENT (sym
, text_section
);
3445 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3446 ++ppc_text_subsegment
;
3447 list_ptr
= &ppc_text_csects
;
3457 if (ppc_toc_csect
!= NULL
3458 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3459 == ppc_data_subsegment
))
3461 S_SET_SEGMENT (sym
, data_section
);
3462 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3463 ++ppc_data_subsegment
;
3464 list_ptr
= &ppc_data_csects
;
3470 /* We set the obstack chunk size to a small value before
3471 changing subsegments, so that we don't use a lot of memory
3472 space for what may be a small section. */
3473 hold_chunksize
= chunksize
;
3476 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3477 symbol_get_tc (sym
)->subseg
);
3479 chunksize
= hold_chunksize
;
3482 ppc_after_toc_frag
= frag_now
;
3484 record_alignment (sec
, align
);
3486 frag_align_code (align
, 0);
3488 frag_align (align
, 0, 0);
3490 symbol_set_frag (sym
, frag_now
);
3491 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3493 symbol_get_tc (sym
)->align
= align
;
3494 symbol_get_tc (sym
)->output
= 1;
3495 symbol_get_tc (sym
)->within
= sym
;
3497 for (list
= *list_ptr
;
3498 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3499 list
= symbol_get_tc (list
)->next
)
3501 symbol_get_tc (list
)->next
= sym
;
3503 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3504 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3508 ppc_current_csect
= sym
;
3512 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3516 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3518 sec
= subseg_new (dw
->name
, subseg
);
3519 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3520 if (oldflags
== SEC_NO_FLAGS
)
3522 /* Just created section. */
3523 gas_assert (dw_sections
[idx
].sect
== NULL
);
3525 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3526 bfd_set_section_alignment (stdoutput
, sec
, 0);
3527 dw_sections
[idx
].sect
= sec
;
3530 /* Not anymore in a csect. */
3531 ppc_current_csect
= NULL
;
3534 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3535 .dwsect flag [, opt-label ]
3539 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3543 const struct xcoff_dwsect_name
*dw
;
3544 struct dw_subsection
*subseg
;
3545 struct dw_section
*dws
;
3549 flag
= get_absolute_expression ();
3551 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3552 if (xcoff_dwsect_names
[i
].flag
== flag
)
3554 dw
= &xcoff_dwsect_names
[i
];
3558 /* Parse opt-label. */
3559 if (*input_line_pointer
== ',')
3564 ++input_line_pointer
;
3566 label
= input_line_pointer
;
3567 c
= get_symbol_end ();
3568 opt_label
= symbol_find_or_make (label
);
3569 *input_line_pointer
= c
;
3574 demand_empty_rest_of_line ();
3576 /* Return now in case of unknown subsection. */
3579 as_bad (_("No known dwarf XCOFF section for flag 0x%08x\n"),
3584 /* Find the subsection. */
3585 dws
= &dw_sections
[i
];
3587 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3589 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3590 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3592 as_bad (_("label %s was not defined in this dwarf section"),
3593 S_GET_NAME (opt_label
));
3594 subseg
= dws
->anon_subseg
;
3598 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3603 /* Switch to the subsection. */
3604 ppc_change_debug_section (i
, subseg
->subseg
);
3608 /* Create a new dw subsection. */
3609 subseg
= (struct dw_subsection
*)
3610 xmalloc (sizeof (struct dw_subsection
));
3612 if (opt_label
== NULL
)
3614 /* The anonymous one. */
3616 subseg
->link
= NULL
;
3617 dws
->anon_subseg
= subseg
;
3622 if (dws
->list_subseg
!= NULL
)
3623 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3627 subseg
->link
= dws
->list_subseg
;
3628 dws
->list_subseg
= subseg
;
3629 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3632 ppc_change_debug_section (i
, subseg
->subseg
);
3636 /* Add the length field. */
3637 expressionS
*exp
= &subseg
->end_exp
;
3640 if (opt_label
!= NULL
)
3641 symbol_set_value_now (opt_label
);
3643 /* Add the length field. Note that according to the AIX assembler
3644 manual, the size of the length field is 4 for powerpc32 but
3645 12 for powerpc64. */
3648 /* Write the 64bit marker. */
3649 md_number_to_chars (frag_more (4), -1, 4);
3652 exp
->X_op
= O_subtract
;
3653 exp
->X_op_symbol
= symbol_temp_new_now ();
3654 exp
->X_add_symbol
= symbol_temp_make ();
3656 sz
= ppc_obj64
? 8 : 4;
3657 exp
->X_add_number
= -sz
;
3658 emit_expr (exp
, sz
);
3663 /* This function handles the .text and .data pseudo-ops. These
3664 pseudo-ops aren't really used by XCOFF; we implement them for the
3665 convenience of people who aren't used to XCOFF. */
3668 ppc_section (int type
)
3675 else if (type
== 'd')
3680 sym
= symbol_find_or_make (name
);
3682 ppc_change_csect (sym
, 2);
3684 demand_empty_rest_of_line ();
3687 /* This function handles the .section pseudo-op. This is mostly to
3688 give an error, since XCOFF only supports .text, .data and .bss, but
3689 we do permit the user to name the text or data section. */
3692 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3695 const char *real_name
;
3699 user_name
= input_line_pointer
;
3700 c
= get_symbol_end ();
3702 if (strcmp (user_name
, ".text") == 0)
3703 real_name
= ".text[PR]";
3704 else if (strcmp (user_name
, ".data") == 0)
3705 real_name
= ".data[RW]";
3708 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3709 *input_line_pointer
= c
;
3710 ignore_rest_of_line ();
3714 *input_line_pointer
= c
;
3716 sym
= symbol_find_or_make (real_name
);
3718 ppc_change_csect (sym
, 2);
3720 demand_empty_rest_of_line ();
3723 /* The .extern pseudo-op. We create an undefined symbol. */
3726 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
3731 name
= input_line_pointer
;
3732 endc
= get_symbol_end ();
3734 (void) symbol_find_or_make (name
);
3736 *input_line_pointer
= endc
;
3738 demand_empty_rest_of_line ();
3741 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3744 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
3750 name
= input_line_pointer
;
3751 endc
= get_symbol_end ();
3753 sym
= symbol_find_or_make (name
);
3755 *input_line_pointer
= endc
;
3757 symbol_get_tc (sym
)->output
= 1;
3759 demand_empty_rest_of_line ();
3762 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
3763 relocations at the beginning of the current csect.
3765 (In principle, there's no reason why the relocations _have_ to be at
3766 the beginning. Anywhere in the csect would do. However, inserting
3767 at the beginning is what the native assmebler does, and it helps to
3768 deal with cases where the .ref statements follow the section contents.)
3770 ??? .refs don't work for empty .csects. However, the native assembler
3771 doesn't report an error in this case, and neither yet do we. */
3774 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
3779 if (ppc_current_csect
== NULL
)
3781 as_bad (_(".ref outside .csect"));
3782 ignore_rest_of_line ();
3788 name
= input_line_pointer
;
3789 c
= get_symbol_end ();
3791 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
3792 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
3794 *input_line_pointer
= c
;
3796 c
= *input_line_pointer
;
3799 input_line_pointer
++;
3801 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3803 as_bad (_("missing symbol name"));
3804 ignore_rest_of_line ();
3811 demand_empty_rest_of_line ();
3814 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3815 although I don't know why it bothers. */
3818 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
3825 name
= input_line_pointer
;
3826 endc
= get_symbol_end ();
3828 sym
= symbol_find_or_make (name
);
3830 *input_line_pointer
= endc
;
3832 if (*input_line_pointer
!= ',')
3834 as_bad (_("missing rename string"));
3835 ignore_rest_of_line ();
3838 ++input_line_pointer
;
3840 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3842 demand_empty_rest_of_line ();
3845 /* The .stabx pseudo-op. This is similar to a normal .stabs
3846 pseudo-op, but slightly different. A sample is
3847 .stabx "main:F-1",.main,142,0
3848 The first argument is the symbol name to create. The second is the
3849 value, and the third is the storage class. The fourth seems to be
3850 always zero, and I am assuming it is the type. */
3853 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
3860 name
= demand_copy_C_string (&len
);
3862 if (*input_line_pointer
!= ',')
3864 as_bad (_("missing value"));
3867 ++input_line_pointer
;
3869 ppc_stab_symbol
= TRUE
;
3870 sym
= symbol_make (name
);
3871 ppc_stab_symbol
= FALSE
;
3873 symbol_get_tc (sym
)->real_name
= name
;
3875 (void) expression (&exp
);
3882 as_bad (_("illegal .stabx expression; zero assumed"));
3883 exp
.X_add_number
= 0;
3886 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3887 symbol_set_frag (sym
, &zero_address_frag
);
3891 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3892 symbol_set_value_expression (sym
, &exp
);
3896 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3897 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3902 /* The value is some complex expression. This will probably
3903 fail at some later point, but this is probably the right
3904 thing to do here. */
3905 symbol_set_value_expression (sym
, &exp
);
3909 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3910 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3912 if (*input_line_pointer
!= ',')
3914 as_bad (_("missing class"));
3917 ++input_line_pointer
;
3919 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3921 if (*input_line_pointer
!= ',')
3923 as_bad (_("missing type"));
3926 ++input_line_pointer
;
3928 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3930 symbol_get_tc (sym
)->output
= 1;
3932 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
3937 .stabx "z",arrays_,133,0
3940 .comm arrays_,13768,3
3942 resolve_symbol_value will copy the exp's "within" into sym's when the
3943 offset is 0. Since this seems to be corner case problem,
3944 only do the correction for storage class C_STSYM. A better solution
3945 would be to have the tc field updated in ppc_symbol_new_hook. */
3947 if (exp
.X_op
== O_symbol
)
3949 if (ppc_current_block
== NULL
)
3950 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
3952 symbol_get_tc (sym
)->within
= ppc_current_block
;
3953 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3957 if (exp
.X_op
!= O_symbol
3958 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3959 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3960 ppc_frob_label (sym
);
3963 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3964 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3965 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3966 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3969 demand_empty_rest_of_line ();
3972 /* The .function pseudo-op. This takes several arguments. The first
3973 argument seems to be the external name of the symbol. The second
3974 argument seems to be the label for the start of the function. gcc
3975 uses the same name for both. I have no idea what the third and
3976 fourth arguments are meant to be. The optional fifth argument is
3977 an expression for the size of the function. In COFF this symbol
3978 gets an aux entry like that used for a csect. */
3981 ppc_function (int ignore ATTRIBUTE_UNUSED
)
3989 name
= input_line_pointer
;
3990 endc
= get_symbol_end ();
3992 /* Ignore any [PR] suffix. */
3993 name
= ppc_canonicalize_symbol_name (name
);
3994 s
= strchr (name
, '[');
3995 if (s
!= (char *) NULL
3996 && strcmp (s
+ 1, "PR]") == 0)
3999 ext_sym
= symbol_find_or_make (name
);
4001 *input_line_pointer
= endc
;
4003 if (*input_line_pointer
!= ',')
4005 as_bad (_("missing symbol name"));
4006 ignore_rest_of_line ();
4009 ++input_line_pointer
;
4011 name
= input_line_pointer
;
4012 endc
= get_symbol_end ();
4014 lab_sym
= symbol_find_or_make (name
);
4016 *input_line_pointer
= endc
;
4018 if (ext_sym
!= lab_sym
)
4022 exp
.X_op
= O_symbol
;
4023 exp
.X_add_symbol
= lab_sym
;
4024 exp
.X_op_symbol
= NULL
;
4025 exp
.X_add_number
= 0;
4027 symbol_set_value_expression (ext_sym
, &exp
);
4030 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4031 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4032 symbol_get_tc (ext_sym
)->output
= 1;
4034 if (*input_line_pointer
== ',')
4038 /* Ignore the third argument. */
4039 ++input_line_pointer
;
4041 if (*input_line_pointer
== ',')
4043 /* Ignore the fourth argument. */
4044 ++input_line_pointer
;
4046 if (*input_line_pointer
== ',')
4048 /* The fifth argument is the function size. */
4049 ++input_line_pointer
;
4050 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4051 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4052 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4057 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4058 SF_SET_FUNCTION (ext_sym
);
4059 SF_SET_PROCESS (ext_sym
);
4060 coff_add_linesym (ext_sym
);
4062 demand_empty_rest_of_line ();
4065 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4066 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4067 with the correct line number */
4069 static symbolS
*saved_bi_sym
= 0;
4072 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4076 sym
= symbol_make (".bf");
4077 S_SET_SEGMENT (sym
, text_section
);
4078 symbol_set_frag (sym
, frag_now
);
4079 S_SET_VALUE (sym
, frag_now_fix ());
4080 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4082 coff_line_base
= get_absolute_expression ();
4084 S_SET_NUMBER_AUXILIARY (sym
, 1);
4085 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4087 /* Line number for bi. */
4090 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4095 symbol_get_tc (sym
)->output
= 1;
4097 ppc_frob_label (sym
);
4099 demand_empty_rest_of_line ();
4102 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4103 ".ef", except that the line number is absolute, not relative to the
4104 most recent ".bf" symbol. */
4107 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4111 sym
= symbol_make (".ef");
4112 S_SET_SEGMENT (sym
, text_section
);
4113 symbol_set_frag (sym
, frag_now
);
4114 S_SET_VALUE (sym
, frag_now_fix ());
4115 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4116 S_SET_NUMBER_AUXILIARY (sym
, 1);
4117 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4118 symbol_get_tc (sym
)->output
= 1;
4120 ppc_frob_label (sym
);
4122 demand_empty_rest_of_line ();
4125 /* The .bi and .ei pseudo-ops. These take a string argument and
4126 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4127 the symbol list. The value of .bi will be know when the next .bf
4133 static symbolS
*last_biei
;
4140 name
= demand_copy_C_string (&len
);
4142 /* The value of these symbols is actually file offset. Here we set
4143 the value to the index into the line number entries. In
4144 ppc_frob_symbols we set the fix_line field, which will cause BFD
4145 to do the right thing. */
4147 sym
= symbol_make (name
);
4148 /* obj-coff.c currently only handles line numbers correctly in the
4150 S_SET_SEGMENT (sym
, text_section
);
4151 S_SET_VALUE (sym
, coff_n_line_nos
);
4152 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4154 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4155 symbol_get_tc (sym
)->output
= 1;
4163 for (look
= last_biei
? last_biei
: symbol_rootP
;
4164 (look
!= (symbolS
*) NULL
4165 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4166 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4167 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4168 look
= symbol_next (look
))
4170 if (look
!= (symbolS
*) NULL
)
4172 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4173 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4177 demand_empty_rest_of_line ();
4180 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4181 There is one argument, which is a csect symbol. The value of the
4182 .bs symbol is the index of this csect symbol. */
4185 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4192 if (ppc_current_block
!= NULL
)
4193 as_bad (_("nested .bs blocks"));
4195 name
= input_line_pointer
;
4196 endc
= get_symbol_end ();
4198 csect
= symbol_find_or_make (name
);
4200 *input_line_pointer
= endc
;
4202 sym
= symbol_make (".bs");
4203 S_SET_SEGMENT (sym
, now_seg
);
4204 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4205 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4206 symbol_get_tc (sym
)->output
= 1;
4208 symbol_get_tc (sym
)->within
= csect
;
4210 ppc_frob_label (sym
);
4212 ppc_current_block
= sym
;
4214 demand_empty_rest_of_line ();
4217 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4220 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4224 if (ppc_current_block
== NULL
)
4225 as_bad (_(".es without preceding .bs"));
4227 sym
= symbol_make (".es");
4228 S_SET_SEGMENT (sym
, now_seg
);
4229 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4230 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4231 symbol_get_tc (sym
)->output
= 1;
4233 ppc_frob_label (sym
);
4235 ppc_current_block
= NULL
;
4237 demand_empty_rest_of_line ();
4240 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4244 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4248 sym
= symbol_make (".bb");
4249 S_SET_SEGMENT (sym
, text_section
);
4250 symbol_set_frag (sym
, frag_now
);
4251 S_SET_VALUE (sym
, frag_now_fix ());
4252 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4254 S_SET_NUMBER_AUXILIARY (sym
, 1);
4255 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4257 symbol_get_tc (sym
)->output
= 1;
4259 SF_SET_PROCESS (sym
);
4261 ppc_frob_label (sym
);
4263 demand_empty_rest_of_line ();
4266 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4270 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4274 sym
= symbol_make (".eb");
4275 S_SET_SEGMENT (sym
, text_section
);
4276 symbol_set_frag (sym
, frag_now
);
4277 S_SET_VALUE (sym
, frag_now_fix ());
4278 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4279 S_SET_NUMBER_AUXILIARY (sym
, 1);
4280 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4281 symbol_get_tc (sym
)->output
= 1;
4283 SF_SET_PROCESS (sym
);
4285 ppc_frob_label (sym
);
4287 demand_empty_rest_of_line ();
4290 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4294 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4300 name
= demand_copy_C_string (&len
);
4301 sym
= symbol_make (name
);
4302 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4303 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4304 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4305 S_SET_VALUE (sym
, 0);
4306 symbol_get_tc (sym
)->output
= 1;
4308 ppc_frob_label (sym
);
4310 demand_empty_rest_of_line ();
4313 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4316 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4320 sym
= symbol_make (".ec");
4321 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4322 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4323 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4324 S_SET_VALUE (sym
, 0);
4325 symbol_get_tc (sym
)->output
= 1;
4327 ppc_frob_label (sym
);
4329 demand_empty_rest_of_line ();
4332 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4335 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4337 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4338 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4345 subseg
= ppc_data_subsegment
;
4346 ++ppc_data_subsegment
;
4348 subseg_new (segment_name (data_section
), subseg
);
4349 ppc_toc_frag
= frag_now
;
4351 sym
= symbol_find_or_make ("TOC[TC0]");
4352 symbol_set_frag (sym
, frag_now
);
4353 S_SET_SEGMENT (sym
, data_section
);
4354 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4355 symbol_get_tc (sym
)->subseg
= subseg
;
4356 symbol_get_tc (sym
)->output
= 1;
4357 symbol_get_tc (sym
)->within
= sym
;
4359 ppc_toc_csect
= sym
;
4361 for (list
= ppc_data_csects
;
4362 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4363 list
= symbol_get_tc (list
)->next
)
4365 symbol_get_tc (list
)->next
= sym
;
4367 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4368 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4372 ppc_current_csect
= ppc_toc_csect
;
4374 demand_empty_rest_of_line ();
4377 /* The AIX assembler automatically aligns the operands of a .long or
4378 .short pseudo-op, and we want to be compatible. */
4381 ppc_xcoff_cons (int log_size
)
4383 frag_align (log_size
, 0, 0);
4384 record_alignment (now_seg
, log_size
);
4385 cons (1 << log_size
);
4389 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4394 (void) expression (&exp
);
4396 if (exp
.X_op
!= O_constant
)
4398 as_bad (_("non-constant byte count"));
4402 byte_count
= exp
.X_add_number
;
4404 if (*input_line_pointer
!= ',')
4406 as_bad (_("missing value"));
4410 ++input_line_pointer
;
4415 ppc_xcoff_end (void)
4419 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4421 struct dw_section
*dws
= &dw_sections
[i
];
4422 struct dw_subsection
*dwss
;
4424 if (dws
->anon_subseg
)
4426 dwss
= dws
->anon_subseg
;
4427 dwss
->link
= dws
->list_subseg
;
4430 dwss
= dws
->list_subseg
;
4432 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4433 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4435 subseg_set (dws
->sect
, dwss
->subseg
);
4436 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4441 #endif /* OBJ_XCOFF */
4442 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4444 /* The .tc pseudo-op. This is used when generating either XCOFF or
4445 ELF. This takes two or more arguments.
4447 When generating XCOFF output, the first argument is the name to
4448 give to this location in the toc; this will be a symbol with class
4449 TC. The rest of the arguments are N-byte values to actually put at
4450 this location in the TOC; often there is just one more argument, a
4451 relocatable symbol reference. The size of the value to store
4452 depends on target word size. A 32-bit target uses 4-byte values, a
4453 64-bit target uses 8-byte values.
4455 When not generating XCOFF output, the arguments are the same, but
4456 the first argument is simply ignored. */
4459 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4463 /* Define the TOC symbol name. */
4469 if (ppc_toc_csect
== (symbolS
*) NULL
4470 || ppc_toc_csect
!= ppc_current_csect
)
4472 as_bad (_(".tc not in .toc section"));
4473 ignore_rest_of_line ();
4477 name
= input_line_pointer
;
4478 endc
= get_symbol_end ();
4480 sym
= symbol_find_or_make (name
);
4482 *input_line_pointer
= endc
;
4484 if (S_IS_DEFINED (sym
))
4488 label
= symbol_get_tc (ppc_current_csect
)->within
;
4489 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4491 as_bad (_(".tc with no label"));
4492 ignore_rest_of_line ();
4496 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4497 symbol_set_frag (label
, symbol_get_frag (sym
));
4498 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4500 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4501 ++input_line_pointer
;
4506 S_SET_SEGMENT (sym
, now_seg
);
4507 symbol_set_frag (sym
, frag_now
);
4508 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4509 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4510 symbol_get_tc (sym
)->output
= 1;
4512 ppc_frob_label (sym
);
4515 #endif /* OBJ_XCOFF */
4519 /* Skip the TOC symbol name. */
4520 while (is_part_of_name (*input_line_pointer
)
4521 || *input_line_pointer
== ' '
4522 || *input_line_pointer
== '['
4523 || *input_line_pointer
== ']'
4524 || *input_line_pointer
== '{'
4525 || *input_line_pointer
== '}')
4526 ++input_line_pointer
;
4528 /* Align to a four/eight byte boundary. */
4529 align
= ppc_obj64
? 3 : 2;
4530 frag_align (align
, 0, 0);
4531 record_alignment (now_seg
, align
);
4532 #endif /* OBJ_ELF */
4534 if (*input_line_pointer
!= ',')
4535 demand_empty_rest_of_line ();
4538 ++input_line_pointer
;
4539 cons (ppc_obj64
? 8 : 4);
4543 /* Pseudo-op .machine. */
4546 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4549 #define MAX_HISTORY 100
4550 static ppc_cpu_t
*cpu_history
;
4551 static int curr_hist
;
4555 if (*input_line_pointer
== '"')
4558 cpu_string
= demand_copy_C_string (&len
);
4563 cpu_string
= input_line_pointer
;
4564 c
= get_symbol_end ();
4565 cpu_string
= xstrdup (cpu_string
);
4566 *input_line_pointer
= c
;
4569 if (cpu_string
!= NULL
)
4571 ppc_cpu_t old_cpu
= ppc_cpu
;
4575 for (p
= cpu_string
; *p
!= 0; p
++)
4578 if (strcmp (cpu_string
, "push") == 0)
4580 if (cpu_history
== NULL
)
4581 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4583 if (curr_hist
>= MAX_HISTORY
)
4584 as_bad (_(".machine stack overflow"));
4586 cpu_history
[curr_hist
++] = ppc_cpu
;
4588 else if (strcmp (cpu_string
, "pop") == 0)
4591 as_bad (_(".machine stack underflow"));
4593 ppc_cpu
= cpu_history
[--curr_hist
];
4595 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, cpu_string
)) != 0)
4598 as_bad (_("invalid machine `%s'"), cpu_string
);
4600 if (ppc_cpu
!= old_cpu
)
4601 ppc_setup_opcodes ();
4604 demand_empty_rest_of_line ();
4607 /* See whether a symbol is in the TOC section. */
4610 ppc_is_toc_sym (symbolS
*sym
)
4613 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
4616 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4618 return strcmp (sname
, ".toc") == 0;
4620 return strcmp (sname
, ".got") == 0;
4623 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4627 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4629 /* Set the current section. */
4631 ppc_set_current_section (segT
new)
4633 ppc_previous_section
= ppc_current_section
;
4634 ppc_current_section
= new;
4637 /* pseudo-op: .previous
4638 behaviour: toggles the current section with the previous section.
4640 warnings: "No previous section" */
4643 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4647 if (ppc_previous_section
== NULL
)
4649 as_warn (_("No previous section to return to. Directive ignored."));
4653 subseg_set (ppc_previous_section
, 0);
4655 ppc_set_current_section (ppc_previous_section
);
4658 /* pseudo-op: .pdata
4659 behaviour: predefined read only data section
4663 initial: .section .pdata "adr3"
4664 a - don't know -- maybe a misprint
4665 d - initialized data
4667 3 - double word aligned (that would be 4 byte boundary)
4670 Tag index tables (also known as the function table) for exception
4671 handling, debugging, etc. */
4674 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4676 if (pdata_section
== 0)
4678 pdata_section
= subseg_new (".pdata", 0);
4680 bfd_set_section_flags (stdoutput
, pdata_section
,
4681 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4682 | SEC_READONLY
| SEC_DATA
));
4684 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4688 pdata_section
= subseg_new (".pdata", 0);
4690 ppc_set_current_section (pdata_section
);
4693 /* pseudo-op: .ydata
4694 behaviour: predefined read only data section
4698 initial: .section .ydata "drw3"
4699 a - don't know -- maybe a misprint
4700 d - initialized data
4702 3 - double word aligned (that would be 4 byte boundary)
4704 Tag tables (also known as the scope table) for exception handling,
4708 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4710 if (ydata_section
== 0)
4712 ydata_section
= subseg_new (".ydata", 0);
4713 bfd_set_section_flags (stdoutput
, ydata_section
,
4714 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4715 | SEC_READONLY
| SEC_DATA
));
4717 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4721 ydata_section
= subseg_new (".ydata", 0);
4723 ppc_set_current_section (ydata_section
);
4726 /* pseudo-op: .reldata
4727 behaviour: predefined read write data section
4728 double word aligned (4-byte)
4729 FIXME: relocation is applied to it
4730 FIXME: what's the difference between this and .data?
4733 initial: .section .reldata "drw3"
4734 d - initialized data
4737 3 - double word aligned (that would be 8 byte boundary)
4740 Like .data, but intended to hold data subject to relocation, such as
4741 function descriptors, etc. */
4744 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
4746 if (reldata_section
== 0)
4748 reldata_section
= subseg_new (".reldata", 0);
4750 bfd_set_section_flags (stdoutput
, reldata_section
,
4751 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4754 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4758 reldata_section
= subseg_new (".reldata", 0);
4760 ppc_set_current_section (reldata_section
);
4763 /* pseudo-op: .rdata
4764 behaviour: predefined read only data section
4768 initial: .section .rdata "dr3"
4769 d - initialized data
4771 3 - double word aligned (that would be 4 byte boundary) */
4774 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
4776 if (rdata_section
== 0)
4778 rdata_section
= subseg_new (".rdata", 0);
4779 bfd_set_section_flags (stdoutput
, rdata_section
,
4780 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4781 | SEC_READONLY
| SEC_DATA
));
4783 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4787 rdata_section
= subseg_new (".rdata", 0);
4789 ppc_set_current_section (rdata_section
);
4792 /* pseudo-op: .ualong
4793 behaviour: much like .int, with the exception that no alignment is
4795 FIXME: test the alignment statement
4800 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
4806 /* pseudo-op: .znop <symbol name>
4807 behaviour: Issue a nop instruction
4808 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4809 the supplied symbol name.
4811 warnings: Missing symbol name */
4814 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
4817 const struct powerpc_opcode
*opcode
;
4828 /* Strip out the symbol name. */
4829 symbol_name
= input_line_pointer
;
4830 c
= get_symbol_end ();
4832 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4833 strcpy (name
, symbol_name
);
4835 sym
= symbol_find_or_make (name
);
4837 *input_line_pointer
= c
;
4841 /* Look up the opcode in the hash table. */
4842 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4844 /* Stick in the nop. */
4845 insn
= opcode
->opcode
;
4847 /* Write out the instruction. */
4849 md_number_to_chars (f
, insn
, 4);
4851 f
- frag_now
->fr_literal
,
4856 BFD_RELOC_16_GOT_PCREL
);
4866 ppc_pe_comm (int lcomm
)
4875 name
= input_line_pointer
;
4876 c
= get_symbol_end ();
4878 /* just after name is now '\0'. */
4879 p
= input_line_pointer
;
4882 if (*input_line_pointer
!= ',')
4884 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4885 ignore_rest_of_line ();
4889 input_line_pointer
++; /* skip ',' */
4890 if ((temp
= get_absolute_expression ()) < 0)
4892 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4893 ignore_rest_of_line ();
4899 /* The third argument to .comm is the alignment. */
4900 if (*input_line_pointer
!= ',')
4904 ++input_line_pointer
;
4905 align
= get_absolute_expression ();
4908 as_warn (_("ignoring bad alignment"));
4915 symbolP
= symbol_find_or_make (name
);
4918 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4920 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4921 S_GET_NAME (symbolP
));
4922 ignore_rest_of_line ();
4926 if (S_GET_VALUE (symbolP
))
4928 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4929 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4930 S_GET_NAME (symbolP
),
4931 (long) S_GET_VALUE (symbolP
),
4936 S_SET_VALUE (symbolP
, (valueT
) temp
);
4937 S_SET_EXTERNAL (symbolP
);
4938 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
4941 demand_empty_rest_of_line ();
4945 * implement the .section pseudo op:
4946 * .section name {, "flags"}
4948 * | +--- optional flags: 'b' for bss
4950 * +-- section name 'l' for lib
4954 * 'd' (apparently m88k for data)
4956 * But if the argument is not a quoted string, treat it as a
4957 * subsegment number.
4959 * FIXME: this is a copy of the section processing from obj-coff.c, with
4960 * additions/changes for the moto-pas assembler support. There are three
4963 * FIXME: I just noticed this. This doesn't work at all really. It it
4964 * setting bits that bfd probably neither understands or uses. The
4965 * correct approach (?) will have to incorporate extra fields attached
4966 * to the section to hold the system specific stuff. (krk)
4969 * 'a' - unknown - referred to in documentation, but no definition supplied
4970 * 'c' - section has code
4971 * 'd' - section has initialized data
4972 * 'u' - section has uninitialized data
4973 * 'i' - section contains directives (info)
4974 * 'n' - section can be discarded
4975 * 'R' - remove section at link time
4977 * Section Protection:
4978 * 'r' - section is readable
4979 * 'w' - section is writeable
4980 * 'x' - section is executable
4981 * 's' - section is sharable
4983 * Section Alignment:
4984 * '0' - align to byte boundary
4985 * '1' - align to halfword undary
4986 * '2' - align to word boundary
4987 * '3' - align to doubleword boundary
4988 * '4' - align to quadword boundary
4989 * '5' - align to 32 byte boundary
4990 * '6' - align to 64 byte boundary
4995 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
4997 /* Strip out the section name. */
5006 section_name
= input_line_pointer
;
5007 c
= get_symbol_end ();
5009 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5010 strcpy (name
, section_name
);
5012 *input_line_pointer
= c
;
5017 flags
= SEC_NO_FLAGS
;
5019 if (strcmp (name
, ".idata$2") == 0)
5023 else if (strcmp (name
, ".idata$3") == 0)
5027 else if (strcmp (name
, ".idata$4") == 0)
5031 else if (strcmp (name
, ".idata$5") == 0)
5035 else if (strcmp (name
, ".idata$6") == 0)
5040 /* Default alignment to 16 byte boundary. */
5043 if (*input_line_pointer
== ',')
5045 ++input_line_pointer
;
5047 if (*input_line_pointer
!= '"')
5048 exp
= get_absolute_expression ();
5051 ++input_line_pointer
;
5052 while (*input_line_pointer
!= '"'
5053 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5055 switch (*input_line_pointer
)
5057 /* Section Contents */
5058 case 'a': /* unknown */
5059 as_bad (_("Unsupported section attribute -- 'a'"));
5061 case 'c': /* code section */
5064 case 'd': /* section has initialized data */
5067 case 'u': /* section has uninitialized data */
5068 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5072 case 'i': /* section contains directives (info) */
5073 /* FIXME: This is IMAGE_SCN_LNK_INFO
5075 flags
|= SEC_HAS_CONTENTS
;
5077 case 'n': /* section can be discarded */
5080 case 'R': /* Remove section at link time */
5081 flags
|= SEC_NEVER_LOAD
;
5083 #if IFLICT_BRAIN_DAMAGE
5084 /* Section Protection */
5085 case 'r': /* section is readable */
5086 flags
|= IMAGE_SCN_MEM_READ
;
5088 case 'w': /* section is writeable */
5089 flags
|= IMAGE_SCN_MEM_WRITE
;
5091 case 'x': /* section is executable */
5092 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5094 case 's': /* section is sharable */
5095 flags
|= IMAGE_SCN_MEM_SHARED
;
5098 /* Section Alignment */
5099 case '0': /* align to byte boundary */
5100 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5103 case '1': /* align to halfword boundary */
5104 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5107 case '2': /* align to word boundary */
5108 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5111 case '3': /* align to doubleword boundary */
5112 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5115 case '4': /* align to quadword boundary */
5116 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5119 case '5': /* align to 32 byte boundary */
5120 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5123 case '6': /* align to 64 byte boundary */
5124 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5129 as_bad (_("unknown section attribute '%c'"),
5130 *input_line_pointer
);
5133 ++input_line_pointer
;
5135 if (*input_line_pointer
== '"')
5136 ++input_line_pointer
;
5140 sec
= subseg_new (name
, (subsegT
) exp
);
5142 ppc_set_current_section (sec
);
5144 if (flags
!= SEC_NO_FLAGS
)
5146 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5147 as_bad (_("error setting flags for \"%s\": %s"),
5148 bfd_section_name (stdoutput
, sec
),
5149 bfd_errmsg (bfd_get_error ()));
5152 bfd_set_section_alignment (stdoutput
, sec
, align
);
5156 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5162 name
= input_line_pointer
;
5163 endc
= get_symbol_end ();
5165 ext_sym
= symbol_find_or_make (name
);
5167 *input_line_pointer
= endc
;
5169 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5170 SF_SET_FUNCTION (ext_sym
);
5171 SF_SET_PROCESS (ext_sym
);
5172 coff_add_linesym (ext_sym
);
5174 demand_empty_rest_of_line ();
5178 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5180 if (tocdata_section
== 0)
5182 tocdata_section
= subseg_new (".tocd", 0);
5183 /* FIXME: section flags won't work. */
5184 bfd_set_section_flags (stdoutput
, tocdata_section
,
5185 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5186 | SEC_READONLY
| SEC_DATA
));
5188 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5192 rdata_section
= subseg_new (".tocd", 0);
5195 ppc_set_current_section (tocdata_section
);
5197 demand_empty_rest_of_line ();
5200 /* Don't adjust TOC relocs to use the section symbol. */
5203 ppc_pe_fix_adjustable (fixS
*fix
)
5205 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5212 /* XCOFF specific symbol and file handling. */
5214 /* Canonicalize the symbol name. We use the to force the suffix, if
5215 any, to use square brackets, and to be in upper case. */
5218 ppc_canonicalize_symbol_name (char *name
)
5222 if (ppc_stab_symbol
)
5225 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5239 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5242 if (*s
== '\0' || s
[1] != '\0')
5243 as_bad (_("bad symbol suffix"));
5251 /* Set the class of a symbol based on the suffix, if any. This is
5252 called whenever a new symbol is created. */
5255 ppc_symbol_new_hook (symbolS
*sym
)
5257 struct ppc_tc_sy
*tc
;
5260 tc
= symbol_get_tc (sym
);
5263 tc
->symbol_class
= -1;
5264 tc
->real_name
= NULL
;
5271 if (ppc_stab_symbol
)
5274 s
= strchr (S_GET_NAME (sym
), '[');
5275 if (s
== (const char *) NULL
)
5277 /* There is no suffix. */
5286 if (strcmp (s
, "BS]") == 0)
5287 tc
->symbol_class
= XMC_BS
;
5290 if (strcmp (s
, "DB]") == 0)
5291 tc
->symbol_class
= XMC_DB
;
5292 else if (strcmp (s
, "DS]") == 0)
5293 tc
->symbol_class
= XMC_DS
;
5296 if (strcmp (s
, "GL]") == 0)
5297 tc
->symbol_class
= XMC_GL
;
5300 if (strcmp (s
, "PR]") == 0)
5301 tc
->symbol_class
= XMC_PR
;
5304 if (strcmp (s
, "RO]") == 0)
5305 tc
->symbol_class
= XMC_RO
;
5306 else if (strcmp (s
, "RW]") == 0)
5307 tc
->symbol_class
= XMC_RW
;
5310 if (strcmp (s
, "SV]") == 0)
5311 tc
->symbol_class
= XMC_SV
;
5314 if (strcmp (s
, "TC]") == 0)
5315 tc
->symbol_class
= XMC_TC
;
5316 else if (strcmp (s
, "TI]") == 0)
5317 tc
->symbol_class
= XMC_TI
;
5318 else if (strcmp (s
, "TB]") == 0)
5319 tc
->symbol_class
= XMC_TB
;
5320 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5321 tc
->symbol_class
= XMC_TC0
;
5324 if (strcmp (s
, "UA]") == 0)
5325 tc
->symbol_class
= XMC_UA
;
5326 else if (strcmp (s
, "UC]") == 0)
5327 tc
->symbol_class
= XMC_UC
;
5330 if (strcmp (s
, "XO]") == 0)
5331 tc
->symbol_class
= XMC_XO
;
5335 if (tc
->symbol_class
== -1)
5336 as_bad (_("Unrecognized symbol suffix"));
5339 /* Set the class of a label based on where it is defined. This
5340 handles symbols without suffixes. Also, move the symbol so that it
5341 follows the csect symbol. */
5344 ppc_frob_label (symbolS
*sym
)
5346 if (ppc_current_csect
!= (symbolS
*) NULL
)
5348 if (symbol_get_tc (sym
)->symbol_class
== -1)
5349 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5351 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5352 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5353 &symbol_rootP
, &symbol_lastP
);
5354 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5355 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5359 dwarf2_emit_label (sym
);
5363 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5364 seen. It tells ppc_adjust_symtab whether it needs to look through
5367 static bfd_boolean ppc_saw_abs
;
5369 /* Change the name of a symbol just before writing it out. Set the
5370 real name if the .rename pseudo-op was used. Otherwise, remove any
5371 class suffix. Return 1 if the symbol should not be included in the
5375 ppc_frob_symbol (symbolS
*sym
)
5377 static symbolS
*ppc_last_function
;
5378 static symbolS
*set_end
;
5380 /* Discard symbols that should not be included in the output symbol
5382 if (! symbol_used_in_reloc_p (sym
)
5383 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5384 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5385 && ! symbol_get_tc (sym
)->output
5386 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5389 /* This one will disappear anyway. Don't make a csect sym for it. */
5390 if (sym
== abs_section_sym
)
5393 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5394 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5400 name
= S_GET_NAME (sym
);
5401 s
= strchr (name
, '[');
5402 if (s
!= (char *) NULL
)
5408 snew
= xmalloc (len
+ 1);
5409 memcpy (snew
, name
, len
);
5412 S_SET_NAME (sym
, snew
);
5416 if (set_end
!= (symbolS
*) NULL
)
5418 SA_SET_SYM_ENDNDX (set_end
, sym
);
5422 if (SF_GET_FUNCTION (sym
))
5424 if (ppc_last_function
!= (symbolS
*) NULL
)
5425 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5426 ppc_last_function
= sym
;
5427 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5429 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5430 SA_SET_SYM_FSIZE (sym
,
5431 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5434 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5435 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5437 if (ppc_last_function
== (symbolS
*) NULL
)
5438 as_bad (_(".ef with no preceding .function"));
5441 set_end
= ppc_last_function
;
5442 ppc_last_function
= NULL
;
5444 /* We don't have a C_EFCN symbol, but we need to force the
5445 COFF backend to believe that it has seen one. */
5446 coff_last_function
= NULL
;
5450 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5451 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5452 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5453 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5454 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5455 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5456 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5457 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5458 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5459 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5460 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5462 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5463 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5464 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5467 union internal_auxent
*a
;
5469 /* Create a csect aux. */
5470 i
= S_GET_NUMBER_AUXILIARY (sym
);
5471 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5472 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5473 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5475 /* This is the TOC table. */
5476 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5477 a
->x_csect
.x_scnlen
.l
= 0;
5478 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5480 else if (symbol_get_tc (sym
)->subseg
!= 0)
5482 /* This is a csect symbol. x_scnlen is the size of the
5484 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5485 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5486 S_GET_SEGMENT (sym
))
5487 - S_GET_VALUE (sym
));
5490 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5491 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5492 - S_GET_VALUE (sym
));
5494 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5496 else if (S_GET_SEGMENT (sym
) == bss_section
)
5498 /* This is a common symbol. */
5499 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5500 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5501 if (S_IS_EXTERNAL (sym
))
5502 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5504 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5506 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5508 /* This is an absolute symbol. The csect will be created by
5509 ppc_adjust_symtab. */
5511 a
->x_csect
.x_smtyp
= XTY_LD
;
5512 if (symbol_get_tc (sym
)->symbol_class
== -1)
5513 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5515 else if (! S_IS_DEFINED (sym
))
5517 /* This is an external symbol. */
5518 a
->x_csect
.x_scnlen
.l
= 0;
5519 a
->x_csect
.x_smtyp
= XTY_ER
;
5521 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5525 /* This is a TOC definition. x_scnlen is the size of the
5527 next
= symbol_next (sym
);
5528 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5529 next
= symbol_next (next
);
5530 if (next
== (symbolS
*) NULL
5531 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5533 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5534 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5536 - S_GET_VALUE (sym
));
5538 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5539 - S_GET_VALUE (sym
));
5543 resolve_symbol_value (next
);
5544 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5545 - S_GET_VALUE (sym
));
5547 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5553 /* This is a normal symbol definition. x_scnlen is the
5554 symbol index of the containing csect. */
5555 if (S_GET_SEGMENT (sym
) == text_section
)
5556 csect
= ppc_text_csects
;
5557 else if (S_GET_SEGMENT (sym
) == data_section
)
5558 csect
= ppc_data_csects
;
5562 /* Skip the initial dummy symbol. */
5563 csect
= symbol_get_tc (csect
)->next
;
5565 if (csect
== (symbolS
*) NULL
)
5567 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5568 a
->x_csect
.x_scnlen
.l
= 0;
5572 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5574 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5575 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5576 > S_GET_VALUE (sym
))
5578 csect
= symbol_get_tc (csect
)->next
;
5581 a
->x_csect
.x_scnlen
.p
=
5582 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5583 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5586 a
->x_csect
.x_smtyp
= XTY_LD
;
5589 a
->x_csect
.x_parmhash
= 0;
5590 a
->x_csect
.x_snhash
= 0;
5591 if (symbol_get_tc (sym
)->symbol_class
== -1)
5592 a
->x_csect
.x_smclas
= XMC_PR
;
5594 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5595 a
->x_csect
.x_stab
= 0;
5596 a
->x_csect
.x_snstab
= 0;
5598 /* Don't let the COFF backend resort these symbols. */
5599 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5601 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5603 /* We want the value to be the symbol index of the referenced
5604 csect symbol. BFD will do that for us if we set the right
5606 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5607 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5609 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5610 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5612 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5617 block
= symbol_get_tc (sym
)->within
;
5620 /* The value is the offset from the enclosing csect. */
5623 csect
= symbol_get_tc (block
)->within
;
5624 resolve_symbol_value (csect
);
5625 base
= S_GET_VALUE (csect
);
5630 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5632 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5633 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5635 /* We want the value to be a file offset into the line numbers.
5636 BFD will do that for us if we set the right flags. We have
5637 already set the value correctly. */
5638 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5644 /* Adjust the symbol table. This creates csect symbols for all
5645 absolute symbols. */
5648 ppc_adjust_symtab (void)
5655 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5659 union internal_auxent
*a
;
5661 if (S_GET_SEGMENT (sym
) != absolute_section
)
5664 csect
= symbol_create (".abs[XO]", absolute_section
,
5665 S_GET_VALUE (sym
), &zero_address_frag
);
5666 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5667 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5668 i
= S_GET_NUMBER_AUXILIARY (csect
);
5669 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5670 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5671 a
->x_csect
.x_scnlen
.l
= 0;
5672 a
->x_csect
.x_smtyp
= XTY_SD
;
5673 a
->x_csect
.x_parmhash
= 0;
5674 a
->x_csect
.x_snhash
= 0;
5675 a
->x_csect
.x_smclas
= XMC_XO
;
5676 a
->x_csect
.x_stab
= 0;
5677 a
->x_csect
.x_snstab
= 0;
5679 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5681 i
= S_GET_NUMBER_AUXILIARY (sym
);
5682 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5683 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5684 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5687 ppc_saw_abs
= FALSE
;
5690 /* Set the VMA for a section. This is called on all the sections in
5694 ppc_frob_section (asection
*sec
)
5696 static bfd_vma vma
= 0;
5698 /* Dwarf sections start at 0. */
5699 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5702 vma
= md_section_align (sec
, vma
);
5703 bfd_set_section_vma (stdoutput
, sec
, vma
);
5704 vma
+= bfd_section_size (stdoutput
, sec
);
5707 #endif /* OBJ_XCOFF */
5710 md_atof (int type
, char *litp
, int *sizep
)
5712 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5715 /* Write a value out to the object file, using the appropriate
5719 md_number_to_chars (char *buf
, valueT val
, int n
)
5721 if (target_big_endian
)
5722 number_to_chars_bigendian (buf
, val
, n
);
5724 number_to_chars_littleendian (buf
, val
, n
);
5727 /* Align a section (I don't know why this is machine dependent). */
5730 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5735 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5737 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5741 /* We don't have any form of relaxing. */
5744 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5745 asection
*seg ATTRIBUTE_UNUSED
)
5751 /* Convert a machine dependent frag. We never generate these. */
5754 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5755 asection
*sec ATTRIBUTE_UNUSED
,
5756 fragS
*fragp ATTRIBUTE_UNUSED
)
5761 /* We have no need to default values of symbols. */
5764 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
5769 /* Functions concerning relocs. */
5771 /* The location from which a PC relative jump should be calculated,
5772 given a PC relative reloc. */
5775 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
5777 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5782 /* This is called to see whether a fixup should be adjusted to use a
5783 section symbol. We take the opportunity to change a fixup against
5784 a symbol in the TOC subsegment into a reloc against the
5785 corresponding .tc symbol. */
5788 ppc_fix_adjustable (fixS
*fix
)
5790 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5791 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5792 TC_SYMFIELD_TYPE
*tc
;
5794 if (symseg
== absolute_section
)
5797 /* Always adjust symbols in debugging sections. */
5798 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
5801 if (ppc_toc_csect
!= (symbolS
*) NULL
5802 && fix
->fx_addsy
!= ppc_toc_csect
5803 && symseg
== data_section
5804 && val
>= ppc_toc_frag
->fr_address
5805 && (ppc_after_toc_frag
== (fragS
*) NULL
5806 || val
< ppc_after_toc_frag
->fr_address
))
5810 for (sy
= symbol_next (ppc_toc_csect
);
5811 sy
!= (symbolS
*) NULL
;
5812 sy
= symbol_next (sy
))
5814 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5816 if (sy_tc
->symbol_class
== XMC_TC0
)
5818 if (sy_tc
->symbol_class
!= XMC_TC
)
5820 if (val
== resolve_symbol_value (sy
))
5823 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5828 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5829 _("symbol in .toc does not match any .tc"));
5832 /* Possibly adjust the reloc to be against the csect. */
5833 tc
= symbol_get_tc (fix
->fx_addsy
);
5835 && tc
->symbol_class
!= XMC_TC0
5836 && tc
->symbol_class
!= XMC_TC
5837 && symseg
!= bss_section
5838 /* Don't adjust if this is a reloc in the toc section. */
5839 && (symseg
!= data_section
5840 || ppc_toc_csect
== NULL
5841 || val
< ppc_toc_frag
->fr_address
5842 || (ppc_after_toc_frag
!= NULL
5843 && val
>= ppc_after_toc_frag
->fr_address
)))
5845 symbolS
*csect
= tc
->within
;
5847 /* If the symbol was not declared by a label (eg: a section symbol),
5848 use the section instead of the csect. This doesn't happen in
5849 normal AIX assembly code. */
5851 csect
= seg_info (symseg
)->sym
;
5853 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5854 fix
->fx_addsy
= csect
;
5859 /* Adjust a reloc against a .lcomm symbol to be against the base
5861 if (symseg
== bss_section
5862 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5864 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5866 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5873 /* A reloc from one csect to another must be kept. The assembler
5874 will, of course, keep relocs between sections, and it will keep
5875 absolute relocs, but we need to force it to keep PC relative relocs
5876 between two csects in the same section. */
5879 ppc_force_relocation (fixS
*fix
)
5881 /* At this point fix->fx_addsy should already have been converted to
5882 a csect symbol. If the csect does not include the fragment, then
5883 we need to force the relocation. */
5885 && fix
->fx_addsy
!= NULL
5886 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5887 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5888 > fix
->fx_frag
->fr_address
)
5889 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5890 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5891 <= fix
->fx_frag
->fr_address
))))
5894 return generic_force_reloc (fix
);
5898 ppc_new_dot_label (symbolS
*sym
)
5900 /* Anchor this label to the current csect for relocations. */
5901 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5904 #endif /* OBJ_XCOFF */
5907 /* If this function returns non-zero, it guarantees that a relocation
5908 will be emitted for a fixup. */
5911 ppc_force_relocation (fixS
*fix
)
5913 /* Branch prediction relocations must force a relocation, as must
5914 the vtable description relocs. */
5915 switch (fix
->fx_r_type
)
5917 case BFD_RELOC_PPC_B16_BRTAKEN
:
5918 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5919 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5920 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5921 case BFD_RELOC_24_PLT_PCREL
:
5922 case BFD_RELOC_PPC64_TOC
:
5928 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5929 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5932 return generic_force_reloc (fix
);
5936 ppc_fix_adjustable (fixS
*fix
)
5938 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5939 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5940 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5941 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5942 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
5943 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
5944 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5945 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5946 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5947 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5948 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
5952 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
5953 rs_align_code frag. */
5956 ppc_handle_align (struct frag
*fragP
)
5958 valueT count
= (fragP
->fr_next
->fr_address
5959 - (fragP
->fr_address
+ fragP
->fr_fix
));
5961 if (count
!= 0 && (count
& 3) == 0)
5963 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
5967 if (count
> 4 * nop_limit
&& count
< 0x2000000)
5971 /* Make a branch, then follow with nops. Insert another
5972 frag to handle the nops. */
5973 md_number_to_chars (dest
, 0x48000000 + count
, 4);
5978 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
5979 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
5980 fragP
->fr_next
= rest
;
5982 rest
->fr_address
+= rest
->fr_fix
+ 4;
5984 /* If we leave the next frag as rs_align_code we'll come here
5985 again, resulting in a bunch of branches rather than a
5986 branch followed by nops. */
5987 rest
->fr_type
= rs_align
;
5988 dest
= rest
->fr_literal
;
5991 md_number_to_chars (dest
, 0x60000000, 4);
5993 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
5994 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
5996 /* For power6 and power7, we want the last nop to be a group
5997 terminating one. Do this by inserting an rs_fill frag immediately
5998 after this one, with its address set to the last nop location.
5999 This will automatically reduce the number of nops in the current
6003 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6005 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6006 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6007 group_nop
->fr_fix
= 0;
6008 group_nop
->fr_offset
= 1;
6009 group_nop
->fr_type
= rs_fill
;
6010 fragP
->fr_next
= group_nop
;
6011 dest
= group_nop
->fr_literal
;
6014 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
6015 /* power7 group terminating nop: "ori 2,2,0". */
6016 md_number_to_chars (dest
, 0x60420000, 4);
6018 /* power6 group terminating nop: "ori 1,1,0". */
6019 md_number_to_chars (dest
, 0x60210000, 4);
6024 /* Apply a fixup to the object code. This is called for all the
6025 fixups we generated by the call to fix_new_exp, above. In the call
6026 above we used a reloc code which was the largest legal reloc code
6027 plus the operand index. Here we undo that to recover the operand
6028 index. At this point all symbol values should be fully resolved,
6029 and we attempt to completely resolve the reloc. If we can not do
6030 that, we determine the correct reloc code and put it back in the
6034 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6036 valueT value
= * valP
;
6039 if (fixP
->fx_addsy
!= NULL
)
6041 /* Hack around bfd_install_relocation brain damage. */
6043 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6048 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6049 the symbol values. If we are doing this relocation the code in
6050 write.c is going to call bfd_install_relocation, which is also
6051 going to use the symbol value. That means that if the reloc is
6052 fully resolved we want to use *valP since bfd_install_relocation is
6054 However, if the reloc is not fully resolved we do not want to
6055 use *valP, and must use fx_offset instead. If the relocation
6056 is PC-relative, we then need to re-apply md_pcrel_from_section
6057 to this new relocation value. */
6058 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6063 value
= fixP
->fx_offset
;
6065 value
-= md_pcrel_from_section (fixP
, seg
);
6069 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6071 /* We can't actually support subtracting a symbol. */
6072 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6075 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
6078 const struct powerpc_operand
*operand
;
6082 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
6084 operand
= &powerpc_operands
[opindex
];
6087 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6088 does not generate a reloc. It uses the offset of `sym' within its
6089 csect. Other usages, such as `.long sym', generate relocs. This
6090 is the documented behaviour of non-TOC symbols. */
6091 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6092 && (operand
->bitm
& 0xfff0) == 0xfff0
6093 && operand
->shift
== 0
6094 && (operand
->insert
== NULL
|| ppc_obj64
)
6095 && fixP
->fx_addsy
!= NULL
6096 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6097 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6098 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6099 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6101 value
= fixP
->fx_offset
;
6106 /* Fetch the instruction, insert the fully resolved operand
6107 value, and stuff the instruction back again. */
6108 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6109 if (target_big_endian
)
6110 insn
= bfd_getb32 ((unsigned char *) where
);
6112 insn
= bfd_getl32 ((unsigned char *) where
);
6113 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
6114 fixP
->tc_fix_data
.ppc_cpu
,
6115 fixP
->fx_file
, fixP
->fx_line
);
6116 if (target_big_endian
)
6117 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6119 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6122 /* Nothing else to do here. */
6125 gas_assert (fixP
->fx_addsy
!= NULL
);
6127 /* Determine a BFD reloc value based on the operand information.
6128 We are only prepared to turn a few of the operands into
6130 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6131 && operand
->bitm
== 0x3fffffc
6132 && operand
->shift
== 0)
6133 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
6134 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
6135 && operand
->bitm
== 0xfffc
6136 && operand
->shift
== 0)
6138 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
6141 if (target_big_endian
)
6142 fixP
->fx_where
+= 2;
6145 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6146 && operand
->bitm
== 0x3fffffc
6147 && operand
->shift
== 0)
6148 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
6149 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
6150 && operand
->bitm
== 0xfffc
6151 && operand
->shift
== 0)
6153 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
6156 if (target_big_endian
)
6157 fixP
->fx_where
+= 2;
6160 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
6161 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6162 && (operand
->bitm
& 0xfff0) == 0xfff0
6163 && operand
->shift
== 0)
6165 if (ppc_is_toc_sym (fixP
->fx_addsy
))
6167 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6170 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6171 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
6176 fixP
->fx_r_type
= BFD_RELOC_16
;
6179 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
6180 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
6184 if (target_big_endian
)
6185 fixP
->fx_where
+= 2;
6187 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
6193 /* Use expr_symbol_where to see if this is an expression
6195 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6196 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6197 _("unresolved expression that must be resolved"));
6199 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6200 _("unsupported relocation against %s"),
6201 S_GET_NAME (fixP
->fx_addsy
));
6209 ppc_elf_validate_fix (fixP
, seg
);
6211 switch (fixP
->fx_r_type
)
6213 case BFD_RELOC_CTOR
:
6220 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6224 case BFD_RELOC_32_PCREL
:
6225 case BFD_RELOC_PPC_EMB_NADDR32
:
6226 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6233 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6236 case BFD_RELOC_64_PCREL
:
6237 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6241 case BFD_RELOC_GPREL16
:
6242 case BFD_RELOC_16_GOT_PCREL
:
6243 case BFD_RELOC_16_GOTOFF
:
6244 case BFD_RELOC_LO16_GOTOFF
:
6245 case BFD_RELOC_HI16_GOTOFF
:
6246 case BFD_RELOC_HI16_S_GOTOFF
:
6247 case BFD_RELOC_16_BASEREL
:
6248 case BFD_RELOC_LO16_BASEREL
:
6249 case BFD_RELOC_HI16_BASEREL
:
6250 case BFD_RELOC_HI16_S_BASEREL
:
6251 case BFD_RELOC_PPC_EMB_NADDR16
:
6252 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6253 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6254 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6255 case BFD_RELOC_PPC_EMB_SDAI16
:
6256 case BFD_RELOC_PPC_EMB_SDA2REL
:
6257 case BFD_RELOC_PPC_EMB_SDA2I16
:
6258 case BFD_RELOC_PPC_EMB_RELSEC16
:
6259 case BFD_RELOC_PPC_EMB_RELST_LO
:
6260 case BFD_RELOC_PPC_EMB_RELST_HI
:
6261 case BFD_RELOC_PPC_EMB_RELST_HA
:
6262 case BFD_RELOC_PPC_EMB_RELSDA
:
6263 case BFD_RELOC_PPC_TOC16
:
6265 case BFD_RELOC_PPC64_TOC16_LO
:
6266 case BFD_RELOC_PPC64_TOC16_HI
:
6267 case BFD_RELOC_PPC64_TOC16_HA
:
6271 if (fixP
->fx_addsy
!= NULL
)
6272 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6273 _("cannot emit PC relative %s relocation against %s"),
6274 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6275 S_GET_NAME (fixP
->fx_addsy
));
6277 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6278 _("cannot emit PC relative %s relocation"),
6279 bfd_get_reloc_code_name (fixP
->fx_r_type
));
6282 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6288 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6291 case BFD_RELOC_16_PCREL
:
6292 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6296 case BFD_RELOC_LO16
:
6298 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6301 case BFD_RELOC_LO16_PCREL
:
6302 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6306 /* This case happens when you write, for example,
6308 where L1 and L2 are defined later. */
6309 case BFD_RELOC_HI16
:
6311 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6314 case BFD_RELOC_HI16_PCREL
:
6315 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6319 case BFD_RELOC_HI16_S
:
6321 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6324 case BFD_RELOC_HI16_S_PCREL
:
6325 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6330 case BFD_RELOC_NONE
:
6335 case BFD_RELOC_PPC64_HIGHER
:
6338 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6339 PPC_HIGHER (value
), 2);
6342 case BFD_RELOC_PPC64_HIGHER_S
:
6345 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6346 PPC_HIGHERA (value
), 2);
6349 case BFD_RELOC_PPC64_HIGHEST
:
6352 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6353 PPC_HIGHEST (value
), 2);
6356 case BFD_RELOC_PPC64_HIGHEST_S
:
6359 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6360 PPC_HIGHESTA (value
), 2);
6363 case BFD_RELOC_PPC64_ADDR16_DS
:
6364 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6365 case BFD_RELOC_PPC64_GOT16_DS
:
6366 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6367 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6368 case BFD_RELOC_PPC64_SECTOFF_DS
:
6369 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6370 case BFD_RELOC_PPC64_TOC16_DS
:
6371 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6372 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6373 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6377 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6378 unsigned long val
, mask
;
6380 if (target_big_endian
)
6381 val
= bfd_getb32 (where
- 2);
6383 val
= bfd_getl32 (where
);
6385 /* lq insns reserve the four lsbs. */
6386 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
6387 && (val
& (0x3f << 26)) == (56u << 26))
6389 val
|= value
& mask
;
6390 if (target_big_endian
)
6391 bfd_putb16 ((bfd_vma
) val
, where
);
6393 bfd_putl16 ((bfd_vma
) val
, where
);
6397 case BFD_RELOC_PPC_B16_BRTAKEN
:
6398 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6399 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6400 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6403 case BFD_RELOC_PPC_TLS
:
6404 case BFD_RELOC_PPC_TLSGD
:
6405 case BFD_RELOC_PPC_TLSLD
:
6408 case BFD_RELOC_PPC_DTPMOD
:
6409 case BFD_RELOC_PPC_TPREL16
:
6410 case BFD_RELOC_PPC_TPREL16_LO
:
6411 case BFD_RELOC_PPC_TPREL16_HI
:
6412 case BFD_RELOC_PPC_TPREL16_HA
:
6413 case BFD_RELOC_PPC_TPREL
:
6414 case BFD_RELOC_PPC_DTPREL16
:
6415 case BFD_RELOC_PPC_DTPREL16_LO
:
6416 case BFD_RELOC_PPC_DTPREL16_HI
:
6417 case BFD_RELOC_PPC_DTPREL16_HA
:
6418 case BFD_RELOC_PPC_DTPREL
:
6419 case BFD_RELOC_PPC_GOT_TLSGD16
:
6420 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6421 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6422 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6423 case BFD_RELOC_PPC_GOT_TLSLD16
:
6424 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6425 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6426 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6427 case BFD_RELOC_PPC_GOT_TPREL16
:
6428 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6429 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6430 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6431 case BFD_RELOC_PPC_GOT_DTPREL16
:
6432 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6433 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6434 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6435 case BFD_RELOC_PPC64_TPREL16_DS
:
6436 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6437 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6438 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6439 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6440 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6441 case BFD_RELOC_PPC64_DTPREL16_DS
:
6442 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6443 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6444 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6445 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6446 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6447 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6450 /* Because SDA21 modifies the register field, the size is set to 4
6451 bytes, rather than 2, so offset it here appropriately. */
6452 case BFD_RELOC_PPC_EMB_SDA21
:
6456 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
6457 + ((target_big_endian
) ? 2 : 0),
6464 /* This can occur if there is a bug in the input assembler, eg:
6465 ".byte <undefined_symbol> - ." */
6467 as_bad (_("Unable to handle reference to symbol %s"),
6468 S_GET_NAME (fixP
->fx_addsy
));
6470 as_bad (_("Unable to resolve expression"));
6474 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6478 case BFD_RELOC_24_PLT_PCREL
:
6479 case BFD_RELOC_PPC_LOCAL24PC
:
6480 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
6488 /* Fetch the instruction, insert the fully resolved operand
6489 value, and stuff the instruction back again. */
6490 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6491 if (target_big_endian
)
6492 insn
= bfd_getb32 ((unsigned char *) where
);
6494 insn
= bfd_getl32 ((unsigned char *) where
);
6495 if ((value
& 3) != 0)
6496 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6497 _("must branch to an address a multiple of 4"));
6498 if ((offsetT
) value
< -0x40000000
6499 || (offsetT
) value
>= 0x40000000)
6500 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6501 _("@local or @plt branch destination is too far away, %ld bytes"),
6503 insn
= insn
| (value
& 0x03fffffc);
6504 if (target_big_endian
)
6505 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6507 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6511 case BFD_RELOC_VTABLE_INHERIT
:
6514 && !S_IS_DEFINED (fixP
->fx_addsy
)
6515 && !S_IS_WEAK (fixP
->fx_addsy
))
6516 S_SET_WEAK (fixP
->fx_addsy
);
6519 case BFD_RELOC_VTABLE_ENTRY
:
6524 /* Generated by reference to `sym@tocbase'. The sym is
6525 ignored by the linker. */
6526 case BFD_RELOC_PPC64_TOC
:
6532 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6539 fixP
->fx_addnumber
= value
;
6541 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6542 from the section contents. If we are going to be emitting a reloc
6543 then the section contents are immaterial, so don't warn if they
6544 happen to overflow. Leave such warnings to ld. */
6546 fixP
->fx_no_overflow
= 1;
6548 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6549 fixP
->fx_addnumber
= 0;
6553 fixP
->fx_addnumber
= 0;
6555 /* We want to use the offset within the toc, not the actual VMA
6557 fixP
->fx_addnumber
=
6558 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6559 - S_GET_VALUE (ppc_toc_csect
);
6565 /* Generate a reloc for a fixup. */
6568 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6572 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6574 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6575 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6576 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6577 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6578 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6580 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6581 _("reloc %d not supported by object file format"),
6582 (int) fixp
->fx_r_type
);
6585 reloc
->addend
= fixp
->fx_addnumber
;
6591 ppc_cfi_frame_initial_instructions (void)
6593 cfi_add_CFA_def_cfa (1, 0);
6597 tc_ppc_regname_to_dw2regnum (char *regname
)
6599 unsigned int regnum
= -1;
6603 static struct { char *name
; int dw2regnum
; } regnames
[] =
6605 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6606 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6607 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6608 { "spe_acc", 111 }, { "spefscr", 112 }
6611 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6612 if (strcmp (regnames
[i
].name
, regname
) == 0)
6613 return regnames
[i
].dw2regnum
;
6615 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6617 p
= regname
+ 1 + (regname
[1] == '.');
6618 regnum
= strtoul (p
, &q
, 10);
6619 if (p
== q
|| *q
|| regnum
>= 32)
6621 if (regname
[0] == 'f')
6623 else if (regname
[0] == 'v')
6626 else if (regname
[0] == 'c' && regname
[1] == 'r')
6628 p
= regname
+ 2 + (regname
[2] == '.');
6629 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6631 regnum
= p
[0] - '0' + 68;