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