1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
7 This file is part of GAS, the GNU Assembler.
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "safe-ctype.h"
27 #include "dw2gencfi.h"
28 #include "opcode/ppc.h"
32 #include "dwarf2dbg.h"
40 #include "coff/xcoff.h"
44 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
46 /* Tell the main code what the endianness is. */
47 extern int target_big_endian
;
49 /* Whether or not, we've set target_big_endian. */
50 static int set_target_endian
= 0;
52 /* Whether to use user friendly register names. */
53 #ifndef TARGET_REG_NAMES_P
55 #define TARGET_REG_NAMES_P TRUE
57 #define TARGET_REG_NAMES_P FALSE
61 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
64 /* #lo(value) denotes the least significant 16 bits of the indicated. */
65 #define PPC_LO(v) ((v) & 0xffff)
67 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
68 #define PPC_HI(v) (((v) >> 16) & 0xffff)
70 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
71 the indicated value, compensating for #lo() being treated as a
73 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
75 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
76 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
78 /* #highera(value) denotes bits 32 through 47 of the indicated value,
79 compensating for #lo() being treated as a signed number. */
80 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
82 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
83 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
85 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
86 compensating for #lo being treated as a signed number. */
87 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
89 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
91 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
93 static void ppc_macro (char *, const struct powerpc_macro
*);
94 static void ppc_byte (int);
96 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
97 static void ppc_tc (int);
98 static void ppc_machine (int);
102 static void ppc_comm (int);
103 static void ppc_bb (int);
104 static void ppc_bc (int);
105 static void ppc_bf (int);
106 static void ppc_biei (int);
107 static void ppc_bs (int);
108 static void ppc_eb (int);
109 static void ppc_ec (int);
110 static void ppc_ef (int);
111 static void ppc_es (int);
112 static void ppc_csect (int);
113 static void ppc_dwsect (int);
114 static void ppc_change_csect (symbolS
*, offsetT
);
115 static void ppc_function (int);
116 static void ppc_extern (int);
117 static void ppc_lglobl (int);
118 static void ppc_ref (int);
119 static void ppc_section (int);
120 static void ppc_named_section (int);
121 static void ppc_stabx (int);
122 static void ppc_rename (int);
123 static void ppc_toc (int);
124 static void ppc_xcoff_cons (int);
125 static void ppc_vbyte (int);
129 static void ppc_elf_cons (int);
130 static void ppc_elf_rdata (int);
131 static void ppc_elf_lcomm (int);
135 static void ppc_previous (int);
136 static void ppc_pdata (int);
137 static void ppc_ydata (int);
138 static void ppc_reldata (int);
139 static void ppc_rdata (int);
140 static void ppc_ualong (int);
141 static void ppc_znop (int);
142 static void ppc_pe_comm (int);
143 static void ppc_pe_section (int);
144 static void ppc_pe_function (int);
145 static void ppc_pe_tocd (int);
148 /* Generic assembler global variables which must be defined by all
152 /* This string holds the chars that always start a comment. If the
153 pre-processor is disabled, these aren't very useful. The macro
154 tc_comment_chars points to this. We use this, rather than the
155 usual comment_chars, so that we can switch for Solaris conventions. */
156 static const char ppc_solaris_comment_chars
[] = "#!";
157 static const char ppc_eabi_comment_chars
[] = "#";
159 #ifdef TARGET_SOLARIS_COMMENT
160 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
162 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
165 const char comment_chars
[] = "#";
168 /* Characters which start a comment at the beginning of a line. */
169 const char line_comment_chars
[] = "#";
171 /* Characters which may be used to separate multiple commands on a
173 const char line_separator_chars
[] = ";";
175 /* Characters which are used to indicate an exponent in a floating
177 const char EXP_CHARS
[] = "eE";
179 /* Characters which mean that a number is a floating point constant,
181 const char FLT_CHARS
[] = "dD";
183 /* Anything that can start an operand needs to be mentioned here,
184 to stop the input scrubber eating whitespace. */
185 const char ppc_symbol_chars
[] = "%[";
187 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
188 int ppc_cie_data_alignment
;
190 /* The dwarf2 minimum instruction length. */
191 int ppc_dwarf2_line_min_insn_length
;
193 /* More than this number of nops in an alignment op gets a branch
195 unsigned long nop_limit
= 4;
197 /* The type of processor we are assembling for. This is one or more
198 of the PPC_OPCODE flags defined in opcode/ppc.h. */
199 ppc_cpu_t ppc_cpu
= 0;
200 ppc_cpu_t sticky
= 0;
202 /* Flags set on encountering toc relocs. */
204 has_large_toc_reloc
= 1,
205 has_small_toc_reloc
= 2
208 /* The target specific pseudo-ops which we support. */
210 const pseudo_typeS md_pseudo_table
[] =
212 /* Pseudo-ops which must be overridden. */
213 { "byte", ppc_byte
, 0 },
216 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
217 legitimately belong in the obj-*.c file. However, XCOFF is based
218 on COFF, and is only implemented for the RS/6000. We just use
219 obj-coff.c, and add what we need here. */
220 { "comm", ppc_comm
, 0 },
221 { "lcomm", ppc_comm
, 1 },
225 { "bi", ppc_biei
, 0 },
227 { "csect", ppc_csect
, 0 },
228 { "dwsect", ppc_dwsect
, 0 },
229 { "data", ppc_section
, 'd' },
233 { "ei", ppc_biei
, 1 },
235 { "extern", ppc_extern
, 0 },
236 { "function", ppc_function
, 0 },
237 { "lglobl", ppc_lglobl
, 0 },
238 { "ref", ppc_ref
, 0 },
239 { "rename", ppc_rename
, 0 },
240 { "section", ppc_named_section
, 0 },
241 { "stabx", ppc_stabx
, 0 },
242 { "text", ppc_section
, 't' },
243 { "toc", ppc_toc
, 0 },
244 { "long", ppc_xcoff_cons
, 2 },
245 { "llong", ppc_xcoff_cons
, 3 },
246 { "word", ppc_xcoff_cons
, 1 },
247 { "short", ppc_xcoff_cons
, 1 },
248 { "vbyte", ppc_vbyte
, 0 },
252 { "llong", ppc_elf_cons
, 8 },
253 { "quad", ppc_elf_cons
, 8 },
254 { "long", ppc_elf_cons
, 4 },
255 { "word", ppc_elf_cons
, 2 },
256 { "short", ppc_elf_cons
, 2 },
257 { "rdata", ppc_elf_rdata
, 0 },
258 { "rodata", ppc_elf_rdata
, 0 },
259 { "lcomm", ppc_elf_lcomm
, 0 },
263 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
264 { "previous", ppc_previous
, 0 },
265 { "pdata", ppc_pdata
, 0 },
266 { "ydata", ppc_ydata
, 0 },
267 { "reldata", ppc_reldata
, 0 },
268 { "rdata", ppc_rdata
, 0 },
269 { "ualong", ppc_ualong
, 0 },
270 { "znop", ppc_znop
, 0 },
271 { "comm", ppc_pe_comm
, 0 },
272 { "lcomm", ppc_pe_comm
, 1 },
273 { "section", ppc_pe_section
, 0 },
274 { "function", ppc_pe_function
,0 },
275 { "tocd", ppc_pe_tocd
, 0 },
278 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
280 { "machine", ppc_machine
, 0 },
287 /* Predefined register names if -mregnames (or default for Windows NT).
288 In general, there are lots of them, in an attempt to be compatible
289 with a number of other Windows NT assemblers. */
291 /* Structure to hold information about predefined registers. */
298 /* List of registers that are pre-defined:
300 Each general register has predefined names of the form:
301 1. r<reg_num> which has the value <reg_num>.
302 2. r.<reg_num> which has the value <reg_num>.
304 Each floating point register has predefined names of the form:
305 1. f<reg_num> which has the value <reg_num>.
306 2. f.<reg_num> which has the value <reg_num>.
308 Each vector unit register has predefined names of the form:
309 1. v<reg_num> which has the value <reg_num>.
310 2. v.<reg_num> which has the value <reg_num>.
312 Each condition register has predefined names of the form:
313 1. cr<reg_num> which has the value <reg_num>.
314 2. cr.<reg_num> which has the value <reg_num>.
316 There are individual registers as well:
317 sp or r.sp has the value 1
318 rtoc or r.toc has the value 2
319 fpscr has the value 0
325 dsisr has the value 18
327 sdr1 has the value 25
328 srr0 has the value 26
329 srr1 has the value 27
331 The table is sorted. Suitable for searching by a binary search. */
333 static const struct pd_reg pre_defined_registers
[] =
335 { "cr.0", 0 }, /* Condition Registers */
355 { "dar", 19 }, /* Data Access Register */
356 { "dec", 22 }, /* Decrementer */
357 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
359 { "f.0", 0 }, /* Floating point registers */
386 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
452 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
493 /* Quantization registers used with pair single instructions. */
511 { "lr", 8 }, /* Link Register */
515 { "r.0", 0 }, /* General Purpose Registers */
548 { "r.sp", 1 }, /* Stack Pointer */
550 { "r.toc", 2 }, /* Pointer to the table of contents */
552 { "r0", 0 }, /* More general purpose registers */
585 { "rtoc", 2 }, /* Table of contents */
587 { "sdr1", 25 }, /* Storage Description Register 1 */
591 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
592 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
594 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
660 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
794 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
796 /* Given NAME, find the register number associated with that name, return
797 the integer value associated with the given name or -1 on failure. */
800 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
802 int middle
, low
, high
;
810 middle
= (low
+ high
) / 2;
811 cmp
= strcasecmp (name
, regs
[middle
].name
);
817 return regs
[middle
].value
;
825 * Summary of register_name.
827 * in: Input_line_pointer points to 1st char of operand.
829 * out: A expressionS.
830 * The operand may have been a register: in this case, X_op == O_register,
831 * X_add_number is set to the register number, and truth is returned.
832 * Input_line_pointer->(next non-blank) char after operand, or is in its
837 register_name (expressionS
*expressionP
)
844 /* Find the spelling of the operand. */
845 start
= name
= input_line_pointer
;
846 if (name
[0] == '%' && ISALPHA (name
[1]))
847 name
= ++input_line_pointer
;
849 else if (!reg_names_p
|| !ISALPHA (name
[0]))
852 c
= get_symbol_end ();
853 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
855 /* Put back the delimiting char. */
856 *input_line_pointer
= c
;
858 /* Look to see if it's in the register table. */
861 expressionP
->X_op
= O_register
;
862 expressionP
->X_add_number
= reg_number
;
864 /* Make the rest nice. */
865 expressionP
->X_add_symbol
= NULL
;
866 expressionP
->X_op_symbol
= NULL
;
870 /* Reset the line as if we had not done anything. */
871 input_line_pointer
= start
;
875 /* This function is called for each symbol seen in an expression. It
876 handles the special parsing which PowerPC assemblers are supposed
877 to use for condition codes. */
879 /* Whether to do the special parsing. */
880 static bfd_boolean cr_operand
;
882 /* Names to recognize in a condition code. This table is sorted. */
883 static const struct pd_reg cr_names
[] =
900 /* Parsing function. This returns non-zero if it recognized an
904 ppc_parse_name (const char *name
, expressionS
*exp
)
913 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
918 exp
->X_op
= O_constant
;
919 exp
->X_add_number
= val
;
924 /* Local variables. */
926 /* Whether to target xcoff64/elf64. */
927 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
929 /* Opcode hash table. */
930 static struct hash_control
*ppc_hash
;
932 /* Macro hash table. */
933 static struct hash_control
*ppc_macro_hash
;
936 /* What type of shared library support to use. */
937 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
939 /* Flags to set in the elf header. */
940 static flagword ppc_flags
= 0;
942 /* Whether this is Solaris or not. */
943 #ifdef TARGET_SOLARIS_COMMENT
944 #define SOLARIS_P TRUE
946 #define SOLARIS_P FALSE
949 static bfd_boolean msolaris
= SOLARIS_P
;
954 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
955 using a bunch of different sections. These assembler sections,
956 however, are all encompassed within the .text or .data sections of
957 the final output file. We handle this by using different
958 subsegments within these main segments. */
960 /* Next subsegment to allocate within the .text segment. */
961 static subsegT ppc_text_subsegment
= 2;
963 /* Linked list of csects in the text section. */
964 static symbolS
*ppc_text_csects
;
966 /* Next subsegment to allocate within the .data segment. */
967 static subsegT ppc_data_subsegment
= 2;
969 /* Linked list of csects in the data section. */
970 static symbolS
*ppc_data_csects
;
972 /* The current csect. */
973 static symbolS
*ppc_current_csect
;
975 /* The RS/6000 assembler uses a TOC which holds addresses of functions
976 and variables. Symbols are put in the TOC with the .tc pseudo-op.
977 A special relocation is used when accessing TOC entries. We handle
978 the TOC as a subsegment within the .data segment. We set it up if
979 we see a .toc pseudo-op, and save the csect symbol here. */
980 static symbolS
*ppc_toc_csect
;
982 /* The first frag in the TOC subsegment. */
983 static fragS
*ppc_toc_frag
;
985 /* The first frag in the first subsegment after the TOC in the .data
986 segment. NULL if there are no subsegments after the TOC. */
987 static fragS
*ppc_after_toc_frag
;
989 /* The current static block. */
990 static symbolS
*ppc_current_block
;
992 /* The COFF debugging section; set by md_begin. This is not the
993 .debug section, but is instead the secret BFD section which will
994 cause BFD to set the section number of a symbol to N_DEBUG. */
995 static asection
*ppc_coff_debug_section
;
997 /* Structure to set the length field of the dwarf sections. */
998 struct dw_subsection
{
999 /* Subsections are simply linked. */
1000 struct dw_subsection
*link
;
1002 /* The subsection number. */
1005 /* Expression to compute the length of the section. */
1006 expressionS end_exp
;
1009 static struct dw_section
{
1010 /* Corresponding section. */
1013 /* Simply linked list of subsections with a label. */
1014 struct dw_subsection
*list_subseg
;
1016 /* The anonymous subsection. */
1017 struct dw_subsection
*anon_subseg
;
1018 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1019 #endif /* OBJ_XCOFF */
1023 /* Various sections that we need for PE coff support. */
1024 static segT ydata_section
;
1025 static segT pdata_section
;
1026 static segT reldata_section
;
1027 static segT rdata_section
;
1028 static segT tocdata_section
;
1030 /* The current section and the previous section. See ppc_previous. */
1031 static segT ppc_previous_section
;
1032 static segT ppc_current_section
;
1037 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1038 #define PPC_APUINFO_ISEL 0x40
1039 #define PPC_APUINFO_PMR 0x41
1040 #define PPC_APUINFO_RFMCI 0x42
1041 #define PPC_APUINFO_CACHELCK 0x43
1042 #define PPC_APUINFO_SPE 0x100
1043 #define PPC_APUINFO_EFS 0x101
1044 #define PPC_APUINFO_BRLOCK 0x102
1045 #define PPC_APUINFO_VLE 0x104
1048 * We keep a list of APUinfo
1050 unsigned long *ppc_apuinfo_list
;
1051 unsigned int ppc_apuinfo_num
;
1052 unsigned int ppc_apuinfo_num_alloc
;
1053 #endif /* OBJ_ELF */
1056 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1058 const char *const md_shortopts
= "um:";
1060 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1061 const struct option md_longopts
[] = {
1062 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1063 {NULL
, no_argument
, NULL
, 0}
1065 const size_t md_longopts_size
= sizeof (md_longopts
);
1068 md_parse_option (int c
, char *arg
)
1075 /* -u means that any undefined symbols should be treated as
1076 external, which is the default for gas anyhow. */
1081 /* Solaris as takes -le (presumably for little endian). For completeness
1082 sake, recognize -be also. */
1083 if (strcmp (arg
, "e") == 0)
1085 target_big_endian
= 0;
1086 set_target_endian
= 1;
1087 if (ppc_cpu
& PPC_OPCODE_VLE
)
1088 as_bad (_("the use of -mvle requires big endian."));
1096 if (strcmp (arg
, "e") == 0)
1098 target_big_endian
= 1;
1099 set_target_endian
= 1;
1107 /* Recognize -K PIC. */
1108 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1111 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1119 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1121 if (strcmp (arg
, "64") == 0)
1125 if (ppc_cpu
& PPC_OPCODE_VLE
)
1126 as_bad (_("the use of -mvle requires -a32."));
1128 as_fatal (_("%s unsupported"), "-a64");
1131 else if (strcmp (arg
, "32") == 0)
1138 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1142 if (strcmp (arg
, "vle") == 0)
1144 if (set_target_endian
&& target_big_endian
== 0)
1145 as_bad (_("the use of -mvle requires big endian."));
1147 as_bad (_("the use of -mvle requires -a32."));
1151 else if (strcmp (arg
, "regnames") == 0)
1154 else if (strcmp (arg
, "no-regnames") == 0)
1155 reg_names_p
= FALSE
;
1158 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1159 that require relocation. */
1160 else if (strcmp (arg
, "relocatable") == 0)
1162 shlib
= SHLIB_MRELOCATABLE
;
1163 ppc_flags
|= EF_PPC_RELOCATABLE
;
1166 else if (strcmp (arg
, "relocatable-lib") == 0)
1168 shlib
= SHLIB_MRELOCATABLE
;
1169 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1172 /* -memb, set embedded bit. */
1173 else if (strcmp (arg
, "emb") == 0)
1174 ppc_flags
|= EF_PPC_EMB
;
1176 /* -mlittle/-mbig set the endianness. */
1177 else if (strcmp (arg
, "little") == 0
1178 || strcmp (arg
, "little-endian") == 0)
1180 target_big_endian
= 0;
1181 set_target_endian
= 1;
1182 if (ppc_cpu
& PPC_OPCODE_VLE
)
1183 as_bad (_("the use of -mvle requires big endian."));
1186 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1188 target_big_endian
= 1;
1189 set_target_endian
= 1;
1192 else if (strcmp (arg
, "solaris") == 0)
1195 ppc_comment_chars
= ppc_solaris_comment_chars
;
1198 else if (strcmp (arg
, "no-solaris") == 0)
1201 ppc_comment_chars
= ppc_eabi_comment_chars
;
1206 as_bad (_("invalid switch -m%s"), arg
);
1212 /* -V: SVR4 argument to print version ID. */
1214 print_version_id ();
1217 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1218 should be emitted or not. FIXME: Not implemented. */
1222 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1223 rather than .stabs.excl, which is ignored by the linker.
1224 FIXME: Not implemented. */
1235 nop_limit
= strtoul (optarg
, &end
, 0);
1237 as_bad (_("--nops needs a numeric argument"));
1249 md_show_usage (FILE *stream
)
1251 fprintf (stream
, _("\
1253 -a32 generate ELF32/XCOFF32\n\
1254 -a64 generate ELF64/XCOFF64\n\
1256 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1257 -mpwr generate code for POWER (RIOS1)\n\
1258 -m601 generate code for PowerPC 601\n\
1259 -mppc, -mppc32, -m603, -m604\n\
1260 generate code for PowerPC 603/604\n\
1261 -m403 generate code for PowerPC 403\n\
1262 -m405 generate code for PowerPC 405\n\
1263 -m440 generate code for PowerPC 440\n\
1264 -m464 generate code for PowerPC 464\n\
1265 -m476 generate code for PowerPC 476\n\
1266 -m7400, -m7410, -m7450, -m7455\n\
1267 generate code for PowerPC 7400/7410/7450/7455\n\
1268 -m750cl generate code for PowerPC 750cl\n"));
1269 fprintf (stream
, _("\
1270 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1271 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1272 -mbooke generate code for 32-bit PowerPC BookE\n\
1273 -ma2 generate code for A2 architecture\n\
1274 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1275 -mpower5, -mpwr5, -mpwr5x\n\
1276 generate code for Power5 architecture\n\
1277 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1278 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1279 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1280 -mcell generate code for Cell Broadband Engine architecture\n\
1281 -mcom generate code Power/PowerPC common instructions\n\
1282 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1283 fprintf (stream
, _("\
1284 -maltivec generate code for AltiVec\n\
1285 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1286 -mhtm generate code for Hardware Transactional Memory\n\
1287 -me300 generate code for PowerPC e300 family\n\
1288 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1289 -me500mc, generate code for Freescale e500mc core complex\n\
1290 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1291 -me5500, generate code for Freescale e5500 core complex\n\
1292 -me6500, generate code for Freescale e6500 core complex\n\
1293 -mspe generate code for Motorola SPE instructions\n\
1294 -mvle generate code for Freescale VLE instructions\n\
1295 -mtitan generate code for AppliedMicro Titan core complex\n\
1296 -mregnames Allow symbolic names for registers\n\
1297 -mno-regnames Do not allow symbolic names for registers\n"));
1299 fprintf (stream
, _("\
1300 -mrelocatable support for GCC's -mrelocatble option\n\
1301 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1302 -memb set PPC_EMB bit in ELF flags\n\
1303 -mlittle, -mlittle-endian, -le\n\
1304 generate code for a little endian machine\n\
1305 -mbig, -mbig-endian, -be\n\
1306 generate code for a big endian machine\n\
1307 -msolaris generate code for Solaris\n\
1308 -mno-solaris do not generate code for Solaris\n\
1309 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1310 -V print assembler version number\n\
1311 -Qy, -Qn ignored\n"));
1313 fprintf (stream
, _("\
1314 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1317 /* Set ppc_cpu if it is not already set. */
1322 const char *default_os
= TARGET_OS
;
1323 const char *default_cpu
= TARGET_CPU
;
1325 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1328 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1329 else if (strncmp (default_os
, "aix", 3) == 0
1330 && default_os
[3] >= '4' && default_os
[3] <= '9')
1331 ppc_cpu
|= PPC_OPCODE_COMMON
;
1332 else if (strncmp (default_os
, "aix3", 4) == 0)
1333 ppc_cpu
|= PPC_OPCODE_POWER
;
1334 else if (strcmp (default_cpu
, "rs6000") == 0)
1335 ppc_cpu
|= PPC_OPCODE_POWER
;
1336 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1337 ppc_cpu
|= PPC_OPCODE_PPC
;
1339 as_fatal (_("unknown default cpu = %s, os = %s"),
1340 default_cpu
, default_os
);
1344 /* Figure out the BFD architecture to use. This function and ppc_mach
1345 are called well before md_begin, when the output file is opened. */
1347 enum bfd_architecture
1350 const char *default_cpu
= TARGET_CPU
;
1353 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1354 return bfd_arch_powerpc
;
1355 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1356 return bfd_arch_powerpc
;
1357 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1358 return bfd_arch_rs6000
;
1359 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1361 if (strcmp (default_cpu
, "rs6000") == 0)
1362 return bfd_arch_rs6000
;
1363 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1364 return bfd_arch_powerpc
;
1367 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1368 return bfd_arch_unknown
;
1375 return bfd_mach_ppc64
;
1376 else if (ppc_arch () == bfd_arch_rs6000
)
1377 return bfd_mach_rs6k
;
1378 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1379 return bfd_mach_ppc_titan
;
1380 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1381 return bfd_mach_ppc_vle
;
1383 return bfd_mach_ppc
;
1387 ppc_target_format (void)
1391 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1393 return "xcoff-powermac";
1396 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1398 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1404 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1405 # elif defined (TE_VXWORKS)
1406 return "elf32-powerpc-vxworks";
1408 return (target_big_endian
1409 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1410 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1415 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1416 Return TRUE if there's a problem, otherwise FALSE. */
1419 insn_validate (const struct powerpc_opcode
*op
)
1421 const unsigned char *o
;
1422 unsigned long omask
= op
->mask
;
1424 /* The mask had better not trim off opcode bits. */
1425 if ((op
->opcode
& omask
) != op
->opcode
)
1427 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1431 /* The operands must not overlap the opcode or each other. */
1432 for (o
= op
->operands
; *o
; ++o
)
1434 if (*o
>= num_powerpc_operands
)
1436 as_bad (_("operand index error for %s"), op
->name
);
1441 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1442 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1446 if (operand
->shift
>= 0)
1447 mask
= operand
->bitm
<< operand
->shift
;
1449 mask
= operand
->bitm
>> -operand
->shift
;
1452 as_bad (_("operand %d overlap in %s"),
1453 (int) (o
- op
->operands
), op
->name
);
1463 /* Insert opcodes and macros into hash tables. Called at startup and
1464 for .machine pseudo. */
1467 ppc_setup_opcodes (void)
1469 const struct powerpc_opcode
*op
;
1470 const struct powerpc_opcode
*op_end
;
1471 const struct powerpc_macro
*macro
;
1472 const struct powerpc_macro
*macro_end
;
1473 bfd_boolean bad_insn
= FALSE
;
1475 if (ppc_hash
!= NULL
)
1476 hash_die (ppc_hash
);
1477 if (ppc_macro_hash
!= NULL
)
1478 hash_die (ppc_macro_hash
);
1480 /* Insert the opcodes into a hash table. */
1481 ppc_hash
= hash_new ();
1483 if (ENABLE_CHECKING
)
1487 /* An index into powerpc_operands is stored in struct fix
1488 fx_pcrel_adjust which is 8 bits wide. */
1489 gas_assert (num_powerpc_operands
< 256);
1491 /* Check operand masks. Code here and in the disassembler assumes
1492 all the 1's in the mask are contiguous. */
1493 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1495 unsigned long mask
= powerpc_operands
[i
].bitm
;
1496 unsigned long right_bit
;
1499 right_bit
= mask
& -mask
;
1501 right_bit
= mask
& -mask
;
1502 if (mask
!= right_bit
)
1504 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1507 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1508 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1509 sizeof (powerpc_operands
[0])) == 0)
1511 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1518 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1519 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1521 if (ENABLE_CHECKING
)
1523 if (op
!= powerpc_opcodes
)
1525 int old_opcode
= PPC_OP (op
[-1].opcode
);
1526 int new_opcode
= PPC_OP (op
[0].opcode
);
1528 #ifdef PRINT_OPCODE_TABLE
1529 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1530 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1531 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1532 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1535 /* The major opcodes had better be sorted. Code in the
1536 disassembler assumes the insns are sorted according to
1538 if (new_opcode
< old_opcode
)
1540 as_bad (_("major opcode is not sorted for %s"),
1545 bad_insn
|= insn_validate (op
);
1548 if ((ppc_cpu
& op
->flags
) != 0
1549 && !(ppc_cpu
& op
->deprecated
))
1553 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1556 as_bad (_("duplicate instruction %s"),
1563 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1564 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1565 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1567 op_end
= vle_opcodes
+ vle_num_opcodes
;
1568 for (op
= vle_opcodes
; op
< op_end
; op
++)
1570 if (ENABLE_CHECKING
)
1572 if (op
!= vle_opcodes
)
1574 unsigned old_seg
, new_seg
;
1576 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1577 old_seg
= VLE_OP_TO_SEG (old_seg
);
1578 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1579 new_seg
= VLE_OP_TO_SEG (new_seg
);
1581 #ifdef PRINT_OPCODE_TABLE
1582 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1583 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1584 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1585 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1587 /* The major opcodes had better be sorted. Code in the
1588 disassembler assumes the insns are sorted according to
1590 if (new_seg
< old_seg
)
1592 as_bad (_("major opcode is not sorted for %s"),
1598 bad_insn
|= insn_validate (op
);
1601 if ((ppc_cpu
& op
->flags
) != 0
1602 && !(ppc_cpu
& op
->deprecated
))
1606 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1609 as_bad (_("duplicate instruction %s"),
1616 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1617 for (op
= vle_opcodes
; op
< op_end
; op
++)
1618 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1620 /* Insert the macros into a hash table. */
1621 ppc_macro_hash
= hash_new ();
1623 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1624 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1626 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1630 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1631 if (retval
!= (const char *) NULL
)
1633 as_bad (_("duplicate macro %s"), macro
->name
);
1643 /* This function is called when the assembler starts up. It is called
1644 after the options have been parsed and the output file has been
1652 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1653 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1656 /* Set the ELF flags if desired. */
1657 if (ppc_flags
&& !msolaris
)
1658 bfd_set_private_flags (stdoutput
, ppc_flags
);
1661 ppc_setup_opcodes ();
1663 /* Tell the main code what the endianness is if it is not overridden
1665 if (!set_target_endian
)
1667 set_target_endian
= 1;
1668 target_big_endian
= PPC_BIG_ENDIAN
;
1672 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1674 /* Create dummy symbols to serve as initial csects. This forces the
1675 text csects to precede the data csects. These symbols will not
1677 ppc_text_csects
= symbol_make ("dummy\001");
1678 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1679 ppc_data_csects
= symbol_make ("dummy\001");
1680 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1685 ppc_current_section
= text_section
;
1686 ppc_previous_section
= 0;
1695 if (ppc_apuinfo_list
== NULL
)
1698 /* Ok, so write the section info out. We have this layout:
1702 0 8 length of "APUinfo\0"
1703 4 (n*4) number of APU's (4 bytes each)
1706 20 APU#1 first APU's info
1707 24 APU#2 second APU's info
1712 asection
*seg
= now_seg
;
1713 subsegT subseg
= now_subseg
;
1714 asection
*apuinfo_secp
= (asection
*) NULL
;
1717 /* Create the .PPC.EMB.apuinfo section. */
1718 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1719 bfd_set_section_flags (stdoutput
,
1721 SEC_HAS_CONTENTS
| SEC_READONLY
);
1724 md_number_to_chars (p
, (valueT
) 8, 4);
1727 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1730 md_number_to_chars (p
, (valueT
) 2, 4);
1733 strcpy (p
, "APUinfo");
1735 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1738 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1741 frag_align (2, 0, 0);
1743 /* We probably can't restore the current segment, for there likely
1746 subseg_set (seg
, subseg
);
1751 /* Insert an operand value into an instruction. */
1753 static unsigned long
1754 ppc_insert_operand (unsigned long insn
,
1755 const struct powerpc_operand
*operand
,
1761 long min
, max
, right
;
1763 max
= operand
->bitm
;
1767 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1769 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1770 max
= (max
>> 1) & -right
;
1771 min
= ~max
& -right
;
1774 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1777 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1786 /* Some people write constants with the sign extension done by
1787 hand but only up to 32 bits. This shouldn't really be valid,
1788 but, to permit this code to assemble on a 64-bit host, we
1789 sign extend the 32-bit value to 64 bits if so doing makes the
1792 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1793 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1794 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1795 val
= val
- 0x80000000 - 0x80000000;
1797 /* Similarly, people write expressions like ~(1<<15), and expect
1798 this to be OK for a 32-bit unsigned value. */
1800 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1801 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1802 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1803 val
= val
+ 0x80000000 + 0x80000000;
1807 || (val
& (right
- 1)) != 0)
1808 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1811 if (operand
->insert
)
1816 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1817 if (errmsg
!= (const char *) NULL
)
1818 as_bad_where (file
, line
, "%s", errmsg
);
1820 else if (operand
->shift
>= 0)
1821 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1823 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1830 /* Parse @got, etc. and return the desired relocation. */
1831 static bfd_reloc_code_real_type
1832 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1836 unsigned int length
: 8;
1837 unsigned int valid32
: 1;
1838 unsigned int valid64
: 1;
1847 const struct map_bfd
*ptr
;
1849 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1850 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1851 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1853 static const struct map_bfd mapping
[] = {
1854 MAP ("l", BFD_RELOC_LO16
),
1855 MAP ("h", BFD_RELOC_HI16
),
1856 MAP ("ha", BFD_RELOC_HI16_S
),
1857 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1858 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1859 MAP ("got", BFD_RELOC_16_GOTOFF
),
1860 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1861 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1862 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1863 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1864 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1865 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1866 MAP ("copy", BFD_RELOC_PPC_COPY
),
1867 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1868 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1869 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1870 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1871 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1872 MAP ("tls", BFD_RELOC_PPC_TLS
),
1873 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1874 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1875 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1876 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1877 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1878 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1879 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1880 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1881 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1882 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1883 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1884 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1885 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1886 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1887 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1888 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1889 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1890 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1891 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1892 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1893 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1894 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1895 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1896 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1897 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1898 MAP32 ("fixup", BFD_RELOC_CTOR
),
1899 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1900 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1901 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1902 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1903 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1904 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1905 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1906 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1907 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1908 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1909 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1910 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1911 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1912 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1913 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1914 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1915 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1916 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1917 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1918 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1919 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1920 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1921 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1922 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1923 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1924 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1925 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1926 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1927 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1928 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1929 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1930 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1931 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1932 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1933 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1934 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1935 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1936 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1937 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1938 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1939 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1940 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1941 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1942 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1943 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1947 return BFD_RELOC_UNUSED
;
1949 for (ch
= *str
, str2
= ident
;
1950 (str2
< ident
+ sizeof (ident
) - 1
1951 && (ISALNUM (ch
) || ch
== '@'));
1954 *str2
++ = TOLOWER (ch
);
1961 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1962 if (ch
== ptr
->string
[0]
1963 && len
== ptr
->length
1964 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1965 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1967 int reloc
= ptr
->reloc
;
1969 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1973 case BFD_RELOC_16_GOTOFF
:
1974 case BFD_RELOC_LO16_GOTOFF
:
1975 case BFD_RELOC_HI16_GOTOFF
:
1976 case BFD_RELOC_HI16_S_GOTOFF
:
1977 as_warn (_("identifier+constant@got means "
1978 "identifier@got+constant"));
1981 case BFD_RELOC_PPC_GOT_TLSGD16
:
1982 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
1983 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
1984 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
1985 case BFD_RELOC_PPC_GOT_TLSLD16
:
1986 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
1987 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
1988 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
1989 case BFD_RELOC_PPC_GOT_DTPREL16
:
1990 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
1991 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
1992 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
1993 case BFD_RELOC_PPC_GOT_TPREL16
:
1994 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
1995 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
1996 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
1997 as_bad (_("symbol+offset not supported for got tls"));
2002 /* Now check for identifier@suffix+constant. */
2003 if (*str
== '-' || *str
== '+')
2005 char *orig_line
= input_line_pointer
;
2006 expressionS new_exp
;
2008 input_line_pointer
= str
;
2009 expression (&new_exp
);
2010 if (new_exp
.X_op
== O_constant
)
2012 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2013 str
= input_line_pointer
;
2016 if (&input_line_pointer
!= str_p
)
2017 input_line_pointer
= orig_line
;
2021 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2022 && exp_p
->X_op
== O_symbol
2023 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2025 /* Change the symbol so that the dummy .TOC. symbol can be
2026 omitted from the object file. */
2027 exp_p
->X_add_symbol
= &abs_symbol
;
2030 return (bfd_reloc_code_real_type
) reloc
;
2033 return BFD_RELOC_UNUSED
;
2036 /* Like normal .long/.short/.word, except support @got, etc.
2037 Clobbers input_line_pointer, checks end-of-line. */
2039 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2042 bfd_reloc_code_real_type reloc
;
2044 if (is_it_end_of_statement ())
2046 demand_empty_rest_of_line ();
2053 if (exp
.X_op
== O_symbol
2054 && *input_line_pointer
== '@'
2055 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2056 &exp
)) != BFD_RELOC_UNUSED
)
2058 reloc_howto_type
*reloc_howto
;
2061 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2062 size
= bfd_get_reloc_size (reloc_howto
);
2066 as_bad (_("%s relocations do not fit in %d bytes\n"),
2067 reloc_howto
->name
, nbytes
);
2074 p
= frag_more (nbytes
);
2075 memset (p
, 0, nbytes
);
2077 if (target_big_endian
)
2078 offset
= nbytes
- size
;
2079 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2084 emit_expr (&exp
, (unsigned int) nbytes
);
2086 while (*input_line_pointer
++ == ',');
2088 /* Put terminator back into stream. */
2089 input_line_pointer
--;
2090 demand_empty_rest_of_line ();
2093 /* Solaris pseduo op to change to the .rodata section. */
2095 ppc_elf_rdata (int xxx
)
2097 char *save_line
= input_line_pointer
;
2098 static char section
[] = ".rodata\n";
2100 /* Just pretend this is .section .rodata */
2101 input_line_pointer
= section
;
2102 obj_elf_section (xxx
);
2104 input_line_pointer
= save_line
;
2107 /* Pseudo op to make file scope bss items. */
2109 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2122 name
= input_line_pointer
;
2123 c
= get_symbol_end ();
2125 /* just after name is now '\0'. */
2126 p
= input_line_pointer
;
2129 if (*input_line_pointer
!= ',')
2131 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2132 ignore_rest_of_line ();
2136 input_line_pointer
++; /* skip ',' */
2137 if ((size
= get_absolute_expression ()) < 0)
2139 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2140 ignore_rest_of_line ();
2144 /* The third argument to .lcomm is the alignment. */
2145 if (*input_line_pointer
!= ',')
2149 ++input_line_pointer
;
2150 align
= get_absolute_expression ();
2153 as_warn (_("ignoring bad alignment"));
2159 symbolP
= symbol_find_or_make (name
);
2162 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2164 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2165 S_GET_NAME (symbolP
));
2166 ignore_rest_of_line ();
2170 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2172 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2173 S_GET_NAME (symbolP
),
2174 (long) S_GET_VALUE (symbolP
),
2177 ignore_rest_of_line ();
2183 old_subsec
= now_subseg
;
2186 /* Convert to a power of 2 alignment. */
2187 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2190 as_bad (_("common alignment not a power of 2"));
2191 ignore_rest_of_line ();
2198 record_alignment (bss_section
, align2
);
2199 subseg_set (bss_section
, 1);
2201 frag_align (align2
, 0, 0);
2202 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2203 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2204 symbol_set_frag (symbolP
, frag_now
);
2205 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2208 S_SET_SIZE (symbolP
, size
);
2209 S_SET_SEGMENT (symbolP
, bss_section
);
2210 subseg_set (old_sec
, old_subsec
);
2211 demand_empty_rest_of_line ();
2214 /* Validate any relocations emitted for -mrelocatable, possibly adding
2215 fixups for word relocations in writable segments, so we can adjust
2218 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2220 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2229 case SHLIB_MRELOCATABLE
:
2230 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2231 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2232 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2233 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2234 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2235 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2236 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2237 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2238 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2239 && (seg
->flags
& SEC_LOAD
) != 0
2240 && strcmp (segment_name (seg
), ".got2") != 0
2241 && strcmp (segment_name (seg
), ".dtors") != 0
2242 && strcmp (segment_name (seg
), ".ctors") != 0
2243 && strcmp (segment_name (seg
), ".fixup") != 0
2244 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2245 && strcmp (segment_name (seg
), ".eh_frame") != 0
2246 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2248 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2249 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2251 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2252 _("relocation cannot be done when using -mrelocatable"));
2259 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2260 function descriptor sym if the corresponding code sym is used. */
2263 ppc_frob_file_before_adjust (void)
2271 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2278 name
= S_GET_NAME (symp
);
2282 if (! S_IS_WEAK (symp
)
2283 || S_IS_DEFINED (symp
))
2286 len
= strlen (name
) + 1;
2287 dotname
= xmalloc (len
+ 1);
2289 memcpy (dotname
+ 1, name
, len
);
2290 dotsym
= symbol_find_noref (dotname
, 1);
2292 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2293 || symbol_used_in_reloc_p (dotsym
)))
2294 symbol_mark_used (symp
);
2298 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2300 && toc_reloc_types
!= has_large_toc_reloc
2301 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2302 as_warn (_("TOC section size exceeds 64k"));
2305 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2306 emitted. Other uses of .TOC. will cause the symbol to be marked
2307 with BSF_KEEP in md_apply_fix. */
2310 ppc_elf_adjust_symtab (void)
2315 symp
= symbol_find (".TOC.");
2318 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2319 if ((bsym
->flags
& BSF_KEEP
) == 0)
2320 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2324 #endif /* OBJ_ELF */
2329 * Summary of parse_toc_entry.
2331 * in: Input_line_pointer points to the '[' in one of:
2333 * [toc] [tocv] [toc32] [toc64]
2335 * Anything else is an error of one kind or another.
2338 * return value: success or failure
2339 * toc_kind: kind of toc reference
2340 * input_line_pointer:
2341 * success: first char after the ']'
2342 * failure: unchanged
2346 * [toc] - rv == success, toc_kind = default_toc
2347 * [tocv] - rv == success, toc_kind = data_in_toc
2348 * [toc32] - rv == success, toc_kind = must_be_32
2349 * [toc64] - rv == success, toc_kind = must_be_64
2353 enum toc_size_qualifier
2355 default_toc
, /* The toc cell constructed should be the system default size */
2356 data_in_toc
, /* This is a direct reference to a toc cell */
2357 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2358 must_be_64
/* The toc cell constructed must be 64 bits wide */
2362 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2367 enum toc_size_qualifier t
;
2369 /* Save the input_line_pointer. */
2370 start
= input_line_pointer
;
2372 /* Skip over the '[' , and whitespace. */
2373 ++input_line_pointer
;
2376 /* Find the spelling of the operand. */
2377 toc_spec
= input_line_pointer
;
2378 c
= get_symbol_end ();
2380 if (strcmp (toc_spec
, "toc") == 0)
2384 else if (strcmp (toc_spec
, "tocv") == 0)
2388 else if (strcmp (toc_spec
, "toc32") == 0)
2392 else if (strcmp (toc_spec
, "toc64") == 0)
2398 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2399 *input_line_pointer
= c
;
2400 input_line_pointer
= start
;
2404 /* Now find the ']'. */
2405 *input_line_pointer
= c
;
2407 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2408 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2412 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2413 input_line_pointer
= start
;
2422 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2423 /* See whether a symbol is in the TOC section. */
2426 ppc_is_toc_sym (symbolS
*sym
)
2429 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2430 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2433 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2435 return strcmp (sname
, ".toc") == 0;
2437 return strcmp (sname
, ".got") == 0;
2440 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2444 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2446 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2450 /* Check we don't already exist. */
2451 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2452 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2455 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2457 if (ppc_apuinfo_num_alloc
== 0)
2459 ppc_apuinfo_num_alloc
= 4;
2460 ppc_apuinfo_list
= (unsigned long *)
2461 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2465 ppc_apuinfo_num_alloc
+= 4;
2466 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2467 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2470 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2476 /* We need to keep a list of fixups. We can't simply generate them as
2477 we go, because that would require us to first create the frag, and
2478 that would screw up references to ``.''. */
2484 bfd_reloc_code_real_type reloc
;
2487 #define MAX_INSN_FIXUPS (5)
2490 #define E_OR2I_INSN 0x7000C000
2491 #define E_AND2I_DOT_INSN 0x7000C800
2492 #define E_OR2IS_INSN 0x7000D000
2493 #define E_LIS_INSN 0x7000E000
2494 #define E_AND2IS_DOT_INSN 0x7000E800
2497 #define E_ADD2I_DOT_INSN 0x70008800
2498 #define E_ADD2IS_INSN 0x70009000
2499 #define E_CMP16I_INSN 0x70009800
2500 #define E_MULL2I_INSN 0x7000A000
2501 #define E_CMPL16I_INSN 0x7000A800
2502 #define E_CMPH16I_INSN 0x7000B000
2503 #define E_CMPHL16I_INSN 0x7000B800
2505 /* This routine is called for each instruction to be assembled. */
2508 md_assemble (char *str
)
2511 const struct powerpc_opcode
*opcode
;
2513 const unsigned char *opindex_ptr
;
2517 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2522 unsigned int insn_length
;
2524 /* Get the opcode. */
2525 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2530 /* Look up the opcode in the hash table. */
2531 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2532 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2534 const struct powerpc_macro
*macro
;
2536 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2537 if (macro
== (const struct powerpc_macro
*) NULL
)
2538 as_bad (_("unrecognized opcode: `%s'"), str
);
2540 ppc_macro (s
, macro
);
2545 insn
= opcode
->opcode
;
2548 while (ISSPACE (*str
))
2551 /* PowerPC operands are just expressions. The only real issue is
2552 that a few operand types are optional. All cases which might use
2553 an optional operand separate the operands only with commas (in some
2554 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2555 have optional operands). Most instructions with optional operands
2556 have only one. Those that have more than one optional operand can
2557 take either all their operands or none. So, before we start seriously
2558 parsing the operands, we check to see if we have optional operands,
2559 and if we do, we count the number of commas to see which operands
2560 have been omitted. */
2562 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2564 const struct powerpc_operand
*operand
;
2566 operand
= &powerpc_operands
[*opindex_ptr
];
2567 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2569 unsigned int opcount
;
2570 unsigned int num_operands_expected
;
2572 /* There is an optional operand. Count the number of
2573 commas in the input line. */
2580 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2587 /* Compute the number of expected operands.
2588 Do not count fake operands. */
2589 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2590 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2591 ++ num_operands_expected
;
2593 /* If there are fewer operands in the line then are called
2594 for by the instruction, we want to skip the optional
2596 if (opcount
< num_operands_expected
)
2603 /* Gather the operands. */
2607 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2609 const struct powerpc_operand
*operand
;
2615 if (next_opindex
== 0)
2616 operand
= &powerpc_operands
[*opindex_ptr
];
2619 operand
= &powerpc_operands
[next_opindex
];
2624 /* If this is a fake operand, then we do not expect anything
2626 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2628 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2629 if (errmsg
!= (const char *) NULL
)
2630 as_bad ("%s", errmsg
);
2634 /* If this is an optional operand, and we are skipping it, just
2636 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2639 if (operand
->insert
)
2641 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2642 if (errmsg
!= (const char *) NULL
)
2643 as_bad ("%s", errmsg
);
2645 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2646 next_opindex
= *opindex_ptr
+ 1;
2650 /* Gather the operand. */
2651 hold
= input_line_pointer
;
2652 input_line_pointer
= str
;
2655 if (*input_line_pointer
== '[')
2657 /* We are expecting something like the second argument here:
2659 * lwz r4,[toc].GS.0.static_int(rtoc)
2660 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2661 * The argument following the `]' must be a symbol name, and the
2662 * register must be the toc register: 'rtoc' or '2'
2664 * The effect is to 0 as the displacement field
2665 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2666 * the appropriate variation) reloc against it based on the symbol.
2667 * The linker will build the toc, and insert the resolved toc offset.
2670 * o The size of the toc entry is currently assumed to be
2671 * 32 bits. This should not be assumed to be a hard coded
2673 * o In an effort to cope with a change from 32 to 64 bits,
2674 * there are also toc entries that are specified to be
2675 * either 32 or 64 bits:
2676 * lwz r4,[toc32].GS.0.static_int(rtoc)
2677 * lwz r4,[toc64].GS.0.static_int(rtoc)
2678 * These demand toc entries of the specified size, and the
2679 * instruction probably requires it.
2683 enum toc_size_qualifier toc_kind
;
2684 bfd_reloc_code_real_type toc_reloc
;
2686 /* Go parse off the [tocXX] part. */
2687 valid_toc
= parse_toc_entry (&toc_kind
);
2691 ignore_rest_of_line ();
2695 /* Now get the symbol following the ']'. */
2701 /* In this case, we may not have seen the symbol yet,
2702 since it is allowed to appear on a .extern or .globl
2703 or just be a label in the .data section. */
2704 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2707 /* 1. The symbol must be defined and either in the toc
2708 section, or a global.
2709 2. The reloc generated must have the TOCDEFN flag set
2710 in upper bit mess of the reloc type.
2711 FIXME: It's a little confusing what the tocv
2712 qualifier can be used for. At the very least, I've
2713 seen three uses, only one of which I'm sure I can
2715 if (ex
.X_op
== O_symbol
)
2717 gas_assert (ex
.X_add_symbol
!= NULL
);
2718 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2721 as_bad (_("[tocv] symbol is not a toc symbol"));
2725 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2728 /* FIXME: these next two specifically specify 32/64 bit
2729 toc entries. We don't support them today. Is this
2730 the right way to say that? */
2731 toc_reloc
= BFD_RELOC_UNUSED
;
2732 as_bad (_("unimplemented toc32 expression modifier"));
2735 /* FIXME: see above. */
2736 toc_reloc
= BFD_RELOC_UNUSED
;
2737 as_bad (_("unimplemented toc64 expression modifier"));
2741 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2747 /* We need to generate a fixup for this expression. */
2748 if (fc
>= MAX_INSN_FIXUPS
)
2749 as_fatal (_("too many fixups"));
2751 fixups
[fc
].reloc
= toc_reloc
;
2752 fixups
[fc
].exp
= ex
;
2753 fixups
[fc
].opindex
= *opindex_ptr
;
2756 /* Ok. We've set up the fixup for the instruction. Now make it
2757 look like the constant 0 was found here. */
2759 ex
.X_op
= O_constant
;
2760 ex
.X_add_number
= 0;
2761 ex
.X_add_symbol
= NULL
;
2762 ex
.X_op_symbol
= NULL
;
2769 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2770 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2771 || !register_name (&ex
))
2773 char save_lex
= lex_type
['%'];
2775 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2776 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2779 lex_type
['%'] |= LEX_BEGIN_NAME
;
2783 lex_type
['%'] = save_lex
;
2787 str
= input_line_pointer
;
2788 input_line_pointer
= hold
;
2790 if (ex
.X_op
== O_illegal
)
2791 as_bad (_("illegal operand"));
2792 else if (ex
.X_op
== O_absent
)
2793 as_bad (_("missing operand"));
2794 else if (ex
.X_op
== O_register
)
2796 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2797 ppc_cpu
, (char *) NULL
, 0);
2799 else if (ex
.X_op
== O_constant
)
2802 /* Allow @HA, @L, @H on constants. */
2803 bfd_reloc_code_real_type reloc
;
2804 char *orig_str
= str
;
2806 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2813 case BFD_RELOC_LO16
:
2814 /* X_unsigned is the default, so if the user has done
2815 something which cleared it, we always produce a
2817 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2818 ex
.X_add_number
&= 0xffff;
2820 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2823 case BFD_RELOC_HI16
:
2824 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2825 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2827 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2830 case BFD_RELOC_HI16_S
:
2831 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2832 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2834 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2837 case BFD_RELOC_PPC64_HIGHER
:
2838 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2839 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2841 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2844 case BFD_RELOC_PPC64_HIGHER_S
:
2845 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2846 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2848 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2851 case BFD_RELOC_PPC64_HIGHEST
:
2852 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2853 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2855 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2858 case BFD_RELOC_PPC64_HIGHEST_S
:
2859 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2860 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2862 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2865 #endif /* OBJ_ELF */
2866 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2867 ppc_cpu
, (char *) NULL
, 0);
2871 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
2873 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2875 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2876 if (sym_name
[0] == '.')
2879 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2881 expressionS tls_exp
;
2883 hold
= input_line_pointer
;
2884 input_line_pointer
= str
+ 1;
2885 expression (&tls_exp
);
2886 if (tls_exp
.X_op
== O_symbol
)
2888 reloc
= BFD_RELOC_UNUSED
;
2889 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2891 reloc
= BFD_RELOC_PPC_TLSGD
;
2892 input_line_pointer
+= 7;
2894 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2896 reloc
= BFD_RELOC_PPC_TLSLD
;
2897 input_line_pointer
+= 7;
2899 if (reloc
!= BFD_RELOC_UNUSED
)
2902 str
= input_line_pointer
;
2904 if (fc
>= MAX_INSN_FIXUPS
)
2905 as_fatal (_("too many fixups"));
2906 fixups
[fc
].exp
= tls_exp
;
2907 fixups
[fc
].opindex
= *opindex_ptr
;
2908 fixups
[fc
].reloc
= reloc
;
2912 input_line_pointer
= hold
;
2916 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2918 /* Some TLS tweaks. */
2924 case BFD_RELOC_PPC_TLS
:
2925 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2926 as_bad (_("@tls may not be used with \"%s\" operands"),
2928 else if (operand
->shift
!= 11)
2929 as_bad (_("@tls may only be used in last operand"));
2931 insn
= ppc_insert_operand (insn
, operand
,
2933 ppc_cpu
, (char *) NULL
, 0);
2936 /* We'll only use the 32 (or 64) bit form of these relocations
2937 in constants. Instructions get the 16 bit form. */
2938 case BFD_RELOC_PPC_DTPREL
:
2939 reloc
= BFD_RELOC_PPC_DTPREL16
;
2941 case BFD_RELOC_PPC_TPREL
:
2942 reloc
= BFD_RELOC_PPC_TPREL16
;
2946 /* If VLE-mode convert LO/HI/HA relocations. */
2947 if (opcode
->flags
& PPC_OPCODE_VLE
)
2949 int tmp_insn
= insn
& opcode
->mask
;
2951 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
2952 || tmp_insn
== E_AND2I_DOT_INSN
2953 || tmp_insn
== E_OR2IS_INSN
2954 || tmp_insn
== E_LIS_INSN
2955 || tmp_insn
== E_AND2IS_DOT_INSN
);
2958 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
2959 || tmp_insn
== E_ADD2IS_INSN
2960 || tmp_insn
== E_CMP16I_INSN
2961 || tmp_insn
== E_MULL2I_INSN
2962 || tmp_insn
== E_CMPL16I_INSN
2963 || tmp_insn
== E_CMPH16I_INSN
2964 || tmp_insn
== E_CMPHL16I_INSN
);
2971 case BFD_RELOC_PPC_EMB_SDA21
:
2972 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
2975 case BFD_RELOC_LO16
:
2977 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
2978 else if (use_a_reloc
)
2979 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
2982 case BFD_RELOC_HI16
:
2984 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
2985 else if (use_a_reloc
)
2986 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
2989 case BFD_RELOC_HI16_S
:
2991 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
2992 else if (use_a_reloc
)
2993 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
2996 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
2998 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3001 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3003 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3006 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3008 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3013 /* For the absolute forms of branches, convert the PC
3014 relative form back into the absolute. */
3015 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3019 case BFD_RELOC_PPC_B26
:
3020 reloc
= BFD_RELOC_PPC_BA26
;
3022 case BFD_RELOC_PPC_B16
:
3023 reloc
= BFD_RELOC_PPC_BA16
;
3025 case BFD_RELOC_PPC_B16_BRTAKEN
:
3026 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3028 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3029 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3038 case BFD_RELOC_PPC_TOC16
:
3039 toc_reloc_types
|= has_small_toc_reloc
;
3041 case BFD_RELOC_PPC64_TOC16_LO
:
3042 case BFD_RELOC_PPC64_TOC16_HI
:
3043 case BFD_RELOC_PPC64_TOC16_HA
:
3044 toc_reloc_types
|= has_large_toc_reloc
;
3050 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3055 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3057 case BFD_RELOC_LO16
:
3058 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3060 case BFD_RELOC_16_GOTOFF
:
3061 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3063 case BFD_RELOC_LO16_GOTOFF
:
3064 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3066 case BFD_RELOC_LO16_PLTOFF
:
3067 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3069 case BFD_RELOC_16_BASEREL
:
3070 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3072 case BFD_RELOC_LO16_BASEREL
:
3073 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3075 case BFD_RELOC_PPC_TOC16
:
3076 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3078 case BFD_RELOC_PPC64_TOC16_LO
:
3079 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3081 case BFD_RELOC_PPC64_PLTGOT16
:
3082 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3084 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3085 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3087 case BFD_RELOC_PPC_DTPREL16
:
3088 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3090 case BFD_RELOC_PPC_DTPREL16_LO
:
3091 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3093 case BFD_RELOC_PPC_TPREL16
:
3094 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3096 case BFD_RELOC_PPC_TPREL16_LO
:
3097 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3099 case BFD_RELOC_PPC_GOT_DTPREL16
:
3100 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3101 case BFD_RELOC_PPC_GOT_TPREL16
:
3102 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3105 as_bad (_("unsupported relocation for DS offset field"));
3110 #endif /* OBJ_ELF */
3112 if (reloc
!= BFD_RELOC_UNUSED
)
3114 /* Determine a BFD reloc value based on the operand information.
3115 We are only prepared to turn a few of the operands into
3117 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3118 && operand
->bitm
== 0x3fffffc
3119 && operand
->shift
== 0)
3120 reloc
= BFD_RELOC_PPC_B26
;
3121 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3122 && operand
->bitm
== 0xfffc
3123 && operand
->shift
== 0)
3124 reloc
= BFD_RELOC_PPC_B16
;
3125 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3126 && operand
->bitm
== 0x1fe
3127 && operand
->shift
== -1)
3128 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3129 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3130 && operand
->bitm
== 0xfffe
3131 && operand
->shift
== 0)
3132 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3133 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3134 && operand
->bitm
== 0x1fffffe
3135 && operand
->shift
== 0)
3136 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3137 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3138 && operand
->bitm
== 0x3fffffc
3139 && operand
->shift
== 0)
3140 reloc
= BFD_RELOC_PPC_BA26
;
3141 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3142 && operand
->bitm
== 0xfffc
3143 && operand
->shift
== 0)
3144 reloc
= BFD_RELOC_PPC_BA16
;
3145 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3146 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3147 && (operand
->bitm
& 0xfff0) == 0xfff0
3148 && operand
->shift
== 0)
3150 if (ppc_is_toc_sym (ex
.X_add_symbol
))
3152 reloc
= BFD_RELOC_PPC_TOC16
;
3155 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3156 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3161 reloc
= BFD_RELOC_16
;
3164 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3165 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3169 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3171 /* We need to generate a fixup for this expression. */
3172 if (fc
>= MAX_INSN_FIXUPS
)
3173 as_fatal (_("too many fixups"));
3174 fixups
[fc
].exp
= ex
;
3175 fixups
[fc
].opindex
= *opindex_ptr
;
3176 fixups
[fc
].reloc
= reloc
;
3184 /* If expecting more operands, then we want to see "),". */
3185 if (*str
== endc
&& opindex_ptr
[1] != 0)
3189 while (ISSPACE (*str
));
3193 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3201 /* The call to expression should have advanced str past any
3204 && (endc
!= ',' || *str
!= '\0'))
3207 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3209 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3217 while (ISSPACE (*str
))
3221 as_bad (_("junk at end of line: `%s'"), str
);
3224 /* Do we need/want an APUinfo section? */
3225 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3228 /* These are all version "1". */
3229 if (opcode
->flags
& PPC_OPCODE_SPE
)
3230 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3231 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3232 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3233 if (opcode
->flags
& PPC_OPCODE_EFS
)
3234 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3235 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3236 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3237 if (opcode
->flags
& PPC_OPCODE_PMR
)
3238 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3239 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3240 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3241 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3242 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3243 if (opcode
->flags
& PPC_OPCODE_VLE
)
3244 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3248 /* Write out the instruction. */
3249 /* Differentiate between two and four byte insns. */
3250 if (ppc_mach () == bfd_mach_ppc_vle
)
3252 if (PPC_OP_SE_VLE (insn
))
3256 addr_mod
= frag_now_fix () & 1;
3261 addr_mod
= frag_now_fix () & 3;
3263 /* All instructions can start on a 2 byte boundary for VLE. */
3264 f
= frag_more (insn_length
);
3265 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3267 if (ppc_mach() == bfd_mach_ppc_vle
)
3268 as_bad (_("instruction address is not a multiple of 2"));
3270 as_bad (_("instruction address is not a multiple of 4"));
3272 frag_now
->insn_addr
= addr_mod
;
3273 frag_now
->has_code
= 1;
3274 md_number_to_chars (f
, insn
, insn_length
);
3277 dwarf2_emit_insn (insn_length
);
3280 /* Create any fixups. */
3281 for (i
= 0; i
< fc
; i
++)
3284 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3286 reloc_howto_type
*reloc_howto
;
3290 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3294 size
= bfd_get_reloc_size (reloc_howto
);
3295 offset
= target_big_endian
? (insn_length
- size
) : 0;
3297 if (size
< 1 || size
> 4)
3300 fixP
= fix_new_exp (frag_now
,
3301 f
- frag_now
->fr_literal
+ offset
,
3304 reloc_howto
->pc_relative
,
3309 const struct powerpc_operand
*operand
;
3311 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3312 fixP
= fix_new_exp (frag_now
,
3313 f
- frag_now
->fr_literal
,
3316 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3319 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3323 /* Handle a macro. Gather all the operands, transform them as
3324 described by the macro, and call md_assemble recursively. All the
3325 operands are separated by commas; we don't accept parentheses
3326 around operands here. */
3329 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3340 /* Gather the users operands into the operands array. */
3345 if (count
>= sizeof operands
/ sizeof operands
[0])
3347 operands
[count
++] = s
;
3348 s
= strchr (s
, ',');
3349 if (s
== (char *) NULL
)
3354 if (count
!= macro
->operands
)
3356 as_bad (_("wrong number of operands"));
3360 /* Work out how large the string must be (the size is unbounded
3361 because it includes user input). */
3363 format
= macro
->format
;
3364 while (*format
!= '\0')
3373 arg
= strtol (format
+ 1, &send
, 10);
3374 know (send
!= format
&& arg
< count
);
3375 len
+= strlen (operands
[arg
]);
3380 /* Put the string together. */
3381 complete
= s
= (char *) alloca (len
+ 1);
3382 format
= macro
->format
;
3383 while (*format
!= '\0')
3389 arg
= strtol (format
+ 1, &send
, 10);
3390 strcpy (s
, operands
[arg
]);
3397 /* Assemble the constructed instruction. */
3398 md_assemble (complete
);
3402 /* For ELF, add support for SHT_ORDERED. */
3405 ppc_section_type (char *str
, size_t len
)
3407 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3414 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3416 if (type
== SHT_ORDERED
)
3417 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3421 #endif /* OBJ_ELF */
3424 /* Pseudo-op handling. */
3426 /* The .byte pseudo-op. This is similar to the normal .byte
3427 pseudo-op, but it can also take a single ASCII string. */
3430 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3432 if (*input_line_pointer
!= '\"')
3438 /* Gather characters. A real double quote is doubled. Unusual
3439 characters are not permitted. */
3440 ++input_line_pointer
;
3445 c
= *input_line_pointer
++;
3449 if (*input_line_pointer
!= '\"')
3451 ++input_line_pointer
;
3454 FRAG_APPEND_1_CHAR (c
);
3457 demand_empty_rest_of_line ();
3462 /* XCOFF specific pseudo-op handling. */
3464 /* This is set if we are creating a .stabx symbol, since we don't want
3465 to handle symbol suffixes for such symbols. */
3466 static bfd_boolean ppc_stab_symbol
;
3468 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3469 symbols in the .bss segment as though they were local common
3470 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3471 aligns .comm and .lcomm to 4 bytes. */
3474 ppc_comm (int lcomm
)
3476 asection
*current_seg
= now_seg
;
3477 subsegT current_subseg
= now_subseg
;
3483 symbolS
*lcomm_sym
= NULL
;
3487 name
= input_line_pointer
;
3488 endc
= get_symbol_end ();
3489 end_name
= input_line_pointer
;
3492 if (*input_line_pointer
!= ',')
3494 as_bad (_("missing size"));
3495 ignore_rest_of_line ();
3498 ++input_line_pointer
;
3500 size
= get_absolute_expression ();
3503 as_bad (_("negative size"));
3504 ignore_rest_of_line ();
3510 /* The third argument to .comm is the alignment. */
3511 if (*input_line_pointer
!= ',')
3515 ++input_line_pointer
;
3516 align
= get_absolute_expression ();
3519 as_warn (_("ignoring bad alignment"));
3529 /* The third argument to .lcomm appears to be the real local
3530 common symbol to create. References to the symbol named in
3531 the first argument are turned into references to the third
3533 if (*input_line_pointer
!= ',')
3535 as_bad (_("missing real symbol name"));
3536 ignore_rest_of_line ();
3539 ++input_line_pointer
;
3541 lcomm_name
= input_line_pointer
;
3542 lcomm_endc
= get_symbol_end ();
3544 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3546 *input_line_pointer
= lcomm_endc
;
3548 /* The fourth argument to .lcomm is the alignment. */
3549 if (*input_line_pointer
!= ',')
3558 ++input_line_pointer
;
3559 align
= get_absolute_expression ();
3562 as_warn (_("ignoring bad alignment"));
3569 sym
= symbol_find_or_make (name
);
3572 if (S_IS_DEFINED (sym
)
3573 || S_GET_VALUE (sym
) != 0)
3575 as_bad (_("attempt to redefine symbol"));
3576 ignore_rest_of_line ();
3580 record_alignment (bss_section
, align
);
3583 || ! S_IS_DEFINED (lcomm_sym
))
3592 S_SET_EXTERNAL (sym
);
3596 symbol_get_tc (lcomm_sym
)->output
= 1;
3597 def_sym
= lcomm_sym
;
3601 subseg_set (bss_section
, 1);
3602 frag_align (align
, 0, 0);
3604 symbol_set_frag (def_sym
, frag_now
);
3605 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3606 def_size
, (char *) NULL
);
3608 S_SET_SEGMENT (def_sym
, bss_section
);
3609 symbol_get_tc (def_sym
)->align
= align
;
3613 /* Align the size of lcomm_sym. */
3614 symbol_get_frag (lcomm_sym
)->fr_offset
=
3615 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3616 &~ ((1 << align
) - 1));
3617 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3618 symbol_get_tc (lcomm_sym
)->align
= align
;
3623 /* Make sym an offset from lcomm_sym. */
3624 S_SET_SEGMENT (sym
, bss_section
);
3625 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3626 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3627 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3630 subseg_set (current_seg
, current_subseg
);
3632 demand_empty_rest_of_line ();
3635 /* The .csect pseudo-op. This switches us into a different
3636 subsegment. The first argument is a symbol whose value is the
3637 start of the .csect. In COFF, csect symbols get special aux
3638 entries defined by the x_csect field of union internal_auxent. The
3639 optional second argument is the alignment (the default is 2). */
3642 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3649 name
= input_line_pointer
;
3650 endc
= get_symbol_end ();
3652 sym
= symbol_find_or_make (name
);
3654 *input_line_pointer
= endc
;
3656 if (S_GET_NAME (sym
)[0] == '\0')
3658 /* An unnamed csect is assumed to be [PR]. */
3659 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3663 if (*input_line_pointer
== ',')
3665 ++input_line_pointer
;
3666 align
= get_absolute_expression ();
3669 ppc_change_csect (sym
, align
);
3671 demand_empty_rest_of_line ();
3674 /* Change to a different csect. */
3677 ppc_change_csect (symbolS
*sym
, offsetT align
)
3679 if (S_IS_DEFINED (sym
))
3680 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3690 /* This is a new csect. We need to look at the symbol class to
3691 figure out whether it should go in the text section or the
3695 switch (symbol_get_tc (sym
)->symbol_class
)
3705 S_SET_SEGMENT (sym
, text_section
);
3706 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3707 ++ppc_text_subsegment
;
3708 list_ptr
= &ppc_text_csects
;
3718 if (ppc_toc_csect
!= NULL
3719 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3720 == ppc_data_subsegment
))
3722 S_SET_SEGMENT (sym
, data_section
);
3723 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3724 ++ppc_data_subsegment
;
3725 list_ptr
= &ppc_data_csects
;
3731 /* We set the obstack chunk size to a small value before
3732 changing subsegments, so that we don't use a lot of memory
3733 space for what may be a small section. */
3734 hold_chunksize
= chunksize
;
3737 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3738 symbol_get_tc (sym
)->subseg
);
3740 chunksize
= hold_chunksize
;
3743 ppc_after_toc_frag
= frag_now
;
3745 record_alignment (sec
, align
);
3747 frag_align_code (align
, 0);
3749 frag_align (align
, 0, 0);
3751 symbol_set_frag (sym
, frag_now
);
3752 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3754 symbol_get_tc (sym
)->align
= align
;
3755 symbol_get_tc (sym
)->output
= 1;
3756 symbol_get_tc (sym
)->within
= sym
;
3758 for (list
= *list_ptr
;
3759 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3760 list
= symbol_get_tc (list
)->next
)
3762 symbol_get_tc (list
)->next
= sym
;
3764 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3765 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3769 ppc_current_csect
= sym
;
3773 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3777 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3779 sec
= subseg_new (dw
->name
, subseg
);
3780 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3781 if (oldflags
== SEC_NO_FLAGS
)
3783 /* Just created section. */
3784 gas_assert (dw_sections
[idx
].sect
== NULL
);
3786 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3787 bfd_set_section_alignment (stdoutput
, sec
, 0);
3788 dw_sections
[idx
].sect
= sec
;
3791 /* Not anymore in a csect. */
3792 ppc_current_csect
= NULL
;
3795 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3796 .dwsect flag [, opt-label ]
3800 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3804 const struct xcoff_dwsect_name
*dw
;
3805 struct dw_subsection
*subseg
;
3806 struct dw_section
*dws
;
3810 flag
= get_absolute_expression ();
3812 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3813 if (xcoff_dwsect_names
[i
].flag
== flag
)
3815 dw
= &xcoff_dwsect_names
[i
];
3819 /* Parse opt-label. */
3820 if (*input_line_pointer
== ',')
3825 ++input_line_pointer
;
3827 label
= input_line_pointer
;
3828 c
= get_symbol_end ();
3829 opt_label
= symbol_find_or_make (label
);
3830 *input_line_pointer
= c
;
3835 demand_empty_rest_of_line ();
3837 /* Return now in case of unknown subsection. */
3840 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3845 /* Find the subsection. */
3846 dws
= &dw_sections
[i
];
3848 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3850 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3851 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3853 as_bad (_("label %s was not defined in this dwarf section"),
3854 S_GET_NAME (opt_label
));
3855 subseg
= dws
->anon_subseg
;
3859 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3864 /* Switch to the subsection. */
3865 ppc_change_debug_section (i
, subseg
->subseg
);
3869 /* Create a new dw subsection. */
3870 subseg
= (struct dw_subsection
*)
3871 xmalloc (sizeof (struct dw_subsection
));
3873 if (opt_label
== NULL
)
3875 /* The anonymous one. */
3877 subseg
->link
= NULL
;
3878 dws
->anon_subseg
= subseg
;
3883 if (dws
->list_subseg
!= NULL
)
3884 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3888 subseg
->link
= dws
->list_subseg
;
3889 dws
->list_subseg
= subseg
;
3890 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3893 ppc_change_debug_section (i
, subseg
->subseg
);
3897 /* Add the length field. */
3898 expressionS
*exp
= &subseg
->end_exp
;
3901 if (opt_label
!= NULL
)
3902 symbol_set_value_now (opt_label
);
3904 /* Add the length field. Note that according to the AIX assembler
3905 manual, the size of the length field is 4 for powerpc32 but
3906 12 for powerpc64. */
3909 /* Write the 64bit marker. */
3910 md_number_to_chars (frag_more (4), -1, 4);
3913 exp
->X_op
= O_subtract
;
3914 exp
->X_op_symbol
= symbol_temp_new_now ();
3915 exp
->X_add_symbol
= symbol_temp_make ();
3917 sz
= ppc_obj64
? 8 : 4;
3918 exp
->X_add_number
= -sz
;
3919 emit_expr (exp
, sz
);
3924 /* This function handles the .text and .data pseudo-ops. These
3925 pseudo-ops aren't really used by XCOFF; we implement them for the
3926 convenience of people who aren't used to XCOFF. */
3929 ppc_section (int type
)
3936 else if (type
== 'd')
3941 sym
= symbol_find_or_make (name
);
3943 ppc_change_csect (sym
, 2);
3945 demand_empty_rest_of_line ();
3948 /* This function handles the .section pseudo-op. This is mostly to
3949 give an error, since XCOFF only supports .text, .data and .bss, but
3950 we do permit the user to name the text or data section. */
3953 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3956 const char *real_name
;
3960 user_name
= input_line_pointer
;
3961 c
= get_symbol_end ();
3963 if (strcmp (user_name
, ".text") == 0)
3964 real_name
= ".text[PR]";
3965 else if (strcmp (user_name
, ".data") == 0)
3966 real_name
= ".data[RW]";
3969 as_bad (_("the XCOFF file format does not support arbitrary sections"));
3970 *input_line_pointer
= c
;
3971 ignore_rest_of_line ();
3975 *input_line_pointer
= c
;
3977 sym
= symbol_find_or_make (real_name
);
3979 ppc_change_csect (sym
, 2);
3981 demand_empty_rest_of_line ();
3984 /* The .extern pseudo-op. We create an undefined symbol. */
3987 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
3992 name
= input_line_pointer
;
3993 endc
= get_symbol_end ();
3995 (void) symbol_find_or_make (name
);
3997 *input_line_pointer
= endc
;
3999 demand_empty_rest_of_line ();
4002 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4005 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4011 name
= input_line_pointer
;
4012 endc
= get_symbol_end ();
4014 sym
= symbol_find_or_make (name
);
4016 *input_line_pointer
= endc
;
4018 symbol_get_tc (sym
)->output
= 1;
4020 demand_empty_rest_of_line ();
4023 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4024 relocations at the beginning of the current csect.
4026 (In principle, there's no reason why the relocations _have_ to be at
4027 the beginning. Anywhere in the csect would do. However, inserting
4028 at the beginning is what the native assmebler does, and it helps to
4029 deal with cases where the .ref statements follow the section contents.)
4031 ??? .refs don't work for empty .csects. However, the native assembler
4032 doesn't report an error in this case, and neither yet do we. */
4035 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4040 if (ppc_current_csect
== NULL
)
4042 as_bad (_(".ref outside .csect"));
4043 ignore_rest_of_line ();
4049 name
= input_line_pointer
;
4050 c
= get_symbol_end ();
4052 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4053 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4055 *input_line_pointer
= c
;
4057 c
= *input_line_pointer
;
4060 input_line_pointer
++;
4062 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4064 as_bad (_("missing symbol name"));
4065 ignore_rest_of_line ();
4072 demand_empty_rest_of_line ();
4075 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4076 although I don't know why it bothers. */
4079 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4086 name
= input_line_pointer
;
4087 endc
= get_symbol_end ();
4089 sym
= symbol_find_or_make (name
);
4091 *input_line_pointer
= endc
;
4093 if (*input_line_pointer
!= ',')
4095 as_bad (_("missing rename string"));
4096 ignore_rest_of_line ();
4099 ++input_line_pointer
;
4101 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4103 demand_empty_rest_of_line ();
4106 /* The .stabx pseudo-op. This is similar to a normal .stabs
4107 pseudo-op, but slightly different. A sample is
4108 .stabx "main:F-1",.main,142,0
4109 The first argument is the symbol name to create. The second is the
4110 value, and the third is the storage class. The fourth seems to be
4111 always zero, and I am assuming it is the type. */
4114 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4121 name
= demand_copy_C_string (&len
);
4123 if (*input_line_pointer
!= ',')
4125 as_bad (_("missing value"));
4128 ++input_line_pointer
;
4130 ppc_stab_symbol
= TRUE
;
4131 sym
= symbol_make (name
);
4132 ppc_stab_symbol
= FALSE
;
4134 symbol_get_tc (sym
)->real_name
= name
;
4136 (void) expression (&exp
);
4143 as_bad (_("illegal .stabx expression; zero assumed"));
4144 exp
.X_add_number
= 0;
4147 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4148 symbol_set_frag (sym
, &zero_address_frag
);
4152 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4153 symbol_set_value_expression (sym
, &exp
);
4157 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4158 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4163 /* The value is some complex expression. This will probably
4164 fail at some later point, but this is probably the right
4165 thing to do here. */
4166 symbol_set_value_expression (sym
, &exp
);
4170 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4171 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4173 if (*input_line_pointer
!= ',')
4175 as_bad (_("missing class"));
4178 ++input_line_pointer
;
4180 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4182 if (*input_line_pointer
!= ',')
4184 as_bad (_("missing type"));
4187 ++input_line_pointer
;
4189 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4191 symbol_get_tc (sym
)->output
= 1;
4193 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4198 .stabx "z",arrays_,133,0
4201 .comm arrays_,13768,3
4203 resolve_symbol_value will copy the exp's "within" into sym's when the
4204 offset is 0. Since this seems to be corner case problem,
4205 only do the correction for storage class C_STSYM. A better solution
4206 would be to have the tc field updated in ppc_symbol_new_hook. */
4208 if (exp
.X_op
== O_symbol
)
4210 if (ppc_current_block
== NULL
)
4211 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4213 symbol_get_tc (sym
)->within
= ppc_current_block
;
4214 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4218 if (exp
.X_op
!= O_symbol
4219 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4220 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4221 ppc_frob_label (sym
);
4224 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4225 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4226 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4227 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4230 demand_empty_rest_of_line ();
4233 /* The .function pseudo-op. This takes several arguments. The first
4234 argument seems to be the external name of the symbol. The second
4235 argument seems to be the label for the start of the function. gcc
4236 uses the same name for both. I have no idea what the third and
4237 fourth arguments are meant to be. The optional fifth argument is
4238 an expression for the size of the function. In COFF this symbol
4239 gets an aux entry like that used for a csect. */
4242 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4250 name
= input_line_pointer
;
4251 endc
= get_symbol_end ();
4253 /* Ignore any [PR] suffix. */
4254 name
= ppc_canonicalize_symbol_name (name
);
4255 s
= strchr (name
, '[');
4256 if (s
!= (char *) NULL
4257 && strcmp (s
+ 1, "PR]") == 0)
4260 ext_sym
= symbol_find_or_make (name
);
4262 *input_line_pointer
= endc
;
4264 if (*input_line_pointer
!= ',')
4266 as_bad (_("missing symbol name"));
4267 ignore_rest_of_line ();
4270 ++input_line_pointer
;
4272 name
= input_line_pointer
;
4273 endc
= get_symbol_end ();
4275 lab_sym
= symbol_find_or_make (name
);
4277 *input_line_pointer
= endc
;
4279 if (ext_sym
!= lab_sym
)
4283 exp
.X_op
= O_symbol
;
4284 exp
.X_add_symbol
= lab_sym
;
4285 exp
.X_op_symbol
= NULL
;
4286 exp
.X_add_number
= 0;
4288 symbol_set_value_expression (ext_sym
, &exp
);
4291 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4292 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4293 symbol_get_tc (ext_sym
)->output
= 1;
4295 if (*input_line_pointer
== ',')
4299 /* Ignore the third argument. */
4300 ++input_line_pointer
;
4302 if (*input_line_pointer
== ',')
4304 /* Ignore the fourth argument. */
4305 ++input_line_pointer
;
4307 if (*input_line_pointer
== ',')
4309 /* The fifth argument is the function size. */
4310 ++input_line_pointer
;
4311 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4312 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4313 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4318 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4319 SF_SET_FUNCTION (ext_sym
);
4320 SF_SET_PROCESS (ext_sym
);
4321 coff_add_linesym (ext_sym
);
4323 demand_empty_rest_of_line ();
4326 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4327 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4328 with the correct line number */
4330 static symbolS
*saved_bi_sym
= 0;
4333 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4337 sym
= symbol_make (".bf");
4338 S_SET_SEGMENT (sym
, text_section
);
4339 symbol_set_frag (sym
, frag_now
);
4340 S_SET_VALUE (sym
, frag_now_fix ());
4341 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4343 coff_line_base
= get_absolute_expression ();
4345 S_SET_NUMBER_AUXILIARY (sym
, 1);
4346 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4348 /* Line number for bi. */
4351 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4356 symbol_get_tc (sym
)->output
= 1;
4358 ppc_frob_label (sym
);
4360 demand_empty_rest_of_line ();
4363 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4364 ".ef", except that the line number is absolute, not relative to the
4365 most recent ".bf" symbol. */
4368 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4372 sym
= symbol_make (".ef");
4373 S_SET_SEGMENT (sym
, text_section
);
4374 symbol_set_frag (sym
, frag_now
);
4375 S_SET_VALUE (sym
, frag_now_fix ());
4376 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4377 S_SET_NUMBER_AUXILIARY (sym
, 1);
4378 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4379 symbol_get_tc (sym
)->output
= 1;
4381 ppc_frob_label (sym
);
4383 demand_empty_rest_of_line ();
4386 /* The .bi and .ei pseudo-ops. These take a string argument and
4387 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4388 the symbol list. The value of .bi will be know when the next .bf
4394 static symbolS
*last_biei
;
4401 name
= demand_copy_C_string (&len
);
4403 /* The value of these symbols is actually file offset. Here we set
4404 the value to the index into the line number entries. In
4405 ppc_frob_symbols we set the fix_line field, which will cause BFD
4406 to do the right thing. */
4408 sym
= symbol_make (name
);
4409 /* obj-coff.c currently only handles line numbers correctly in the
4411 S_SET_SEGMENT (sym
, text_section
);
4412 S_SET_VALUE (sym
, coff_n_line_nos
);
4413 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4415 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4416 symbol_get_tc (sym
)->output
= 1;
4424 for (look
= last_biei
? last_biei
: symbol_rootP
;
4425 (look
!= (symbolS
*) NULL
4426 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4427 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4428 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4429 look
= symbol_next (look
))
4431 if (look
!= (symbolS
*) NULL
)
4433 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4434 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4438 demand_empty_rest_of_line ();
4441 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4442 There is one argument, which is a csect symbol. The value of the
4443 .bs symbol is the index of this csect symbol. */
4446 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4453 if (ppc_current_block
!= NULL
)
4454 as_bad (_("nested .bs blocks"));
4456 name
= input_line_pointer
;
4457 endc
= get_symbol_end ();
4459 csect
= symbol_find_or_make (name
);
4461 *input_line_pointer
= endc
;
4463 sym
= symbol_make (".bs");
4464 S_SET_SEGMENT (sym
, now_seg
);
4465 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4466 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4467 symbol_get_tc (sym
)->output
= 1;
4469 symbol_get_tc (sym
)->within
= csect
;
4471 ppc_frob_label (sym
);
4473 ppc_current_block
= sym
;
4475 demand_empty_rest_of_line ();
4478 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4481 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4485 if (ppc_current_block
== NULL
)
4486 as_bad (_(".es without preceding .bs"));
4488 sym
= symbol_make (".es");
4489 S_SET_SEGMENT (sym
, now_seg
);
4490 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4491 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4492 symbol_get_tc (sym
)->output
= 1;
4494 ppc_frob_label (sym
);
4496 ppc_current_block
= NULL
;
4498 demand_empty_rest_of_line ();
4501 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4505 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4509 sym
= symbol_make (".bb");
4510 S_SET_SEGMENT (sym
, text_section
);
4511 symbol_set_frag (sym
, frag_now
);
4512 S_SET_VALUE (sym
, frag_now_fix ());
4513 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4515 S_SET_NUMBER_AUXILIARY (sym
, 1);
4516 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4518 symbol_get_tc (sym
)->output
= 1;
4520 SF_SET_PROCESS (sym
);
4522 ppc_frob_label (sym
);
4524 demand_empty_rest_of_line ();
4527 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4531 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4535 sym
= symbol_make (".eb");
4536 S_SET_SEGMENT (sym
, text_section
);
4537 symbol_set_frag (sym
, frag_now
);
4538 S_SET_VALUE (sym
, frag_now_fix ());
4539 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4540 S_SET_NUMBER_AUXILIARY (sym
, 1);
4541 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4542 symbol_get_tc (sym
)->output
= 1;
4544 SF_SET_PROCESS (sym
);
4546 ppc_frob_label (sym
);
4548 demand_empty_rest_of_line ();
4551 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4555 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4561 name
= demand_copy_C_string (&len
);
4562 sym
= symbol_make (name
);
4563 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4564 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4565 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4566 S_SET_VALUE (sym
, 0);
4567 symbol_get_tc (sym
)->output
= 1;
4569 ppc_frob_label (sym
);
4571 demand_empty_rest_of_line ();
4574 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4577 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4581 sym
= symbol_make (".ec");
4582 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4583 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4584 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4585 S_SET_VALUE (sym
, 0);
4586 symbol_get_tc (sym
)->output
= 1;
4588 ppc_frob_label (sym
);
4590 demand_empty_rest_of_line ();
4593 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4596 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4598 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4599 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4606 subseg
= ppc_data_subsegment
;
4607 ++ppc_data_subsegment
;
4609 subseg_new (segment_name (data_section
), subseg
);
4610 ppc_toc_frag
= frag_now
;
4612 sym
= symbol_find_or_make ("TOC[TC0]");
4613 symbol_set_frag (sym
, frag_now
);
4614 S_SET_SEGMENT (sym
, data_section
);
4615 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4616 symbol_get_tc (sym
)->subseg
= subseg
;
4617 symbol_get_tc (sym
)->output
= 1;
4618 symbol_get_tc (sym
)->within
= sym
;
4620 ppc_toc_csect
= sym
;
4622 for (list
= ppc_data_csects
;
4623 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4624 list
= symbol_get_tc (list
)->next
)
4626 symbol_get_tc (list
)->next
= sym
;
4628 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4629 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4633 ppc_current_csect
= ppc_toc_csect
;
4635 demand_empty_rest_of_line ();
4638 /* The AIX assembler automatically aligns the operands of a .long or
4639 .short pseudo-op, and we want to be compatible. */
4642 ppc_xcoff_cons (int log_size
)
4644 frag_align (log_size
, 0, 0);
4645 record_alignment (now_seg
, log_size
);
4646 cons (1 << log_size
);
4650 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4655 (void) expression (&exp
);
4657 if (exp
.X_op
!= O_constant
)
4659 as_bad (_("non-constant byte count"));
4663 byte_count
= exp
.X_add_number
;
4665 if (*input_line_pointer
!= ',')
4667 as_bad (_("missing value"));
4671 ++input_line_pointer
;
4676 ppc_xcoff_end (void)
4680 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4682 struct dw_section
*dws
= &dw_sections
[i
];
4683 struct dw_subsection
*dwss
;
4685 if (dws
->anon_subseg
)
4687 dwss
= dws
->anon_subseg
;
4688 dwss
->link
= dws
->list_subseg
;
4691 dwss
= dws
->list_subseg
;
4693 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4694 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4696 subseg_set (dws
->sect
, dwss
->subseg
);
4697 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4702 #endif /* OBJ_XCOFF */
4703 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4705 /* The .tc pseudo-op. This is used when generating either XCOFF or
4706 ELF. This takes two or more arguments.
4708 When generating XCOFF output, the first argument is the name to
4709 give to this location in the toc; this will be a symbol with class
4710 TC. The rest of the arguments are N-byte values to actually put at
4711 this location in the TOC; often there is just one more argument, a
4712 relocatable symbol reference. The size of the value to store
4713 depends on target word size. A 32-bit target uses 4-byte values, a
4714 64-bit target uses 8-byte values.
4716 When not generating XCOFF output, the arguments are the same, but
4717 the first argument is simply ignored. */
4720 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4724 /* Define the TOC symbol name. */
4730 if (ppc_toc_csect
== (symbolS
*) NULL
4731 || ppc_toc_csect
!= ppc_current_csect
)
4733 as_bad (_(".tc not in .toc section"));
4734 ignore_rest_of_line ();
4738 name
= input_line_pointer
;
4739 endc
= get_symbol_end ();
4741 sym
= symbol_find_or_make (name
);
4743 *input_line_pointer
= endc
;
4745 if (S_IS_DEFINED (sym
))
4749 label
= symbol_get_tc (ppc_current_csect
)->within
;
4750 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4752 as_bad (_(".tc with no label"));
4753 ignore_rest_of_line ();
4757 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4758 symbol_set_frag (label
, symbol_get_frag (sym
));
4759 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4761 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4762 ++input_line_pointer
;
4767 S_SET_SEGMENT (sym
, now_seg
);
4768 symbol_set_frag (sym
, frag_now
);
4769 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4770 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4771 symbol_get_tc (sym
)->output
= 1;
4773 ppc_frob_label (sym
);
4776 #endif /* OBJ_XCOFF */
4780 /* Skip the TOC symbol name. */
4781 while (is_part_of_name (*input_line_pointer
)
4782 || *input_line_pointer
== ' '
4783 || *input_line_pointer
== '['
4784 || *input_line_pointer
== ']'
4785 || *input_line_pointer
== '{'
4786 || *input_line_pointer
== '}')
4787 ++input_line_pointer
;
4789 /* Align to a four/eight byte boundary. */
4790 align
= ppc_obj64
? 3 : 2;
4791 frag_align (align
, 0, 0);
4792 record_alignment (now_seg
, align
);
4793 #endif /* OBJ_ELF */
4795 if (*input_line_pointer
!= ',')
4796 demand_empty_rest_of_line ();
4799 ++input_line_pointer
;
4800 cons (ppc_obj64
? 8 : 4);
4804 /* Pseudo-op .machine. */
4807 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4810 #define MAX_HISTORY 100
4811 static ppc_cpu_t
*cpu_history
;
4812 static int curr_hist
;
4816 if (*input_line_pointer
== '"')
4819 cpu_string
= demand_copy_C_string (&len
);
4824 cpu_string
= input_line_pointer
;
4825 c
= get_symbol_end ();
4826 cpu_string
= xstrdup (cpu_string
);
4827 *input_line_pointer
= c
;
4830 if (cpu_string
!= NULL
)
4832 ppc_cpu_t old_cpu
= ppc_cpu
;
4836 for (p
= cpu_string
; *p
!= 0; p
++)
4839 if (strcmp (cpu_string
, "push") == 0)
4841 if (cpu_history
== NULL
)
4842 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4844 if (curr_hist
>= MAX_HISTORY
)
4845 as_bad (_(".machine stack overflow"));
4847 cpu_history
[curr_hist
++] = ppc_cpu
;
4849 else if (strcmp (cpu_string
, "pop") == 0)
4852 as_bad (_(".machine stack underflow"));
4854 ppc_cpu
= cpu_history
[--curr_hist
];
4856 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4859 as_bad (_("invalid machine `%s'"), cpu_string
);
4861 if (ppc_cpu
!= old_cpu
)
4862 ppc_setup_opcodes ();
4865 demand_empty_rest_of_line ();
4867 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4871 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4873 /* Set the current section. */
4875 ppc_set_current_section (segT
new)
4877 ppc_previous_section
= ppc_current_section
;
4878 ppc_current_section
= new;
4881 /* pseudo-op: .previous
4882 behaviour: toggles the current section with the previous section.
4884 warnings: "No previous section" */
4887 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4889 if (ppc_previous_section
== NULL
)
4891 as_warn (_("no previous section to return to, ignored."));
4895 subseg_set (ppc_previous_section
, 0);
4897 ppc_set_current_section (ppc_previous_section
);
4900 /* pseudo-op: .pdata
4901 behaviour: predefined read only data section
4905 initial: .section .pdata "adr3"
4906 a - don't know -- maybe a misprint
4907 d - initialized data
4909 3 - double word aligned (that would be 4 byte boundary)
4912 Tag index tables (also known as the function table) for exception
4913 handling, debugging, etc. */
4916 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4918 if (pdata_section
== 0)
4920 pdata_section
= subseg_new (".pdata", 0);
4922 bfd_set_section_flags (stdoutput
, pdata_section
,
4923 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4924 | SEC_READONLY
| SEC_DATA
));
4926 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4930 pdata_section
= subseg_new (".pdata", 0);
4932 ppc_set_current_section (pdata_section
);
4935 /* pseudo-op: .ydata
4936 behaviour: predefined read only data section
4940 initial: .section .ydata "drw3"
4941 a - don't know -- maybe a misprint
4942 d - initialized data
4944 3 - double word aligned (that would be 4 byte boundary)
4946 Tag tables (also known as the scope table) for exception handling,
4950 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4952 if (ydata_section
== 0)
4954 ydata_section
= subseg_new (".ydata", 0);
4955 bfd_set_section_flags (stdoutput
, ydata_section
,
4956 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4957 | SEC_READONLY
| SEC_DATA
));
4959 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4963 ydata_section
= subseg_new (".ydata", 0);
4965 ppc_set_current_section (ydata_section
);
4968 /* pseudo-op: .reldata
4969 behaviour: predefined read write data section
4970 double word aligned (4-byte)
4971 FIXME: relocation is applied to it
4972 FIXME: what's the difference between this and .data?
4975 initial: .section .reldata "drw3"
4976 d - initialized data
4979 3 - double word aligned (that would be 8 byte boundary)
4982 Like .data, but intended to hold data subject to relocation, such as
4983 function descriptors, etc. */
4986 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
4988 if (reldata_section
== 0)
4990 reldata_section
= subseg_new (".reldata", 0);
4992 bfd_set_section_flags (stdoutput
, reldata_section
,
4993 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4996 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5000 reldata_section
= subseg_new (".reldata", 0);
5002 ppc_set_current_section (reldata_section
);
5005 /* pseudo-op: .rdata
5006 behaviour: predefined read only data section
5010 initial: .section .rdata "dr3"
5011 d - initialized data
5013 3 - double word aligned (that would be 4 byte boundary) */
5016 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5018 if (rdata_section
== 0)
5020 rdata_section
= subseg_new (".rdata", 0);
5021 bfd_set_section_flags (stdoutput
, rdata_section
,
5022 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5023 | SEC_READONLY
| SEC_DATA
));
5025 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5029 rdata_section
= subseg_new (".rdata", 0);
5031 ppc_set_current_section (rdata_section
);
5034 /* pseudo-op: .ualong
5035 behaviour: much like .int, with the exception that no alignment is
5037 FIXME: test the alignment statement
5042 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5048 /* pseudo-op: .znop <symbol name>
5049 behaviour: Issue a nop instruction
5050 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5051 the supplied symbol name.
5053 warnings: Missing symbol name */
5056 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5059 const struct powerpc_opcode
*opcode
;
5066 /* Strip out the symbol name. */
5067 symbol_name
= input_line_pointer
;
5068 c
= get_symbol_end ();
5070 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5071 strcpy (name
, symbol_name
);
5073 sym
= symbol_find_or_make (name
);
5075 *input_line_pointer
= c
;
5079 /* Look up the opcode in the hash table. */
5080 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5082 /* Stick in the nop. */
5083 insn
= opcode
->opcode
;
5085 /* Write out the instruction. */
5087 md_number_to_chars (f
, insn
, 4);
5089 f
- frag_now
->fr_literal
,
5094 BFD_RELOC_16_GOT_PCREL
);
5104 ppc_pe_comm (int lcomm
)
5113 name
= input_line_pointer
;
5114 c
= get_symbol_end ();
5116 /* just after name is now '\0'. */
5117 p
= input_line_pointer
;
5120 if (*input_line_pointer
!= ',')
5122 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5123 ignore_rest_of_line ();
5127 input_line_pointer
++; /* skip ',' */
5128 if ((temp
= get_absolute_expression ()) < 0)
5130 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5131 ignore_rest_of_line ();
5137 /* The third argument to .comm is the alignment. */
5138 if (*input_line_pointer
!= ',')
5142 ++input_line_pointer
;
5143 align
= get_absolute_expression ();
5146 as_warn (_("ignoring bad alignment"));
5153 symbolP
= symbol_find_or_make (name
);
5156 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5158 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5159 S_GET_NAME (symbolP
));
5160 ignore_rest_of_line ();
5164 if (S_GET_VALUE (symbolP
))
5166 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5167 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5168 S_GET_NAME (symbolP
),
5169 (long) S_GET_VALUE (symbolP
),
5174 S_SET_VALUE (symbolP
, (valueT
) temp
);
5175 S_SET_EXTERNAL (symbolP
);
5176 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5179 demand_empty_rest_of_line ();
5183 * implement the .section pseudo op:
5184 * .section name {, "flags"}
5186 * | +--- optional flags: 'b' for bss
5188 * +-- section name 'l' for lib
5192 * 'd' (apparently m88k for data)
5194 * But if the argument is not a quoted string, treat it as a
5195 * subsegment number.
5197 * FIXME: this is a copy of the section processing from obj-coff.c, with
5198 * additions/changes for the moto-pas assembler support. There are three
5201 * FIXME: I just noticed this. This doesn't work at all really. It it
5202 * setting bits that bfd probably neither understands or uses. The
5203 * correct approach (?) will have to incorporate extra fields attached
5204 * to the section to hold the system specific stuff. (krk)
5207 * 'a' - unknown - referred to in documentation, but no definition supplied
5208 * 'c' - section has code
5209 * 'd' - section has initialized data
5210 * 'u' - section has uninitialized data
5211 * 'i' - section contains directives (info)
5212 * 'n' - section can be discarded
5213 * 'R' - remove section at link time
5215 * Section Protection:
5216 * 'r' - section is readable
5217 * 'w' - section is writeable
5218 * 'x' - section is executable
5219 * 's' - section is sharable
5221 * Section Alignment:
5222 * '0' - align to byte boundary
5223 * '1' - align to halfword undary
5224 * '2' - align to word boundary
5225 * '3' - align to doubleword boundary
5226 * '4' - align to quadword boundary
5227 * '5' - align to 32 byte boundary
5228 * '6' - align to 64 byte boundary
5233 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5235 /* Strip out the section name. */
5244 section_name
= input_line_pointer
;
5245 c
= get_symbol_end ();
5247 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5248 strcpy (name
, section_name
);
5250 *input_line_pointer
= c
;
5255 flags
= SEC_NO_FLAGS
;
5257 if (strcmp (name
, ".idata$2") == 0)
5261 else if (strcmp (name
, ".idata$3") == 0)
5265 else if (strcmp (name
, ".idata$4") == 0)
5269 else if (strcmp (name
, ".idata$5") == 0)
5273 else if (strcmp (name
, ".idata$6") == 0)
5278 /* Default alignment to 16 byte boundary. */
5281 if (*input_line_pointer
== ',')
5283 ++input_line_pointer
;
5285 if (*input_line_pointer
!= '"')
5286 exp
= get_absolute_expression ();
5289 ++input_line_pointer
;
5290 while (*input_line_pointer
!= '"'
5291 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5293 switch (*input_line_pointer
)
5295 /* Section Contents */
5296 case 'a': /* unknown */
5297 as_bad (_("unsupported section attribute -- 'a'"));
5299 case 'c': /* code section */
5302 case 'd': /* section has initialized data */
5305 case 'u': /* section has uninitialized data */
5306 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5310 case 'i': /* section contains directives (info) */
5311 /* FIXME: This is IMAGE_SCN_LNK_INFO
5313 flags
|= SEC_HAS_CONTENTS
;
5315 case 'n': /* section can be discarded */
5318 case 'R': /* Remove section at link time */
5319 flags
|= SEC_NEVER_LOAD
;
5321 #if IFLICT_BRAIN_DAMAGE
5322 /* Section Protection */
5323 case 'r': /* section is readable */
5324 flags
|= IMAGE_SCN_MEM_READ
;
5326 case 'w': /* section is writeable */
5327 flags
|= IMAGE_SCN_MEM_WRITE
;
5329 case 'x': /* section is executable */
5330 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5332 case 's': /* section is sharable */
5333 flags
|= IMAGE_SCN_MEM_SHARED
;
5336 /* Section Alignment */
5337 case '0': /* align to byte boundary */
5338 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5341 case '1': /* align to halfword boundary */
5342 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5345 case '2': /* align to word boundary */
5346 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5349 case '3': /* align to doubleword boundary */
5350 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5353 case '4': /* align to quadword boundary */
5354 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5357 case '5': /* align to 32 byte boundary */
5358 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5361 case '6': /* align to 64 byte boundary */
5362 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5367 as_bad (_("unknown section attribute '%c'"),
5368 *input_line_pointer
);
5371 ++input_line_pointer
;
5373 if (*input_line_pointer
== '"')
5374 ++input_line_pointer
;
5378 sec
= subseg_new (name
, (subsegT
) exp
);
5380 ppc_set_current_section (sec
);
5382 if (flags
!= SEC_NO_FLAGS
)
5384 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5385 as_bad (_("error setting flags for \"%s\": %s"),
5386 bfd_section_name (stdoutput
, sec
),
5387 bfd_errmsg (bfd_get_error ()));
5390 bfd_set_section_alignment (stdoutput
, sec
, align
);
5394 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5400 name
= input_line_pointer
;
5401 endc
= get_symbol_end ();
5403 ext_sym
= symbol_find_or_make (name
);
5405 *input_line_pointer
= endc
;
5407 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5408 SF_SET_FUNCTION (ext_sym
);
5409 SF_SET_PROCESS (ext_sym
);
5410 coff_add_linesym (ext_sym
);
5412 demand_empty_rest_of_line ();
5416 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5418 if (tocdata_section
== 0)
5420 tocdata_section
= subseg_new (".tocd", 0);
5421 /* FIXME: section flags won't work. */
5422 bfd_set_section_flags (stdoutput
, tocdata_section
,
5423 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5424 | SEC_READONLY
| SEC_DATA
));
5426 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5430 rdata_section
= subseg_new (".tocd", 0);
5433 ppc_set_current_section (tocdata_section
);
5435 demand_empty_rest_of_line ();
5438 /* Don't adjust TOC relocs to use the section symbol. */
5441 ppc_pe_fix_adjustable (fixS
*fix
)
5443 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5450 /* XCOFF specific symbol and file handling. */
5452 /* Canonicalize the symbol name. We use the to force the suffix, if
5453 any, to use square brackets, and to be in upper case. */
5456 ppc_canonicalize_symbol_name (char *name
)
5460 if (ppc_stab_symbol
)
5463 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5477 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5480 if (*s
== '\0' || s
[1] != '\0')
5481 as_bad (_("bad symbol suffix"));
5489 /* Set the class of a symbol based on the suffix, if any. This is
5490 called whenever a new symbol is created. */
5493 ppc_symbol_new_hook (symbolS
*sym
)
5495 struct ppc_tc_sy
*tc
;
5498 tc
= symbol_get_tc (sym
);
5501 tc
->symbol_class
= -1;
5502 tc
->real_name
= NULL
;
5509 if (ppc_stab_symbol
)
5512 s
= strchr (S_GET_NAME (sym
), '[');
5513 if (s
== (const char *) NULL
)
5515 /* There is no suffix. */
5524 if (strcmp (s
, "BS]") == 0)
5525 tc
->symbol_class
= XMC_BS
;
5528 if (strcmp (s
, "DB]") == 0)
5529 tc
->symbol_class
= XMC_DB
;
5530 else if (strcmp (s
, "DS]") == 0)
5531 tc
->symbol_class
= XMC_DS
;
5534 if (strcmp (s
, "GL]") == 0)
5535 tc
->symbol_class
= XMC_GL
;
5538 if (strcmp (s
, "PR]") == 0)
5539 tc
->symbol_class
= XMC_PR
;
5542 if (strcmp (s
, "RO]") == 0)
5543 tc
->symbol_class
= XMC_RO
;
5544 else if (strcmp (s
, "RW]") == 0)
5545 tc
->symbol_class
= XMC_RW
;
5548 if (strcmp (s
, "SV]") == 0)
5549 tc
->symbol_class
= XMC_SV
;
5552 if (strcmp (s
, "TC]") == 0)
5553 tc
->symbol_class
= XMC_TC
;
5554 else if (strcmp (s
, "TI]") == 0)
5555 tc
->symbol_class
= XMC_TI
;
5556 else if (strcmp (s
, "TB]") == 0)
5557 tc
->symbol_class
= XMC_TB
;
5558 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5559 tc
->symbol_class
= XMC_TC0
;
5562 if (strcmp (s
, "UA]") == 0)
5563 tc
->symbol_class
= XMC_UA
;
5564 else if (strcmp (s
, "UC]") == 0)
5565 tc
->symbol_class
= XMC_UC
;
5568 if (strcmp (s
, "XO]") == 0)
5569 tc
->symbol_class
= XMC_XO
;
5573 if (tc
->symbol_class
== -1)
5574 as_bad (_("unrecognized symbol suffix"));
5577 /* Set the class of a label based on where it is defined. This
5578 handles symbols without suffixes. Also, move the symbol so that it
5579 follows the csect symbol. */
5582 ppc_frob_label (symbolS
*sym
)
5584 if (ppc_current_csect
!= (symbolS
*) NULL
)
5586 if (symbol_get_tc (sym
)->symbol_class
== -1)
5587 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5589 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5590 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5591 &symbol_rootP
, &symbol_lastP
);
5592 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5593 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5597 dwarf2_emit_label (sym
);
5601 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5602 seen. It tells ppc_adjust_symtab whether it needs to look through
5605 static bfd_boolean ppc_saw_abs
;
5607 /* Change the name of a symbol just before writing it out. Set the
5608 real name if the .rename pseudo-op was used. Otherwise, remove any
5609 class suffix. Return 1 if the symbol should not be included in the
5613 ppc_frob_symbol (symbolS
*sym
)
5615 static symbolS
*ppc_last_function
;
5616 static symbolS
*set_end
;
5618 /* Discard symbols that should not be included in the output symbol
5620 if (! symbol_used_in_reloc_p (sym
)
5621 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5622 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5623 && ! symbol_get_tc (sym
)->output
5624 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5627 /* This one will disappear anyway. Don't make a csect sym for it. */
5628 if (sym
== abs_section_sym
)
5631 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5632 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5638 name
= S_GET_NAME (sym
);
5639 s
= strchr (name
, '[');
5640 if (s
!= (char *) NULL
)
5646 snew
= xmalloc (len
+ 1);
5647 memcpy (snew
, name
, len
);
5650 S_SET_NAME (sym
, snew
);
5654 if (set_end
!= (symbolS
*) NULL
)
5656 SA_SET_SYM_ENDNDX (set_end
, sym
);
5660 if (SF_GET_FUNCTION (sym
))
5662 if (ppc_last_function
!= (symbolS
*) NULL
)
5663 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5664 ppc_last_function
= sym
;
5665 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5667 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5668 SA_SET_SYM_FSIZE (sym
,
5669 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5672 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5673 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5675 if (ppc_last_function
== (symbolS
*) NULL
)
5676 as_bad (_(".ef with no preceding .function"));
5679 set_end
= ppc_last_function
;
5680 ppc_last_function
= NULL
;
5682 /* We don't have a C_EFCN symbol, but we need to force the
5683 COFF backend to believe that it has seen one. */
5684 coff_last_function
= NULL
;
5688 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5689 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5690 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5691 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5692 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5693 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5694 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5695 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5696 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5697 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5698 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5700 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5701 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5702 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5705 union internal_auxent
*a
;
5707 /* Create a csect aux. */
5708 i
= S_GET_NUMBER_AUXILIARY (sym
);
5709 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5710 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5711 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5713 /* This is the TOC table. */
5714 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5715 a
->x_csect
.x_scnlen
.l
= 0;
5716 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5718 else if (symbol_get_tc (sym
)->subseg
!= 0)
5720 /* This is a csect symbol. x_scnlen is the size of the
5722 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5723 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5724 S_GET_SEGMENT (sym
))
5725 - S_GET_VALUE (sym
));
5728 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5729 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5730 - S_GET_VALUE (sym
));
5732 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5734 else if (S_GET_SEGMENT (sym
) == bss_section
)
5736 /* This is a common symbol. */
5737 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5738 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5739 if (S_IS_EXTERNAL (sym
))
5740 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5742 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5744 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5746 /* This is an absolute symbol. The csect will be created by
5747 ppc_adjust_symtab. */
5749 a
->x_csect
.x_smtyp
= XTY_LD
;
5750 if (symbol_get_tc (sym
)->symbol_class
== -1)
5751 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5753 else if (! S_IS_DEFINED (sym
))
5755 /* This is an external symbol. */
5756 a
->x_csect
.x_scnlen
.l
= 0;
5757 a
->x_csect
.x_smtyp
= XTY_ER
;
5759 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5763 /* This is a TOC definition. x_scnlen is the size of the
5765 next
= symbol_next (sym
);
5766 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5767 next
= symbol_next (next
);
5768 if (next
== (symbolS
*) NULL
5769 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5771 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5772 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5774 - S_GET_VALUE (sym
));
5776 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5777 - S_GET_VALUE (sym
));
5781 resolve_symbol_value (next
);
5782 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5783 - S_GET_VALUE (sym
));
5785 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5791 /* This is a normal symbol definition. x_scnlen is the
5792 symbol index of the containing csect. */
5793 if (S_GET_SEGMENT (sym
) == text_section
)
5794 csect
= ppc_text_csects
;
5795 else if (S_GET_SEGMENT (sym
) == data_section
)
5796 csect
= ppc_data_csects
;
5800 /* Skip the initial dummy symbol. */
5801 csect
= symbol_get_tc (csect
)->next
;
5803 if (csect
== (symbolS
*) NULL
)
5805 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5806 a
->x_csect
.x_scnlen
.l
= 0;
5810 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5812 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5813 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5814 > S_GET_VALUE (sym
))
5816 csect
= symbol_get_tc (csect
)->next
;
5819 a
->x_csect
.x_scnlen
.p
=
5820 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5821 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5824 a
->x_csect
.x_smtyp
= XTY_LD
;
5827 a
->x_csect
.x_parmhash
= 0;
5828 a
->x_csect
.x_snhash
= 0;
5829 if (symbol_get_tc (sym
)->symbol_class
== -1)
5830 a
->x_csect
.x_smclas
= XMC_PR
;
5832 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5833 a
->x_csect
.x_stab
= 0;
5834 a
->x_csect
.x_snstab
= 0;
5836 /* Don't let the COFF backend resort these symbols. */
5837 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5839 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5841 /* We want the value to be the symbol index of the referenced
5842 csect symbol. BFD will do that for us if we set the right
5844 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5845 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5847 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5848 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5850 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5855 block
= symbol_get_tc (sym
)->within
;
5858 /* The value is the offset from the enclosing csect. */
5861 csect
= symbol_get_tc (block
)->within
;
5862 resolve_symbol_value (csect
);
5863 base
= S_GET_VALUE (csect
);
5868 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5870 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5871 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5873 /* We want the value to be a file offset into the line numbers.
5874 BFD will do that for us if we set the right flags. We have
5875 already set the value correctly. */
5876 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5882 /* Adjust the symbol table. This creates csect symbols for all
5883 absolute symbols. */
5886 ppc_adjust_symtab (void)
5893 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5897 union internal_auxent
*a
;
5899 if (S_GET_SEGMENT (sym
) != absolute_section
)
5902 csect
= symbol_create (".abs[XO]", absolute_section
,
5903 S_GET_VALUE (sym
), &zero_address_frag
);
5904 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5905 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5906 i
= S_GET_NUMBER_AUXILIARY (csect
);
5907 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5908 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5909 a
->x_csect
.x_scnlen
.l
= 0;
5910 a
->x_csect
.x_smtyp
= XTY_SD
;
5911 a
->x_csect
.x_parmhash
= 0;
5912 a
->x_csect
.x_snhash
= 0;
5913 a
->x_csect
.x_smclas
= XMC_XO
;
5914 a
->x_csect
.x_stab
= 0;
5915 a
->x_csect
.x_snstab
= 0;
5917 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5919 i
= S_GET_NUMBER_AUXILIARY (sym
);
5920 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5921 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5922 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5925 ppc_saw_abs
= FALSE
;
5928 /* Set the VMA for a section. This is called on all the sections in
5932 ppc_frob_section (asection
*sec
)
5934 static bfd_vma vma
= 0;
5936 /* Dwarf sections start at 0. */
5937 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5940 vma
= md_section_align (sec
, vma
);
5941 bfd_set_section_vma (stdoutput
, sec
, vma
);
5942 vma
+= bfd_section_size (stdoutput
, sec
);
5945 #endif /* OBJ_XCOFF */
5948 md_atof (int type
, char *litp
, int *sizep
)
5950 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5953 /* Write a value out to the object file, using the appropriate
5957 md_number_to_chars (char *buf
, valueT val
, int n
)
5959 if (target_big_endian
)
5960 number_to_chars_bigendian (buf
, val
, n
);
5962 number_to_chars_littleendian (buf
, val
, n
);
5965 /* Align a section (I don't know why this is machine dependent). */
5968 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5973 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5975 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5979 /* We don't have any form of relaxing. */
5982 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5983 asection
*seg ATTRIBUTE_UNUSED
)
5989 /* Convert a machine dependent frag. We never generate these. */
5992 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5993 asection
*sec ATTRIBUTE_UNUSED
,
5994 fragS
*fragp ATTRIBUTE_UNUSED
)
5999 /* We have no need to default values of symbols. */
6002 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6007 /* Functions concerning relocs. */
6009 /* The location from which a PC relative jump should be calculated,
6010 given a PC relative reloc. */
6013 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6015 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6020 /* This is called to see whether a fixup should be adjusted to use a
6021 section symbol. We take the opportunity to change a fixup against
6022 a symbol in the TOC subsegment into a reloc against the
6023 corresponding .tc symbol. */
6026 ppc_fix_adjustable (fixS
*fix
)
6028 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6029 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6030 TC_SYMFIELD_TYPE
*tc
;
6032 if (symseg
== absolute_section
)
6035 /* Always adjust symbols in debugging sections. */
6036 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6039 if (ppc_toc_csect
!= (symbolS
*) NULL
6040 && fix
->fx_addsy
!= ppc_toc_csect
6041 && symseg
== data_section
6042 && val
>= ppc_toc_frag
->fr_address
6043 && (ppc_after_toc_frag
== (fragS
*) NULL
6044 || val
< ppc_after_toc_frag
->fr_address
))
6048 for (sy
= symbol_next (ppc_toc_csect
);
6049 sy
!= (symbolS
*) NULL
;
6050 sy
= symbol_next (sy
))
6052 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6054 if (sy_tc
->symbol_class
== XMC_TC0
)
6056 if (sy_tc
->symbol_class
!= XMC_TC
)
6058 if (val
== resolve_symbol_value (sy
))
6061 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6066 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6067 _("symbol in .toc does not match any .tc"));
6070 /* Possibly adjust the reloc to be against the csect. */
6071 tc
= symbol_get_tc (fix
->fx_addsy
);
6073 && tc
->symbol_class
!= XMC_TC0
6074 && tc
->symbol_class
!= XMC_TC
6075 && symseg
!= bss_section
6076 /* Don't adjust if this is a reloc in the toc section. */
6077 && (symseg
!= data_section
6078 || ppc_toc_csect
== NULL
6079 || val
< ppc_toc_frag
->fr_address
6080 || (ppc_after_toc_frag
!= NULL
6081 && val
>= ppc_after_toc_frag
->fr_address
)))
6083 symbolS
*csect
= tc
->within
;
6085 /* If the symbol was not declared by a label (eg: a section symbol),
6086 use the section instead of the csect. This doesn't happen in
6087 normal AIX assembly code. */
6089 csect
= seg_info (symseg
)->sym
;
6091 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6092 fix
->fx_addsy
= csect
;
6097 /* Adjust a reloc against a .lcomm symbol to be against the base
6099 if (symseg
== bss_section
6100 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6102 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6104 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6111 /* A reloc from one csect to another must be kept. The assembler
6112 will, of course, keep relocs between sections, and it will keep
6113 absolute relocs, but we need to force it to keep PC relative relocs
6114 between two csects in the same section. */
6117 ppc_force_relocation (fixS
*fix
)
6119 /* At this point fix->fx_addsy should already have been converted to
6120 a csect symbol. If the csect does not include the fragment, then
6121 we need to force the relocation. */
6123 && fix
->fx_addsy
!= NULL
6124 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6125 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6126 > fix
->fx_frag
->fr_address
)
6127 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6128 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6129 <= fix
->fx_frag
->fr_address
))))
6132 return generic_force_reloc (fix
);
6136 ppc_new_dot_label (symbolS
*sym
)
6138 /* Anchor this label to the current csect for relocations. */
6139 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6142 #endif /* OBJ_XCOFF */
6145 /* If this function returns non-zero, it guarantees that a relocation
6146 will be emitted for a fixup. */
6149 ppc_force_relocation (fixS
*fix
)
6151 /* Branch prediction relocations must force a relocation, as must
6152 the vtable description relocs. */
6153 switch (fix
->fx_r_type
)
6155 case BFD_RELOC_PPC_B16_BRTAKEN
:
6156 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6157 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6158 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6159 case BFD_RELOC_24_PLT_PCREL
:
6160 case BFD_RELOC_PPC64_TOC
:
6166 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6167 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6170 return generic_force_reloc (fix
);
6174 ppc_fix_adjustable (fixS
*fix
)
6176 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6177 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6178 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6179 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6180 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6181 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6182 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6183 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6184 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6185 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6186 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6191 ppc_frag_check (struct frag
*fragP
)
6193 if (!fragP
->has_code
)
6196 if (ppc_mach() == bfd_mach_ppc_vle
)
6198 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6199 as_bad (_("instruction address is not a multiple of 2"));
6203 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6204 as_bad (_("instruction address is not a multiple of 4"));
6208 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6209 rs_align_code frag. */
6212 ppc_handle_align (struct frag
*fragP
)
6214 valueT count
= (fragP
->fr_next
->fr_address
6215 - (fragP
->fr_address
+ fragP
->fr_fix
));
6217 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6219 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6222 md_number_to_chars (dest
, 0x4400, 2);
6224 else if (count
!= 0 && (count
& 3) == 0)
6226 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6230 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6234 /* Make a branch, then follow with nops. Insert another
6235 frag to handle the nops. */
6236 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6241 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6242 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6243 fragP
->fr_next
= rest
;
6245 rest
->fr_address
+= rest
->fr_fix
+ 4;
6247 /* If we leave the next frag as rs_align_code we'll come here
6248 again, resulting in a bunch of branches rather than a
6249 branch followed by nops. */
6250 rest
->fr_type
= rs_align
;
6251 dest
= rest
->fr_literal
;
6254 md_number_to_chars (dest
, 0x60000000, 4);
6256 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6257 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6258 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6260 /* For power6, power7 and power8, we want the last nop to be a group
6261 terminating one. Do this by inserting an rs_fill frag immediately
6262 after this one, with its address set to the last nop location.
6263 This will automatically reduce the number of nops in the current
6267 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6269 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6270 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6271 group_nop
->fr_fix
= 0;
6272 group_nop
->fr_offset
= 1;
6273 group_nop
->fr_type
= rs_fill
;
6274 fragP
->fr_next
= group_nop
;
6275 dest
= group_nop
->fr_literal
;
6278 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6279 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6281 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6282 /* e500mc group terminating nop: "ori 0,0,0". */
6283 md_number_to_chars (dest
, 0x60000000, 4);
6285 /* power7/power8 group terminating nop: "ori 2,2,0". */
6286 md_number_to_chars (dest
, 0x60420000, 4);
6289 /* power6 group terminating nop: "ori 1,1,0". */
6290 md_number_to_chars (dest
, 0x60210000, 4);
6295 /* Apply a fixup to the object code. This is called for all the
6296 fixups we generated by the calls to fix_new_exp, above. */
6299 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6301 valueT value
= * valP
;
6303 const struct powerpc_operand
*operand
;
6306 if (fixP
->fx_addsy
!= NULL
)
6308 /* Hack around bfd_install_relocation brain damage. */
6310 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6315 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6316 the symbol values. If we are doing this relocation the code in
6317 write.c is going to call bfd_install_relocation, which is also
6318 going to use the symbol value. That means that if the reloc is
6319 fully resolved we want to use *valP since bfd_install_relocation is
6321 However, if the reloc is not fully resolved we do not want to
6322 use *valP, and must use fx_offset instead. If the relocation
6323 is PC-relative, we then need to re-apply md_pcrel_from_section
6324 to this new relocation value. */
6325 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6330 value
= fixP
->fx_offset
;
6332 value
-= md_pcrel_from_section (fixP
, seg
);
6336 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6338 /* We can't actually support subtracting a symbol. */
6339 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6343 if (fixP
->fx_pcrel_adjust
!= 0)
6345 /* This is a fixup on an instruction. */
6346 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6348 operand
= &powerpc_operands
[opindex
];
6350 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6351 does not generate a reloc. It uses the offset of `sym' within its
6352 csect. Other usages, such as `.long sym', generate relocs. This
6353 is the documented behaviour of non-TOC symbols. */
6354 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6355 && (operand
->bitm
& 0xfff0) == 0xfff0
6356 && operand
->shift
== 0
6357 && (operand
->insert
== NULL
|| ppc_obj64
)
6358 && fixP
->fx_addsy
!= NULL
6359 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6360 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6361 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6362 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6364 value
= fixP
->fx_offset
;
6370 /* Calculate value to be stored in field. */
6372 switch (fixP
->fx_r_type
)
6375 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6376 case BFD_RELOC_PPC_VLE_LO16A
:
6377 case BFD_RELOC_PPC_VLE_LO16D
:
6379 case BFD_RELOC_LO16
:
6380 case BFD_RELOC_LO16_PCREL
:
6381 fieldval
= value
& 0xffff;
6383 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6384 fieldval
= (fieldval
^ 0x8000) - 0x8000;
6385 fixP
->fx_no_overflow
= 1;
6389 case BFD_RELOC_PPC_VLE_HI16A
:
6390 case BFD_RELOC_PPC_VLE_HI16D
:
6392 case BFD_RELOC_HI16
:
6393 case BFD_RELOC_HI16_PCREL
:
6394 fieldval
= PPC_HI (value
);
6395 goto sign_extend_16
;
6398 case BFD_RELOC_PPC_VLE_HA16A
:
6399 case BFD_RELOC_PPC_VLE_HA16D
:
6401 case BFD_RELOC_HI16_S
:
6402 case BFD_RELOC_HI16_S_PCREL
:
6403 fieldval
= PPC_HA (value
);
6404 goto sign_extend_16
;
6407 case BFD_RELOC_PPC64_HIGHER
:
6408 fieldval
= PPC_HIGHER (value
);
6409 goto sign_extend_16
;
6411 case BFD_RELOC_PPC64_HIGHER_S
:
6412 fieldval
= PPC_HIGHERA (value
);
6413 goto sign_extend_16
;
6415 case BFD_RELOC_PPC64_HIGHEST
:
6416 fieldval
= PPC_HIGHEST (value
);
6417 goto sign_extend_16
;
6419 case BFD_RELOC_PPC64_HIGHEST_S
:
6420 fieldval
= PPC_HIGHESTA (value
);
6421 goto sign_extend_16
;
6428 if (operand
!= NULL
)
6430 /* Handle relocs in an insn. */
6434 switch (fixP
->fx_r_type
)
6437 /* The following relocs can't be calculated by the assembler.
6438 Leave the field zero. */
6439 case BFD_RELOC_PPC_TPREL16
:
6440 case BFD_RELOC_PPC_TPREL16_LO
:
6441 case BFD_RELOC_PPC_TPREL16_HI
:
6442 case BFD_RELOC_PPC_TPREL16_HA
:
6443 case BFD_RELOC_PPC_DTPREL16
:
6444 case BFD_RELOC_PPC_DTPREL16_LO
:
6445 case BFD_RELOC_PPC_DTPREL16_HI
:
6446 case BFD_RELOC_PPC_DTPREL16_HA
:
6447 case BFD_RELOC_PPC_GOT_TLSGD16
:
6448 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6449 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6450 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6451 case BFD_RELOC_PPC_GOT_TLSLD16
:
6452 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6453 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6454 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6455 case BFD_RELOC_PPC_GOT_TPREL16
:
6456 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6457 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6458 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6459 case BFD_RELOC_PPC_GOT_DTPREL16
:
6460 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6461 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6462 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6463 case BFD_RELOC_PPC64_TPREL16_DS
:
6464 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6465 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6466 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6467 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6468 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6469 case BFD_RELOC_PPC64_DTPREL16_DS
:
6470 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6471 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6472 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6473 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6474 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6475 gas_assert (fixP
->fx_addsy
!= NULL
);
6476 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6480 /* These also should leave the field zero for the same
6481 reason. Note that older versions of gas wrote values
6482 here. If we want to go back to the old behaviour, then
6483 all _LO and _LO_DS cases will need to be treated like
6484 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6485 case BFD_RELOC_16_GOTOFF
:
6486 case BFD_RELOC_LO16_GOTOFF
:
6487 case BFD_RELOC_HI16_GOTOFF
:
6488 case BFD_RELOC_HI16_S_GOTOFF
:
6489 case BFD_RELOC_LO16_PLTOFF
:
6490 case BFD_RELOC_HI16_PLTOFF
:
6491 case BFD_RELOC_HI16_S_PLTOFF
:
6492 case BFD_RELOC_GPREL16
:
6493 case BFD_RELOC_16_BASEREL
:
6494 case BFD_RELOC_LO16_BASEREL
:
6495 case BFD_RELOC_HI16_BASEREL
:
6496 case BFD_RELOC_HI16_S_BASEREL
:
6497 case BFD_RELOC_PPC_TOC16
:
6498 case BFD_RELOC_PPC64_TOC16_LO
:
6499 case BFD_RELOC_PPC64_TOC16_HI
:
6500 case BFD_RELOC_PPC64_TOC16_HA
:
6501 case BFD_RELOC_PPC64_PLTGOT16
:
6502 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6503 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6504 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6505 case BFD_RELOC_PPC64_GOT16_DS
:
6506 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6507 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6508 case BFD_RELOC_PPC64_SECTOFF_DS
:
6509 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6510 case BFD_RELOC_PPC64_TOC16_DS
:
6511 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6512 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6513 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6514 case BFD_RELOC_PPC_EMB_NADDR16
:
6515 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6516 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6517 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6518 case BFD_RELOC_PPC_EMB_SDAI16
:
6519 case BFD_RELOC_PPC_EMB_SDA2I16
:
6520 case BFD_RELOC_PPC_EMB_SDA2REL
:
6521 case BFD_RELOC_PPC_EMB_SDA21
:
6522 case BFD_RELOC_PPC_EMB_MRKREF
:
6523 case BFD_RELOC_PPC_EMB_RELSEC16
:
6524 case BFD_RELOC_PPC_EMB_RELST_LO
:
6525 case BFD_RELOC_PPC_EMB_RELST_HI
:
6526 case BFD_RELOC_PPC_EMB_RELST_HA
:
6527 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6528 case BFD_RELOC_PPC_EMB_RELSDA
:
6529 case BFD_RELOC_PPC_VLE_SDA21
:
6530 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6531 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6532 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6533 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6534 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6535 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6536 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6537 gas_assert (fixP
->fx_addsy
!= NULL
);
6540 case BFD_RELOC_PPC_TLS
:
6541 case BFD_RELOC_PPC_TLSGD
:
6542 case BFD_RELOC_PPC_TLSLD
:
6548 case BFD_RELOC_PPC_B16
:
6549 /* Adjust the offset to the instruction boundary. */
6559 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6560 contents can stay at zero. */
6561 #define APPLY_RELOC fixP->fx_done
6563 #define APPLY_RELOC 1
6565 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6567 /* Fetch the instruction, insert the fully resolved operand
6568 value, and stuff the instruction back again. */
6569 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6570 if (target_big_endian
)
6572 if (fixP
->fx_size
== 4)
6573 insn
= bfd_getb32 ((unsigned char *) where
);
6575 insn
= bfd_getb16 ((unsigned char *) where
);
6579 if (fixP
->fx_size
== 4)
6580 insn
= bfd_getl32 ((unsigned char *) where
);
6582 insn
= bfd_getl16 ((unsigned char *) where
);
6584 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6585 fixP
->tc_fix_data
.ppc_cpu
,
6586 fixP
->fx_file
, fixP
->fx_line
);
6587 if (target_big_endian
)
6589 if (fixP
->fx_size
== 4)
6590 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6592 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6596 if (fixP
->fx_size
== 4)
6597 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6599 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6604 /* Nothing else to do here. */
6607 gas_assert (fixP
->fx_addsy
!= NULL
);
6608 if (fixP
->fx_r_type
== BFD_RELOC_UNUSED
)
6613 /* Use expr_symbol_where to see if this is an expression
6615 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6616 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6617 _("unresolved expression that must be resolved"));
6619 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6620 _("unsupported relocation against %s"),
6621 S_GET_NAME (fixP
->fx_addsy
));
6628 /* Handle relocs in data. */
6629 switch (fixP
->fx_r_type
)
6631 case BFD_RELOC_VTABLE_INHERIT
:
6633 && !S_IS_DEFINED (fixP
->fx_addsy
)
6634 && !S_IS_WEAK (fixP
->fx_addsy
))
6635 S_SET_WEAK (fixP
->fx_addsy
);
6638 case BFD_RELOC_VTABLE_ENTRY
:
6643 /* These can appear with @l etc. in data. */
6644 case BFD_RELOC_LO16
:
6645 case BFD_RELOC_LO16_PCREL
:
6646 case BFD_RELOC_HI16
:
6647 case BFD_RELOC_HI16_PCREL
:
6648 case BFD_RELOC_HI16_S
:
6649 case BFD_RELOC_HI16_S_PCREL
:
6650 case BFD_RELOC_PPC64_HIGHER
:
6651 case BFD_RELOC_PPC64_HIGHER_S
:
6652 case BFD_RELOC_PPC64_HIGHEST
:
6653 case BFD_RELOC_PPC64_HIGHEST_S
:
6656 case BFD_RELOC_PPC_DTPMOD
:
6657 case BFD_RELOC_PPC_TPREL
:
6658 case BFD_RELOC_PPC_DTPREL
:
6659 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6662 /* Just punt all of these to the linker. */
6663 case BFD_RELOC_PPC_B16_BRTAKEN
:
6664 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6665 case BFD_RELOC_16_GOTOFF
:
6666 case BFD_RELOC_LO16_GOTOFF
:
6667 case BFD_RELOC_HI16_GOTOFF
:
6668 case BFD_RELOC_HI16_S_GOTOFF
:
6669 case BFD_RELOC_LO16_PLTOFF
:
6670 case BFD_RELOC_HI16_PLTOFF
:
6671 case BFD_RELOC_HI16_S_PLTOFF
:
6672 case BFD_RELOC_PPC_COPY
:
6673 case BFD_RELOC_PPC_GLOB_DAT
:
6674 case BFD_RELOC_16_BASEREL
:
6675 case BFD_RELOC_LO16_BASEREL
:
6676 case BFD_RELOC_HI16_BASEREL
:
6677 case BFD_RELOC_HI16_S_BASEREL
:
6678 case BFD_RELOC_PPC_TLS
:
6679 case BFD_RELOC_PPC_DTPREL16_LO
:
6680 case BFD_RELOC_PPC_DTPREL16_HI
:
6681 case BFD_RELOC_PPC_DTPREL16_HA
:
6682 case BFD_RELOC_PPC_TPREL16_LO
:
6683 case BFD_RELOC_PPC_TPREL16_HI
:
6684 case BFD_RELOC_PPC_TPREL16_HA
:
6685 case BFD_RELOC_PPC_GOT_TLSGD16
:
6686 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6687 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6688 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6689 case BFD_RELOC_PPC_GOT_TLSLD16
:
6690 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6691 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6692 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6693 case BFD_RELOC_PPC_GOT_DTPREL16
:
6694 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6695 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6696 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6697 case BFD_RELOC_PPC_GOT_TPREL16
:
6698 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6699 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6700 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6701 case BFD_RELOC_24_PLT_PCREL
:
6702 case BFD_RELOC_PPC_LOCAL24PC
:
6703 case BFD_RELOC_32_PLT_PCREL
:
6704 case BFD_RELOC_GPREL16
:
6705 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6706 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6707 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6708 case BFD_RELOC_PPC_EMB_NADDR32
:
6709 case BFD_RELOC_PPC_EMB_NADDR16
:
6710 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6711 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6712 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6713 case BFD_RELOC_PPC_EMB_SDAI16
:
6714 case BFD_RELOC_PPC_EMB_SDA2REL
:
6715 case BFD_RELOC_PPC_EMB_SDA2I16
:
6716 case BFD_RELOC_PPC_EMB_SDA21
:
6717 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6718 case BFD_RELOC_PPC_EMB_MRKREF
:
6719 case BFD_RELOC_PPC_EMB_RELSEC16
:
6720 case BFD_RELOC_PPC_EMB_RELST_LO
:
6721 case BFD_RELOC_PPC_EMB_RELST_HI
:
6722 case BFD_RELOC_PPC_EMB_RELST_HA
:
6723 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6724 case BFD_RELOC_PPC_EMB_RELSDA
:
6725 case BFD_RELOC_PPC64_TOC
:
6726 case BFD_RELOC_PPC_TOC16
:
6727 case BFD_RELOC_PPC64_TOC16_LO
:
6728 case BFD_RELOC_PPC64_TOC16_HI
:
6729 case BFD_RELOC_PPC64_TOC16_HA
:
6730 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6731 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6732 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6733 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6734 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6735 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6736 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6737 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6743 case BFD_RELOC_NONE
:
6745 case BFD_RELOC_CTOR
:
6747 case BFD_RELOC_32_PCREL
:
6750 case BFD_RELOC_64_PCREL
:
6752 case BFD_RELOC_16_PCREL
:
6758 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6763 if (fixP
->fx_size
&& APPLY_RELOC
)
6764 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6765 fieldval
, fixP
->fx_size
);
6768 /* We are only able to convert some relocs to pc-relative. */
6769 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
6771 switch (fixP
->fx_r_type
)
6773 case BFD_RELOC_LO16
:
6774 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6777 case BFD_RELOC_HI16
:
6778 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6781 case BFD_RELOC_HI16_S
:
6782 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6786 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6790 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6794 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6797 /* Some of course are already pc-relative. */
6798 case BFD_RELOC_LO16_PCREL
:
6799 case BFD_RELOC_HI16_PCREL
:
6800 case BFD_RELOC_HI16_S_PCREL
:
6801 case BFD_RELOC_64_PCREL
:
6802 case BFD_RELOC_32_PCREL
:
6803 case BFD_RELOC_16_PCREL
:
6804 case BFD_RELOC_PPC_B16
:
6805 case BFD_RELOC_PPC_B16_BRTAKEN
:
6806 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6807 case BFD_RELOC_PPC_B26
:
6808 case BFD_RELOC_PPC_LOCAL24PC
:
6809 case BFD_RELOC_24_PLT_PCREL
:
6810 case BFD_RELOC_32_PLT_PCREL
:
6811 case BFD_RELOC_64_PLT_PCREL
:
6812 case BFD_RELOC_PPC_VLE_REL8
:
6813 case BFD_RELOC_PPC_VLE_REL15
:
6814 case BFD_RELOC_PPC_VLE_REL24
:
6823 /* Use expr_symbol_where to see if this is an
6824 expression symbol. */
6825 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6826 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6827 _("unresolved expression that must"
6830 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6831 _("cannot emit PC relative %s relocation"
6833 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6834 S_GET_NAME (fixP
->fx_addsy
));
6837 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6838 _("unable to resolve expression"));
6845 ppc_elf_validate_fix (fixP
, seg
);
6846 fixP
->fx_addnumber
= value
;
6848 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6849 from the section contents. If we are going to be emitting a reloc
6850 then the section contents are immaterial, so don't warn if they
6851 happen to overflow. Leave such warnings to ld. */
6854 fixP
->fx_no_overflow
= 1;
6856 /* Arrange to emit .TOC. as a normal symbol if used in anything
6857 but .TOC.@tocbase. */
6859 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
6860 && fixP
->fx_addsy
!= NULL
6861 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
6862 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
6865 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6866 fixP
->fx_addnumber
= 0;
6870 fixP
->fx_addnumber
= 0;
6872 /* We want to use the offset within the toc, not the actual VMA
6874 fixP
->fx_addnumber
=
6875 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6876 - S_GET_VALUE (ppc_toc_csect
);
6882 /* Generate a reloc for a fixup. */
6885 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6889 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6891 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6892 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6893 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6894 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6895 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6897 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6898 _("reloc %d not supported by object file format"),
6899 (int) fixp
->fx_r_type
);
6902 reloc
->addend
= fixp
->fx_addnumber
;
6908 ppc_cfi_frame_initial_instructions (void)
6910 cfi_add_CFA_def_cfa (1, 0);
6914 tc_ppc_regname_to_dw2regnum (char *regname
)
6916 unsigned int regnum
= -1;
6920 static struct { char *name
; int dw2regnum
; } regnames
[] =
6922 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6923 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6924 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6925 { "spe_acc", 111 }, { "spefscr", 112 }
6928 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6929 if (strcmp (regnames
[i
].name
, regname
) == 0)
6930 return regnames
[i
].dw2regnum
;
6932 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6934 p
= regname
+ 1 + (regname
[1] == '.');
6935 regnum
= strtoul (p
, &q
, 10);
6936 if (p
== q
|| *q
|| regnum
>= 32)
6938 if (regname
[0] == 'f')
6940 else if (regname
[0] == 'v')
6943 else if (regname
[0] == 'c' && regname
[1] == 'r')
6945 p
= regname
+ 2 + (regname
[2] == '.');
6946 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6948 regnum
= p
[0] - '0' + 68;