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) ^ 0x8000) - 0x8000)
91 /* For the time being on ppc64, don't report overflow on @h and @ha
92 applied to constants. */
93 #define REPORT_OVERFLOW_HI 0
95 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
97 static void ppc_macro (char *, const struct powerpc_macro
*);
98 static void ppc_byte (int);
100 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
101 static void ppc_tc (int);
102 static void ppc_machine (int);
106 static void ppc_comm (int);
107 static void ppc_bb (int);
108 static void ppc_bc (int);
109 static void ppc_bf (int);
110 static void ppc_biei (int);
111 static void ppc_bs (int);
112 static void ppc_eb (int);
113 static void ppc_ec (int);
114 static void ppc_ef (int);
115 static void ppc_es (int);
116 static void ppc_csect (int);
117 static void ppc_dwsect (int);
118 static void ppc_change_csect (symbolS
*, offsetT
);
119 static void ppc_function (int);
120 static void ppc_extern (int);
121 static void ppc_lglobl (int);
122 static void ppc_ref (int);
123 static void ppc_section (int);
124 static void ppc_named_section (int);
125 static void ppc_stabx (int);
126 static void ppc_rename (int);
127 static void ppc_toc (int);
128 static void ppc_xcoff_cons (int);
129 static void ppc_vbyte (int);
133 static void ppc_elf_cons (int);
134 static void ppc_elf_rdata (int);
135 static void ppc_elf_lcomm (int);
139 static void ppc_previous (int);
140 static void ppc_pdata (int);
141 static void ppc_ydata (int);
142 static void ppc_reldata (int);
143 static void ppc_rdata (int);
144 static void ppc_ualong (int);
145 static void ppc_znop (int);
146 static void ppc_pe_comm (int);
147 static void ppc_pe_section (int);
148 static void ppc_pe_function (int);
149 static void ppc_pe_tocd (int);
152 /* Generic assembler global variables which must be defined by all
156 /* This string holds the chars that always start a comment. If the
157 pre-processor is disabled, these aren't very useful. The macro
158 tc_comment_chars points to this. We use this, rather than the
159 usual comment_chars, so that we can switch for Solaris conventions. */
160 static const char ppc_solaris_comment_chars
[] = "#!";
161 static const char ppc_eabi_comment_chars
[] = "#";
163 #ifdef TARGET_SOLARIS_COMMENT
164 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
166 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
169 const char comment_chars
[] = "#";
172 /* Characters which start a comment at the beginning of a line. */
173 const char line_comment_chars
[] = "#";
175 /* Characters which may be used to separate multiple commands on a
177 const char line_separator_chars
[] = ";";
179 /* Characters which are used to indicate an exponent in a floating
181 const char EXP_CHARS
[] = "eE";
183 /* Characters which mean that a number is a floating point constant,
185 const char FLT_CHARS
[] = "dD";
187 /* Anything that can start an operand needs to be mentioned here,
188 to stop the input scrubber eating whitespace. */
189 const char ppc_symbol_chars
[] = "%[";
191 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
192 int ppc_cie_data_alignment
;
194 /* The dwarf2 minimum instruction length. */
195 int ppc_dwarf2_line_min_insn_length
;
197 /* More than this number of nops in an alignment op gets a branch
199 unsigned long nop_limit
= 4;
201 /* The type of processor we are assembling for. This is one or more
202 of the PPC_OPCODE flags defined in opcode/ppc.h. */
203 ppc_cpu_t ppc_cpu
= 0;
204 ppc_cpu_t sticky
= 0;
206 /* Flags set on encountering toc relocs. */
208 has_large_toc_reloc
= 1,
209 has_small_toc_reloc
= 2
212 /* The target specific pseudo-ops which we support. */
214 const pseudo_typeS md_pseudo_table
[] =
216 /* Pseudo-ops which must be overridden. */
217 { "byte", ppc_byte
, 0 },
220 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
221 legitimately belong in the obj-*.c file. However, XCOFF is based
222 on COFF, and is only implemented for the RS/6000. We just use
223 obj-coff.c, and add what we need here. */
224 { "comm", ppc_comm
, 0 },
225 { "lcomm", ppc_comm
, 1 },
229 { "bi", ppc_biei
, 0 },
231 { "csect", ppc_csect
, 0 },
232 { "dwsect", ppc_dwsect
, 0 },
233 { "data", ppc_section
, 'd' },
237 { "ei", ppc_biei
, 1 },
239 { "extern", ppc_extern
, 0 },
240 { "function", ppc_function
, 0 },
241 { "lglobl", ppc_lglobl
, 0 },
242 { "ref", ppc_ref
, 0 },
243 { "rename", ppc_rename
, 0 },
244 { "section", ppc_named_section
, 0 },
245 { "stabx", ppc_stabx
, 0 },
246 { "text", ppc_section
, 't' },
247 { "toc", ppc_toc
, 0 },
248 { "long", ppc_xcoff_cons
, 2 },
249 { "llong", ppc_xcoff_cons
, 3 },
250 { "word", ppc_xcoff_cons
, 1 },
251 { "short", ppc_xcoff_cons
, 1 },
252 { "vbyte", ppc_vbyte
, 0 },
256 { "llong", ppc_elf_cons
, 8 },
257 { "quad", ppc_elf_cons
, 8 },
258 { "long", ppc_elf_cons
, 4 },
259 { "word", ppc_elf_cons
, 2 },
260 { "short", ppc_elf_cons
, 2 },
261 { "rdata", ppc_elf_rdata
, 0 },
262 { "rodata", ppc_elf_rdata
, 0 },
263 { "lcomm", ppc_elf_lcomm
, 0 },
267 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
268 { "previous", ppc_previous
, 0 },
269 { "pdata", ppc_pdata
, 0 },
270 { "ydata", ppc_ydata
, 0 },
271 { "reldata", ppc_reldata
, 0 },
272 { "rdata", ppc_rdata
, 0 },
273 { "ualong", ppc_ualong
, 0 },
274 { "znop", ppc_znop
, 0 },
275 { "comm", ppc_pe_comm
, 0 },
276 { "lcomm", ppc_pe_comm
, 1 },
277 { "section", ppc_pe_section
, 0 },
278 { "function", ppc_pe_function
,0 },
279 { "tocd", ppc_pe_tocd
, 0 },
282 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
284 { "machine", ppc_machine
, 0 },
291 /* Predefined register names if -mregnames (or default for Windows NT).
292 In general, there are lots of them, in an attempt to be compatible
293 with a number of other Windows NT assemblers. */
295 /* Structure to hold information about predefined registers. */
302 /* List of registers that are pre-defined:
304 Each general register has predefined names of the form:
305 1. r<reg_num> which has the value <reg_num>.
306 2. r.<reg_num> which has the value <reg_num>.
308 Each floating point register has predefined names of the form:
309 1. f<reg_num> which has the value <reg_num>.
310 2. f.<reg_num> which has the value <reg_num>.
312 Each vector unit register has predefined names of the form:
313 1. v<reg_num> which has the value <reg_num>.
314 2. v.<reg_num> which has the value <reg_num>.
316 Each condition register has predefined names of the form:
317 1. cr<reg_num> which has the value <reg_num>.
318 2. cr.<reg_num> which has the value <reg_num>.
320 There are individual registers as well:
321 sp or r.sp has the value 1
322 rtoc or r.toc has the value 2
323 fpscr has the value 0
329 dsisr has the value 18
331 sdr1 has the value 25
332 srr0 has the value 26
333 srr1 has the value 27
335 The table is sorted. Suitable for searching by a binary search. */
337 static const struct pd_reg pre_defined_registers
[] =
339 { "cr.0", 0 }, /* Condition Registers */
359 { "dar", 19 }, /* Data Access Register */
360 { "dec", 22 }, /* Decrementer */
361 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
363 { "f.0", 0 }, /* Floating point registers */
390 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
456 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
497 /* Quantization registers used with pair single instructions. */
515 { "lr", 8 }, /* Link Register */
519 { "r.0", 0 }, /* General Purpose Registers */
552 { "r.sp", 1 }, /* Stack Pointer */
554 { "r.toc", 2 }, /* Pointer to the table of contents */
556 { "r0", 0 }, /* More general purpose registers */
589 { "rtoc", 2 }, /* Table of contents */
591 { "sdr1", 25 }, /* Storage Description Register 1 */
595 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
596 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
598 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
664 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
798 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
800 /* Given NAME, find the register number associated with that name, return
801 the integer value associated with the given name or -1 on failure. */
804 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
806 int middle
, low
, high
;
814 middle
= (low
+ high
) / 2;
815 cmp
= strcasecmp (name
, regs
[middle
].name
);
821 return regs
[middle
].value
;
829 * Summary of register_name.
831 * in: Input_line_pointer points to 1st char of operand.
833 * out: A expressionS.
834 * The operand may have been a register: in this case, X_op == O_register,
835 * X_add_number is set to the register number, and truth is returned.
836 * Input_line_pointer->(next non-blank) char after operand, or is in its
841 register_name (expressionS
*expressionP
)
848 /* Find the spelling of the operand. */
849 start
= name
= input_line_pointer
;
850 if (name
[0] == '%' && ISALPHA (name
[1]))
851 name
= ++input_line_pointer
;
853 else if (!reg_names_p
|| !ISALPHA (name
[0]))
856 c
= get_symbol_end ();
857 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
859 /* Put back the delimiting char. */
860 *input_line_pointer
= c
;
862 /* Look to see if it's in the register table. */
865 expressionP
->X_op
= O_register
;
866 expressionP
->X_add_number
= reg_number
;
868 /* Make the rest nice. */
869 expressionP
->X_add_symbol
= NULL
;
870 expressionP
->X_op_symbol
= NULL
;
874 /* Reset the line as if we had not done anything. */
875 input_line_pointer
= start
;
879 /* This function is called for each symbol seen in an expression. It
880 handles the special parsing which PowerPC assemblers are supposed
881 to use for condition codes. */
883 /* Whether to do the special parsing. */
884 static bfd_boolean cr_operand
;
886 /* Names to recognize in a condition code. This table is sorted. */
887 static const struct pd_reg cr_names
[] =
904 /* Parsing function. This returns non-zero if it recognized an
908 ppc_parse_name (const char *name
, expressionS
*exp
)
917 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
922 exp
->X_op
= O_constant
;
923 exp
->X_add_number
= val
;
928 /* Local variables. */
930 /* Whether to target xcoff64/elf64. */
931 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
933 /* Opcode hash table. */
934 static struct hash_control
*ppc_hash
;
936 /* Macro hash table. */
937 static struct hash_control
*ppc_macro_hash
;
940 /* What type of shared library support to use. */
941 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
943 /* Flags to set in the elf header. */
944 static flagword ppc_flags
= 0;
946 /* Whether this is Solaris or not. */
947 #ifdef TARGET_SOLARIS_COMMENT
948 #define SOLARIS_P TRUE
950 #define SOLARIS_P FALSE
953 static bfd_boolean msolaris
= SOLARIS_P
;
958 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
959 using a bunch of different sections. These assembler sections,
960 however, are all encompassed within the .text or .data sections of
961 the final output file. We handle this by using different
962 subsegments within these main segments. */
964 /* Next subsegment to allocate within the .text segment. */
965 static subsegT ppc_text_subsegment
= 2;
967 /* Linked list of csects in the text section. */
968 static symbolS
*ppc_text_csects
;
970 /* Next subsegment to allocate within the .data segment. */
971 static subsegT ppc_data_subsegment
= 2;
973 /* Linked list of csects in the data section. */
974 static symbolS
*ppc_data_csects
;
976 /* The current csect. */
977 static symbolS
*ppc_current_csect
;
979 /* The RS/6000 assembler uses a TOC which holds addresses of functions
980 and variables. Symbols are put in the TOC with the .tc pseudo-op.
981 A special relocation is used when accessing TOC entries. We handle
982 the TOC as a subsegment within the .data segment. We set it up if
983 we see a .toc pseudo-op, and save the csect symbol here. */
984 static symbolS
*ppc_toc_csect
;
986 /* The first frag in the TOC subsegment. */
987 static fragS
*ppc_toc_frag
;
989 /* The first frag in the first subsegment after the TOC in the .data
990 segment. NULL if there are no subsegments after the TOC. */
991 static fragS
*ppc_after_toc_frag
;
993 /* The current static block. */
994 static symbolS
*ppc_current_block
;
996 /* The COFF debugging section; set by md_begin. This is not the
997 .debug section, but is instead the secret BFD section which will
998 cause BFD to set the section number of a symbol to N_DEBUG. */
999 static asection
*ppc_coff_debug_section
;
1001 /* Structure to set the length field of the dwarf sections. */
1002 struct dw_subsection
{
1003 /* Subsections are simply linked. */
1004 struct dw_subsection
*link
;
1006 /* The subsection number. */
1009 /* Expression to compute the length of the section. */
1010 expressionS end_exp
;
1013 static struct dw_section
{
1014 /* Corresponding section. */
1017 /* Simply linked list of subsections with a label. */
1018 struct dw_subsection
*list_subseg
;
1020 /* The anonymous subsection. */
1021 struct dw_subsection
*anon_subseg
;
1022 } dw_sections
[XCOFF_DWSECT_NBR_NAMES
];
1023 #endif /* OBJ_XCOFF */
1027 /* Various sections that we need for PE coff support. */
1028 static segT ydata_section
;
1029 static segT pdata_section
;
1030 static segT reldata_section
;
1031 static segT rdata_section
;
1032 static segT tocdata_section
;
1034 /* The current section and the previous section. See ppc_previous. */
1035 static segT ppc_previous_section
;
1036 static segT ppc_current_section
;
1041 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1042 #define PPC_APUINFO_ISEL 0x40
1043 #define PPC_APUINFO_PMR 0x41
1044 #define PPC_APUINFO_RFMCI 0x42
1045 #define PPC_APUINFO_CACHELCK 0x43
1046 #define PPC_APUINFO_SPE 0x100
1047 #define PPC_APUINFO_EFS 0x101
1048 #define PPC_APUINFO_BRLOCK 0x102
1049 #define PPC_APUINFO_VLE 0x104
1052 * We keep a list of APUinfo
1054 unsigned long *ppc_apuinfo_list
;
1055 unsigned int ppc_apuinfo_num
;
1056 unsigned int ppc_apuinfo_num_alloc
;
1057 #endif /* OBJ_ELF */
1060 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1062 const char *const md_shortopts
= "um:";
1064 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1065 const struct option md_longopts
[] = {
1066 {"nops", required_argument
, NULL
, OPTION_NOPS
},
1067 {NULL
, no_argument
, NULL
, 0}
1069 const size_t md_longopts_size
= sizeof (md_longopts
);
1072 md_parse_option (int c
, char *arg
)
1079 /* -u means that any undefined symbols should be treated as
1080 external, which is the default for gas anyhow. */
1085 /* Solaris as takes -le (presumably for little endian). For completeness
1086 sake, recognize -be also. */
1087 if (strcmp (arg
, "e") == 0)
1089 target_big_endian
= 0;
1090 set_target_endian
= 1;
1091 if (ppc_cpu
& PPC_OPCODE_VLE
)
1092 as_bad (_("the use of -mvle requires big endian."));
1100 if (strcmp (arg
, "e") == 0)
1102 target_big_endian
= 1;
1103 set_target_endian
= 1;
1111 /* Recognize -K PIC. */
1112 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1115 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1123 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1125 if (strcmp (arg
, "64") == 0)
1129 if (ppc_cpu
& PPC_OPCODE_VLE
)
1130 as_bad (_("the use of -mvle requires -a32."));
1132 as_fatal (_("%s unsupported"), "-a64");
1135 else if (strcmp (arg
, "32") == 0)
1142 new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, arg
);
1146 if (strcmp (arg
, "vle") == 0)
1148 if (set_target_endian
&& target_big_endian
== 0)
1149 as_bad (_("the use of -mvle requires big endian."));
1151 as_bad (_("the use of -mvle requires -a32."));
1155 else if (strcmp (arg
, "regnames") == 0)
1158 else if (strcmp (arg
, "no-regnames") == 0)
1159 reg_names_p
= FALSE
;
1162 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1163 that require relocation. */
1164 else if (strcmp (arg
, "relocatable") == 0)
1166 shlib
= SHLIB_MRELOCATABLE
;
1167 ppc_flags
|= EF_PPC_RELOCATABLE
;
1170 else if (strcmp (arg
, "relocatable-lib") == 0)
1172 shlib
= SHLIB_MRELOCATABLE
;
1173 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1176 /* -memb, set embedded bit. */
1177 else if (strcmp (arg
, "emb") == 0)
1178 ppc_flags
|= EF_PPC_EMB
;
1180 /* -mlittle/-mbig set the endianness. */
1181 else if (strcmp (arg
, "little") == 0
1182 || strcmp (arg
, "little-endian") == 0)
1184 target_big_endian
= 0;
1185 set_target_endian
= 1;
1186 if (ppc_cpu
& PPC_OPCODE_VLE
)
1187 as_bad (_("the use of -mvle requires big endian."));
1190 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1192 target_big_endian
= 1;
1193 set_target_endian
= 1;
1196 else if (strcmp (arg
, "solaris") == 0)
1199 ppc_comment_chars
= ppc_solaris_comment_chars
;
1202 else if (strcmp (arg
, "no-solaris") == 0)
1205 ppc_comment_chars
= ppc_eabi_comment_chars
;
1210 as_bad (_("invalid switch -m%s"), arg
);
1216 /* -V: SVR4 argument to print version ID. */
1218 print_version_id ();
1221 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1222 should be emitted or not. FIXME: Not implemented. */
1226 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1227 rather than .stabs.excl, which is ignored by the linker.
1228 FIXME: Not implemented. */
1239 nop_limit
= strtoul (optarg
, &end
, 0);
1241 as_bad (_("--nops needs a numeric argument"));
1253 md_show_usage (FILE *stream
)
1255 fprintf (stream
, _("\
1257 -a32 generate ELF32/XCOFF32\n\
1258 -a64 generate ELF64/XCOFF64\n\
1260 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1261 -mpwr generate code for POWER (RIOS1)\n\
1262 -m601 generate code for PowerPC 601\n\
1263 -mppc, -mppc32, -m603, -m604\n\
1264 generate code for PowerPC 603/604\n\
1265 -m403 generate code for PowerPC 403\n\
1266 -m405 generate code for PowerPC 405\n\
1267 -m440 generate code for PowerPC 440\n\
1268 -m464 generate code for PowerPC 464\n\
1269 -m476 generate code for PowerPC 476\n\
1270 -m7400, -m7410, -m7450, -m7455\n\
1271 generate code for PowerPC 7400/7410/7450/7455\n\
1272 -m750cl generate code for PowerPC 750cl\n"));
1273 fprintf (stream
, _("\
1274 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1275 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1276 -mbooke generate code for 32-bit PowerPC BookE\n\
1277 -ma2 generate code for A2 architecture\n\
1278 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1279 -mpower5, -mpwr5, -mpwr5x\n\
1280 generate code for Power5 architecture\n\
1281 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1282 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1283 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1284 -mcell generate code for Cell Broadband Engine architecture\n\
1285 -mcom generate code Power/PowerPC common instructions\n\
1286 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1287 fprintf (stream
, _("\
1288 -maltivec generate code for AltiVec\n\
1289 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1290 -mhtm generate code for Hardware Transactional Memory\n\
1291 -me300 generate code for PowerPC e300 family\n\
1292 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1293 -me500mc, generate code for Freescale e500mc core complex\n\
1294 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1295 -me5500, generate code for Freescale e5500 core complex\n\
1296 -me6500, generate code for Freescale e6500 core complex\n\
1297 -mspe generate code for Motorola SPE instructions\n\
1298 -mvle generate code for Freescale VLE instructions\n\
1299 -mtitan generate code for AppliedMicro Titan core complex\n\
1300 -mregnames Allow symbolic names for registers\n\
1301 -mno-regnames Do not allow symbolic names for registers\n"));
1303 fprintf (stream
, _("\
1304 -mrelocatable support for GCC's -mrelocatble option\n\
1305 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1306 -memb set PPC_EMB bit in ELF flags\n\
1307 -mlittle, -mlittle-endian, -le\n\
1308 generate code for a little endian machine\n\
1309 -mbig, -mbig-endian, -be\n\
1310 generate code for a big endian machine\n\
1311 -msolaris generate code for Solaris\n\
1312 -mno-solaris do not generate code for Solaris\n\
1313 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1314 -V print assembler version number\n\
1315 -Qy, -Qn ignored\n"));
1317 fprintf (stream
, _("\
1318 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1321 /* Set ppc_cpu if it is not already set. */
1326 const char *default_os
= TARGET_OS
;
1327 const char *default_cpu
= TARGET_CPU
;
1329 if ((ppc_cpu
& ~(ppc_cpu_t
) PPC_OPCODE_ANY
) == 0)
1332 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
1333 else if (strncmp (default_os
, "aix", 3) == 0
1334 && default_os
[3] >= '4' && default_os
[3] <= '9')
1335 ppc_cpu
|= PPC_OPCODE_COMMON
;
1336 else if (strncmp (default_os
, "aix3", 4) == 0)
1337 ppc_cpu
|= PPC_OPCODE_POWER
;
1338 else if (strcmp (default_cpu
, "rs6000") == 0)
1339 ppc_cpu
|= PPC_OPCODE_POWER
;
1340 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1341 ppc_cpu
|= PPC_OPCODE_PPC
;
1343 as_fatal (_("unknown default cpu = %s, os = %s"),
1344 default_cpu
, default_os
);
1348 /* Figure out the BFD architecture to use. This function and ppc_mach
1349 are called well before md_begin, when the output file is opened. */
1351 enum bfd_architecture
1354 const char *default_cpu
= TARGET_CPU
;
1357 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1358 return bfd_arch_powerpc
;
1359 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1360 return bfd_arch_powerpc
;
1361 if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1362 return bfd_arch_rs6000
;
1363 if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1365 if (strcmp (default_cpu
, "rs6000") == 0)
1366 return bfd_arch_rs6000
;
1367 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1368 return bfd_arch_powerpc
;
1371 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1372 return bfd_arch_unknown
;
1379 return bfd_mach_ppc64
;
1380 else if (ppc_arch () == bfd_arch_rs6000
)
1381 return bfd_mach_rs6k
;
1382 else if (ppc_cpu
& PPC_OPCODE_TITAN
)
1383 return bfd_mach_ppc_titan
;
1384 else if (ppc_cpu
& PPC_OPCODE_VLE
)
1385 return bfd_mach_ppc_vle
;
1387 return bfd_mach_ppc
;
1391 ppc_target_format (void)
1395 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1397 return "xcoff-powermac";
1400 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1402 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1408 return (ppc_obj64
? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1409 # elif defined (TE_VXWORKS)
1410 return "elf32-powerpc-vxworks";
1412 return (target_big_endian
1413 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1414 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1419 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1420 Return TRUE if there's a problem, otherwise FALSE. */
1423 insn_validate (const struct powerpc_opcode
*op
)
1425 const unsigned char *o
;
1426 unsigned long omask
= op
->mask
;
1428 /* The mask had better not trim off opcode bits. */
1429 if ((op
->opcode
& omask
) != op
->opcode
)
1431 as_bad (_("mask trims opcode bits for %s"), op
->name
);
1435 /* The operands must not overlap the opcode or each other. */
1436 for (o
= op
->operands
; *o
; ++o
)
1438 if (*o
>= num_powerpc_operands
)
1440 as_bad (_("operand index error for %s"), op
->name
);
1445 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1446 if (operand
->shift
!= PPC_OPSHIFT_INV
)
1450 if (operand
->shift
>= 0)
1451 mask
= operand
->bitm
<< operand
->shift
;
1453 mask
= operand
->bitm
>> -operand
->shift
;
1456 as_bad (_("operand %d overlap in %s"),
1457 (int) (o
- op
->operands
), op
->name
);
1467 /* Insert opcodes and macros into hash tables. Called at startup and
1468 for .machine pseudo. */
1471 ppc_setup_opcodes (void)
1473 const struct powerpc_opcode
*op
;
1474 const struct powerpc_opcode
*op_end
;
1475 const struct powerpc_macro
*macro
;
1476 const struct powerpc_macro
*macro_end
;
1477 bfd_boolean bad_insn
= FALSE
;
1479 if (ppc_hash
!= NULL
)
1480 hash_die (ppc_hash
);
1481 if (ppc_macro_hash
!= NULL
)
1482 hash_die (ppc_macro_hash
);
1484 /* Insert the opcodes into a hash table. */
1485 ppc_hash
= hash_new ();
1487 if (ENABLE_CHECKING
)
1491 /* An index into powerpc_operands is stored in struct fix
1492 fx_pcrel_adjust which is 8 bits wide. */
1493 gas_assert (num_powerpc_operands
< 256);
1495 /* Check operand masks. Code here and in the disassembler assumes
1496 all the 1's in the mask are contiguous. */
1497 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1499 unsigned long mask
= powerpc_operands
[i
].bitm
;
1500 unsigned long right_bit
;
1503 right_bit
= mask
& -mask
;
1505 right_bit
= mask
& -mask
;
1506 if (mask
!= right_bit
)
1508 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1511 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1512 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1513 sizeof (powerpc_operands
[0])) == 0)
1515 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1522 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1523 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1525 if (ENABLE_CHECKING
)
1527 if (op
!= powerpc_opcodes
)
1529 int old_opcode
= PPC_OP (op
[-1].opcode
);
1530 int new_opcode
= PPC_OP (op
[0].opcode
);
1532 #ifdef PRINT_OPCODE_TABLE
1533 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1534 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1535 (unsigned int) new_opcode
, (unsigned int) op
->opcode
,
1536 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1539 /* The major opcodes had better be sorted. Code in the
1540 disassembler assumes the insns are sorted according to
1542 if (new_opcode
< old_opcode
)
1544 as_bad (_("major opcode is not sorted for %s"),
1549 bad_insn
|= insn_validate (op
);
1552 if ((ppc_cpu
& op
->flags
) != 0
1553 && !(ppc_cpu
& op
->deprecated
))
1557 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1560 as_bad (_("duplicate instruction %s"),
1567 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1568 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1569 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1571 op_end
= vle_opcodes
+ vle_num_opcodes
;
1572 for (op
= vle_opcodes
; op
< op_end
; op
++)
1574 if (ENABLE_CHECKING
)
1576 if (op
!= vle_opcodes
)
1578 unsigned old_seg
, new_seg
;
1580 old_seg
= VLE_OP (op
[-1].opcode
, op
[-1].mask
);
1581 old_seg
= VLE_OP_TO_SEG (old_seg
);
1582 new_seg
= VLE_OP (op
[0].opcode
, op
[0].mask
);
1583 new_seg
= VLE_OP_TO_SEG (new_seg
);
1585 #ifdef PRINT_OPCODE_TABLE
1586 printf ("%-14s\t#%04u\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1587 op
->name
, (unsigned int) (op
- powerpc_opcodes
),
1588 (unsigned int) new_seg
, (unsigned int) op
->opcode
,
1589 (unsigned int) op
->mask
, (unsigned long long) op
->flags
);
1591 /* The major opcodes had better be sorted. Code in the
1592 disassembler assumes the insns are sorted according to
1594 if (new_seg
< old_seg
)
1596 as_bad (_("major opcode is not sorted for %s"),
1602 bad_insn
|= insn_validate (op
);
1605 if ((ppc_cpu
& op
->flags
) != 0
1606 && !(ppc_cpu
& op
->deprecated
))
1610 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1613 as_bad (_("duplicate instruction %s"),
1620 if ((ppc_cpu
& PPC_OPCODE_VLE
) != 0)
1621 for (op
= vle_opcodes
; op
< op_end
; op
++)
1622 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1624 /* Insert the macros into a hash table. */
1625 ppc_macro_hash
= hash_new ();
1627 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1628 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1630 if ((macro
->flags
& ppc_cpu
) != 0 || (ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1634 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1635 if (retval
!= (const char *) NULL
)
1637 as_bad (_("duplicate macro %s"), macro
->name
);
1647 /* This function is called when the assembler starts up. It is called
1648 after the options have been parsed and the output file has been
1656 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1657 ppc_dwarf2_line_min_insn_length
= (ppc_cpu
& PPC_OPCODE_VLE
) ? 2 : 4;
1660 /* Set the ELF flags if desired. */
1661 if (ppc_flags
&& !msolaris
)
1662 bfd_set_private_flags (stdoutput
, ppc_flags
);
1665 ppc_setup_opcodes ();
1667 /* Tell the main code what the endianness is if it is not overridden
1669 if (!set_target_endian
)
1671 set_target_endian
= 1;
1672 target_big_endian
= PPC_BIG_ENDIAN
;
1676 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1678 /* Create dummy symbols to serve as initial csects. This forces the
1679 text csects to precede the data csects. These symbols will not
1681 ppc_text_csects
= symbol_make ("dummy\001");
1682 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1683 ppc_data_csects
= symbol_make ("dummy\001");
1684 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1689 ppc_current_section
= text_section
;
1690 ppc_previous_section
= 0;
1699 if (ppc_apuinfo_list
== NULL
)
1702 /* Ok, so write the section info out. We have this layout:
1706 0 8 length of "APUinfo\0"
1707 4 (n*4) number of APU's (4 bytes each)
1710 20 APU#1 first APU's info
1711 24 APU#2 second APU's info
1716 asection
*seg
= now_seg
;
1717 subsegT subseg
= now_subseg
;
1718 asection
*apuinfo_secp
= (asection
*) NULL
;
1721 /* Create the .PPC.EMB.apuinfo section. */
1722 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1723 bfd_set_section_flags (stdoutput
,
1725 SEC_HAS_CONTENTS
| SEC_READONLY
);
1728 md_number_to_chars (p
, (valueT
) 8, 4);
1731 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1734 md_number_to_chars (p
, (valueT
) 2, 4);
1737 strcpy (p
, "APUinfo");
1739 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1742 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1745 frag_align (2, 0, 0);
1747 /* We probably can't restore the current segment, for there likely
1750 subseg_set (seg
, subseg
);
1755 /* Insert an operand value into an instruction. */
1757 static unsigned long
1758 ppc_insert_operand (unsigned long insn
,
1759 const struct powerpc_operand
*operand
,
1765 long min
, max
, right
;
1767 max
= operand
->bitm
;
1771 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1773 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1774 max
= (max
>> 1) & -right
;
1775 min
= ~max
& -right
;
1778 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1781 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1790 /* Some people write constants with the sign extension done by
1791 hand but only up to 32 bits. This shouldn't really be valid,
1792 but, to permit this code to assemble on a 64-bit host, we
1793 sign extend the 32-bit value to 64 bits if so doing makes the
1796 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1797 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1798 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1799 val
= val
- 0x80000000 - 0x80000000;
1801 /* Similarly, people write expressions like ~(1<<15), and expect
1802 this to be OK for a 32-bit unsigned value. */
1804 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1805 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1806 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1807 val
= val
+ 0x80000000 + 0x80000000;
1811 || (val
& (right
- 1)) != 0)
1812 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1815 if (operand
->insert
)
1820 insn
= (*operand
->insert
) (insn
, (long) val
, cpu
, &errmsg
);
1821 if (errmsg
!= (const char *) NULL
)
1822 as_bad_where (file
, line
, "%s", errmsg
);
1824 else if (operand
->shift
>= 0)
1825 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1827 insn
|= ((long) val
& operand
->bitm
) >> -operand
->shift
;
1834 /* Parse @got, etc. and return the desired relocation. */
1835 static bfd_reloc_code_real_type
1836 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1840 unsigned int length
: 8;
1841 unsigned int valid32
: 1;
1842 unsigned int valid64
: 1;
1851 const struct map_bfd
*ptr
;
1853 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1854 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1855 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1857 static const struct map_bfd mapping
[] = {
1858 MAP ("l", BFD_RELOC_LO16
),
1859 MAP ("h", BFD_RELOC_HI16
),
1860 MAP ("ha", BFD_RELOC_HI16_S
),
1861 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1862 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1863 MAP ("got", BFD_RELOC_16_GOTOFF
),
1864 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1865 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1866 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1867 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1868 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1869 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1870 MAP ("copy", BFD_RELOC_PPC_COPY
),
1871 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1872 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1873 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1874 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1875 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1876 MAP ("tls", BFD_RELOC_PPC_TLS
),
1877 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1878 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1879 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1880 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1881 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1882 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1883 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1884 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1885 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1886 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1887 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1888 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1889 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1890 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1891 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1892 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1893 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1894 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1895 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1896 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1897 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1898 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1899 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1900 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1901 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1902 MAP32 ("fixup", BFD_RELOC_CTOR
),
1903 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1904 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1905 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1906 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1907 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1908 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1909 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A
),
1910 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A
),
1911 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A
),
1912 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1913 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1914 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1915 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1916 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1917 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1918 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1919 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1920 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1921 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO
),
1922 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1923 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1924 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1925 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1926 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1927 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1928 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1929 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1930 MAP64 ("high", BFD_RELOC_PPC64_ADDR16_HIGH
),
1931 MAP64 ("higha", BFD_RELOC_PPC64_ADDR16_HIGHA
),
1932 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1933 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1934 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1935 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1936 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1937 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1938 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1939 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1940 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1941 MAP64 ("dtprel@high", BFD_RELOC_PPC64_DTPREL16_HIGH
),
1942 MAP64 ("dtprel@higha", BFD_RELOC_PPC64_DTPREL16_HIGHA
),
1943 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1944 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1945 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1946 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1947 MAP64 ("tprel@high", BFD_RELOC_PPC64_TPREL16_HIGH
),
1948 MAP64 ("tprel@higha", BFD_RELOC_PPC64_TPREL16_HIGHA
),
1949 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1950 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1951 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1952 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1953 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1957 return BFD_RELOC_UNUSED
;
1959 for (ch
= *str
, str2
= ident
;
1960 (str2
< ident
+ sizeof (ident
) - 1
1961 && (ISALNUM (ch
) || ch
== '@'));
1964 *str2
++ = TOLOWER (ch
);
1971 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1972 if (ch
== ptr
->string
[0]
1973 && len
== ptr
->length
1974 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1975 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1977 int reloc
= ptr
->reloc
;
1979 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1983 case BFD_RELOC_16_GOTOFF
:
1984 case BFD_RELOC_LO16_GOTOFF
:
1985 case BFD_RELOC_HI16_GOTOFF
:
1986 case BFD_RELOC_HI16_S_GOTOFF
:
1987 as_warn (_("identifier+constant@got means "
1988 "identifier@got+constant"));
1991 case BFD_RELOC_PPC_GOT_TLSGD16
:
1992 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
1993 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
1994 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
1995 case BFD_RELOC_PPC_GOT_TLSLD16
:
1996 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
1997 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
1998 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
1999 case BFD_RELOC_PPC_GOT_DTPREL16
:
2000 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2001 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
2002 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
2003 case BFD_RELOC_PPC_GOT_TPREL16
:
2004 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2005 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
2006 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
2007 as_bad (_("symbol+offset not supported for got tls"));
2012 /* Now check for identifier@suffix+constant. */
2013 if (*str
== '-' || *str
== '+')
2015 char *orig_line
= input_line_pointer
;
2016 expressionS new_exp
;
2018 input_line_pointer
= str
;
2019 expression (&new_exp
);
2020 if (new_exp
.X_op
== O_constant
)
2022 exp_p
->X_add_number
+= new_exp
.X_add_number
;
2023 str
= input_line_pointer
;
2026 if (&input_line_pointer
!= str_p
)
2027 input_line_pointer
= orig_line
;
2031 if (reloc
== (int) BFD_RELOC_PPC64_TOC
2032 && exp_p
->X_op
== O_symbol
2033 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
2035 /* Change the symbol so that the dummy .TOC. symbol can be
2036 omitted from the object file. */
2037 exp_p
->X_add_symbol
= &abs_symbol
;
2040 return (bfd_reloc_code_real_type
) reloc
;
2043 return BFD_RELOC_UNUSED
;
2046 /* Like normal .long/.short/.word, except support @got, etc.
2047 Clobbers input_line_pointer, checks end-of-line. */
2049 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2052 bfd_reloc_code_real_type reloc
;
2054 if (is_it_end_of_statement ())
2056 demand_empty_rest_of_line ();
2063 if (*input_line_pointer
== '@'
2064 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
2065 &exp
)) != BFD_RELOC_UNUSED
)
2067 reloc_howto_type
*reloc_howto
;
2070 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
2071 size
= bfd_get_reloc_size (reloc_howto
);
2075 as_bad (_("%s relocations do not fit in %d bytes\n"),
2076 reloc_howto
->name
, nbytes
);
2083 p
= frag_more (nbytes
);
2084 memset (p
, 0, nbytes
);
2086 if (target_big_endian
)
2087 offset
= nbytes
- size
;
2088 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
2093 emit_expr (&exp
, (unsigned int) nbytes
);
2095 while (*input_line_pointer
++ == ',');
2097 /* Put terminator back into stream. */
2098 input_line_pointer
--;
2099 demand_empty_rest_of_line ();
2102 /* Solaris pseduo op to change to the .rodata section. */
2104 ppc_elf_rdata (int xxx
)
2106 char *save_line
= input_line_pointer
;
2107 static char section
[] = ".rodata\n";
2109 /* Just pretend this is .section .rodata */
2110 input_line_pointer
= section
;
2111 obj_elf_section (xxx
);
2113 input_line_pointer
= save_line
;
2116 /* Pseudo op to make file scope bss items. */
2118 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
2131 name
= input_line_pointer
;
2132 c
= get_symbol_end ();
2134 /* just after name is now '\0'. */
2135 p
= input_line_pointer
;
2138 if (*input_line_pointer
!= ',')
2140 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2141 ignore_rest_of_line ();
2145 input_line_pointer
++; /* skip ',' */
2146 if ((size
= get_absolute_expression ()) < 0)
2148 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2149 ignore_rest_of_line ();
2153 /* The third argument to .lcomm is the alignment. */
2154 if (*input_line_pointer
!= ',')
2158 ++input_line_pointer
;
2159 align
= get_absolute_expression ();
2162 as_warn (_("ignoring bad alignment"));
2168 symbolP
= symbol_find_or_make (name
);
2171 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2173 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2174 S_GET_NAME (symbolP
));
2175 ignore_rest_of_line ();
2179 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2181 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2182 S_GET_NAME (symbolP
),
2183 (long) S_GET_VALUE (symbolP
),
2186 ignore_rest_of_line ();
2192 old_subsec
= now_subseg
;
2195 /* Convert to a power of 2 alignment. */
2196 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2199 as_bad (_("common alignment not a power of 2"));
2200 ignore_rest_of_line ();
2207 record_alignment (bss_section
, align2
);
2208 subseg_set (bss_section
, 1);
2210 frag_align (align2
, 0, 0);
2211 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2212 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2213 symbol_set_frag (symbolP
, frag_now
);
2214 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2217 S_SET_SIZE (symbolP
, size
);
2218 S_SET_SEGMENT (symbolP
, bss_section
);
2219 subseg_set (old_sec
, old_subsec
);
2220 demand_empty_rest_of_line ();
2223 /* Validate any relocations emitted for -mrelocatable, possibly adding
2224 fixups for word relocations in writable segments, so we can adjust
2227 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2229 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2238 case SHLIB_MRELOCATABLE
:
2239 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2240 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2241 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2242 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2243 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2244 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2245 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2246 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2247 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2248 && (seg
->flags
& SEC_LOAD
) != 0
2249 && strcmp (segment_name (seg
), ".got2") != 0
2250 && strcmp (segment_name (seg
), ".dtors") != 0
2251 && strcmp (segment_name (seg
), ".ctors") != 0
2252 && strcmp (segment_name (seg
), ".fixup") != 0
2253 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2254 && strcmp (segment_name (seg
), ".eh_frame") != 0
2255 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2257 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2258 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2260 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2261 _("relocation cannot be done when using -mrelocatable"));
2268 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2269 function descriptor sym if the corresponding code sym is used. */
2272 ppc_frob_file_before_adjust (void)
2280 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2287 name
= S_GET_NAME (symp
);
2291 if (! S_IS_WEAK (symp
)
2292 || S_IS_DEFINED (symp
))
2295 len
= strlen (name
) + 1;
2296 dotname
= xmalloc (len
+ 1);
2298 memcpy (dotname
+ 1, name
, len
);
2299 dotsym
= symbol_find_noref (dotname
, 1);
2301 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2302 || symbol_used_in_reloc_p (dotsym
)))
2303 symbol_mark_used (symp
);
2307 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2309 && toc_reloc_types
!= has_large_toc_reloc
2310 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2311 as_warn (_("TOC section size exceeds 64k"));
2314 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2315 emitted. Other uses of .TOC. will cause the symbol to be marked
2316 with BSF_KEEP in md_apply_fix. */
2319 ppc_elf_adjust_symtab (void)
2324 symp
= symbol_find (".TOC.");
2327 asymbol
*bsym
= symbol_get_bfdsym (symp
);
2328 if ((bsym
->flags
& BSF_KEEP
) == 0)
2329 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2333 #endif /* OBJ_ELF */
2338 * Summary of parse_toc_entry.
2340 * in: Input_line_pointer points to the '[' in one of:
2342 * [toc] [tocv] [toc32] [toc64]
2344 * Anything else is an error of one kind or another.
2347 * return value: success or failure
2348 * toc_kind: kind of toc reference
2349 * input_line_pointer:
2350 * success: first char after the ']'
2351 * failure: unchanged
2355 * [toc] - rv == success, toc_kind = default_toc
2356 * [tocv] - rv == success, toc_kind = data_in_toc
2357 * [toc32] - rv == success, toc_kind = must_be_32
2358 * [toc64] - rv == success, toc_kind = must_be_64
2362 enum toc_size_qualifier
2364 default_toc
, /* The toc cell constructed should be the system default size */
2365 data_in_toc
, /* This is a direct reference to a toc cell */
2366 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2367 must_be_64
/* The toc cell constructed must be 64 bits wide */
2371 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2376 enum toc_size_qualifier t
;
2378 /* Save the input_line_pointer. */
2379 start
= input_line_pointer
;
2381 /* Skip over the '[' , and whitespace. */
2382 ++input_line_pointer
;
2385 /* Find the spelling of the operand. */
2386 toc_spec
= input_line_pointer
;
2387 c
= get_symbol_end ();
2389 if (strcmp (toc_spec
, "toc") == 0)
2393 else if (strcmp (toc_spec
, "tocv") == 0)
2397 else if (strcmp (toc_spec
, "toc32") == 0)
2401 else if (strcmp (toc_spec
, "toc64") == 0)
2407 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2408 *input_line_pointer
= c
;
2409 input_line_pointer
= start
;
2413 /* Now find the ']'. */
2414 *input_line_pointer
= c
;
2416 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2417 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2421 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2422 input_line_pointer
= start
;
2431 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2432 /* See whether a symbol is in the TOC section. */
2435 ppc_is_toc_sym (symbolS
*sym
)
2438 return (symbol_get_tc (sym
)->symbol_class
== XMC_TC
2439 || symbol_get_tc (sym
)->symbol_class
== XMC_TC0
);
2442 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
2444 return strcmp (sname
, ".toc") == 0;
2446 return strcmp (sname
, ".got") == 0;
2449 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2453 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2455 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2459 /* Check we don't already exist. */
2460 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2461 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2464 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2466 if (ppc_apuinfo_num_alloc
== 0)
2468 ppc_apuinfo_num_alloc
= 4;
2469 ppc_apuinfo_list
= (unsigned long *)
2470 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2474 ppc_apuinfo_num_alloc
+= 4;
2475 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2476 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2479 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2485 /* We need to keep a list of fixups. We can't simply generate them as
2486 we go, because that would require us to first create the frag, and
2487 that would screw up references to ``.''. */
2493 bfd_reloc_code_real_type reloc
;
2496 #define MAX_INSN_FIXUPS (5)
2499 #define E_OR2I_INSN 0x7000C000
2500 #define E_AND2I_DOT_INSN 0x7000C800
2501 #define E_OR2IS_INSN 0x7000D000
2502 #define E_LIS_INSN 0x7000E000
2503 #define E_AND2IS_DOT_INSN 0x7000E800
2506 #define E_ADD2I_DOT_INSN 0x70008800
2507 #define E_ADD2IS_INSN 0x70009000
2508 #define E_CMP16I_INSN 0x70009800
2509 #define E_MULL2I_INSN 0x7000A000
2510 #define E_CMPL16I_INSN 0x7000A800
2511 #define E_CMPH16I_INSN 0x7000B000
2512 #define E_CMPHL16I_INSN 0x7000B800
2514 /* This routine is called for each instruction to be assembled. */
2517 md_assemble (char *str
)
2520 const struct powerpc_opcode
*opcode
;
2522 const unsigned char *opindex_ptr
;
2526 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2531 unsigned int insn_length
;
2533 /* Get the opcode. */
2534 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2539 /* Look up the opcode in the hash table. */
2540 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2541 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2543 const struct powerpc_macro
*macro
;
2545 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2546 if (macro
== (const struct powerpc_macro
*) NULL
)
2547 as_bad (_("unrecognized opcode: `%s'"), str
);
2549 ppc_macro (s
, macro
);
2554 insn
= opcode
->opcode
;
2557 while (ISSPACE (*str
))
2560 /* PowerPC operands are just expressions. The only real issue is
2561 that a few operand types are optional. All cases which might use
2562 an optional operand separate the operands only with commas (in some
2563 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2564 have optional operands). Most instructions with optional operands
2565 have only one. Those that have more than one optional operand can
2566 take either all their operands or none. So, before we start seriously
2567 parsing the operands, we check to see if we have optional operands,
2568 and if we do, we count the number of commas to see which operands
2569 have been omitted. */
2571 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2573 const struct powerpc_operand
*operand
;
2575 operand
= &powerpc_operands
[*opindex_ptr
];
2576 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2578 unsigned int opcount
;
2579 unsigned int num_operands_expected
;
2581 /* There is an optional operand. Count the number of
2582 commas in the input line. */
2589 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2596 /* Compute the number of expected operands.
2597 Do not count fake operands. */
2598 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2599 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2600 ++ num_operands_expected
;
2602 /* If there are fewer operands in the line then are called
2603 for by the instruction, we want to skip the optional
2605 if (opcount
< num_operands_expected
)
2612 /* Gather the operands. */
2616 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2618 const struct powerpc_operand
*operand
;
2624 if (next_opindex
== 0)
2625 operand
= &powerpc_operands
[*opindex_ptr
];
2628 operand
= &powerpc_operands
[next_opindex
];
2633 /* If this is a fake operand, then we do not expect anything
2635 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2637 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2638 if (errmsg
!= (const char *) NULL
)
2639 as_bad ("%s", errmsg
);
2643 /* If this is an optional operand, and we are skipping it, just
2645 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2648 if (operand
->insert
)
2650 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2651 if (errmsg
!= (const char *) NULL
)
2652 as_bad ("%s", errmsg
);
2654 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2655 next_opindex
= *opindex_ptr
+ 1;
2659 /* Gather the operand. */
2660 hold
= input_line_pointer
;
2661 input_line_pointer
= str
;
2664 if (*input_line_pointer
== '[')
2666 /* We are expecting something like the second argument here:
2668 * lwz r4,[toc].GS.0.static_int(rtoc)
2669 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2670 * The argument following the `]' must be a symbol name, and the
2671 * register must be the toc register: 'rtoc' or '2'
2673 * The effect is to 0 as the displacement field
2674 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2675 * the appropriate variation) reloc against it based on the symbol.
2676 * The linker will build the toc, and insert the resolved toc offset.
2679 * o The size of the toc entry is currently assumed to be
2680 * 32 bits. This should not be assumed to be a hard coded
2682 * o In an effort to cope with a change from 32 to 64 bits,
2683 * there are also toc entries that are specified to be
2684 * either 32 or 64 bits:
2685 * lwz r4,[toc32].GS.0.static_int(rtoc)
2686 * lwz r4,[toc64].GS.0.static_int(rtoc)
2687 * These demand toc entries of the specified size, and the
2688 * instruction probably requires it.
2692 enum toc_size_qualifier toc_kind
;
2693 bfd_reloc_code_real_type toc_reloc
;
2695 /* Go parse off the [tocXX] part. */
2696 valid_toc
= parse_toc_entry (&toc_kind
);
2700 ignore_rest_of_line ();
2704 /* Now get the symbol following the ']'. */
2710 /* In this case, we may not have seen the symbol yet,
2711 since it is allowed to appear on a .extern or .globl
2712 or just be a label in the .data section. */
2713 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2716 /* 1. The symbol must be defined and either in the toc
2717 section, or a global.
2718 2. The reloc generated must have the TOCDEFN flag set
2719 in upper bit mess of the reloc type.
2720 FIXME: It's a little confusing what the tocv
2721 qualifier can be used for. At the very least, I've
2722 seen three uses, only one of which I'm sure I can
2724 if (ex
.X_op
== O_symbol
)
2726 gas_assert (ex
.X_add_symbol
!= NULL
);
2727 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2730 as_bad (_("[tocv] symbol is not a toc symbol"));
2734 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2737 /* FIXME: these next two specifically specify 32/64 bit
2738 toc entries. We don't support them today. Is this
2739 the right way to say that? */
2740 toc_reloc
= BFD_RELOC_UNUSED
;
2741 as_bad (_("unimplemented toc32 expression modifier"));
2744 /* FIXME: see above. */
2745 toc_reloc
= BFD_RELOC_UNUSED
;
2746 as_bad (_("unimplemented toc64 expression modifier"));
2750 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2756 /* We need to generate a fixup for this expression. */
2757 if (fc
>= MAX_INSN_FIXUPS
)
2758 as_fatal (_("too many fixups"));
2760 fixups
[fc
].reloc
= toc_reloc
;
2761 fixups
[fc
].exp
= ex
;
2762 fixups
[fc
].opindex
= *opindex_ptr
;
2765 /* Ok. We've set up the fixup for the instruction. Now make it
2766 look like the constant 0 was found here. */
2768 ex
.X_op
= O_constant
;
2769 ex
.X_add_number
= 0;
2770 ex
.X_add_symbol
= NULL
;
2771 ex
.X_op_symbol
= NULL
;
2778 && (((operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2779 || ((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)))
2780 || !register_name (&ex
))
2782 char save_lex
= lex_type
['%'];
2784 if (((operand
->flags
& PPC_OPERAND_CR_REG
) != 0)
2785 || (operand
->flags
& PPC_OPERAND_CR_BIT
) != 0)
2788 lex_type
['%'] |= LEX_BEGIN_NAME
;
2792 lex_type
['%'] = save_lex
;
2796 str
= input_line_pointer
;
2797 input_line_pointer
= hold
;
2799 if (ex
.X_op
== O_illegal
)
2800 as_bad (_("illegal operand"));
2801 else if (ex
.X_op
== O_absent
)
2802 as_bad (_("missing operand"));
2803 else if (ex
.X_op
== O_register
)
2805 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2806 ppc_cpu
, (char *) NULL
, 0);
2808 else if (ex
.X_op
== O_constant
)
2811 /* Allow @HA, @L, @H on constants. */
2812 bfd_reloc_code_real_type reloc
;
2813 char *orig_str
= str
;
2815 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2822 case BFD_RELOC_LO16
:
2823 ex
.X_add_number
&= 0xffff;
2824 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2825 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2828 case BFD_RELOC_HI16
:
2829 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2831 /* PowerPC64 @h is tested for overflow. */
2832 ex
.X_add_number
= (addressT
) ex
.X_add_number
>> 16;
2833 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2835 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2837 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2843 case BFD_RELOC_PPC64_ADDR16_HIGH
:
2844 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2845 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2846 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2849 case BFD_RELOC_HI16_S
:
2850 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
2852 /* PowerPC64 @ha is tested for overflow. */
2854 = ((addressT
) ex
.X_add_number
+ 0x8000) >> 16;
2855 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2857 addressT sign
= (((addressT
) -1 >> 16) + 1) >> 1;
2859 = ((addressT
) ex
.X_add_number
^ sign
) - sign
;
2865 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
2866 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2867 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2868 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2871 case BFD_RELOC_PPC64_HIGHER
:
2872 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2873 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2874 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2877 case BFD_RELOC_PPC64_HIGHER_S
:
2878 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2879 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2880 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2883 case BFD_RELOC_PPC64_HIGHEST
:
2884 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2885 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2886 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2889 case BFD_RELOC_PPC64_HIGHEST_S
:
2890 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2891 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
2892 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2895 #endif /* OBJ_ELF */
2896 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2897 ppc_cpu
, (char *) NULL
, 0);
2901 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
2903 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2905 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2906 if (sym_name
[0] == '.')
2909 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2911 expressionS tls_exp
;
2913 hold
= input_line_pointer
;
2914 input_line_pointer
= str
+ 1;
2915 expression (&tls_exp
);
2916 if (tls_exp
.X_op
== O_symbol
)
2918 reloc
= BFD_RELOC_UNUSED
;
2919 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2921 reloc
= BFD_RELOC_PPC_TLSGD
;
2922 input_line_pointer
+= 7;
2924 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2926 reloc
= BFD_RELOC_PPC_TLSLD
;
2927 input_line_pointer
+= 7;
2929 if (reloc
!= BFD_RELOC_UNUSED
)
2932 str
= input_line_pointer
;
2934 if (fc
>= MAX_INSN_FIXUPS
)
2935 as_fatal (_("too many fixups"));
2936 fixups
[fc
].exp
= tls_exp
;
2937 fixups
[fc
].opindex
= *opindex_ptr
;
2938 fixups
[fc
].reloc
= reloc
;
2942 input_line_pointer
= hold
;
2946 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2948 /* Some TLS tweaks. */
2954 case BFD_RELOC_PPC_TLS
:
2955 if (!_bfd_elf_ppc_at_tls_transform (opcode
->opcode
, 0))
2956 as_bad (_("@tls may not be used with \"%s\" operands"),
2958 else if (operand
->shift
!= 11)
2959 as_bad (_("@tls may only be used in last operand"));
2961 insn
= ppc_insert_operand (insn
, operand
,
2963 ppc_cpu
, (char *) NULL
, 0);
2966 /* We'll only use the 32 (or 64) bit form of these relocations
2967 in constants. Instructions get the 16 bit form. */
2968 case BFD_RELOC_PPC_DTPREL
:
2969 reloc
= BFD_RELOC_PPC_DTPREL16
;
2971 case BFD_RELOC_PPC_TPREL
:
2972 reloc
= BFD_RELOC_PPC_TPREL16
;
2976 /* If VLE-mode convert LO/HI/HA relocations. */
2977 if (opcode
->flags
& PPC_OPCODE_VLE
)
2979 int tmp_insn
= insn
& opcode
->mask
;
2981 int use_d_reloc
= (tmp_insn
== E_OR2I_INSN
2982 || tmp_insn
== E_AND2I_DOT_INSN
2983 || tmp_insn
== E_OR2IS_INSN
2984 || tmp_insn
== E_LIS_INSN
2985 || tmp_insn
== E_AND2IS_DOT_INSN
);
2988 int use_a_reloc
= (tmp_insn
== E_ADD2I_DOT_INSN
2989 || tmp_insn
== E_ADD2IS_INSN
2990 || tmp_insn
== E_CMP16I_INSN
2991 || tmp_insn
== E_MULL2I_INSN
2992 || tmp_insn
== E_CMPL16I_INSN
2993 || tmp_insn
== E_CMPH16I_INSN
2994 || tmp_insn
== E_CMPHL16I_INSN
);
3001 case BFD_RELOC_PPC_EMB_SDA21
:
3002 reloc
= BFD_RELOC_PPC_VLE_SDA21
;
3005 case BFD_RELOC_LO16
:
3007 reloc
= BFD_RELOC_PPC_VLE_LO16D
;
3008 else if (use_a_reloc
)
3009 reloc
= BFD_RELOC_PPC_VLE_LO16A
;
3012 case BFD_RELOC_HI16
:
3014 reloc
= BFD_RELOC_PPC_VLE_HI16D
;
3015 else if (use_a_reloc
)
3016 reloc
= BFD_RELOC_PPC_VLE_HI16A
;
3019 case BFD_RELOC_HI16_S
:
3021 reloc
= BFD_RELOC_PPC_VLE_HA16D
;
3022 else if (use_a_reloc
)
3023 reloc
= BFD_RELOC_PPC_VLE_HA16A
;
3026 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
3028 reloc
= BFD_RELOC_PPC_VLE_SDAREL_LO16D
;
3031 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
3033 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HI16D
;
3036 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
3038 reloc
= BFD_RELOC_PPC_VLE_SDAREL_HA16D
;
3043 /* For the absolute forms of branches, convert the PC
3044 relative form back into the absolute. */
3045 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
3049 case BFD_RELOC_PPC_B26
:
3050 reloc
= BFD_RELOC_PPC_BA26
;
3052 case BFD_RELOC_PPC_B16
:
3053 reloc
= BFD_RELOC_PPC_BA16
;
3055 case BFD_RELOC_PPC_B16_BRTAKEN
:
3056 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
3058 case BFD_RELOC_PPC_B16_BRNTAKEN
:
3059 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
3068 case BFD_RELOC_PPC_TOC16
:
3069 toc_reloc_types
|= has_small_toc_reloc
;
3071 case BFD_RELOC_PPC64_TOC16_LO
:
3072 case BFD_RELOC_PPC64_TOC16_HI
:
3073 case BFD_RELOC_PPC64_TOC16_HA
:
3074 toc_reloc_types
|= has_large_toc_reloc
;
3080 if ((operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
3085 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3087 case BFD_RELOC_LO16
:
3088 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
3090 case BFD_RELOC_16_GOTOFF
:
3091 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
3093 case BFD_RELOC_LO16_GOTOFF
:
3094 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
3096 case BFD_RELOC_LO16_PLTOFF
:
3097 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
3099 case BFD_RELOC_16_BASEREL
:
3100 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
3102 case BFD_RELOC_LO16_BASEREL
:
3103 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
3105 case BFD_RELOC_PPC_TOC16
:
3106 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3108 case BFD_RELOC_PPC64_TOC16_LO
:
3109 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
3111 case BFD_RELOC_PPC64_PLTGOT16
:
3112 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
3114 case BFD_RELOC_PPC64_PLTGOT16_LO
:
3115 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
3117 case BFD_RELOC_PPC_DTPREL16
:
3118 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
3120 case BFD_RELOC_PPC_DTPREL16_LO
:
3121 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
3123 case BFD_RELOC_PPC_TPREL16
:
3124 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
3126 case BFD_RELOC_PPC_TPREL16_LO
:
3127 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
3129 case BFD_RELOC_PPC_GOT_DTPREL16
:
3130 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
3131 case BFD_RELOC_PPC_GOT_TPREL16
:
3132 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
3135 as_bad (_("unsupported relocation for DS offset field"));
3140 #endif /* OBJ_ELF */
3142 if (reloc
!= BFD_RELOC_UNUSED
)
3144 /* Determine a BFD reloc value based on the operand information.
3145 We are only prepared to turn a few of the operands into
3147 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3148 && operand
->bitm
== 0x3fffffc
3149 && operand
->shift
== 0)
3150 reloc
= BFD_RELOC_PPC_B26
;
3151 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3152 && operand
->bitm
== 0xfffc
3153 && operand
->shift
== 0)
3154 reloc
= BFD_RELOC_PPC_B16
;
3155 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3156 && operand
->bitm
== 0x1fe
3157 && operand
->shift
== -1)
3158 reloc
= BFD_RELOC_PPC_VLE_REL8
;
3159 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3160 && operand
->bitm
== 0xfffe
3161 && operand
->shift
== 0)
3162 reloc
= BFD_RELOC_PPC_VLE_REL15
;
3163 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
3164 && operand
->bitm
== 0x1fffffe
3165 && operand
->shift
== 0)
3166 reloc
= BFD_RELOC_PPC_VLE_REL24
;
3167 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3168 && operand
->bitm
== 0x3fffffc
3169 && operand
->shift
== 0)
3170 reloc
= BFD_RELOC_PPC_BA26
;
3171 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
3172 && operand
->bitm
== 0xfffc
3173 && operand
->shift
== 0)
3174 reloc
= BFD_RELOC_PPC_BA16
;
3175 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3176 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
3177 && (operand
->bitm
& 0xfff0) == 0xfff0
3178 && operand
->shift
== 0)
3180 /* Note: the symbol may be not yet defined. */
3181 if (ppc_is_toc_sym (ex
.X_add_symbol
))
3183 reloc
= BFD_RELOC_PPC_TOC16
;
3186 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3187 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
3192 reloc
= BFD_RELOC_16
;
3195 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
3196 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
3200 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3202 /* We need to generate a fixup for this expression. */
3203 if (fc
>= MAX_INSN_FIXUPS
)
3204 as_fatal (_("too many fixups"));
3205 fixups
[fc
].exp
= ex
;
3206 fixups
[fc
].opindex
= *opindex_ptr
;
3207 fixups
[fc
].reloc
= reloc
;
3215 /* If expecting more operands, then we want to see "),". */
3216 if (*str
== endc
&& opindex_ptr
[1] != 0)
3220 while (ISSPACE (*str
));
3224 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
3232 /* The call to expression should have advanced str past any
3235 && (endc
!= ',' || *str
!= '\0'))
3238 as_bad (_("syntax error; end of line, expected `%c'"), endc
);
3240 as_bad (_("syntax error; found `%c', expected `%c'"), *str
, endc
);
3248 while (ISSPACE (*str
))
3252 as_bad (_("junk at end of line: `%s'"), str
);
3255 /* Do we need/want an APUinfo section? */
3256 if ((ppc_cpu
& (PPC_OPCODE_E500
| PPC_OPCODE_E500MC
| PPC_OPCODE_VLE
)) != 0
3259 /* These are all version "1". */
3260 if (opcode
->flags
& PPC_OPCODE_SPE
)
3261 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
3262 if (opcode
->flags
& PPC_OPCODE_ISEL
)
3263 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
3264 if (opcode
->flags
& PPC_OPCODE_EFS
)
3265 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
3266 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
3267 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
3268 if (opcode
->flags
& PPC_OPCODE_PMR
)
3269 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
3270 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
3271 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
3272 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
3273 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
3274 if (opcode
->flags
& PPC_OPCODE_VLE
)
3275 ppc_apuinfo_section_add (PPC_APUINFO_VLE
, 1);
3279 /* Write out the instruction. */
3280 /* Differentiate between two and four byte insns. */
3281 if (ppc_mach () == bfd_mach_ppc_vle
)
3283 if (PPC_OP_SE_VLE (insn
))
3287 addr_mod
= frag_now_fix () & 1;
3292 addr_mod
= frag_now_fix () & 3;
3294 /* All instructions can start on a 2 byte boundary for VLE. */
3295 f
= frag_more (insn_length
);
3296 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
3298 if (ppc_mach() == bfd_mach_ppc_vle
)
3299 as_bad (_("instruction address is not a multiple of 2"));
3301 as_bad (_("instruction address is not a multiple of 4"));
3303 frag_now
->insn_addr
= addr_mod
;
3304 frag_now
->has_code
= 1;
3305 md_number_to_chars (f
, insn
, insn_length
);
3308 dwarf2_emit_insn (insn_length
);
3311 /* Create any fixups. */
3312 for (i
= 0; i
< fc
; i
++)
3315 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
3317 reloc_howto_type
*reloc_howto
;
3321 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
3325 size
= bfd_get_reloc_size (reloc_howto
);
3326 offset
= target_big_endian
? (insn_length
- size
) : 0;
3328 if (size
< 1 || size
> 4)
3331 fixP
= fix_new_exp (frag_now
,
3332 f
- frag_now
->fr_literal
+ offset
,
3335 reloc_howto
->pc_relative
,
3340 const struct powerpc_operand
*operand
;
3342 operand
= &powerpc_operands
[fixups
[i
].opindex
];
3343 fixP
= fix_new_exp (frag_now
,
3344 f
- frag_now
->fr_literal
,
3347 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
3350 fixP
->fx_pcrel_adjust
= fixups
[i
].opindex
;
3354 /* Handle a macro. Gather all the operands, transform them as
3355 described by the macro, and call md_assemble recursively. All the
3356 operands are separated by commas; we don't accept parentheses
3357 around operands here. */
3360 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3371 /* Gather the users operands into the operands array. */
3376 if (count
>= sizeof operands
/ sizeof operands
[0])
3378 operands
[count
++] = s
;
3379 s
= strchr (s
, ',');
3380 if (s
== (char *) NULL
)
3385 if (count
!= macro
->operands
)
3387 as_bad (_("wrong number of operands"));
3391 /* Work out how large the string must be (the size is unbounded
3392 because it includes user input). */
3394 format
= macro
->format
;
3395 while (*format
!= '\0')
3404 arg
= strtol (format
+ 1, &send
, 10);
3405 know (send
!= format
&& arg
< count
);
3406 len
+= strlen (operands
[arg
]);
3411 /* Put the string together. */
3412 complete
= s
= (char *) alloca (len
+ 1);
3413 format
= macro
->format
;
3414 while (*format
!= '\0')
3420 arg
= strtol (format
+ 1, &send
, 10);
3421 strcpy (s
, operands
[arg
]);
3428 /* Assemble the constructed instruction. */
3429 md_assemble (complete
);
3433 /* For ELF, add support for SHT_ORDERED. */
3436 ppc_section_type (char *str
, size_t len
)
3438 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3445 ppc_section_flags (flagword flags
, bfd_vma attr ATTRIBUTE_UNUSED
, int type
)
3447 if (type
== SHT_ORDERED
)
3448 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3452 #endif /* OBJ_ELF */
3455 /* Pseudo-op handling. */
3457 /* The .byte pseudo-op. This is similar to the normal .byte
3458 pseudo-op, but it can also take a single ASCII string. */
3461 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3463 if (*input_line_pointer
!= '\"')
3469 /* Gather characters. A real double quote is doubled. Unusual
3470 characters are not permitted. */
3471 ++input_line_pointer
;
3476 c
= *input_line_pointer
++;
3480 if (*input_line_pointer
!= '\"')
3482 ++input_line_pointer
;
3485 FRAG_APPEND_1_CHAR (c
);
3488 demand_empty_rest_of_line ();
3493 /* XCOFF specific pseudo-op handling. */
3495 /* This is set if we are creating a .stabx symbol, since we don't want
3496 to handle symbol suffixes for such symbols. */
3497 static bfd_boolean ppc_stab_symbol
;
3499 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3500 symbols in the .bss segment as though they were local common
3501 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3502 aligns .comm and .lcomm to 4 bytes. */
3505 ppc_comm (int lcomm
)
3507 asection
*current_seg
= now_seg
;
3508 subsegT current_subseg
= now_subseg
;
3514 symbolS
*lcomm_sym
= NULL
;
3518 name
= input_line_pointer
;
3519 endc
= get_symbol_end ();
3520 end_name
= input_line_pointer
;
3523 if (*input_line_pointer
!= ',')
3525 as_bad (_("missing size"));
3526 ignore_rest_of_line ();
3529 ++input_line_pointer
;
3531 size
= get_absolute_expression ();
3534 as_bad (_("negative size"));
3535 ignore_rest_of_line ();
3541 /* The third argument to .comm is the alignment. */
3542 if (*input_line_pointer
!= ',')
3546 ++input_line_pointer
;
3547 align
= get_absolute_expression ();
3550 as_warn (_("ignoring bad alignment"));
3560 /* The third argument to .lcomm appears to be the real local
3561 common symbol to create. References to the symbol named in
3562 the first argument are turned into references to the third
3564 if (*input_line_pointer
!= ',')
3566 as_bad (_("missing real symbol name"));
3567 ignore_rest_of_line ();
3570 ++input_line_pointer
;
3572 lcomm_name
= input_line_pointer
;
3573 lcomm_endc
= get_symbol_end ();
3575 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3577 *input_line_pointer
= lcomm_endc
;
3579 /* The fourth argument to .lcomm is the alignment. */
3580 if (*input_line_pointer
!= ',')
3589 ++input_line_pointer
;
3590 align
= get_absolute_expression ();
3593 as_warn (_("ignoring bad alignment"));
3600 sym
= symbol_find_or_make (name
);
3603 if (S_IS_DEFINED (sym
)
3604 || S_GET_VALUE (sym
) != 0)
3606 as_bad (_("attempt to redefine symbol"));
3607 ignore_rest_of_line ();
3611 record_alignment (bss_section
, align
);
3614 || ! S_IS_DEFINED (lcomm_sym
))
3623 S_SET_EXTERNAL (sym
);
3627 symbol_get_tc (lcomm_sym
)->output
= 1;
3628 def_sym
= lcomm_sym
;
3632 subseg_set (bss_section
, 1);
3633 frag_align (align
, 0, 0);
3635 symbol_set_frag (def_sym
, frag_now
);
3636 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3637 def_size
, (char *) NULL
);
3639 S_SET_SEGMENT (def_sym
, bss_section
);
3640 symbol_get_tc (def_sym
)->align
= align
;
3644 /* Align the size of lcomm_sym. */
3645 symbol_get_frag (lcomm_sym
)->fr_offset
=
3646 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3647 &~ ((1 << align
) - 1));
3648 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3649 symbol_get_tc (lcomm_sym
)->align
= align
;
3654 /* Make sym an offset from lcomm_sym. */
3655 S_SET_SEGMENT (sym
, bss_section
);
3656 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3657 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3658 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3661 subseg_set (current_seg
, current_subseg
);
3663 demand_empty_rest_of_line ();
3666 /* The .csect pseudo-op. This switches us into a different
3667 subsegment. The first argument is a symbol whose value is the
3668 start of the .csect. In COFF, csect symbols get special aux
3669 entries defined by the x_csect field of union internal_auxent. The
3670 optional second argument is the alignment (the default is 2). */
3673 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3680 name
= input_line_pointer
;
3681 endc
= get_symbol_end ();
3683 sym
= symbol_find_or_make (name
);
3685 *input_line_pointer
= endc
;
3687 if (S_GET_NAME (sym
)[0] == '\0')
3689 /* An unnamed csect is assumed to be [PR]. */
3690 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3694 if (*input_line_pointer
== ',')
3696 ++input_line_pointer
;
3697 align
= get_absolute_expression ();
3700 ppc_change_csect (sym
, align
);
3702 demand_empty_rest_of_line ();
3705 /* Change to a different csect. */
3708 ppc_change_csect (symbolS
*sym
, offsetT align
)
3710 if (S_IS_DEFINED (sym
))
3711 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3721 /* This is a new csect. We need to look at the symbol class to
3722 figure out whether it should go in the text section or the
3726 switch (symbol_get_tc (sym
)->symbol_class
)
3736 S_SET_SEGMENT (sym
, text_section
);
3737 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3738 ++ppc_text_subsegment
;
3739 list_ptr
= &ppc_text_csects
;
3749 if (ppc_toc_csect
!= NULL
3750 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3751 == ppc_data_subsegment
))
3753 S_SET_SEGMENT (sym
, data_section
);
3754 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3755 ++ppc_data_subsegment
;
3756 list_ptr
= &ppc_data_csects
;
3762 /* We set the obstack chunk size to a small value before
3763 changing subsegments, so that we don't use a lot of memory
3764 space for what may be a small section. */
3765 hold_chunksize
= chunksize
;
3768 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3769 symbol_get_tc (sym
)->subseg
);
3771 chunksize
= hold_chunksize
;
3774 ppc_after_toc_frag
= frag_now
;
3776 record_alignment (sec
, align
);
3778 frag_align_code (align
, 0);
3780 frag_align (align
, 0, 0);
3782 symbol_set_frag (sym
, frag_now
);
3783 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3785 symbol_get_tc (sym
)->align
= align
;
3786 symbol_get_tc (sym
)->output
= 1;
3787 symbol_get_tc (sym
)->within
= sym
;
3789 for (list
= *list_ptr
;
3790 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3791 list
= symbol_get_tc (list
)->next
)
3793 symbol_get_tc (list
)->next
= sym
;
3795 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3796 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3800 ppc_current_csect
= sym
;
3804 ppc_change_debug_section (unsigned int idx
, subsegT subseg
)
3808 const struct xcoff_dwsect_name
*dw
= &xcoff_dwsect_names
[idx
];
3810 sec
= subseg_new (dw
->name
, subseg
);
3811 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
3812 if (oldflags
== SEC_NO_FLAGS
)
3814 /* Just created section. */
3815 gas_assert (dw_sections
[idx
].sect
== NULL
);
3817 bfd_set_section_flags (stdoutput
, sec
, SEC_DEBUGGING
);
3818 bfd_set_section_alignment (stdoutput
, sec
, 0);
3819 dw_sections
[idx
].sect
= sec
;
3822 /* Not anymore in a csect. */
3823 ppc_current_csect
= NULL
;
3826 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3827 .dwsect flag [, opt-label ]
3831 ppc_dwsect (int ignore ATTRIBUTE_UNUSED
)
3835 const struct xcoff_dwsect_name
*dw
;
3836 struct dw_subsection
*subseg
;
3837 struct dw_section
*dws
;
3841 flag
= get_absolute_expression ();
3843 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
3844 if (xcoff_dwsect_names
[i
].flag
== flag
)
3846 dw
= &xcoff_dwsect_names
[i
];
3850 /* Parse opt-label. */
3851 if (*input_line_pointer
== ',')
3856 ++input_line_pointer
;
3858 label
= input_line_pointer
;
3859 c
= get_symbol_end ();
3860 opt_label
= symbol_find_or_make (label
);
3861 *input_line_pointer
= c
;
3866 demand_empty_rest_of_line ();
3868 /* Return now in case of unknown subsection. */
3871 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3876 /* Find the subsection. */
3877 dws
= &dw_sections
[i
];
3879 if (opt_label
!= NULL
&& S_IS_DEFINED (opt_label
))
3881 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3882 if (dws
->sect
== NULL
|| S_GET_SEGMENT (opt_label
) != dws
->sect
)
3884 as_bad (_("label %s was not defined in this dwarf section"),
3885 S_GET_NAME (opt_label
));
3886 subseg
= dws
->anon_subseg
;
3890 subseg
= symbol_get_tc (opt_label
)->u
.dw
;
3895 /* Switch to the subsection. */
3896 ppc_change_debug_section (i
, subseg
->subseg
);
3900 /* Create a new dw subsection. */
3901 subseg
= (struct dw_subsection
*)
3902 xmalloc (sizeof (struct dw_subsection
));
3904 if (opt_label
== NULL
)
3906 /* The anonymous one. */
3908 subseg
->link
= NULL
;
3909 dws
->anon_subseg
= subseg
;
3914 if (dws
->list_subseg
!= NULL
)
3915 subseg
->subseg
= dws
->list_subseg
->subseg
+ 1;
3919 subseg
->link
= dws
->list_subseg
;
3920 dws
->list_subseg
= subseg
;
3921 symbol_get_tc (opt_label
)->u
.dw
= subseg
;
3924 ppc_change_debug_section (i
, subseg
->subseg
);
3928 /* Add the length field. */
3929 expressionS
*exp
= &subseg
->end_exp
;
3932 if (opt_label
!= NULL
)
3933 symbol_set_value_now (opt_label
);
3935 /* Add the length field. Note that according to the AIX assembler
3936 manual, the size of the length field is 4 for powerpc32 but
3937 12 for powerpc64. */
3940 /* Write the 64bit marker. */
3941 md_number_to_chars (frag_more (4), -1, 4);
3944 exp
->X_op
= O_subtract
;
3945 exp
->X_op_symbol
= symbol_temp_new_now ();
3946 exp
->X_add_symbol
= symbol_temp_make ();
3948 sz
= ppc_obj64
? 8 : 4;
3949 exp
->X_add_number
= -sz
;
3950 emit_expr (exp
, sz
);
3955 /* This function handles the .text and .data pseudo-ops. These
3956 pseudo-ops aren't really used by XCOFF; we implement them for the
3957 convenience of people who aren't used to XCOFF. */
3960 ppc_section (int type
)
3967 else if (type
== 'd')
3972 sym
= symbol_find_or_make (name
);
3974 ppc_change_csect (sym
, 2);
3976 demand_empty_rest_of_line ();
3979 /* This function handles the .section pseudo-op. This is mostly to
3980 give an error, since XCOFF only supports .text, .data and .bss, but
3981 we do permit the user to name the text or data section. */
3984 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3987 const char *real_name
;
3991 user_name
= input_line_pointer
;
3992 c
= get_symbol_end ();
3994 if (strcmp (user_name
, ".text") == 0)
3995 real_name
= ".text[PR]";
3996 else if (strcmp (user_name
, ".data") == 0)
3997 real_name
= ".data[RW]";
4000 as_bad (_("the XCOFF file format does not support arbitrary sections"));
4001 *input_line_pointer
= c
;
4002 ignore_rest_of_line ();
4006 *input_line_pointer
= c
;
4008 sym
= symbol_find_or_make (real_name
);
4010 ppc_change_csect (sym
, 2);
4012 demand_empty_rest_of_line ();
4015 /* The .extern pseudo-op. We create an undefined symbol. */
4018 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
4023 name
= input_line_pointer
;
4024 endc
= get_symbol_end ();
4026 (void) symbol_find_or_make (name
);
4028 *input_line_pointer
= endc
;
4030 demand_empty_rest_of_line ();
4033 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
4036 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
4042 name
= input_line_pointer
;
4043 endc
= get_symbol_end ();
4045 sym
= symbol_find_or_make (name
);
4047 *input_line_pointer
= endc
;
4049 symbol_get_tc (sym
)->output
= 1;
4051 demand_empty_rest_of_line ();
4054 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4055 relocations at the beginning of the current csect.
4057 (In principle, there's no reason why the relocations _have_ to be at
4058 the beginning. Anywhere in the csect would do. However, inserting
4059 at the beginning is what the native assmebler does, and it helps to
4060 deal with cases where the .ref statements follow the section contents.)
4062 ??? .refs don't work for empty .csects. However, the native assembler
4063 doesn't report an error in this case, and neither yet do we. */
4066 ppc_ref (int ignore ATTRIBUTE_UNUSED
)
4071 if (ppc_current_csect
== NULL
)
4073 as_bad (_(".ref outside .csect"));
4074 ignore_rest_of_line ();
4080 name
= input_line_pointer
;
4081 c
= get_symbol_end ();
4083 fix_at_start (symbol_get_frag (ppc_current_csect
), 0,
4084 symbol_find_or_make (name
), 0, FALSE
, BFD_RELOC_NONE
);
4086 *input_line_pointer
= c
;
4088 c
= *input_line_pointer
;
4091 input_line_pointer
++;
4093 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
4095 as_bad (_("missing symbol name"));
4096 ignore_rest_of_line ();
4103 demand_empty_rest_of_line ();
4106 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4107 although I don't know why it bothers. */
4110 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
4117 name
= input_line_pointer
;
4118 endc
= get_symbol_end ();
4120 sym
= symbol_find_or_make (name
);
4122 *input_line_pointer
= endc
;
4124 if (*input_line_pointer
!= ',')
4126 as_bad (_("missing rename string"));
4127 ignore_rest_of_line ();
4130 ++input_line_pointer
;
4132 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
4134 demand_empty_rest_of_line ();
4137 /* The .stabx pseudo-op. This is similar to a normal .stabs
4138 pseudo-op, but slightly different. A sample is
4139 .stabx "main:F-1",.main,142,0
4140 The first argument is the symbol name to create. The second is the
4141 value, and the third is the storage class. The fourth seems to be
4142 always zero, and I am assuming it is the type. */
4145 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
4152 name
= demand_copy_C_string (&len
);
4154 if (*input_line_pointer
!= ',')
4156 as_bad (_("missing value"));
4159 ++input_line_pointer
;
4161 ppc_stab_symbol
= TRUE
;
4162 sym
= symbol_make (name
);
4163 ppc_stab_symbol
= FALSE
;
4165 symbol_get_tc (sym
)->real_name
= name
;
4167 (void) expression (&exp
);
4174 as_bad (_("illegal .stabx expression; zero assumed"));
4175 exp
.X_add_number
= 0;
4178 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
4179 symbol_set_frag (sym
, &zero_address_frag
);
4183 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
4184 symbol_set_value_expression (sym
, &exp
);
4188 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
4189 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
4194 /* The value is some complex expression. This will probably
4195 fail at some later point, but this is probably the right
4196 thing to do here. */
4197 symbol_set_value_expression (sym
, &exp
);
4201 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4202 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4204 if (*input_line_pointer
!= ',')
4206 as_bad (_("missing class"));
4209 ++input_line_pointer
;
4211 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
4213 if (*input_line_pointer
!= ',')
4215 as_bad (_("missing type"));
4218 ++input_line_pointer
;
4220 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
4222 symbol_get_tc (sym
)->output
= 1;
4224 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4229 .stabx "z",arrays_,133,0
4232 .comm arrays_,13768,3
4234 resolve_symbol_value will copy the exp's "within" into sym's when the
4235 offset is 0. Since this seems to be corner case problem,
4236 only do the correction for storage class C_STSYM. A better solution
4237 would be to have the tc field updated in ppc_symbol_new_hook. */
4239 if (exp
.X_op
== O_symbol
)
4241 if (ppc_current_block
== NULL
)
4242 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4244 symbol_get_tc (sym
)->within
= ppc_current_block
;
4245 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
4249 if (exp
.X_op
!= O_symbol
4250 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
4251 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
4252 ppc_frob_label (sym
);
4255 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4256 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
4257 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
4258 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4261 demand_empty_rest_of_line ();
4264 /* The .function pseudo-op. This takes several arguments. The first
4265 argument seems to be the external name of the symbol. The second
4266 argument seems to be the label for the start of the function. gcc
4267 uses the same name for both. I have no idea what the third and
4268 fourth arguments are meant to be. The optional fifth argument is
4269 an expression for the size of the function. In COFF this symbol
4270 gets an aux entry like that used for a csect. */
4273 ppc_function (int ignore ATTRIBUTE_UNUSED
)
4281 name
= input_line_pointer
;
4282 endc
= get_symbol_end ();
4284 /* Ignore any [PR] suffix. */
4285 name
= ppc_canonicalize_symbol_name (name
);
4286 s
= strchr (name
, '[');
4287 if (s
!= (char *) NULL
4288 && strcmp (s
+ 1, "PR]") == 0)
4291 ext_sym
= symbol_find_or_make (name
);
4293 *input_line_pointer
= endc
;
4295 if (*input_line_pointer
!= ',')
4297 as_bad (_("missing symbol name"));
4298 ignore_rest_of_line ();
4301 ++input_line_pointer
;
4303 name
= input_line_pointer
;
4304 endc
= get_symbol_end ();
4306 lab_sym
= symbol_find_or_make (name
);
4308 *input_line_pointer
= endc
;
4310 if (ext_sym
!= lab_sym
)
4314 exp
.X_op
= O_symbol
;
4315 exp
.X_add_symbol
= lab_sym
;
4316 exp
.X_op_symbol
= NULL
;
4317 exp
.X_add_number
= 0;
4319 symbol_set_value_expression (ext_sym
, &exp
);
4322 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
4323 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
4324 symbol_get_tc (ext_sym
)->output
= 1;
4326 if (*input_line_pointer
== ',')
4330 /* Ignore the third argument. */
4331 ++input_line_pointer
;
4333 if (*input_line_pointer
== ',')
4335 /* Ignore the fourth argument. */
4336 ++input_line_pointer
;
4338 if (*input_line_pointer
== ',')
4340 /* The fifth argument is the function size. */
4341 ++input_line_pointer
;
4342 symbol_get_tc (ext_sym
)->u
.size
= symbol_new
4343 ("L0\001", absolute_section
,(valueT
) 0, &zero_address_frag
);
4344 pseudo_set (symbol_get_tc (ext_sym
)->u
.size
);
4349 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4350 SF_SET_FUNCTION (ext_sym
);
4351 SF_SET_PROCESS (ext_sym
);
4352 coff_add_linesym (ext_sym
);
4354 demand_empty_rest_of_line ();
4357 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4358 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4359 with the correct line number */
4361 static symbolS
*saved_bi_sym
= 0;
4364 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
4368 sym
= symbol_make (".bf");
4369 S_SET_SEGMENT (sym
, text_section
);
4370 symbol_set_frag (sym
, frag_now
);
4371 S_SET_VALUE (sym
, frag_now_fix ());
4372 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4374 coff_line_base
= get_absolute_expression ();
4376 S_SET_NUMBER_AUXILIARY (sym
, 1);
4377 SA_SET_SYM_LNNO (sym
, coff_line_base
);
4379 /* Line number for bi. */
4382 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
4387 symbol_get_tc (sym
)->output
= 1;
4389 ppc_frob_label (sym
);
4391 demand_empty_rest_of_line ();
4394 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4395 ".ef", except that the line number is absolute, not relative to the
4396 most recent ".bf" symbol. */
4399 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
4403 sym
= symbol_make (".ef");
4404 S_SET_SEGMENT (sym
, text_section
);
4405 symbol_set_frag (sym
, frag_now
);
4406 S_SET_VALUE (sym
, frag_now_fix ());
4407 S_SET_STORAGE_CLASS (sym
, C_FCN
);
4408 S_SET_NUMBER_AUXILIARY (sym
, 1);
4409 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4410 symbol_get_tc (sym
)->output
= 1;
4412 ppc_frob_label (sym
);
4414 demand_empty_rest_of_line ();
4417 /* The .bi and .ei pseudo-ops. These take a string argument and
4418 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4419 the symbol list. The value of .bi will be know when the next .bf
4425 static symbolS
*last_biei
;
4432 name
= demand_copy_C_string (&len
);
4434 /* The value of these symbols is actually file offset. Here we set
4435 the value to the index into the line number entries. In
4436 ppc_frob_symbols we set the fix_line field, which will cause BFD
4437 to do the right thing. */
4439 sym
= symbol_make (name
);
4440 /* obj-coff.c currently only handles line numbers correctly in the
4442 S_SET_SEGMENT (sym
, text_section
);
4443 S_SET_VALUE (sym
, coff_n_line_nos
);
4444 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4446 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
4447 symbol_get_tc (sym
)->output
= 1;
4455 for (look
= last_biei
? last_biei
: symbol_rootP
;
4456 (look
!= (symbolS
*) NULL
4457 && (S_GET_STORAGE_CLASS (look
) == C_FILE
4458 || S_GET_STORAGE_CLASS (look
) == C_BINCL
4459 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
4460 look
= symbol_next (look
))
4462 if (look
!= (symbolS
*) NULL
)
4464 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4465 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
4469 demand_empty_rest_of_line ();
4472 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4473 There is one argument, which is a csect symbol. The value of the
4474 .bs symbol is the index of this csect symbol. */
4477 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
4484 if (ppc_current_block
!= NULL
)
4485 as_bad (_("nested .bs blocks"));
4487 name
= input_line_pointer
;
4488 endc
= get_symbol_end ();
4490 csect
= symbol_find_or_make (name
);
4492 *input_line_pointer
= endc
;
4494 sym
= symbol_make (".bs");
4495 S_SET_SEGMENT (sym
, now_seg
);
4496 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
4497 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4498 symbol_get_tc (sym
)->output
= 1;
4500 symbol_get_tc (sym
)->within
= csect
;
4502 ppc_frob_label (sym
);
4504 ppc_current_block
= sym
;
4506 demand_empty_rest_of_line ();
4509 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4512 ppc_es (int ignore ATTRIBUTE_UNUSED
)
4516 if (ppc_current_block
== NULL
)
4517 as_bad (_(".es without preceding .bs"));
4519 sym
= symbol_make (".es");
4520 S_SET_SEGMENT (sym
, now_seg
);
4521 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
4522 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4523 symbol_get_tc (sym
)->output
= 1;
4525 ppc_frob_label (sym
);
4527 ppc_current_block
= NULL
;
4529 demand_empty_rest_of_line ();
4532 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4536 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
4540 sym
= symbol_make (".bb");
4541 S_SET_SEGMENT (sym
, text_section
);
4542 symbol_set_frag (sym
, frag_now
);
4543 S_SET_VALUE (sym
, frag_now_fix ());
4544 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4546 S_SET_NUMBER_AUXILIARY (sym
, 1);
4547 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4549 symbol_get_tc (sym
)->output
= 1;
4551 SF_SET_PROCESS (sym
);
4553 ppc_frob_label (sym
);
4555 demand_empty_rest_of_line ();
4558 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4562 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4566 sym
= symbol_make (".eb");
4567 S_SET_SEGMENT (sym
, text_section
);
4568 symbol_set_frag (sym
, frag_now
);
4569 S_SET_VALUE (sym
, frag_now_fix ());
4570 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4571 S_SET_NUMBER_AUXILIARY (sym
, 1);
4572 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4573 symbol_get_tc (sym
)->output
= 1;
4575 SF_SET_PROCESS (sym
);
4577 ppc_frob_label (sym
);
4579 demand_empty_rest_of_line ();
4582 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4586 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4592 name
= demand_copy_C_string (&len
);
4593 sym
= symbol_make (name
);
4594 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4595 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4596 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4597 S_SET_VALUE (sym
, 0);
4598 symbol_get_tc (sym
)->output
= 1;
4600 ppc_frob_label (sym
);
4602 demand_empty_rest_of_line ();
4605 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4608 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4612 sym
= symbol_make (".ec");
4613 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4614 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4615 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4616 S_SET_VALUE (sym
, 0);
4617 symbol_get_tc (sym
)->output
= 1;
4619 ppc_frob_label (sym
);
4621 demand_empty_rest_of_line ();
4624 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4627 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4629 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4630 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4637 subseg
= ppc_data_subsegment
;
4638 ++ppc_data_subsegment
;
4640 subseg_new (segment_name (data_section
), subseg
);
4641 ppc_toc_frag
= frag_now
;
4643 sym
= symbol_find_or_make ("TOC[TC0]");
4644 symbol_set_frag (sym
, frag_now
);
4645 S_SET_SEGMENT (sym
, data_section
);
4646 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4647 symbol_get_tc (sym
)->subseg
= subseg
;
4648 symbol_get_tc (sym
)->output
= 1;
4649 symbol_get_tc (sym
)->within
= sym
;
4651 ppc_toc_csect
= sym
;
4653 for (list
= ppc_data_csects
;
4654 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4655 list
= symbol_get_tc (list
)->next
)
4657 symbol_get_tc (list
)->next
= sym
;
4659 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4660 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4664 ppc_current_csect
= ppc_toc_csect
;
4666 demand_empty_rest_of_line ();
4669 /* The AIX assembler automatically aligns the operands of a .long or
4670 .short pseudo-op, and we want to be compatible. */
4673 ppc_xcoff_cons (int log_size
)
4675 frag_align (log_size
, 0, 0);
4676 record_alignment (now_seg
, log_size
);
4677 cons (1 << log_size
);
4681 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4686 (void) expression (&exp
);
4688 if (exp
.X_op
!= O_constant
)
4690 as_bad (_("non-constant byte count"));
4694 byte_count
= exp
.X_add_number
;
4696 if (*input_line_pointer
!= ',')
4698 as_bad (_("missing value"));
4702 ++input_line_pointer
;
4707 ppc_xcoff_end (void)
4711 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
4713 struct dw_section
*dws
= &dw_sections
[i
];
4714 struct dw_subsection
*dwss
;
4716 if (dws
->anon_subseg
)
4718 dwss
= dws
->anon_subseg
;
4719 dwss
->link
= dws
->list_subseg
;
4722 dwss
= dws
->list_subseg
;
4724 for (; dwss
!= NULL
; dwss
= dwss
->link
)
4725 if (dwss
->end_exp
.X_add_symbol
!= NULL
)
4727 subseg_set (dws
->sect
, dwss
->subseg
);
4728 symbol_set_value_now (dwss
->end_exp
.X_add_symbol
);
4733 #endif /* OBJ_XCOFF */
4734 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4736 /* The .tc pseudo-op. This is used when generating either XCOFF or
4737 ELF. This takes two or more arguments.
4739 When generating XCOFF output, the first argument is the name to
4740 give to this location in the toc; this will be a symbol with class
4741 TC. The rest of the arguments are N-byte values to actually put at
4742 this location in the TOC; often there is just one more argument, a
4743 relocatable symbol reference. The size of the value to store
4744 depends on target word size. A 32-bit target uses 4-byte values, a
4745 64-bit target uses 8-byte values.
4747 When not generating XCOFF output, the arguments are the same, but
4748 the first argument is simply ignored. */
4751 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4755 /* Define the TOC symbol name. */
4761 if (ppc_toc_csect
== (symbolS
*) NULL
4762 || ppc_toc_csect
!= ppc_current_csect
)
4764 as_bad (_(".tc not in .toc section"));
4765 ignore_rest_of_line ();
4769 name
= input_line_pointer
;
4770 endc
= get_symbol_end ();
4772 sym
= symbol_find_or_make (name
);
4774 *input_line_pointer
= endc
;
4776 if (S_IS_DEFINED (sym
))
4780 label
= symbol_get_tc (ppc_current_csect
)->within
;
4781 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4783 as_bad (_(".tc with no label"));
4784 ignore_rest_of_line ();
4788 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4789 symbol_set_frag (label
, symbol_get_frag (sym
));
4790 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4792 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4793 ++input_line_pointer
;
4798 S_SET_SEGMENT (sym
, now_seg
);
4799 symbol_set_frag (sym
, frag_now
);
4800 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4801 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4802 symbol_get_tc (sym
)->output
= 1;
4804 ppc_frob_label (sym
);
4807 #endif /* OBJ_XCOFF */
4811 /* Skip the TOC symbol name. */
4812 while (is_part_of_name (*input_line_pointer
)
4813 || *input_line_pointer
== ' '
4814 || *input_line_pointer
== '['
4815 || *input_line_pointer
== ']'
4816 || *input_line_pointer
== '{'
4817 || *input_line_pointer
== '}')
4818 ++input_line_pointer
;
4820 /* Align to a four/eight byte boundary. */
4821 align
= ppc_obj64
? 3 : 2;
4822 frag_align (align
, 0, 0);
4823 record_alignment (now_seg
, align
);
4824 #endif /* OBJ_ELF */
4826 if (*input_line_pointer
!= ',')
4827 demand_empty_rest_of_line ();
4830 ++input_line_pointer
;
4831 cons (ppc_obj64
? 8 : 4);
4835 /* Pseudo-op .machine. */
4838 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4841 #define MAX_HISTORY 100
4842 static ppc_cpu_t
*cpu_history
;
4843 static int curr_hist
;
4847 if (*input_line_pointer
== '"')
4850 cpu_string
= demand_copy_C_string (&len
);
4855 cpu_string
= input_line_pointer
;
4856 c
= get_symbol_end ();
4857 cpu_string
= xstrdup (cpu_string
);
4858 *input_line_pointer
= c
;
4861 if (cpu_string
!= NULL
)
4863 ppc_cpu_t old_cpu
= ppc_cpu
;
4867 for (p
= cpu_string
; *p
!= 0; p
++)
4870 if (strcmp (cpu_string
, "push") == 0)
4872 if (cpu_history
== NULL
)
4873 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4875 if (curr_hist
>= MAX_HISTORY
)
4876 as_bad (_(".machine stack overflow"));
4878 cpu_history
[curr_hist
++] = ppc_cpu
;
4880 else if (strcmp (cpu_string
, "pop") == 0)
4883 as_bad (_(".machine stack underflow"));
4885 ppc_cpu
= cpu_history
[--curr_hist
];
4887 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, &sticky
, cpu_string
)) != 0)
4890 as_bad (_("invalid machine `%s'"), cpu_string
);
4892 if (ppc_cpu
!= old_cpu
)
4893 ppc_setup_opcodes ();
4896 demand_empty_rest_of_line ();
4898 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4902 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4904 /* Set the current section. */
4906 ppc_set_current_section (segT
new)
4908 ppc_previous_section
= ppc_current_section
;
4909 ppc_current_section
= new;
4912 /* pseudo-op: .previous
4913 behaviour: toggles the current section with the previous section.
4915 warnings: "No previous section" */
4918 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4920 if (ppc_previous_section
== NULL
)
4922 as_warn (_("no previous section to return to, ignored."));
4926 subseg_set (ppc_previous_section
, 0);
4928 ppc_set_current_section (ppc_previous_section
);
4931 /* pseudo-op: .pdata
4932 behaviour: predefined read only data section
4936 initial: .section .pdata "adr3"
4937 a - don't know -- maybe a misprint
4938 d - initialized data
4940 3 - double word aligned (that would be 4 byte boundary)
4943 Tag index tables (also known as the function table) for exception
4944 handling, debugging, etc. */
4947 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4949 if (pdata_section
== 0)
4951 pdata_section
= subseg_new (".pdata", 0);
4953 bfd_set_section_flags (stdoutput
, pdata_section
,
4954 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4955 | SEC_READONLY
| SEC_DATA
));
4957 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4961 pdata_section
= subseg_new (".pdata", 0);
4963 ppc_set_current_section (pdata_section
);
4966 /* pseudo-op: .ydata
4967 behaviour: predefined read only data section
4971 initial: .section .ydata "drw3"
4972 a - don't know -- maybe a misprint
4973 d - initialized data
4975 3 - double word aligned (that would be 4 byte boundary)
4977 Tag tables (also known as the scope table) for exception handling,
4981 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4983 if (ydata_section
== 0)
4985 ydata_section
= subseg_new (".ydata", 0);
4986 bfd_set_section_flags (stdoutput
, ydata_section
,
4987 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4988 | SEC_READONLY
| SEC_DATA
));
4990 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4994 ydata_section
= subseg_new (".ydata", 0);
4996 ppc_set_current_section (ydata_section
);
4999 /* pseudo-op: .reldata
5000 behaviour: predefined read write data section
5001 double word aligned (4-byte)
5002 FIXME: relocation is applied to it
5003 FIXME: what's the difference between this and .data?
5006 initial: .section .reldata "drw3"
5007 d - initialized data
5010 3 - double word aligned (that would be 8 byte boundary)
5013 Like .data, but intended to hold data subject to relocation, such as
5014 function descriptors, etc. */
5017 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
5019 if (reldata_section
== 0)
5021 reldata_section
= subseg_new (".reldata", 0);
5023 bfd_set_section_flags (stdoutput
, reldata_section
,
5024 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5027 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
5031 reldata_section
= subseg_new (".reldata", 0);
5033 ppc_set_current_section (reldata_section
);
5036 /* pseudo-op: .rdata
5037 behaviour: predefined read only data section
5041 initial: .section .rdata "dr3"
5042 d - initialized data
5044 3 - double word aligned (that would be 4 byte boundary) */
5047 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
5049 if (rdata_section
== 0)
5051 rdata_section
= subseg_new (".rdata", 0);
5052 bfd_set_section_flags (stdoutput
, rdata_section
,
5053 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5054 | SEC_READONLY
| SEC_DATA
));
5056 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
5060 rdata_section
= subseg_new (".rdata", 0);
5062 ppc_set_current_section (rdata_section
);
5065 /* pseudo-op: .ualong
5066 behaviour: much like .int, with the exception that no alignment is
5068 FIXME: test the alignment statement
5073 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
5079 /* pseudo-op: .znop <symbol name>
5080 behaviour: Issue a nop instruction
5081 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5082 the supplied symbol name.
5084 warnings: Missing symbol name */
5087 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
5090 const struct powerpc_opcode
*opcode
;
5097 /* Strip out the symbol name. */
5098 symbol_name
= input_line_pointer
;
5099 c
= get_symbol_end ();
5101 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
5102 strcpy (name
, symbol_name
);
5104 sym
= symbol_find_or_make (name
);
5106 *input_line_pointer
= c
;
5110 /* Look up the opcode in the hash table. */
5111 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
5113 /* Stick in the nop. */
5114 insn
= opcode
->opcode
;
5116 /* Write out the instruction. */
5118 md_number_to_chars (f
, insn
, 4);
5120 f
- frag_now
->fr_literal
,
5125 BFD_RELOC_16_GOT_PCREL
);
5135 ppc_pe_comm (int lcomm
)
5144 name
= input_line_pointer
;
5145 c
= get_symbol_end ();
5147 /* just after name is now '\0'. */
5148 p
= input_line_pointer
;
5151 if (*input_line_pointer
!= ',')
5153 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5154 ignore_rest_of_line ();
5158 input_line_pointer
++; /* skip ',' */
5159 if ((temp
= get_absolute_expression ()) < 0)
5161 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
5162 ignore_rest_of_line ();
5168 /* The third argument to .comm is the alignment. */
5169 if (*input_line_pointer
!= ',')
5173 ++input_line_pointer
;
5174 align
= get_absolute_expression ();
5177 as_warn (_("ignoring bad alignment"));
5184 symbolP
= symbol_find_or_make (name
);
5187 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
5189 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5190 S_GET_NAME (symbolP
));
5191 ignore_rest_of_line ();
5195 if (S_GET_VALUE (symbolP
))
5197 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
5198 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5199 S_GET_NAME (symbolP
),
5200 (long) S_GET_VALUE (symbolP
),
5205 S_SET_VALUE (symbolP
, (valueT
) temp
);
5206 S_SET_EXTERNAL (symbolP
);
5207 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
5210 demand_empty_rest_of_line ();
5214 * implement the .section pseudo op:
5215 * .section name {, "flags"}
5217 * | +--- optional flags: 'b' for bss
5219 * +-- section name 'l' for lib
5223 * 'd' (apparently m88k for data)
5225 * But if the argument is not a quoted string, treat it as a
5226 * subsegment number.
5228 * FIXME: this is a copy of the section processing from obj-coff.c, with
5229 * additions/changes for the moto-pas assembler support. There are three
5232 * FIXME: I just noticed this. This doesn't work at all really. It it
5233 * setting bits that bfd probably neither understands or uses. The
5234 * correct approach (?) will have to incorporate extra fields attached
5235 * to the section to hold the system specific stuff. (krk)
5238 * 'a' - unknown - referred to in documentation, but no definition supplied
5239 * 'c' - section has code
5240 * 'd' - section has initialized data
5241 * 'u' - section has uninitialized data
5242 * 'i' - section contains directives (info)
5243 * 'n' - section can be discarded
5244 * 'R' - remove section at link time
5246 * Section Protection:
5247 * 'r' - section is readable
5248 * 'w' - section is writeable
5249 * 'x' - section is executable
5250 * 's' - section is sharable
5252 * Section Alignment:
5253 * '0' - align to byte boundary
5254 * '1' - align to halfword undary
5255 * '2' - align to word boundary
5256 * '3' - align to doubleword boundary
5257 * '4' - align to quadword boundary
5258 * '5' - align to 32 byte boundary
5259 * '6' - align to 64 byte boundary
5264 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
5266 /* Strip out the section name. */
5275 section_name
= input_line_pointer
;
5276 c
= get_symbol_end ();
5278 name
= xmalloc (input_line_pointer
- section_name
+ 1);
5279 strcpy (name
, section_name
);
5281 *input_line_pointer
= c
;
5286 flags
= SEC_NO_FLAGS
;
5288 if (strcmp (name
, ".idata$2") == 0)
5292 else if (strcmp (name
, ".idata$3") == 0)
5296 else if (strcmp (name
, ".idata$4") == 0)
5300 else if (strcmp (name
, ".idata$5") == 0)
5304 else if (strcmp (name
, ".idata$6") == 0)
5309 /* Default alignment to 16 byte boundary. */
5312 if (*input_line_pointer
== ',')
5314 ++input_line_pointer
;
5316 if (*input_line_pointer
!= '"')
5317 exp
= get_absolute_expression ();
5320 ++input_line_pointer
;
5321 while (*input_line_pointer
!= '"'
5322 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5324 switch (*input_line_pointer
)
5326 /* Section Contents */
5327 case 'a': /* unknown */
5328 as_bad (_("unsupported section attribute -- 'a'"));
5330 case 'c': /* code section */
5333 case 'd': /* section has initialized data */
5336 case 'u': /* section has uninitialized data */
5337 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5341 case 'i': /* section contains directives (info) */
5342 /* FIXME: This is IMAGE_SCN_LNK_INFO
5344 flags
|= SEC_HAS_CONTENTS
;
5346 case 'n': /* section can be discarded */
5349 case 'R': /* Remove section at link time */
5350 flags
|= SEC_NEVER_LOAD
;
5352 #if IFLICT_BRAIN_DAMAGE
5353 /* Section Protection */
5354 case 'r': /* section is readable */
5355 flags
|= IMAGE_SCN_MEM_READ
;
5357 case 'w': /* section is writeable */
5358 flags
|= IMAGE_SCN_MEM_WRITE
;
5360 case 'x': /* section is executable */
5361 flags
|= IMAGE_SCN_MEM_EXECUTE
;
5363 case 's': /* section is sharable */
5364 flags
|= IMAGE_SCN_MEM_SHARED
;
5367 /* Section Alignment */
5368 case '0': /* align to byte boundary */
5369 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
5372 case '1': /* align to halfword boundary */
5373 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
5376 case '2': /* align to word boundary */
5377 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
5380 case '3': /* align to doubleword boundary */
5381 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
5384 case '4': /* align to quadword boundary */
5385 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
5388 case '5': /* align to 32 byte boundary */
5389 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
5392 case '6': /* align to 64 byte boundary */
5393 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
5398 as_bad (_("unknown section attribute '%c'"),
5399 *input_line_pointer
);
5402 ++input_line_pointer
;
5404 if (*input_line_pointer
== '"')
5405 ++input_line_pointer
;
5409 sec
= subseg_new (name
, (subsegT
) exp
);
5411 ppc_set_current_section (sec
);
5413 if (flags
!= SEC_NO_FLAGS
)
5415 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
5416 as_bad (_("error setting flags for \"%s\": %s"),
5417 bfd_section_name (stdoutput
, sec
),
5418 bfd_errmsg (bfd_get_error ()));
5421 bfd_set_section_alignment (stdoutput
, sec
, align
);
5425 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
5431 name
= input_line_pointer
;
5432 endc
= get_symbol_end ();
5434 ext_sym
= symbol_find_or_make (name
);
5436 *input_line_pointer
= endc
;
5438 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
5439 SF_SET_FUNCTION (ext_sym
);
5440 SF_SET_PROCESS (ext_sym
);
5441 coff_add_linesym (ext_sym
);
5443 demand_empty_rest_of_line ();
5447 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
5449 if (tocdata_section
== 0)
5451 tocdata_section
= subseg_new (".tocd", 0);
5452 /* FIXME: section flags won't work. */
5453 bfd_set_section_flags (stdoutput
, tocdata_section
,
5454 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
5455 | SEC_READONLY
| SEC_DATA
));
5457 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
5461 rdata_section
= subseg_new (".tocd", 0);
5464 ppc_set_current_section (tocdata_section
);
5466 demand_empty_rest_of_line ();
5469 /* Don't adjust TOC relocs to use the section symbol. */
5472 ppc_pe_fix_adjustable (fixS
*fix
)
5474 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
5481 /* XCOFF specific symbol and file handling. */
5483 /* Canonicalize the symbol name. We use the to force the suffix, if
5484 any, to use square brackets, and to be in upper case. */
5487 ppc_canonicalize_symbol_name (char *name
)
5491 if (ppc_stab_symbol
)
5494 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
5508 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
5511 if (*s
== '\0' || s
[1] != '\0')
5512 as_bad (_("bad symbol suffix"));
5520 /* Set the class of a symbol based on the suffix, if any. This is
5521 called whenever a new symbol is created. */
5524 ppc_symbol_new_hook (symbolS
*sym
)
5526 struct ppc_tc_sy
*tc
;
5529 tc
= symbol_get_tc (sym
);
5532 tc
->symbol_class
= -1;
5533 tc
->real_name
= NULL
;
5540 if (ppc_stab_symbol
)
5543 s
= strchr (S_GET_NAME (sym
), '[');
5544 if (s
== (const char *) NULL
)
5546 /* There is no suffix. */
5555 if (strcmp (s
, "BS]") == 0)
5556 tc
->symbol_class
= XMC_BS
;
5559 if (strcmp (s
, "DB]") == 0)
5560 tc
->symbol_class
= XMC_DB
;
5561 else if (strcmp (s
, "DS]") == 0)
5562 tc
->symbol_class
= XMC_DS
;
5565 if (strcmp (s
, "GL]") == 0)
5566 tc
->symbol_class
= XMC_GL
;
5569 if (strcmp (s
, "PR]") == 0)
5570 tc
->symbol_class
= XMC_PR
;
5573 if (strcmp (s
, "RO]") == 0)
5574 tc
->symbol_class
= XMC_RO
;
5575 else if (strcmp (s
, "RW]") == 0)
5576 tc
->symbol_class
= XMC_RW
;
5579 if (strcmp (s
, "SV]") == 0)
5580 tc
->symbol_class
= XMC_SV
;
5583 if (strcmp (s
, "TC]") == 0)
5584 tc
->symbol_class
= XMC_TC
;
5585 else if (strcmp (s
, "TI]") == 0)
5586 tc
->symbol_class
= XMC_TI
;
5587 else if (strcmp (s
, "TB]") == 0)
5588 tc
->symbol_class
= XMC_TB
;
5589 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5590 tc
->symbol_class
= XMC_TC0
;
5593 if (strcmp (s
, "UA]") == 0)
5594 tc
->symbol_class
= XMC_UA
;
5595 else if (strcmp (s
, "UC]") == 0)
5596 tc
->symbol_class
= XMC_UC
;
5599 if (strcmp (s
, "XO]") == 0)
5600 tc
->symbol_class
= XMC_XO
;
5604 if (tc
->symbol_class
== -1)
5605 as_bad (_("unrecognized symbol suffix"));
5608 /* Set the class of a label based on where it is defined. This
5609 handles symbols without suffixes. Also, move the symbol so that it
5610 follows the csect symbol. */
5613 ppc_frob_label (symbolS
*sym
)
5615 if (ppc_current_csect
!= (symbolS
*) NULL
)
5617 if (symbol_get_tc (sym
)->symbol_class
== -1)
5618 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5620 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5621 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5622 &symbol_rootP
, &symbol_lastP
);
5623 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5624 symbol_get_tc (sym
)->within
= ppc_current_csect
;
5628 dwarf2_emit_label (sym
);
5632 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5633 seen. It tells ppc_adjust_symtab whether it needs to look through
5636 static bfd_boolean ppc_saw_abs
;
5638 /* Change the name of a symbol just before writing it out. Set the
5639 real name if the .rename pseudo-op was used. Otherwise, remove any
5640 class suffix. Return 1 if the symbol should not be included in the
5644 ppc_frob_symbol (symbolS
*sym
)
5646 static symbolS
*ppc_last_function
;
5647 static symbolS
*set_end
;
5649 /* Discard symbols that should not be included in the output symbol
5651 if (! symbol_used_in_reloc_p (sym
)
5652 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5653 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5654 && ! symbol_get_tc (sym
)->output
5655 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5658 /* This one will disappear anyway. Don't make a csect sym for it. */
5659 if (sym
== abs_section_sym
)
5662 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5663 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5669 name
= S_GET_NAME (sym
);
5670 s
= strchr (name
, '[');
5671 if (s
!= (char *) NULL
)
5677 snew
= xmalloc (len
+ 1);
5678 memcpy (snew
, name
, len
);
5681 S_SET_NAME (sym
, snew
);
5685 if (set_end
!= (symbolS
*) NULL
)
5687 SA_SET_SYM_ENDNDX (set_end
, sym
);
5691 if (SF_GET_FUNCTION (sym
))
5693 if (ppc_last_function
!= (symbolS
*) NULL
)
5694 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5695 ppc_last_function
= sym
;
5696 if (symbol_get_tc (sym
)->u
.size
!= (symbolS
*) NULL
)
5698 resolve_symbol_value (symbol_get_tc (sym
)->u
.size
);
5699 SA_SET_SYM_FSIZE (sym
,
5700 (long) S_GET_VALUE (symbol_get_tc (sym
)->u
.size
));
5703 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5704 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5706 if (ppc_last_function
== (symbolS
*) NULL
)
5707 as_bad (_(".ef with no preceding .function"));
5710 set_end
= ppc_last_function
;
5711 ppc_last_function
= NULL
;
5713 /* We don't have a C_EFCN symbol, but we need to force the
5714 COFF backend to believe that it has seen one. */
5715 coff_last_function
= NULL
;
5719 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5720 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5721 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5722 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5723 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5724 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5725 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5726 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5727 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5728 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5729 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5731 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5732 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5733 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5736 union internal_auxent
*a
;
5738 /* Create a csect aux. */
5739 i
= S_GET_NUMBER_AUXILIARY (sym
);
5740 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5741 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5742 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5744 /* This is the TOC table. */
5745 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5746 a
->x_csect
.x_scnlen
.l
= 0;
5747 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5749 else if (symbol_get_tc (sym
)->subseg
!= 0)
5751 /* This is a csect symbol. x_scnlen is the size of the
5753 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5754 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5755 S_GET_SEGMENT (sym
))
5756 - S_GET_VALUE (sym
));
5759 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5760 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5761 - S_GET_VALUE (sym
));
5763 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5765 else if (S_GET_SEGMENT (sym
) == bss_section
)
5767 /* This is a common symbol. */
5768 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5769 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5770 if (S_IS_EXTERNAL (sym
))
5771 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5773 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5775 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5777 /* This is an absolute symbol. The csect will be created by
5778 ppc_adjust_symtab. */
5780 a
->x_csect
.x_smtyp
= XTY_LD
;
5781 if (symbol_get_tc (sym
)->symbol_class
== -1)
5782 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5784 else if (! S_IS_DEFINED (sym
))
5786 /* This is an external symbol. */
5787 a
->x_csect
.x_scnlen
.l
= 0;
5788 a
->x_csect
.x_smtyp
= XTY_ER
;
5790 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5794 /* This is a TOC definition. x_scnlen is the size of the
5796 next
= symbol_next (sym
);
5797 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5798 next
= symbol_next (next
);
5799 if (next
== (symbolS
*) NULL
5800 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5802 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5803 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5805 - S_GET_VALUE (sym
));
5807 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5808 - S_GET_VALUE (sym
));
5812 resolve_symbol_value (next
);
5813 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5814 - S_GET_VALUE (sym
));
5816 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5822 /* This is a normal symbol definition. x_scnlen is the
5823 symbol index of the containing csect. */
5824 if (S_GET_SEGMENT (sym
) == text_section
)
5825 csect
= ppc_text_csects
;
5826 else if (S_GET_SEGMENT (sym
) == data_section
)
5827 csect
= ppc_data_csects
;
5831 /* Skip the initial dummy symbol. */
5832 csect
= symbol_get_tc (csect
)->next
;
5834 if (csect
== (symbolS
*) NULL
)
5836 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5837 a
->x_csect
.x_scnlen
.l
= 0;
5841 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5843 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5844 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5845 > S_GET_VALUE (sym
))
5847 csect
= symbol_get_tc (csect
)->next
;
5850 a
->x_csect
.x_scnlen
.p
=
5851 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5852 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5855 a
->x_csect
.x_smtyp
= XTY_LD
;
5858 a
->x_csect
.x_parmhash
= 0;
5859 a
->x_csect
.x_snhash
= 0;
5860 if (symbol_get_tc (sym
)->symbol_class
== -1)
5861 a
->x_csect
.x_smclas
= XMC_PR
;
5863 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5864 a
->x_csect
.x_stab
= 0;
5865 a
->x_csect
.x_snstab
= 0;
5867 /* Don't let the COFF backend resort these symbols. */
5868 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5870 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5872 /* We want the value to be the symbol index of the referenced
5873 csect symbol. BFD will do that for us if we set the right
5875 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5876 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5878 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5879 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5881 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5886 block
= symbol_get_tc (sym
)->within
;
5889 /* The value is the offset from the enclosing csect. */
5892 csect
= symbol_get_tc (block
)->within
;
5893 resolve_symbol_value (csect
);
5894 base
= S_GET_VALUE (csect
);
5899 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - base
);
5901 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5902 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5904 /* We want the value to be a file offset into the line numbers.
5905 BFD will do that for us if we set the right flags. We have
5906 already set the value correctly. */
5907 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5913 /* Adjust the symbol table. This creates csect symbols for all
5914 absolute symbols. */
5917 ppc_adjust_symtab (void)
5924 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5928 union internal_auxent
*a
;
5930 if (S_GET_SEGMENT (sym
) != absolute_section
)
5933 csect
= symbol_create (".abs[XO]", absolute_section
,
5934 S_GET_VALUE (sym
), &zero_address_frag
);
5935 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5936 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5937 i
= S_GET_NUMBER_AUXILIARY (csect
);
5938 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5939 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5940 a
->x_csect
.x_scnlen
.l
= 0;
5941 a
->x_csect
.x_smtyp
= XTY_SD
;
5942 a
->x_csect
.x_parmhash
= 0;
5943 a
->x_csect
.x_snhash
= 0;
5944 a
->x_csect
.x_smclas
= XMC_XO
;
5945 a
->x_csect
.x_stab
= 0;
5946 a
->x_csect
.x_snstab
= 0;
5948 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5950 i
= S_GET_NUMBER_AUXILIARY (sym
);
5951 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5952 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5953 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5956 ppc_saw_abs
= FALSE
;
5959 /* Set the VMA for a section. This is called on all the sections in
5963 ppc_frob_section (asection
*sec
)
5965 static bfd_vma vma
= 0;
5967 /* Dwarf sections start at 0. */
5968 if (bfd_get_section_flags (NULL
, sec
) & SEC_DEBUGGING
)
5971 vma
= md_section_align (sec
, vma
);
5972 bfd_set_section_vma (stdoutput
, sec
, vma
);
5973 vma
+= bfd_section_size (stdoutput
, sec
);
5976 #endif /* OBJ_XCOFF */
5979 md_atof (int type
, char *litp
, int *sizep
)
5981 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5984 /* Write a value out to the object file, using the appropriate
5988 md_number_to_chars (char *buf
, valueT val
, int n
)
5990 if (target_big_endian
)
5991 number_to_chars_bigendian (buf
, val
, n
);
5993 number_to_chars_littleendian (buf
, val
, n
);
5996 /* Align a section (I don't know why this is machine dependent). */
5999 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
6004 int align
= bfd_get_section_alignment (stdoutput
, seg
);
6006 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
6010 /* We don't have any form of relaxing. */
6013 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
6014 asection
*seg ATTRIBUTE_UNUSED
)
6020 /* Convert a machine dependent frag. We never generate these. */
6023 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
6024 asection
*sec ATTRIBUTE_UNUSED
,
6025 fragS
*fragp ATTRIBUTE_UNUSED
)
6030 /* We have no need to default values of symbols. */
6033 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
6038 /* Functions concerning relocs. */
6040 /* The location from which a PC relative jump should be calculated,
6041 given a PC relative reloc. */
6044 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
6046 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6051 /* This is called to see whether a fixup should be adjusted to use a
6052 section symbol. We take the opportunity to change a fixup against
6053 a symbol in the TOC subsegment into a reloc against the
6054 corresponding .tc symbol. */
6057 ppc_fix_adjustable (fixS
*fix
)
6059 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
6060 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
6061 TC_SYMFIELD_TYPE
*tc
;
6063 if (symseg
== absolute_section
)
6066 /* Always adjust symbols in debugging sections. */
6067 if (bfd_get_section_flags (stdoutput
, symseg
) & SEC_DEBUGGING
)
6070 if (ppc_toc_csect
!= (symbolS
*) NULL
6071 && fix
->fx_addsy
!= ppc_toc_csect
6072 && symseg
== data_section
6073 && val
>= ppc_toc_frag
->fr_address
6074 && (ppc_after_toc_frag
== (fragS
*) NULL
6075 || val
< ppc_after_toc_frag
->fr_address
))
6079 for (sy
= symbol_next (ppc_toc_csect
);
6080 sy
!= (symbolS
*) NULL
;
6081 sy
= symbol_next (sy
))
6083 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
6085 if (sy_tc
->symbol_class
== XMC_TC0
)
6087 if (sy_tc
->symbol_class
!= XMC_TC
)
6089 if (val
== resolve_symbol_value (sy
))
6092 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
6097 as_bad_where (fix
->fx_file
, fix
->fx_line
,
6098 _("symbol in .toc does not match any .tc"));
6101 /* Possibly adjust the reloc to be against the csect. */
6102 tc
= symbol_get_tc (fix
->fx_addsy
);
6104 && tc
->symbol_class
!= XMC_TC0
6105 && tc
->symbol_class
!= XMC_TC
6106 && symseg
!= bss_section
6107 /* Don't adjust if this is a reloc in the toc section. */
6108 && (symseg
!= data_section
6109 || ppc_toc_csect
== NULL
6110 || val
< ppc_toc_frag
->fr_address
6111 || (ppc_after_toc_frag
!= NULL
6112 && val
>= ppc_after_toc_frag
->fr_address
)))
6114 symbolS
*csect
= tc
->within
;
6116 /* If the symbol was not declared by a label (eg: a section symbol),
6117 use the section instead of the csect. This doesn't happen in
6118 normal AIX assembly code. */
6120 csect
= seg_info (symseg
)->sym
;
6122 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
6123 fix
->fx_addsy
= csect
;
6128 /* Adjust a reloc against a .lcomm symbol to be against the base
6130 if (symseg
== bss_section
6131 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
6133 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
6135 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
6142 /* A reloc from one csect to another must be kept. The assembler
6143 will, of course, keep relocs between sections, and it will keep
6144 absolute relocs, but we need to force it to keep PC relative relocs
6145 between two csects in the same section. */
6148 ppc_force_relocation (fixS
*fix
)
6150 /* At this point fix->fx_addsy should already have been converted to
6151 a csect symbol. If the csect does not include the fragment, then
6152 we need to force the relocation. */
6154 && fix
->fx_addsy
!= NULL
6155 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
6156 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
6157 > fix
->fx_frag
->fr_address
)
6158 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
6159 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
6160 <= fix
->fx_frag
->fr_address
))))
6163 return generic_force_reloc (fix
);
6167 ppc_new_dot_label (symbolS
*sym
)
6169 /* Anchor this label to the current csect for relocations. */
6170 symbol_get_tc (sym
)->within
= ppc_current_csect
;
6173 #endif /* OBJ_XCOFF */
6176 /* If this function returns non-zero, it guarantees that a relocation
6177 will be emitted for a fixup. */
6180 ppc_force_relocation (fixS
*fix
)
6182 /* Branch prediction relocations must force a relocation, as must
6183 the vtable description relocs. */
6184 switch (fix
->fx_r_type
)
6186 case BFD_RELOC_PPC_B16_BRTAKEN
:
6187 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6188 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6189 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6190 case BFD_RELOC_24_PLT_PCREL
:
6191 case BFD_RELOC_PPC64_TOC
:
6197 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6198 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
6201 return generic_force_reloc (fix
);
6205 ppc_fix_adjustable (fixS
*fix
)
6207 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
6208 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
6209 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
6210 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
6211 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_DS
6212 && fix
->fx_r_type
!= BFD_RELOC_PPC64_GOT16_LO_DS
6213 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
6214 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
6215 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
6216 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
6217 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
6222 ppc_frag_check (struct frag
*fragP
)
6224 if (!fragP
->has_code
)
6227 if (ppc_mach() == bfd_mach_ppc_vle
)
6229 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 1) != 0)
6230 as_bad (_("instruction address is not a multiple of 2"));
6234 if (((fragP
->fr_address
+ fragP
->insn_addr
) & 3) != 0)
6235 as_bad (_("instruction address is not a multiple of 4"));
6239 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6240 rs_align_code frag. */
6243 ppc_handle_align (struct frag
*fragP
)
6245 valueT count
= (fragP
->fr_next
->fr_address
6246 - (fragP
->fr_address
+ fragP
->fr_fix
));
6248 if (ppc_mach() == bfd_mach_ppc_vle
&& count
!= 0 && (count
& 1) == 0)
6250 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6253 md_number_to_chars (dest
, 0x4400, 2);
6255 else if (count
!= 0 && (count
& 3) == 0)
6257 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
6261 if (count
> 4 * nop_limit
&& count
< 0x2000000)
6265 /* Make a branch, then follow with nops. Insert another
6266 frag to handle the nops. */
6267 md_number_to_chars (dest
, 0x48000000 + count
, 4);
6272 rest
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6273 memcpy (rest
, fragP
, SIZEOF_STRUCT_FRAG
);
6274 fragP
->fr_next
= rest
;
6276 rest
->fr_address
+= rest
->fr_fix
+ 4;
6278 /* If we leave the next frag as rs_align_code we'll come here
6279 again, resulting in a bunch of branches rather than a
6280 branch followed by nops. */
6281 rest
->fr_type
= rs_align
;
6282 dest
= rest
->fr_literal
;
6285 md_number_to_chars (dest
, 0x60000000, 4);
6287 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
6288 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6289 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6291 /* For power6, power7 and power8, we want the last nop to be a group
6292 terminating one. Do this by inserting an rs_fill frag immediately
6293 after this one, with its address set to the last nop location.
6294 This will automatically reduce the number of nops in the current
6298 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
6300 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
6301 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
6302 group_nop
->fr_fix
= 0;
6303 group_nop
->fr_offset
= 1;
6304 group_nop
->fr_type
= rs_fill
;
6305 fragP
->fr_next
= group_nop
;
6306 dest
= group_nop
->fr_literal
;
6309 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0
6310 || (ppc_cpu
& PPC_OPCODE_POWER8
) != 0)
6312 if (ppc_cpu
& PPC_OPCODE_E500MC
)
6313 /* e500mc group terminating nop: "ori 0,0,0". */
6314 md_number_to_chars (dest
, 0x60000000, 4);
6316 /* power7/power8 group terminating nop: "ori 2,2,0". */
6317 md_number_to_chars (dest
, 0x60420000, 4);
6320 /* power6 group terminating nop: "ori 1,1,0". */
6321 md_number_to_chars (dest
, 0x60210000, 4);
6326 /* Apply a fixup to the object code. This is called for all the
6327 fixups we generated by the calls to fix_new_exp, above. */
6330 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
6332 valueT value
= * valP
;
6334 const struct powerpc_operand
*operand
;
6337 if (fixP
->fx_addsy
!= NULL
)
6339 /* Hack around bfd_install_relocation brain damage. */
6341 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
6346 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6347 the symbol values. If we are doing this relocation the code in
6348 write.c is going to call bfd_install_relocation, which is also
6349 going to use the symbol value. That means that if the reloc is
6350 fully resolved we want to use *valP since bfd_install_relocation is
6352 However, if the reloc is not fully resolved we do not want to
6353 use *valP, and must use fx_offset instead. If the relocation
6354 is PC-relative, we then need to re-apply md_pcrel_from_section
6355 to this new relocation value. */
6356 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
6361 value
= fixP
->fx_offset
;
6363 value
-= md_pcrel_from_section (fixP
, seg
);
6367 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
6369 /* We can't actually support subtracting a symbol. */
6370 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
6374 if (fixP
->fx_pcrel_adjust
!= 0)
6376 /* This is a fixup on an instruction. */
6377 int opindex
= fixP
->fx_pcrel_adjust
& 0xff;
6379 operand
= &powerpc_operands
[opindex
];
6381 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6382 does not generate a reloc. It uses the offset of `sym' within its
6383 csect. Other usages, such as `.long sym', generate relocs. This
6384 is the documented behaviour of non-TOC symbols. */
6385 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
6386 && (operand
->bitm
& 0xfff0) == 0xfff0
6387 && operand
->shift
== 0
6388 && (operand
->insert
== NULL
|| ppc_obj64
)
6389 && fixP
->fx_addsy
!= NULL
6390 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
6391 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
6392 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
6393 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
6395 value
= fixP
->fx_offset
;
6399 /* During parsing of instructions, a TOC16 reloc is generated for
6400 instructions such as 'lwz RT,SYM(RB)' if SYM is a symbol defined
6401 in the toc. But at parse time, SYM may be not yet defined, so
6402 check again here. */
6403 if (fixP
->fx_r_type
== BFD_RELOC_16
6404 && fixP
->fx_addsy
!= NULL
6405 && ppc_is_toc_sym (fixP
->fx_addsy
))
6406 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
6410 /* Calculate value to be stored in field. */
6412 switch (fixP
->fx_r_type
)
6415 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6416 case BFD_RELOC_PPC_VLE_LO16A
:
6417 case BFD_RELOC_PPC_VLE_LO16D
:
6419 case BFD_RELOC_LO16
:
6420 case BFD_RELOC_LO16_PCREL
:
6421 fieldval
= value
& 0xffff;
6423 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6424 fieldval
= SEX16 (fieldval
);
6425 fixP
->fx_no_overflow
= 1;
6428 case BFD_RELOC_HI16
:
6429 case BFD_RELOC_HI16_PCREL
:
6431 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6433 fieldval
= value
>> 16;
6434 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6436 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6437 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6443 case BFD_RELOC_PPC_VLE_HI16A
:
6444 case BFD_RELOC_PPC_VLE_HI16D
:
6445 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6447 fieldval
= PPC_HI (value
);
6448 goto sign_extend_16
;
6450 case BFD_RELOC_HI16_S
:
6451 case BFD_RELOC_HI16_S_PCREL
:
6453 if (REPORT_OVERFLOW_HI
&& ppc_obj64
)
6455 fieldval
= (value
+ 0x8000) >> 16;
6456 if (operand
!= NULL
&& (operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
6458 valueT sign
= (((valueT
) -1 >> 16) + 1) >> 1;
6459 fieldval
= ((valueT
) fieldval
^ sign
) - sign
;
6465 case BFD_RELOC_PPC_VLE_HA16A
:
6466 case BFD_RELOC_PPC_VLE_HA16D
:
6467 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6469 fieldval
= PPC_HA (value
);
6470 goto sign_extend_16
;
6473 case BFD_RELOC_PPC64_HIGHER
:
6474 fieldval
= PPC_HIGHER (value
);
6475 goto sign_extend_16
;
6477 case BFD_RELOC_PPC64_HIGHER_S
:
6478 fieldval
= PPC_HIGHERA (value
);
6479 goto sign_extend_16
;
6481 case BFD_RELOC_PPC64_HIGHEST
:
6482 fieldval
= PPC_HIGHEST (value
);
6483 goto sign_extend_16
;
6485 case BFD_RELOC_PPC64_HIGHEST_S
:
6486 fieldval
= PPC_HIGHESTA (value
);
6487 goto sign_extend_16
;
6494 if (operand
!= NULL
)
6496 /* Handle relocs in an insn. */
6500 switch (fixP
->fx_r_type
)
6503 /* The following relocs can't be calculated by the assembler.
6504 Leave the field zero. */
6505 case BFD_RELOC_PPC_TPREL16
:
6506 case BFD_RELOC_PPC_TPREL16_LO
:
6507 case BFD_RELOC_PPC_TPREL16_HI
:
6508 case BFD_RELOC_PPC_TPREL16_HA
:
6509 case BFD_RELOC_PPC_DTPREL16
:
6510 case BFD_RELOC_PPC_DTPREL16_LO
:
6511 case BFD_RELOC_PPC_DTPREL16_HI
:
6512 case BFD_RELOC_PPC_DTPREL16_HA
:
6513 case BFD_RELOC_PPC_GOT_TLSGD16
:
6514 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6515 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6516 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6517 case BFD_RELOC_PPC_GOT_TLSLD16
:
6518 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6519 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6520 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6521 case BFD_RELOC_PPC_GOT_TPREL16
:
6522 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6523 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6524 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6525 case BFD_RELOC_PPC_GOT_DTPREL16
:
6526 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6527 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6528 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6529 case BFD_RELOC_PPC64_TPREL16_DS
:
6530 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6531 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6532 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6533 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6534 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6535 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6536 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6537 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6538 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6539 case BFD_RELOC_PPC64_DTPREL16_DS
:
6540 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6541 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6542 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6543 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6544 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6545 gas_assert (fixP
->fx_addsy
!= NULL
);
6546 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6550 /* These also should leave the field zero for the same
6551 reason. Note that older versions of gas wrote values
6552 here. If we want to go back to the old behaviour, then
6553 all _LO and _LO_DS cases will need to be treated like
6554 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6555 case BFD_RELOC_16_GOTOFF
:
6556 case BFD_RELOC_LO16_GOTOFF
:
6557 case BFD_RELOC_HI16_GOTOFF
:
6558 case BFD_RELOC_HI16_S_GOTOFF
:
6559 case BFD_RELOC_LO16_PLTOFF
:
6560 case BFD_RELOC_HI16_PLTOFF
:
6561 case BFD_RELOC_HI16_S_PLTOFF
:
6562 case BFD_RELOC_GPREL16
:
6563 case BFD_RELOC_16_BASEREL
:
6564 case BFD_RELOC_LO16_BASEREL
:
6565 case BFD_RELOC_HI16_BASEREL
:
6566 case BFD_RELOC_HI16_S_BASEREL
:
6567 case BFD_RELOC_PPC_TOC16
:
6568 case BFD_RELOC_PPC64_TOC16_LO
:
6569 case BFD_RELOC_PPC64_TOC16_HI
:
6570 case BFD_RELOC_PPC64_TOC16_HA
:
6571 case BFD_RELOC_PPC64_PLTGOT16
:
6572 case BFD_RELOC_PPC64_PLTGOT16_LO
:
6573 case BFD_RELOC_PPC64_PLTGOT16_HI
:
6574 case BFD_RELOC_PPC64_PLTGOT16_HA
:
6575 case BFD_RELOC_PPC64_GOT16_DS
:
6576 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6577 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6578 case BFD_RELOC_PPC64_SECTOFF_DS
:
6579 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6580 case BFD_RELOC_PPC64_TOC16_DS
:
6581 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6582 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6583 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6584 case BFD_RELOC_PPC_EMB_NADDR16
:
6585 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6586 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6587 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6588 case BFD_RELOC_PPC_EMB_SDAI16
:
6589 case BFD_RELOC_PPC_EMB_SDA2I16
:
6590 case BFD_RELOC_PPC_EMB_SDA2REL
:
6591 case BFD_RELOC_PPC_EMB_SDA21
:
6592 case BFD_RELOC_PPC_EMB_MRKREF
:
6593 case BFD_RELOC_PPC_EMB_RELSEC16
:
6594 case BFD_RELOC_PPC_EMB_RELST_LO
:
6595 case BFD_RELOC_PPC_EMB_RELST_HI
:
6596 case BFD_RELOC_PPC_EMB_RELST_HA
:
6597 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6598 case BFD_RELOC_PPC_EMB_RELSDA
:
6599 case BFD_RELOC_PPC_VLE_SDA21
:
6600 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6601 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6602 case BFD_RELOC_PPC_VLE_SDAREL_LO16D
:
6603 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6604 case BFD_RELOC_PPC_VLE_SDAREL_HI16D
:
6605 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6606 case BFD_RELOC_PPC_VLE_SDAREL_HA16D
:
6607 gas_assert (fixP
->fx_addsy
!= NULL
);
6610 case BFD_RELOC_PPC_TLS
:
6611 case BFD_RELOC_PPC_TLSGD
:
6612 case BFD_RELOC_PPC_TLSLD
:
6618 case BFD_RELOC_PPC_B16
:
6619 /* Adjust the offset to the instruction boundary. */
6629 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6630 contents can stay at zero. */
6631 #define APPLY_RELOC fixP->fx_done
6633 #define APPLY_RELOC 1
6635 if ((fieldval
!= 0 && APPLY_RELOC
) || operand
->insert
!= NULL
)
6637 /* Fetch the instruction, insert the fully resolved operand
6638 value, and stuff the instruction back again. */
6639 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6640 if (target_big_endian
)
6642 if (fixP
->fx_size
== 4)
6643 insn
= bfd_getb32 ((unsigned char *) where
);
6645 insn
= bfd_getb16 ((unsigned char *) where
);
6649 if (fixP
->fx_size
== 4)
6650 insn
= bfd_getl32 ((unsigned char *) where
);
6652 insn
= bfd_getl16 ((unsigned char *) where
);
6654 insn
= ppc_insert_operand (insn
, operand
, fieldval
,
6655 fixP
->tc_fix_data
.ppc_cpu
,
6656 fixP
->fx_file
, fixP
->fx_line
);
6657 if (target_big_endian
)
6659 if (fixP
->fx_size
== 4)
6660 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6662 bfd_putb16 ((bfd_vma
) insn
, (unsigned char *) where
);
6666 if (fixP
->fx_size
== 4)
6667 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6669 bfd_putl16 ((bfd_vma
) insn
, (unsigned char *) where
);
6674 /* Nothing else to do here. */
6677 gas_assert (fixP
->fx_addsy
!= NULL
);
6678 if (fixP
->fx_r_type
== BFD_RELOC_UNUSED
)
6683 /* Use expr_symbol_where to see if this is an expression
6685 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6686 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6687 _("unresolved expression that must be resolved"));
6689 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6690 _("unsupported relocation against %s"),
6691 S_GET_NAME (fixP
->fx_addsy
));
6698 /* Handle relocs in data. */
6699 switch (fixP
->fx_r_type
)
6701 case BFD_RELOC_VTABLE_INHERIT
:
6703 && !S_IS_DEFINED (fixP
->fx_addsy
)
6704 && !S_IS_WEAK (fixP
->fx_addsy
))
6705 S_SET_WEAK (fixP
->fx_addsy
);
6708 case BFD_RELOC_VTABLE_ENTRY
:
6713 /* These can appear with @l etc. in data. */
6714 case BFD_RELOC_LO16
:
6715 case BFD_RELOC_LO16_PCREL
:
6716 case BFD_RELOC_HI16
:
6717 case BFD_RELOC_HI16_PCREL
:
6718 case BFD_RELOC_HI16_S
:
6719 case BFD_RELOC_HI16_S_PCREL
:
6720 case BFD_RELOC_PPC64_HIGHER
:
6721 case BFD_RELOC_PPC64_HIGHER_S
:
6722 case BFD_RELOC_PPC64_HIGHEST
:
6723 case BFD_RELOC_PPC64_HIGHEST_S
:
6724 case BFD_RELOC_PPC64_ADDR16_HIGH
:
6725 case BFD_RELOC_PPC64_ADDR16_HIGHA
:
6728 case BFD_RELOC_PPC_DTPMOD
:
6729 case BFD_RELOC_PPC_TPREL
:
6730 case BFD_RELOC_PPC_DTPREL
:
6731 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6734 /* Just punt all of these to the linker. */
6735 case BFD_RELOC_PPC_B16_BRTAKEN
:
6736 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6737 case BFD_RELOC_16_GOTOFF
:
6738 case BFD_RELOC_LO16_GOTOFF
:
6739 case BFD_RELOC_HI16_GOTOFF
:
6740 case BFD_RELOC_HI16_S_GOTOFF
:
6741 case BFD_RELOC_LO16_PLTOFF
:
6742 case BFD_RELOC_HI16_PLTOFF
:
6743 case BFD_RELOC_HI16_S_PLTOFF
:
6744 case BFD_RELOC_PPC_COPY
:
6745 case BFD_RELOC_PPC_GLOB_DAT
:
6746 case BFD_RELOC_16_BASEREL
:
6747 case BFD_RELOC_LO16_BASEREL
:
6748 case BFD_RELOC_HI16_BASEREL
:
6749 case BFD_RELOC_HI16_S_BASEREL
:
6750 case BFD_RELOC_PPC_TLS
:
6751 case BFD_RELOC_PPC_DTPREL16_LO
:
6752 case BFD_RELOC_PPC_DTPREL16_HI
:
6753 case BFD_RELOC_PPC_DTPREL16_HA
:
6754 case BFD_RELOC_PPC_TPREL16_LO
:
6755 case BFD_RELOC_PPC_TPREL16_HI
:
6756 case BFD_RELOC_PPC_TPREL16_HA
:
6757 case BFD_RELOC_PPC_GOT_TLSGD16
:
6758 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6759 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6760 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6761 case BFD_RELOC_PPC_GOT_TLSLD16
:
6762 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6763 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6764 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6765 case BFD_RELOC_PPC_GOT_DTPREL16
:
6766 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6767 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6768 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6769 case BFD_RELOC_PPC_GOT_TPREL16
:
6770 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6771 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6772 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6773 case BFD_RELOC_24_PLT_PCREL
:
6774 case BFD_RELOC_PPC_LOCAL24PC
:
6775 case BFD_RELOC_32_PLT_PCREL
:
6776 case BFD_RELOC_GPREL16
:
6777 case BFD_RELOC_PPC_VLE_SDAREL_LO16A
:
6778 case BFD_RELOC_PPC_VLE_SDAREL_HI16A
:
6779 case BFD_RELOC_PPC_VLE_SDAREL_HA16A
:
6780 case BFD_RELOC_PPC_EMB_NADDR32
:
6781 case BFD_RELOC_PPC_EMB_NADDR16
:
6782 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
6783 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
6784 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
6785 case BFD_RELOC_PPC_EMB_SDAI16
:
6786 case BFD_RELOC_PPC_EMB_SDA2REL
:
6787 case BFD_RELOC_PPC_EMB_SDA2I16
:
6788 case BFD_RELOC_PPC_EMB_SDA21
:
6789 case BFD_RELOC_PPC_VLE_SDA21_LO
:
6790 case BFD_RELOC_PPC_EMB_MRKREF
:
6791 case BFD_RELOC_PPC_EMB_RELSEC16
:
6792 case BFD_RELOC_PPC_EMB_RELST_LO
:
6793 case BFD_RELOC_PPC_EMB_RELST_HI
:
6794 case BFD_RELOC_PPC_EMB_RELST_HA
:
6795 case BFD_RELOC_PPC_EMB_BIT_FLD
:
6796 case BFD_RELOC_PPC_EMB_RELSDA
:
6797 case BFD_RELOC_PPC64_TOC
:
6798 case BFD_RELOC_PPC_TOC16
:
6799 case BFD_RELOC_PPC64_TOC16_LO
:
6800 case BFD_RELOC_PPC64_TOC16_HI
:
6801 case BFD_RELOC_PPC64_TOC16_HA
:
6802 case BFD_RELOC_PPC64_DTPREL16_HIGH
:
6803 case BFD_RELOC_PPC64_DTPREL16_HIGHA
:
6804 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6805 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6806 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6807 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6808 case BFD_RELOC_PPC64_TPREL16_HIGH
:
6809 case BFD_RELOC_PPC64_TPREL16_HIGHA
:
6810 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6811 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6812 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6813 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6819 case BFD_RELOC_NONE
:
6821 case BFD_RELOC_CTOR
:
6823 case BFD_RELOC_32_PCREL
:
6826 case BFD_RELOC_64_PCREL
:
6828 case BFD_RELOC_16_PCREL
:
6834 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6839 if (fixP
->fx_size
&& APPLY_RELOC
)
6840 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6841 fieldval
, fixP
->fx_size
);
6844 /* We are only able to convert some relocs to pc-relative. */
6845 if (!fixP
->fx_done
&& fixP
->fx_pcrel
)
6847 switch (fixP
->fx_r_type
)
6849 case BFD_RELOC_LO16
:
6850 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6853 case BFD_RELOC_HI16
:
6854 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6857 case BFD_RELOC_HI16_S
:
6858 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6862 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
6866 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
6870 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
6873 /* Some of course are already pc-relative. */
6874 case BFD_RELOC_LO16_PCREL
:
6875 case BFD_RELOC_HI16_PCREL
:
6876 case BFD_RELOC_HI16_S_PCREL
:
6877 case BFD_RELOC_64_PCREL
:
6878 case BFD_RELOC_32_PCREL
:
6879 case BFD_RELOC_16_PCREL
:
6880 case BFD_RELOC_PPC_B16
:
6881 case BFD_RELOC_PPC_B16_BRTAKEN
:
6882 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6883 case BFD_RELOC_PPC_B26
:
6884 case BFD_RELOC_PPC_LOCAL24PC
:
6885 case BFD_RELOC_24_PLT_PCREL
:
6886 case BFD_RELOC_32_PLT_PCREL
:
6887 case BFD_RELOC_64_PLT_PCREL
:
6888 case BFD_RELOC_PPC_VLE_REL8
:
6889 case BFD_RELOC_PPC_VLE_REL15
:
6890 case BFD_RELOC_PPC_VLE_REL24
:
6899 /* Use expr_symbol_where to see if this is an
6900 expression symbol. */
6901 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
6902 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6903 _("unresolved expression that must"
6906 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6907 _("cannot emit PC relative %s relocation"
6909 bfd_get_reloc_code_name (fixP
->fx_r_type
),
6910 S_GET_NAME (fixP
->fx_addsy
));
6913 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6914 _("unable to resolve expression"));
6921 ppc_elf_validate_fix (fixP
, seg
);
6922 fixP
->fx_addnumber
= value
;
6924 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6925 from the section contents. If we are going to be emitting a reloc
6926 then the section contents are immaterial, so don't warn if they
6927 happen to overflow. Leave such warnings to ld. */
6930 fixP
->fx_no_overflow
= 1;
6932 /* Arrange to emit .TOC. as a normal symbol if used in anything
6933 but .TOC.@tocbase. */
6935 && fixP
->fx_r_type
!= BFD_RELOC_PPC64_TOC
6936 && fixP
->fx_addsy
!= NULL
6937 && strcmp (S_GET_NAME (fixP
->fx_addsy
), ".TOC.") == 0)
6938 symbol_get_bfdsym (fixP
->fx_addsy
)->flags
|= BSF_KEEP
;
6941 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6942 fixP
->fx_addnumber
= 0;
6946 fixP
->fx_addnumber
= 0;
6948 /* We want to use the offset within the toc, not the actual VMA
6950 fixP
->fx_addnumber
=
6951 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6952 - S_GET_VALUE (ppc_toc_csect
);
6953 /* Set *valP to avoid errors. */
6960 /* Generate a reloc for a fixup. */
6963 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6967 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6969 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6970 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6971 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6972 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6973 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6975 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6976 _("reloc %d not supported by object file format"),
6977 (int) fixp
->fx_r_type
);
6980 reloc
->addend
= fixp
->fx_addnumber
;
6986 ppc_cfi_frame_initial_instructions (void)
6988 cfi_add_CFA_def_cfa (1, 0);
6992 tc_ppc_regname_to_dw2regnum (char *regname
)
6994 unsigned int regnum
= -1;
6998 static struct { char *name
; int dw2regnum
; } regnames
[] =
7000 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
7001 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
7002 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
7003 { "spe_acc", 111 }, { "spefscr", 112 }
7006 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
7007 if (strcmp (regnames
[i
].name
, regname
) == 0)
7008 return regnames
[i
].dw2regnum
;
7010 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
7012 p
= regname
+ 1 + (regname
[1] == '.');
7013 regnum
= strtoul (p
, &q
, 10);
7014 if (p
== q
|| *q
|| regnum
>= 32)
7016 if (regname
[0] == 'f')
7018 else if (regname
[0] == 'v')
7021 else if (regname
[0] == 'c' && regname
[1] == 'r')
7023 p
= regname
+ 2 + (regname
[2] == '.');
7024 if (p
[0] < '0' || p
[0] > '7' || p
[1])
7026 regnum
= p
[0] - '0' + 68;