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 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "safe-ctype.h"
26 #include "dw2gencfi.h"
27 #include "opcode/ppc.h"
31 #include "dwarf2dbg.h"
38 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
40 /* Tell the main code what the endianness is. */
41 extern int target_big_endian
;
43 /* Whether or not, we've set target_big_endian. */
44 static int set_target_endian
= 0;
46 /* Whether to use user friendly register names. */
47 #ifndef TARGET_REG_NAMES_P
49 #define TARGET_REG_NAMES_P TRUE
51 #define TARGET_REG_NAMES_P FALSE
55 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
58 /* #lo(value) denotes the least significant 16 bits of the indicated. */
59 #define PPC_LO(v) ((v) & 0xffff)
61 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
62 #define PPC_HI(v) (((v) >> 16) & 0xffff)
64 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
65 the indicated value, compensating for #lo() being treated as a
67 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
69 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
70 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
72 /* #highera(value) denotes bits 32 through 47 of the indicated value,
73 compensating for #lo() being treated as a signed number. */
74 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
76 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
77 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
79 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
80 compensating for #lo being treated as a signed number. */
81 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
83 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
85 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
87 static void ppc_macro (char *, const struct powerpc_macro
*);
88 static void ppc_byte (int);
90 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
91 static void ppc_tc (int);
92 static void ppc_machine (int);
96 static void ppc_comm (int);
97 static void ppc_bb (int);
98 static void ppc_bc (int);
99 static void ppc_bf (int);
100 static void ppc_biei (int);
101 static void ppc_bs (int);
102 static void ppc_eb (int);
103 static void ppc_ec (int);
104 static void ppc_ef (int);
105 static void ppc_es (int);
106 static void ppc_csect (int);
107 static void ppc_change_csect (symbolS
*, offsetT
);
108 static void ppc_function (int);
109 static void ppc_extern (int);
110 static void ppc_lglobl (int);
111 static void ppc_section (int);
112 static void ppc_named_section (int);
113 static void ppc_stabx (int);
114 static void ppc_rename (int);
115 static void ppc_toc (int);
116 static void ppc_xcoff_cons (int);
117 static void ppc_vbyte (int);
121 static void ppc_elf_cons (int);
122 static void ppc_elf_rdata (int);
123 static void ppc_elf_lcomm (int);
127 static void ppc_previous (int);
128 static void ppc_pdata (int);
129 static void ppc_ydata (int);
130 static void ppc_reldata (int);
131 static void ppc_rdata (int);
132 static void ppc_ualong (int);
133 static void ppc_znop (int);
134 static void ppc_pe_comm (int);
135 static void ppc_pe_section (int);
136 static void ppc_pe_function (int);
137 static void ppc_pe_tocd (int);
140 /* Generic assembler global variables which must be defined by all
144 /* This string holds the chars that always start a comment. If the
145 pre-processor is disabled, these aren't very useful. The macro
146 tc_comment_chars points to this. We use this, rather than the
147 usual comment_chars, so that we can switch for Solaris conventions. */
148 static const char ppc_solaris_comment_chars
[] = "#!";
149 static const char ppc_eabi_comment_chars
[] = "#";
151 #ifdef TARGET_SOLARIS_COMMENT
152 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
154 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
157 const char comment_chars
[] = "#";
160 /* Characters which start a comment at the beginning of a line. */
161 const char line_comment_chars
[] = "#";
163 /* Characters which may be used to separate multiple commands on a
165 const char line_separator_chars
[] = ";";
167 /* Characters which are used to indicate an exponent in a floating
169 const char EXP_CHARS
[] = "eE";
171 /* Characters which mean that a number is a floating point constant,
173 const char FLT_CHARS
[] = "dD";
175 /* Anything that can start an operand needs to be mentioned here,
176 to stop the input scrubber eating whitespace. */
177 const char ppc_symbol_chars
[] = "%[";
179 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
180 int ppc_cie_data_alignment
;
182 /* The type of processor we are assembling for. This is one or more
183 of the PPC_OPCODE flags defined in opcode/ppc.h. */
184 ppc_cpu_t ppc_cpu
= 0;
186 /* The target specific pseudo-ops which we support. */
188 const pseudo_typeS md_pseudo_table
[] =
190 /* Pseudo-ops which must be overridden. */
191 { "byte", ppc_byte
, 0 },
194 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
195 legitimately belong in the obj-*.c file. However, XCOFF is based
196 on COFF, and is only implemented for the RS/6000. We just use
197 obj-coff.c, and add what we need here. */
198 { "comm", ppc_comm
, 0 },
199 { "lcomm", ppc_comm
, 1 },
203 { "bi", ppc_biei
, 0 },
205 { "csect", ppc_csect
, 0 },
206 { "data", ppc_section
, 'd' },
210 { "ei", ppc_biei
, 1 },
212 { "extern", ppc_extern
, 0 },
213 { "function", ppc_function
, 0 },
214 { "lglobl", ppc_lglobl
, 0 },
215 { "rename", ppc_rename
, 0 },
216 { "section", ppc_named_section
, 0 },
217 { "stabx", ppc_stabx
, 0 },
218 { "text", ppc_section
, 't' },
219 { "toc", ppc_toc
, 0 },
220 { "long", ppc_xcoff_cons
, 2 },
221 { "llong", ppc_xcoff_cons
, 3 },
222 { "word", ppc_xcoff_cons
, 1 },
223 { "short", ppc_xcoff_cons
, 1 },
224 { "vbyte", ppc_vbyte
, 0 },
228 { "llong", ppc_elf_cons
, 8 },
229 { "quad", ppc_elf_cons
, 8 },
230 { "long", ppc_elf_cons
, 4 },
231 { "word", ppc_elf_cons
, 2 },
232 { "short", ppc_elf_cons
, 2 },
233 { "rdata", ppc_elf_rdata
, 0 },
234 { "rodata", ppc_elf_rdata
, 0 },
235 { "lcomm", ppc_elf_lcomm
, 0 },
239 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
240 { "previous", ppc_previous
, 0 },
241 { "pdata", ppc_pdata
, 0 },
242 { "ydata", ppc_ydata
, 0 },
243 { "reldata", ppc_reldata
, 0 },
244 { "rdata", ppc_rdata
, 0 },
245 { "ualong", ppc_ualong
, 0 },
246 { "znop", ppc_znop
, 0 },
247 { "comm", ppc_pe_comm
, 0 },
248 { "lcomm", ppc_pe_comm
, 1 },
249 { "section", ppc_pe_section
, 0 },
250 { "function", ppc_pe_function
,0 },
251 { "tocd", ppc_pe_tocd
, 0 },
254 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
256 { "machine", ppc_machine
, 0 },
263 /* Predefined register names if -mregnames (or default for Windows NT).
264 In general, there are lots of them, in an attempt to be compatible
265 with a number of other Windows NT assemblers. */
267 /* Structure to hold information about predefined registers. */
274 /* List of registers that are pre-defined:
276 Each general register has predefined names of the form:
277 1. r<reg_num> which has the value <reg_num>.
278 2. r.<reg_num> which has the value <reg_num>.
280 Each floating point register has predefined names of the form:
281 1. f<reg_num> which has the value <reg_num>.
282 2. f.<reg_num> which has the value <reg_num>.
284 Each vector unit register has predefined names of the form:
285 1. v<reg_num> which has the value <reg_num>.
286 2. v.<reg_num> which has the value <reg_num>.
288 Each condition register has predefined names of the form:
289 1. cr<reg_num> which has the value <reg_num>.
290 2. cr.<reg_num> which has the value <reg_num>.
292 There are individual registers as well:
293 sp or r.sp has the value 1
294 rtoc or r.toc has the value 2
295 fpscr has the value 0
301 dsisr has the value 18
303 sdr1 has the value 25
304 srr0 has the value 26
305 srr1 has the value 27
307 The table is sorted. Suitable for searching by a binary search. */
309 static const struct pd_reg pre_defined_registers
[] =
311 { "cr.0", 0 }, /* Condition Registers */
331 { "dar", 19 }, /* Data Access Register */
332 { "dec", 22 }, /* Decrementer */
333 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
335 { "f.0", 0 }, /* Floating point registers */
362 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
428 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
469 /* Quantization registers used with pair single instructions. */
487 { "lr", 8 }, /* Link Register */
491 { "r.0", 0 }, /* General Purpose Registers */
524 { "r.sp", 1 }, /* Stack Pointer */
526 { "r.toc", 2 }, /* Pointer to the table of contents */
528 { "r0", 0 }, /* More general purpose registers */
561 { "rtoc", 2 }, /* Table of contents */
563 { "sdr1", 25 }, /* Storage Description Register 1 */
567 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
568 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
570 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
636 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
770 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
772 /* Given NAME, find the register number associated with that name, return
773 the integer value associated with the given name or -1 on failure. */
776 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
778 int middle
, low
, high
;
786 middle
= (low
+ high
) / 2;
787 cmp
= strcasecmp (name
, regs
[middle
].name
);
793 return regs
[middle
].value
;
801 * Summary of register_name.
803 * in: Input_line_pointer points to 1st char of operand.
805 * out: A expressionS.
806 * The operand may have been a register: in this case, X_op == O_register,
807 * X_add_number is set to the register number, and truth is returned.
808 * Input_line_pointer->(next non-blank) char after operand, or is in its
813 register_name (expressionS
*expressionP
)
820 /* Find the spelling of the operand. */
821 start
= name
= input_line_pointer
;
822 if (name
[0] == '%' && ISALPHA (name
[1]))
823 name
= ++input_line_pointer
;
825 else if (!reg_names_p
|| !ISALPHA (name
[0]))
828 c
= get_symbol_end ();
829 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
831 /* Put back the delimiting char. */
832 *input_line_pointer
= c
;
834 /* Look to see if it's in the register table. */
837 expressionP
->X_op
= O_register
;
838 expressionP
->X_add_number
= reg_number
;
840 /* Make the rest nice. */
841 expressionP
->X_add_symbol
= NULL
;
842 expressionP
->X_op_symbol
= NULL
;
846 /* Reset the line as if we had not done anything. */
847 input_line_pointer
= start
;
851 /* This function is called for each symbol seen in an expression. It
852 handles the special parsing which PowerPC assemblers are supposed
853 to use for condition codes. */
855 /* Whether to do the special parsing. */
856 static bfd_boolean cr_operand
;
858 /* Names to recognize in a condition code. This table is sorted. */
859 static const struct pd_reg cr_names
[] =
876 /* Parsing function. This returns non-zero if it recognized an
880 ppc_parse_name (const char *name
, expressionS
*expr
)
889 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
894 expr
->X_op
= O_constant
;
895 expr
->X_add_number
= val
;
900 /* Local variables. */
902 /* Whether to target xcoff64/elf64. */
903 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
905 /* Opcode hash table. */
906 static struct hash_control
*ppc_hash
;
908 /* Macro hash table. */
909 static struct hash_control
*ppc_macro_hash
;
912 /* What type of shared library support to use. */
913 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
915 /* Flags to set in the elf header. */
916 static flagword ppc_flags
= 0;
918 /* Whether this is Solaris or not. */
919 #ifdef TARGET_SOLARIS_COMMENT
920 #define SOLARIS_P TRUE
922 #define SOLARIS_P FALSE
925 static bfd_boolean msolaris
= SOLARIS_P
;
930 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
931 using a bunch of different sections. These assembler sections,
932 however, are all encompassed within the .text or .data sections of
933 the final output file. We handle this by using different
934 subsegments within these main segments. */
936 /* Next subsegment to allocate within the .text segment. */
937 static subsegT ppc_text_subsegment
= 2;
939 /* Linked list of csects in the text section. */
940 static symbolS
*ppc_text_csects
;
942 /* Next subsegment to allocate within the .data segment. */
943 static subsegT ppc_data_subsegment
= 2;
945 /* Linked list of csects in the data section. */
946 static symbolS
*ppc_data_csects
;
948 /* The current csect. */
949 static symbolS
*ppc_current_csect
;
951 /* The RS/6000 assembler uses a TOC which holds addresses of functions
952 and variables. Symbols are put in the TOC with the .tc pseudo-op.
953 A special relocation is used when accessing TOC entries. We handle
954 the TOC as a subsegment within the .data segment. We set it up if
955 we see a .toc pseudo-op, and save the csect symbol here. */
956 static symbolS
*ppc_toc_csect
;
958 /* The first frag in the TOC subsegment. */
959 static fragS
*ppc_toc_frag
;
961 /* The first frag in the first subsegment after the TOC in the .data
962 segment. NULL if there are no subsegments after the TOC. */
963 static fragS
*ppc_after_toc_frag
;
965 /* The current static block. */
966 static symbolS
*ppc_current_block
;
968 /* The COFF debugging section; set by md_begin. This is not the
969 .debug section, but is instead the secret BFD section which will
970 cause BFD to set the section number of a symbol to N_DEBUG. */
971 static asection
*ppc_coff_debug_section
;
973 #endif /* OBJ_XCOFF */
977 /* Various sections that we need for PE coff support. */
978 static segT ydata_section
;
979 static segT pdata_section
;
980 static segT reldata_section
;
981 static segT rdata_section
;
982 static segT tocdata_section
;
984 /* The current section and the previous section. See ppc_previous. */
985 static segT ppc_previous_section
;
986 static segT ppc_current_section
;
991 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
992 #define PPC_APUINFO_ISEL 0x40
993 #define PPC_APUINFO_PMR 0x41
994 #define PPC_APUINFO_RFMCI 0x42
995 #define PPC_APUINFO_CACHELCK 0x43
996 #define PPC_APUINFO_SPE 0x100
997 #define PPC_APUINFO_EFS 0x101
998 #define PPC_APUINFO_BRLOCK 0x102
1001 * We keep a list of APUinfo
1003 unsigned long *ppc_apuinfo_list
;
1004 unsigned int ppc_apuinfo_num
;
1005 unsigned int ppc_apuinfo_num_alloc
;
1006 #endif /* OBJ_ELF */
1009 const char *const md_shortopts
= "b:l:usm:K:VQ:";
1011 const char *const md_shortopts
= "um:";
1013 const struct option md_longopts
[] = {
1014 {NULL
, no_argument
, NULL
, 0}
1016 const size_t md_longopts_size
= sizeof (md_longopts
);
1019 md_parse_option (int c
, char *arg
)
1026 /* -u means that any undefined symbols should be treated as
1027 external, which is the default for gas anyhow. */
1032 /* Solaris as takes -le (presumably for little endian). For completeness
1033 sake, recognize -be also. */
1034 if (strcmp (arg
, "e") == 0)
1036 target_big_endian
= 0;
1037 set_target_endian
= 1;
1045 if (strcmp (arg
, "e") == 0)
1047 target_big_endian
= 1;
1048 set_target_endian
= 1;
1056 /* Recognize -K PIC. */
1057 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
1060 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1068 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1070 if (strcmp (arg
, "64") == 0)
1075 as_fatal (_("%s unsupported"), "-a64");
1078 else if (strcmp (arg
, "32") == 0)
1085 if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, arg
)) != 0)
1088 else if (strcmp (arg
, "regnames") == 0)
1091 else if (strcmp (arg
, "no-regnames") == 0)
1092 reg_names_p
= FALSE
;
1095 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1096 that require relocation. */
1097 else if (strcmp (arg
, "relocatable") == 0)
1099 shlib
= SHLIB_MRELOCATABLE
;
1100 ppc_flags
|= EF_PPC_RELOCATABLE
;
1103 else if (strcmp (arg
, "relocatable-lib") == 0)
1105 shlib
= SHLIB_MRELOCATABLE
;
1106 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1109 /* -memb, set embedded bit. */
1110 else if (strcmp (arg
, "emb") == 0)
1111 ppc_flags
|= EF_PPC_EMB
;
1113 /* -mlittle/-mbig set the endianess. */
1114 else if (strcmp (arg
, "little") == 0
1115 || strcmp (arg
, "little-endian") == 0)
1117 target_big_endian
= 0;
1118 set_target_endian
= 1;
1121 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1123 target_big_endian
= 1;
1124 set_target_endian
= 1;
1127 else if (strcmp (arg
, "solaris") == 0)
1130 ppc_comment_chars
= ppc_solaris_comment_chars
;
1133 else if (strcmp (arg
, "no-solaris") == 0)
1136 ppc_comment_chars
= ppc_eabi_comment_chars
;
1141 as_bad (_("invalid switch -m%s"), arg
);
1147 /* -V: SVR4 argument to print version ID. */
1149 print_version_id ();
1152 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1153 should be emitted or not. FIXME: Not implemented. */
1157 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1158 rather than .stabs.excl, which is ignored by the linker.
1159 FIXME: Not implemented. */
1175 md_show_usage (FILE *stream
)
1177 fprintf (stream
, _("\
1179 -a32 generate ELF32/XCOFF32\n\
1180 -a64 generate ELF64/XCOFF64\n\
1182 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1183 -mpwr generate code for POWER (RIOS1)\n\
1184 -m601 generate code for PowerPC 601\n\
1185 -mppc, -mppc32, -m603, -m604\n\
1186 generate code for PowerPC 603/604\n\
1187 -m403 generate code for PowerPC 403\n\
1188 -m405 generate code for PowerPC 405\n\
1189 -m440 generate code for PowerPC 440\n\
1190 -m464 generate code for PowerPC 464\n\
1191 -m476 generate code for PowerPC 476\n\
1192 -m7400, -m7410, -m7450, -m7455\n\
1193 generate code for PowerPC 7400/7410/7450/7455\n\
1194 -m750cl generate code for PowerPC 750cl\n"));
1195 fprintf (stream
, _("\
1196 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1197 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1198 -mbooke generate code for 32-bit PowerPC BookE\n\
1199 -ma2 generate code for A2 architecture\n\
1200 -mpower4 generate code for Power4 architecture\n\
1201 -mpower5 generate code for Power5 architecture\n\
1202 -mpower6 generate code for Power6 architecture\n\
1203 -mpower7 generate code for Power7 architecture\n\
1204 -mcell generate code for Cell Broadband Engine architecture\n\
1205 -mcom generate code Power/PowerPC common instructions\n\
1206 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1207 fprintf (stream
, _("\
1208 -maltivec generate code for AltiVec\n\
1209 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1210 -me300 generate code for PowerPC e300 family\n\
1211 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1212 -me500mc, generate code for Freescale e500mc core complex\n\
1213 -mspe generate code for Motorola SPE instructions\n\
1214 -mregnames Allow symbolic names for registers\n\
1215 -mno-regnames Do not allow symbolic names for registers\n"));
1217 fprintf (stream
, _("\
1218 -mrelocatable support for GCC's -mrelocatble option\n\
1219 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1220 -memb set PPC_EMB bit in ELF flags\n\
1221 -mlittle, -mlittle-endian, -l, -le\n\
1222 generate code for a little endian machine\n\
1223 -mbig, -mbig-endian, -b, -be\n\
1224 generate code for a big endian machine\n\
1225 -msolaris generate code for Solaris\n\
1226 -mno-solaris do not generate code for Solaris\n\
1227 -V print assembler version number\n\
1228 -Qy, -Qn ignored\n"));
1232 /* Set ppc_cpu if it is not already set. */
1237 const char *default_os
= TARGET_OS
;
1238 const char *default_cpu
= TARGET_CPU
;
1240 if ((ppc_cpu
& ~PPC_OPCODE_ANY
) == 0)
1243 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1244 else if (strncmp (default_os
, "aix", 3) == 0
1245 && default_os
[3] >= '4' && default_os
[3] <= '9')
1246 ppc_cpu
|= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1247 else if (strncmp (default_os
, "aix3", 4) == 0)
1248 ppc_cpu
|= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1249 else if (strcmp (default_cpu
, "rs6000") == 0)
1250 ppc_cpu
|= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1251 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1252 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
1254 as_fatal (_("Unknown default cpu = %s, os = %s"),
1255 default_cpu
, default_os
);
1259 /* Figure out the BFD architecture to use. This function and ppc_mach
1260 are called well before md_begin, when the output file is opened. */
1262 enum bfd_architecture
1265 const char *default_cpu
= TARGET_CPU
;
1268 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1269 return bfd_arch_powerpc
;
1270 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1271 return bfd_arch_rs6000
;
1272 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1274 if (strcmp (default_cpu
, "rs6000") == 0)
1275 return bfd_arch_rs6000
;
1276 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1277 return bfd_arch_powerpc
;
1280 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1281 return bfd_arch_unknown
;
1288 return bfd_mach_ppc64
;
1289 else if (ppc_arch () == bfd_arch_rs6000
)
1290 return bfd_mach_rs6k
;
1292 return bfd_mach_ppc
;
1296 ppc_target_format (void)
1300 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1302 return "xcoff-powermac";
1305 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1307 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1313 return "elf32-powerpc-vxworks";
1315 return (target_big_endian
1316 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1317 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1322 /* Insert opcodes and macros into hash tables. Called at startup and
1326 ppc_setup_opcodes (void)
1328 const struct powerpc_opcode
*op
;
1329 const struct powerpc_opcode
*op_end
;
1330 const struct powerpc_macro
*macro
;
1331 const struct powerpc_macro
*macro_end
;
1332 bfd_boolean bad_insn
= FALSE
;
1334 if (ppc_hash
!= NULL
)
1335 hash_die (ppc_hash
);
1336 if (ppc_macro_hash
!= NULL
)
1337 hash_die (ppc_macro_hash
);
1339 /* Insert the opcodes into a hash table. */
1340 ppc_hash
= hash_new ();
1342 if (ENABLE_CHECKING
)
1346 /* Check operand masks. Code here and in the disassembler assumes
1347 all the 1's in the mask are contiguous. */
1348 for (i
= 0; i
< num_powerpc_operands
; ++i
)
1350 unsigned long mask
= powerpc_operands
[i
].bitm
;
1351 unsigned long right_bit
;
1354 right_bit
= mask
& -mask
;
1356 right_bit
= mask
& -mask
;
1357 if (mask
!= right_bit
)
1359 as_bad (_("powerpc_operands[%d].bitm invalid"), i
);
1362 for (j
= i
+ 1; j
< num_powerpc_operands
; ++j
)
1363 if (memcmp (&powerpc_operands
[i
], &powerpc_operands
[j
],
1364 sizeof (powerpc_operands
[0])) == 0)
1366 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1373 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1374 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1376 if (ENABLE_CHECKING
)
1378 const unsigned char *o
;
1379 unsigned long omask
= op
->mask
;
1381 if (op
!= powerpc_opcodes
)
1383 /* The major opcodes had better be sorted. Code in the
1384 disassembler assumes the insns are sorted according to
1386 if (PPC_OP (op
[0].opcode
) < PPC_OP (op
[-1].opcode
))
1388 as_bad (_("major opcode is not sorted for %s"),
1393 /* Warn if the table isn't more strictly ordered.
1394 Unfortunately it doesn't seem possible to order the
1395 table on much more than the major opcode, which makes
1396 it difficult to implement a binary search in the
1397 disassembler. The problem is that we have multiple
1398 ways to disassemble instructions, and we usually want
1399 to choose a more specific form (with more bits set in
1400 the opcode) than a more general form. eg. all of the
1401 following are equivalent:
1402 bne label # opcode = 0x40820000, mask = 0xff830003
1403 bf 2,label # opcode = 0x40800000, mask = 0xff800003
1404 bc 4,2,label # opcode = 0x40000000, mask = 0xfc000003
1406 There are also cases where the table needs to be out
1407 of order to disassemble the correct instruction for
1408 processor variants. */
1411 unsigned long t1
= op
[0].opcode
;
1412 unsigned long t2
= op
[-1].opcode
;
1414 if (((t1
^ t2
) & 0xfc0007ff) == 0
1415 && (t1
& 0xfc0006df) == 0x7c000286)
1417 /* spr field is split. */
1418 t1
= ((t1
& ~0x1ff800)
1419 | ((t1
& 0xf800) << 5) | ((t1
& 0x1f0000) >> 5));
1420 t2
= ((t2
& ~0x1ff800)
1421 | ((t2
& 0xf800) << 5) | ((t2
& 0x1f0000) >> 5));
1424 as_warn (_("%s (%08lx %08lx) after %s (%08lx %08lx)"),
1425 op
[0].name
, op
[0].opcode
, op
[0].mask
,
1426 op
[-1].name
, op
[-1].opcode
, op
[-1].mask
);
1430 /* The mask had better not trim off opcode bits. */
1431 if ((op
->opcode
& omask
) != op
->opcode
)
1433 as_bad (_("mask trims opcode bits for %s"),
1438 /* The operands must not overlap the opcode or each other. */
1439 for (o
= op
->operands
; *o
; ++o
)
1440 if (*o
>= num_powerpc_operands
)
1442 as_bad (_("operand index error for %s"),
1448 const struct powerpc_operand
*operand
= &powerpc_operands
[*o
];
1449 if (operand
->shift
>= 0)
1451 unsigned long mask
= operand
->bitm
<< operand
->shift
;
1454 as_bad (_("operand %d overlap in %s"),
1455 (int) (o
- op
->operands
), op
->name
);
1463 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1464 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1465 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1466 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1467 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1468 && !(ppc_cpu
& op
->deprecated
))
1472 retval
= hash_insert (ppc_hash
, op
->name
, (void *) op
);
1475 /* Ignore Power duplicates for -m601. */
1476 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1477 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1480 as_bad (_("duplicate instruction %s"),
1487 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1488 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1489 hash_insert (ppc_hash
, op
->name
, (void *) op
);
1491 /* Insert the macros into a hash table. */
1492 ppc_macro_hash
= hash_new ();
1494 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1495 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1497 if ((macro
->flags
& ppc_cpu
) != 0)
1501 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (void *) macro
);
1502 if (retval
!= (const char *) NULL
)
1504 as_bad (_("duplicate macro %s"), macro
->name
);
1514 /* This function is called when the assembler starts up. It is called
1515 after the options have been parsed and the output file has been
1523 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1526 /* Set the ELF flags if desired. */
1527 if (ppc_flags
&& !msolaris
)
1528 bfd_set_private_flags (stdoutput
, ppc_flags
);
1531 ppc_setup_opcodes ();
1533 /* Tell the main code what the endianness is if it is not overridden
1535 if (!set_target_endian
)
1537 set_target_endian
= 1;
1538 target_big_endian
= PPC_BIG_ENDIAN
;
1542 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1544 /* Create dummy symbols to serve as initial csects. This forces the
1545 text csects to precede the data csects. These symbols will not
1547 ppc_text_csects
= symbol_make ("dummy\001");
1548 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1549 ppc_data_csects
= symbol_make ("dummy\001");
1550 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1555 ppc_current_section
= text_section
;
1556 ppc_previous_section
= 0;
1565 if (ppc_apuinfo_list
== NULL
)
1568 /* Ok, so write the section info out. We have this layout:
1572 0 8 length of "APUinfo\0"
1573 4 (n*4) number of APU's (4 bytes each)
1576 20 APU#1 first APU's info
1577 24 APU#2 second APU's info
1582 asection
*seg
= now_seg
;
1583 subsegT subseg
= now_subseg
;
1584 asection
*apuinfo_secp
= (asection
*) NULL
;
1587 /* Create the .PPC.EMB.apuinfo section. */
1588 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1589 bfd_set_section_flags (stdoutput
,
1591 SEC_HAS_CONTENTS
| SEC_READONLY
);
1594 md_number_to_chars (p
, (valueT
) 8, 4);
1597 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1600 md_number_to_chars (p
, (valueT
) 2, 4);
1603 strcpy (p
, "APUinfo");
1605 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1608 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1611 frag_align (2, 0, 0);
1613 /* We probably can't restore the current segment, for there likely
1616 subseg_set (seg
, subseg
);
1621 /* Insert an operand value into an instruction. */
1623 static unsigned long
1624 ppc_insert_operand (unsigned long insn
,
1625 const struct powerpc_operand
*operand
,
1631 long min
, max
, right
;
1633 max
= operand
->bitm
;
1637 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1639 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) == 0)
1640 max
= (max
>> 1) & -right
;
1641 min
= ~max
& -right
;
1644 if ((operand
->flags
& PPC_OPERAND_PLUS1
) != 0)
1647 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1656 /* Some people write constants with the sign extension done by
1657 hand but only up to 32 bits. This shouldn't really be valid,
1658 but, to permit this code to assemble on a 64-bit host, we
1659 sign extend the 32-bit value to 64 bits if so doing makes the
1662 && (offsetT
) (val
- 0x80000000 - 0x80000000) >= min
1663 && (offsetT
) (val
- 0x80000000 - 0x80000000) <= max
1664 && ((val
- 0x80000000 - 0x80000000) & (right
- 1)) == 0)
1665 val
= val
- 0x80000000 - 0x80000000;
1667 /* Similarly, people write expressions like ~(1<<15), and expect
1668 this to be OK for a 32-bit unsigned value. */
1670 && (offsetT
) (val
+ 0x80000000 + 0x80000000) >= min
1671 && (offsetT
) (val
+ 0x80000000 + 0x80000000) <= max
1672 && ((val
+ 0x80000000 + 0x80000000) & (right
- 1)) == 0)
1673 val
= val
+ 0x80000000 + 0x80000000;
1677 || (val
& (right
- 1)) != 0)
1678 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1681 if (operand
->insert
)
1686 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1687 if (errmsg
!= (const char *) NULL
)
1688 as_bad_where (file
, line
, "%s", errmsg
);
1691 insn
|= ((long) val
& operand
->bitm
) << operand
->shift
;
1698 /* Parse @got, etc. and return the desired relocation. */
1699 static bfd_reloc_code_real_type
1700 ppc_elf_suffix (char **str_p
, expressionS
*exp_p
)
1704 unsigned int length
: 8;
1705 unsigned int valid32
: 1;
1706 unsigned int valid64
: 1;
1715 const struct map_bfd
*ptr
;
1717 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1718 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1719 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1721 static const struct map_bfd mapping
[] = {
1722 MAP ("l", BFD_RELOC_LO16
),
1723 MAP ("h", BFD_RELOC_HI16
),
1724 MAP ("ha", BFD_RELOC_HI16_S
),
1725 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1726 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1727 MAP ("got", BFD_RELOC_16_GOTOFF
),
1728 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1729 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1730 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1731 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1732 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1733 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1734 MAP ("copy", BFD_RELOC_PPC_COPY
),
1735 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1736 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1737 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1738 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1739 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1740 MAP ("tls", BFD_RELOC_PPC_TLS
),
1741 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1742 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1743 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1744 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1745 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1746 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1747 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1748 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1749 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1750 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1751 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1752 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1753 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1754 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1755 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1756 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1757 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1758 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1759 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1760 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1761 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1762 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1763 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1764 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1765 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1766 MAP32 ("fixup", BFD_RELOC_CTOR
),
1767 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1768 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1769 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1770 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1771 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1772 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1773 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1774 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1775 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1776 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1777 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1778 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1779 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1780 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1781 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1782 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1783 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1784 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1785 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1786 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1787 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1788 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1789 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1790 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1791 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1792 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1793 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1794 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1795 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1796 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1797 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1798 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1799 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1800 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1801 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1802 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1803 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1804 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1805 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1806 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1807 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1811 return BFD_RELOC_UNUSED
;
1813 for (ch
= *str
, str2
= ident
;
1814 (str2
< ident
+ sizeof (ident
) - 1
1815 && (ISALNUM (ch
) || ch
== '@'));
1818 *str2
++ = TOLOWER (ch
);
1825 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1826 if (ch
== ptr
->string
[0]
1827 && len
== ptr
->length
1828 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1829 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1831 int reloc
= ptr
->reloc
;
1833 if (!ppc_obj64
&& exp_p
->X_add_number
!= 0)
1837 case BFD_RELOC_16_GOTOFF
:
1838 case BFD_RELOC_LO16_GOTOFF
:
1839 case BFD_RELOC_HI16_GOTOFF
:
1840 case BFD_RELOC_HI16_S_GOTOFF
:
1841 as_warn (_("identifier+constant@got means "
1842 "identifier@got+constant"));
1845 case BFD_RELOC_PPC_GOT_TLSGD16
:
1846 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
1847 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
1848 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
1849 case BFD_RELOC_PPC_GOT_TLSLD16
:
1850 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
1851 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
1852 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
1853 case BFD_RELOC_PPC_GOT_DTPREL16
:
1854 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
1855 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
1856 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
1857 case BFD_RELOC_PPC_GOT_TPREL16
:
1858 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
1859 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
1860 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
1861 as_bad (_("symbol+offset not supported for got tls"));
1866 /* Now check for identifier@suffix+constant. */
1867 if (*str
== '-' || *str
== '+')
1869 char *orig_line
= input_line_pointer
;
1870 expressionS new_exp
;
1872 input_line_pointer
= str
;
1873 expression (&new_exp
);
1874 if (new_exp
.X_op
== O_constant
)
1876 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1877 str
= input_line_pointer
;
1880 if (&input_line_pointer
!= str_p
)
1881 input_line_pointer
= orig_line
;
1885 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1886 && exp_p
->X_op
== O_symbol
1887 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
1889 /* Change the symbol so that the dummy .TOC. symbol can be
1890 omitted from the object file. */
1891 exp_p
->X_add_symbol
= &abs_symbol
;
1894 return (bfd_reloc_code_real_type
) reloc
;
1897 return BFD_RELOC_UNUSED
;
1900 /* Like normal .long/.short/.word, except support @got, etc.
1901 Clobbers input_line_pointer, checks end-of-line. */
1903 ppc_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long, 8=.llong */)
1906 bfd_reloc_code_real_type reloc
;
1908 if (is_it_end_of_statement ())
1910 demand_empty_rest_of_line ();
1917 if (exp
.X_op
== O_symbol
1918 && *input_line_pointer
== '@'
1919 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1920 &exp
)) != BFD_RELOC_UNUSED
)
1922 reloc_howto_type
*reloc_howto
;
1925 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1926 size
= bfd_get_reloc_size (reloc_howto
);
1930 as_bad (_("%s relocations do not fit in %d bytes\n"),
1931 reloc_howto
->name
, nbytes
);
1938 p
= frag_more (nbytes
);
1940 if (target_big_endian
)
1941 offset
= nbytes
- size
;
1942 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1947 emit_expr (&exp
, (unsigned int) nbytes
);
1949 while (*input_line_pointer
++ == ',');
1951 /* Put terminator back into stream. */
1952 input_line_pointer
--;
1953 demand_empty_rest_of_line ();
1956 /* Solaris pseduo op to change to the .rodata section. */
1958 ppc_elf_rdata (int xxx
)
1960 char *save_line
= input_line_pointer
;
1961 static char section
[] = ".rodata\n";
1963 /* Just pretend this is .section .rodata */
1964 input_line_pointer
= section
;
1965 obj_elf_section (xxx
);
1967 input_line_pointer
= save_line
;
1970 /* Pseudo op to make file scope bss items. */
1972 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED
)
1985 name
= input_line_pointer
;
1986 c
= get_symbol_end ();
1988 /* just after name is now '\0'. */
1989 p
= input_line_pointer
;
1992 if (*input_line_pointer
!= ',')
1994 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1995 ignore_rest_of_line ();
1999 input_line_pointer
++; /* skip ',' */
2000 if ((size
= get_absolute_expression ()) < 0)
2002 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
2003 ignore_rest_of_line ();
2007 /* The third argument to .lcomm is the alignment. */
2008 if (*input_line_pointer
!= ',')
2012 ++input_line_pointer
;
2013 align
= get_absolute_expression ();
2016 as_warn (_("ignoring bad alignment"));
2022 symbolP
= symbol_find_or_make (name
);
2025 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
2027 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2028 S_GET_NAME (symbolP
));
2029 ignore_rest_of_line ();
2033 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
2035 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2036 S_GET_NAME (symbolP
),
2037 (long) S_GET_VALUE (symbolP
),
2040 ignore_rest_of_line ();
2046 old_subsec
= now_subseg
;
2049 /* Convert to a power of 2 alignment. */
2050 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
2053 as_bad (_("Common alignment not a power of 2"));
2054 ignore_rest_of_line ();
2061 record_alignment (bss_section
, align2
);
2062 subseg_set (bss_section
, 0);
2064 frag_align (align2
, 0, 0);
2065 if (S_GET_SEGMENT (symbolP
) == bss_section
)
2066 symbol_get_frag (symbolP
)->fr_symbol
= 0;
2067 symbol_set_frag (symbolP
, frag_now
);
2068 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
2071 S_SET_SIZE (symbolP
, size
);
2072 S_SET_SEGMENT (symbolP
, bss_section
);
2073 subseg_set (old_sec
, old_subsec
);
2074 demand_empty_rest_of_line ();
2077 /* Validate any relocations emitted for -mrelocatable, possibly adding
2078 fixups for word relocations in writable segments, so we can adjust
2081 ppc_elf_validate_fix (fixS
*fixp
, segT seg
)
2083 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
2092 case SHLIB_MRELOCATABLE
:
2093 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
2094 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
2095 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
2096 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
2097 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
2098 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
2099 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
2100 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
2101 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
2102 && (seg
->flags
& SEC_LOAD
) != 0
2103 && strcmp (segment_name (seg
), ".got2") != 0
2104 && strcmp (segment_name (seg
), ".dtors") != 0
2105 && strcmp (segment_name (seg
), ".ctors") != 0
2106 && strcmp (segment_name (seg
), ".fixup") != 0
2107 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
2108 && strcmp (segment_name (seg
), ".eh_frame") != 0
2109 && strcmp (segment_name (seg
), ".ex_shared") != 0)
2111 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
2112 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
2114 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2115 _("Relocation cannot be done when using -mrelocatable"));
2122 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2123 function descriptor sym if the corresponding code sym is used. */
2126 ppc_frob_file_before_adjust (void)
2134 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2141 name
= S_GET_NAME (symp
);
2145 if (! S_IS_WEAK (symp
)
2146 || S_IS_DEFINED (symp
))
2149 len
= strlen (name
) + 1;
2150 dotname
= xmalloc (len
+ 1);
2152 memcpy (dotname
+ 1, name
, len
);
2153 dotsym
= symbol_find_noref (dotname
, 1);
2155 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
2156 || symbol_used_in_reloc_p (dotsym
)))
2157 symbol_mark_used (symp
);
2161 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
2163 && bfd_section_size (stdoutput
, toc
) > 0x10000)
2164 as_warn (_("TOC section size exceeds 64k"));
2166 /* Don't emit .TOC. symbol. */
2167 symp
= symbol_find (".TOC.");
2169 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2171 #endif /* OBJ_ELF */
2176 * Summary of parse_toc_entry.
2178 * in: Input_line_pointer points to the '[' in one of:
2180 * [toc] [tocv] [toc32] [toc64]
2182 * Anything else is an error of one kind or another.
2185 * return value: success or failure
2186 * toc_kind: kind of toc reference
2187 * input_line_pointer:
2188 * success: first char after the ']'
2189 * failure: unchanged
2193 * [toc] - rv == success, toc_kind = default_toc
2194 * [tocv] - rv == success, toc_kind = data_in_toc
2195 * [toc32] - rv == success, toc_kind = must_be_32
2196 * [toc64] - rv == success, toc_kind = must_be_64
2200 enum toc_size_qualifier
2202 default_toc
, /* The toc cell constructed should be the system default size */
2203 data_in_toc
, /* This is a direct reference to a toc cell */
2204 must_be_32
, /* The toc cell constructed must be 32 bits wide */
2205 must_be_64
/* The toc cell constructed must be 64 bits wide */
2209 parse_toc_entry (enum toc_size_qualifier
*toc_kind
)
2214 enum toc_size_qualifier t
;
2216 /* Save the input_line_pointer. */
2217 start
= input_line_pointer
;
2219 /* Skip over the '[' , and whitespace. */
2220 ++input_line_pointer
;
2223 /* Find the spelling of the operand. */
2224 toc_spec
= input_line_pointer
;
2225 c
= get_symbol_end ();
2227 if (strcmp (toc_spec
, "toc") == 0)
2231 else if (strcmp (toc_spec
, "tocv") == 0)
2235 else if (strcmp (toc_spec
, "toc32") == 0)
2239 else if (strcmp (toc_spec
, "toc64") == 0)
2245 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2246 *input_line_pointer
= c
;
2247 input_line_pointer
= start
;
2251 /* Now find the ']'. */
2252 *input_line_pointer
= c
;
2254 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2255 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2259 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2260 input_line_pointer
= start
;
2271 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2273 ppc_apuinfo_section_add (unsigned int apu
, unsigned int version
)
2277 /* Check we don't already exist. */
2278 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2279 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2282 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2284 if (ppc_apuinfo_num_alloc
== 0)
2286 ppc_apuinfo_num_alloc
= 4;
2287 ppc_apuinfo_list
= (unsigned long *)
2288 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2292 ppc_apuinfo_num_alloc
+= 4;
2293 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2294 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2297 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2303 /* We need to keep a list of fixups. We can't simply generate them as
2304 we go, because that would require us to first create the frag, and
2305 that would screw up references to ``.''. */
2311 bfd_reloc_code_real_type reloc
;
2314 #define MAX_INSN_FIXUPS (5)
2316 /* This routine is called for each instruction to be assembled. */
2319 md_assemble (char *str
)
2322 const struct powerpc_opcode
*opcode
;
2324 const unsigned char *opindex_ptr
;
2328 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2334 bfd_reloc_code_real_type reloc
;
2337 /* Get the opcode. */
2338 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2343 /* Look up the opcode in the hash table. */
2344 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2345 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2347 const struct powerpc_macro
*macro
;
2349 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2350 if (macro
== (const struct powerpc_macro
*) NULL
)
2351 as_bad (_("Unrecognized opcode: `%s'"), str
);
2353 ppc_macro (s
, macro
);
2358 insn
= opcode
->opcode
;
2361 while (ISSPACE (*str
))
2364 /* PowerPC operands are just expressions. The only real issue is
2365 that a few operand types are optional. All cases which might use
2366 an optional operand separate the operands only with commas (in some
2367 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2368 have optional operands). Most instructions with optional operands
2369 have only one. Those that have more than one optional operand can
2370 take either all their operands or none. So, before we start seriously
2371 parsing the operands, we check to see if we have optional operands,
2372 and if we do, we count the number of commas to see which operands
2373 have been omitted. */
2375 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2377 const struct powerpc_operand
*operand
;
2379 operand
= &powerpc_operands
[*opindex_ptr
];
2380 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2382 unsigned int opcount
;
2383 unsigned int num_operands_expected
;
2386 /* There is an optional operand. Count the number of
2387 commas in the input line. */
2394 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2401 /* Compute the number of expected operands.
2402 Do not count fake operands. */
2403 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2404 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2405 ++ num_operands_expected
;
2407 /* If there are fewer operands in the line then are called
2408 for by the instruction, we want to skip the optional
2410 if (opcount
< num_operands_expected
)
2417 /* Gather the operands. */
2421 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2423 const struct powerpc_operand
*operand
;
2429 if (next_opindex
== 0)
2430 operand
= &powerpc_operands
[*opindex_ptr
];
2433 operand
= &powerpc_operands
[next_opindex
];
2438 /* If this is a fake operand, then we do not expect anything
2440 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2442 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2443 if (errmsg
!= (const char *) NULL
)
2444 as_bad ("%s", errmsg
);
2448 /* If this is an optional operand, and we are skipping it, just
2450 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2453 if (operand
->insert
)
2455 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2456 if (errmsg
!= (const char *) NULL
)
2457 as_bad ("%s", errmsg
);
2459 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2460 next_opindex
= *opindex_ptr
+ 1;
2464 /* Gather the operand. */
2465 hold
= input_line_pointer
;
2466 input_line_pointer
= str
;
2469 if (*input_line_pointer
== '[')
2471 /* We are expecting something like the second argument here:
2473 * lwz r4,[toc].GS.0.static_int(rtoc)
2474 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2475 * The argument following the `]' must be a symbol name, and the
2476 * register must be the toc register: 'rtoc' or '2'
2478 * The effect is to 0 as the displacement field
2479 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2480 * the appropriate variation) reloc against it based on the symbol.
2481 * The linker will build the toc, and insert the resolved toc offset.
2484 * o The size of the toc entry is currently assumed to be
2485 * 32 bits. This should not be assumed to be a hard coded
2487 * o In an effort to cope with a change from 32 to 64 bits,
2488 * there are also toc entries that are specified to be
2489 * either 32 or 64 bits:
2490 * lwz r4,[toc32].GS.0.static_int(rtoc)
2491 * lwz r4,[toc64].GS.0.static_int(rtoc)
2492 * These demand toc entries of the specified size, and the
2493 * instruction probably requires it.
2497 enum toc_size_qualifier toc_kind
;
2498 bfd_reloc_code_real_type toc_reloc
;
2500 /* Go parse off the [tocXX] part. */
2501 valid_toc
= parse_toc_entry (&toc_kind
);
2505 /* Note: message has already been issued.
2506 FIXME: what sort of recovery should we do?
2507 demand_rest_of_line (); return; ? */
2510 /* Now get the symbol following the ']'. */
2516 /* In this case, we may not have seen the symbol yet,
2517 since it is allowed to appear on a .extern or .globl
2518 or just be a label in the .data section. */
2519 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2522 /* 1. The symbol must be defined and either in the toc
2523 section, or a global.
2524 2. The reloc generated must have the TOCDEFN flag set
2525 in upper bit mess of the reloc type.
2526 FIXME: It's a little confusing what the tocv
2527 qualifier can be used for. At the very least, I've
2528 seen three uses, only one of which I'm sure I can
2530 if (ex
.X_op
== O_symbol
)
2532 gas_assert (ex
.X_add_symbol
!= NULL
);
2533 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2536 as_bad (_("[tocv] symbol is not a toc symbol"));
2540 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2543 /* FIXME: these next two specifically specify 32/64 bit
2544 toc entries. We don't support them today. Is this
2545 the right way to say that? */
2546 toc_reloc
= BFD_RELOC_UNUSED
;
2547 as_bad (_("Unimplemented toc32 expression modifier"));
2550 /* FIXME: see above. */
2551 toc_reloc
= BFD_RELOC_UNUSED
;
2552 as_bad (_("Unimplemented toc64 expression modifier"));
2556 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2562 /* We need to generate a fixup for this expression. */
2563 if (fc
>= MAX_INSN_FIXUPS
)
2564 as_fatal (_("too many fixups"));
2566 fixups
[fc
].reloc
= toc_reloc
;
2567 fixups
[fc
].exp
= ex
;
2568 fixups
[fc
].opindex
= *opindex_ptr
;
2571 /* Ok. We've set up the fixup for the instruction. Now make it
2572 look like the constant 0 was found here. */
2574 ex
.X_op
= O_constant
;
2575 ex
.X_add_number
= 0;
2576 ex
.X_add_symbol
= NULL
;
2577 ex
.X_op_symbol
= NULL
;
2583 if ((reg_names_p
&& (operand
->flags
& PPC_OPERAND_CR
) != 0)
2584 || !register_name (&ex
))
2586 char save_lex
= lex_type
['%'];
2588 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2591 lex_type
['%'] |= LEX_BEGIN_NAME
;
2595 lex_type
['%'] = save_lex
;
2599 str
= input_line_pointer
;
2600 input_line_pointer
= hold
;
2602 if (ex
.X_op
== O_illegal
)
2603 as_bad (_("illegal operand"));
2604 else if (ex
.X_op
== O_absent
)
2605 as_bad (_("missing operand"));
2606 else if (ex
.X_op
== O_register
)
2608 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2609 ppc_cpu
, (char *) NULL
, 0);
2611 else if (ex
.X_op
== O_constant
)
2614 /* Allow @HA, @L, @H on constants. */
2615 char *orig_str
= str
;
2617 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2624 case BFD_RELOC_LO16
:
2625 /* X_unsigned is the default, so if the user has done
2626 something which cleared it, we always produce a
2628 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2629 ex
.X_add_number
&= 0xffff;
2631 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2634 case BFD_RELOC_HI16
:
2635 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2636 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2638 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2641 case BFD_RELOC_HI16_S
:
2642 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2643 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2645 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2648 case BFD_RELOC_PPC64_HIGHER
:
2649 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2650 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2652 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2655 case BFD_RELOC_PPC64_HIGHER_S
:
2656 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2657 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2659 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2662 case BFD_RELOC_PPC64_HIGHEST
:
2663 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2664 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2666 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2669 case BFD_RELOC_PPC64_HIGHEST_S
:
2670 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2671 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2673 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2676 #endif /* OBJ_ELF */
2677 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2678 ppc_cpu
, (char *) NULL
, 0);
2683 if (ex
.X_op
== O_symbol
&& str
[0] == '(')
2685 const char *sym_name
= S_GET_NAME (ex
.X_add_symbol
);
2686 if (sym_name
[0] == '.')
2689 if (strcasecmp (sym_name
, "__tls_get_addr") == 0)
2691 expressionS tls_exp
;
2693 hold
= input_line_pointer
;
2694 input_line_pointer
= str
+ 1;
2695 expression (&tls_exp
);
2696 if (tls_exp
.X_op
== O_symbol
)
2698 reloc
= BFD_RELOC_UNUSED
;
2699 if (strncasecmp (input_line_pointer
, "@tlsgd)", 7) == 0)
2701 reloc
= BFD_RELOC_PPC_TLSGD
;
2702 input_line_pointer
+= 7;
2704 else if (strncasecmp (input_line_pointer
, "@tlsld)", 7) == 0)
2706 reloc
= BFD_RELOC_PPC_TLSLD
;
2707 input_line_pointer
+= 7;
2709 if (reloc
!= BFD_RELOC_UNUSED
)
2712 str
= input_line_pointer
;
2714 if (fc
>= MAX_INSN_FIXUPS
)
2715 as_fatal (_("too many fixups"));
2716 fixups
[fc
].exp
= tls_exp
;
2717 fixups
[fc
].opindex
= *opindex_ptr
;
2718 fixups
[fc
].reloc
= reloc
;
2722 input_line_pointer
= hold
;
2726 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2728 /* Some TLS tweaks. */
2734 case BFD_RELOC_PPC_TLS
:
2735 insn
= ppc_insert_operand (insn
, operand
, ppc_obj64
? 13 : 2,
2736 ppc_cpu
, (char *) NULL
, 0);
2739 /* We'll only use the 32 (or 64) bit form of these relocations
2740 in constants. Instructions get the 16 bit form. */
2741 case BFD_RELOC_PPC_DTPREL
:
2742 reloc
= BFD_RELOC_PPC_DTPREL16
;
2744 case BFD_RELOC_PPC_TPREL
:
2745 reloc
= BFD_RELOC_PPC_TPREL16
;
2749 /* For the absolute forms of branches, convert the PC
2750 relative form back into the absolute. */
2751 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2755 case BFD_RELOC_PPC_B26
:
2756 reloc
= BFD_RELOC_PPC_BA26
;
2758 case BFD_RELOC_PPC_B16
:
2759 reloc
= BFD_RELOC_PPC_BA16
;
2761 case BFD_RELOC_PPC_B16_BRTAKEN
:
2762 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2764 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2765 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2773 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
2778 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2780 case BFD_RELOC_LO16
:
2781 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2783 case BFD_RELOC_16_GOTOFF
:
2784 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2786 case BFD_RELOC_LO16_GOTOFF
:
2787 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2789 case BFD_RELOC_LO16_PLTOFF
:
2790 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2792 case BFD_RELOC_16_BASEREL
:
2793 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2795 case BFD_RELOC_LO16_BASEREL
:
2796 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2798 case BFD_RELOC_PPC_TOC16
:
2799 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2801 case BFD_RELOC_PPC64_TOC16_LO
:
2802 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2804 case BFD_RELOC_PPC64_PLTGOT16
:
2805 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2807 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2808 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2810 case BFD_RELOC_PPC_DTPREL16
:
2811 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2813 case BFD_RELOC_PPC_DTPREL16_LO
:
2814 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2816 case BFD_RELOC_PPC_TPREL16
:
2817 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2819 case BFD_RELOC_PPC_TPREL16_LO
:
2820 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2822 case BFD_RELOC_PPC_GOT_DTPREL16
:
2823 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2824 case BFD_RELOC_PPC_GOT_TPREL16
:
2825 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2828 as_bad (_("unsupported relocation for DS offset field"));
2834 /* We need to generate a fixup for this expression. */
2835 if (fc
>= MAX_INSN_FIXUPS
)
2836 as_fatal (_("too many fixups"));
2837 fixups
[fc
].exp
= ex
;
2838 fixups
[fc
].opindex
= *opindex_ptr
;
2839 fixups
[fc
].reloc
= reloc
;
2845 /* We need to generate a fixup for this expression. */
2846 if (fc
>= MAX_INSN_FIXUPS
)
2847 as_fatal (_("too many fixups"));
2848 fixups
[fc
].exp
= ex
;
2849 fixups
[fc
].opindex
= *opindex_ptr
;
2850 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2853 #endif /* OBJ_ELF */
2859 /* If expecting more operands, then we want to see "),". */
2860 if (*str
== endc
&& opindex_ptr
[1] != 0)
2864 while (ISSPACE (*str
));
2868 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2876 /* The call to expression should have advanced str past any
2879 && (endc
!= ',' || *str
!= '\0'))
2881 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2889 while (ISSPACE (*str
))
2893 as_bad (_("junk at end of line: `%s'"), str
);
2896 /* Do we need/want a APUinfo section? */
2897 if ((ppc_cpu
& PPC_OPCODE_E500MC
) != 0)
2899 /* These are all version "1". */
2900 if (opcode
->flags
& PPC_OPCODE_SPE
)
2901 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2902 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2903 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2904 if (opcode
->flags
& PPC_OPCODE_EFS
)
2905 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2906 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2907 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2908 if (opcode
->flags
& PPC_OPCODE_PMR
)
2909 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2910 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2911 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2912 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2913 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2917 /* Write out the instruction. */
2919 addr_mod
= frag_now_fix () & 3;
2920 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
2921 as_bad (_("instruction address is not a multiple of 4"));
2922 frag_now
->insn_addr
= addr_mod
;
2923 frag_now
->has_code
= 1;
2924 md_number_to_chars (f
, insn
, 4);
2927 dwarf2_emit_insn (4);
2930 /* Create any fixups. At this point we do not use a
2931 bfd_reloc_code_real_type, but instead just use the
2932 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2933 handle fixups for any operand type, although that is admittedly
2934 not a very exciting feature. We pick a BFD reloc type in
2936 for (i
= 0; i
< fc
; i
++)
2938 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2940 reloc_howto_type
*reloc_howto
;
2945 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2949 size
= bfd_get_reloc_size (reloc_howto
);
2950 offset
= target_big_endian
? (4 - size
) : 0;
2952 if (size
< 1 || size
> 4)
2955 fixP
= fix_new_exp (frag_now
,
2956 f
- frag_now
->fr_literal
+ offset
,
2959 reloc_howto
->pc_relative
,
2962 /* Turn off complaints that the addend is too large for things like
2964 switch (fixups
[i
].reloc
)
2966 case BFD_RELOC_16_GOTOFF
:
2967 case BFD_RELOC_PPC_TOC16
:
2968 case BFD_RELOC_LO16
:
2969 case BFD_RELOC_HI16
:
2970 case BFD_RELOC_HI16_S
:
2972 case BFD_RELOC_PPC64_HIGHER
:
2973 case BFD_RELOC_PPC64_HIGHER_S
:
2974 case BFD_RELOC_PPC64_HIGHEST
:
2975 case BFD_RELOC_PPC64_HIGHEST_S
:
2977 fixP
->fx_no_overflow
= 1;
2985 const struct powerpc_operand
*operand
;
2987 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2988 fix_new_exp (frag_now
,
2989 f
- frag_now
->fr_literal
,
2992 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2993 ((bfd_reloc_code_real_type
)
2994 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2999 /* Handle a macro. Gather all the operands, transform them as
3000 described by the macro, and call md_assemble recursively. All the
3001 operands are separated by commas; we don't accept parentheses
3002 around operands here. */
3005 ppc_macro (char *str
, const struct powerpc_macro
*macro
)
3016 /* Gather the users operands into the operands array. */
3021 if (count
>= sizeof operands
/ sizeof operands
[0])
3023 operands
[count
++] = s
;
3024 s
= strchr (s
, ',');
3025 if (s
== (char *) NULL
)
3030 if (count
!= macro
->operands
)
3032 as_bad (_("wrong number of operands"));
3036 /* Work out how large the string must be (the size is unbounded
3037 because it includes user input). */
3039 format
= macro
->format
;
3040 while (*format
!= '\0')
3049 arg
= strtol (format
+ 1, &send
, 10);
3050 know (send
!= format
&& arg
< count
);
3051 len
+= strlen (operands
[arg
]);
3056 /* Put the string together. */
3057 complete
= s
= (char *) alloca (len
+ 1);
3058 format
= macro
->format
;
3059 while (*format
!= '\0')
3065 arg
= strtol (format
+ 1, &send
, 10);
3066 strcpy (s
, operands
[arg
]);
3073 /* Assemble the constructed instruction. */
3074 md_assemble (complete
);
3078 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
3081 ppc_section_letter (int letter
, char **ptr_msg
)
3086 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
3091 ppc_section_word (char *str
, size_t len
)
3093 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
3100 ppc_section_type (char *str
, size_t len
)
3102 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
3109 ppc_section_flags (flagword flags
, bfd_vma attr
, int type
)
3111 if (type
== SHT_ORDERED
)
3112 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
3114 if (attr
& SHF_EXCLUDE
)
3115 flags
|= SEC_EXCLUDE
;
3119 #endif /* OBJ_ELF */
3122 /* Pseudo-op handling. */
3124 /* The .byte pseudo-op. This is similar to the normal .byte
3125 pseudo-op, but it can also take a single ASCII string. */
3128 ppc_byte (int ignore ATTRIBUTE_UNUSED
)
3130 if (*input_line_pointer
!= '\"')
3136 /* Gather characters. A real double quote is doubled. Unusual
3137 characters are not permitted. */
3138 ++input_line_pointer
;
3143 c
= *input_line_pointer
++;
3147 if (*input_line_pointer
!= '\"')
3149 ++input_line_pointer
;
3152 FRAG_APPEND_1_CHAR (c
);
3155 demand_empty_rest_of_line ();
3160 /* XCOFF specific pseudo-op handling. */
3162 /* This is set if we are creating a .stabx symbol, since we don't want
3163 to handle symbol suffixes for such symbols. */
3164 static bfd_boolean ppc_stab_symbol
;
3166 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3167 symbols in the .bss segment as though they were local common
3168 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3169 aligns .comm and .lcomm to 4 bytes. */
3172 ppc_comm (int lcomm
)
3174 asection
*current_seg
= now_seg
;
3175 subsegT current_subseg
= now_subseg
;
3181 symbolS
*lcomm_sym
= NULL
;
3185 name
= input_line_pointer
;
3186 endc
= get_symbol_end ();
3187 end_name
= input_line_pointer
;
3190 if (*input_line_pointer
!= ',')
3192 as_bad (_("missing size"));
3193 ignore_rest_of_line ();
3196 ++input_line_pointer
;
3198 size
= get_absolute_expression ();
3201 as_bad (_("negative size"));
3202 ignore_rest_of_line ();
3208 /* The third argument to .comm is the alignment. */
3209 if (*input_line_pointer
!= ',')
3213 ++input_line_pointer
;
3214 align
= get_absolute_expression ();
3217 as_warn (_("ignoring bad alignment"));
3232 /* The third argument to .lcomm appears to be the real local
3233 common symbol to create. References to the symbol named in
3234 the first argument are turned into references to the third
3236 if (*input_line_pointer
!= ',')
3238 as_bad (_("missing real symbol name"));
3239 ignore_rest_of_line ();
3242 ++input_line_pointer
;
3244 lcomm_name
= input_line_pointer
;
3245 lcomm_endc
= get_symbol_end ();
3247 lcomm_sym
= symbol_find_or_make (lcomm_name
);
3249 *input_line_pointer
= lcomm_endc
;
3253 sym
= symbol_find_or_make (name
);
3256 if (S_IS_DEFINED (sym
)
3257 || S_GET_VALUE (sym
) != 0)
3259 as_bad (_("attempt to redefine symbol"));
3260 ignore_rest_of_line ();
3264 record_alignment (bss_section
, align
);
3267 || ! S_IS_DEFINED (lcomm_sym
))
3276 S_SET_EXTERNAL (sym
);
3280 symbol_get_tc (lcomm_sym
)->output
= 1;
3281 def_sym
= lcomm_sym
;
3285 subseg_set (bss_section
, 1);
3286 frag_align (align
, 0, 0);
3288 symbol_set_frag (def_sym
, frag_now
);
3289 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3290 def_size
, (char *) NULL
);
3292 S_SET_SEGMENT (def_sym
, bss_section
);
3293 symbol_get_tc (def_sym
)->align
= align
;
3297 /* Align the size of lcomm_sym. */
3298 symbol_get_frag (lcomm_sym
)->fr_offset
=
3299 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3300 &~ ((1 << align
) - 1));
3301 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3302 symbol_get_tc (lcomm_sym
)->align
= align
;
3307 /* Make sym an offset from lcomm_sym. */
3308 S_SET_SEGMENT (sym
, bss_section
);
3309 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3310 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3311 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3314 subseg_set (current_seg
, current_subseg
);
3316 demand_empty_rest_of_line ();
3319 /* The .csect pseudo-op. This switches us into a different
3320 subsegment. The first argument is a symbol whose value is the
3321 start of the .csect. In COFF, csect symbols get special aux
3322 entries defined by the x_csect field of union internal_auxent. The
3323 optional second argument is the alignment (the default is 2). */
3326 ppc_csect (int ignore ATTRIBUTE_UNUSED
)
3333 name
= input_line_pointer
;
3334 endc
= get_symbol_end ();
3336 sym
= symbol_find_or_make (name
);
3338 *input_line_pointer
= endc
;
3340 if (S_GET_NAME (sym
)[0] == '\0')
3342 /* An unnamed csect is assumed to be [PR]. */
3343 symbol_get_tc (sym
)->symbol_class
= XMC_PR
;
3347 if (*input_line_pointer
== ',')
3349 ++input_line_pointer
;
3350 align
= get_absolute_expression ();
3353 ppc_change_csect (sym
, align
);
3355 demand_empty_rest_of_line ();
3358 /* Change to a different csect. */
3361 ppc_change_csect (symbolS
*sym
, offsetT align
)
3363 if (S_IS_DEFINED (sym
))
3364 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3374 /* This is a new csect. We need to look at the symbol class to
3375 figure out whether it should go in the text section or the
3379 switch (symbol_get_tc (sym
)->symbol_class
)
3389 S_SET_SEGMENT (sym
, text_section
);
3390 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3391 ++ppc_text_subsegment
;
3392 list_ptr
= &ppc_text_csects
;
3402 if (ppc_toc_csect
!= NULL
3403 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3404 == ppc_data_subsegment
))
3406 S_SET_SEGMENT (sym
, data_section
);
3407 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3408 ++ppc_data_subsegment
;
3409 list_ptr
= &ppc_data_csects
;
3415 /* We set the obstack chunk size to a small value before
3416 changing subsegments, so that we don't use a lot of memory
3417 space for what may be a small section. */
3418 hold_chunksize
= chunksize
;
3421 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3422 symbol_get_tc (sym
)->subseg
);
3424 chunksize
= hold_chunksize
;
3427 ppc_after_toc_frag
= frag_now
;
3429 record_alignment (sec
, align
);
3431 frag_align_code (align
, 0);
3433 frag_align (align
, 0, 0);
3435 symbol_set_frag (sym
, frag_now
);
3436 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3438 symbol_get_tc (sym
)->align
= align
;
3439 symbol_get_tc (sym
)->output
= 1;
3440 symbol_get_tc (sym
)->within
= sym
;
3442 for (list
= *list_ptr
;
3443 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3444 list
= symbol_get_tc (list
)->next
)
3446 symbol_get_tc (list
)->next
= sym
;
3448 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3449 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3453 ppc_current_csect
= sym
;
3456 /* This function handles the .text and .data pseudo-ops. These
3457 pseudo-ops aren't really used by XCOFF; we implement them for the
3458 convenience of people who aren't used to XCOFF. */
3461 ppc_section (int type
)
3468 else if (type
== 'd')
3473 sym
= symbol_find_or_make (name
);
3475 ppc_change_csect (sym
, 2);
3477 demand_empty_rest_of_line ();
3480 /* This function handles the .section pseudo-op. This is mostly to
3481 give an error, since XCOFF only supports .text, .data and .bss, but
3482 we do permit the user to name the text or data section. */
3485 ppc_named_section (int ignore ATTRIBUTE_UNUSED
)
3488 const char *real_name
;
3492 user_name
= input_line_pointer
;
3493 c
= get_symbol_end ();
3495 if (strcmp (user_name
, ".text") == 0)
3496 real_name
= ".text[PR]";
3497 else if (strcmp (user_name
, ".data") == 0)
3498 real_name
= ".data[RW]";
3501 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3502 *input_line_pointer
= c
;
3503 ignore_rest_of_line ();
3507 *input_line_pointer
= c
;
3509 sym
= symbol_find_or_make (real_name
);
3511 ppc_change_csect (sym
, 2);
3513 demand_empty_rest_of_line ();
3516 /* The .extern pseudo-op. We create an undefined symbol. */
3519 ppc_extern (int ignore ATTRIBUTE_UNUSED
)
3524 name
= input_line_pointer
;
3525 endc
= get_symbol_end ();
3527 (void) symbol_find_or_make (name
);
3529 *input_line_pointer
= endc
;
3531 demand_empty_rest_of_line ();
3534 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3537 ppc_lglobl (int ignore ATTRIBUTE_UNUSED
)
3543 name
= input_line_pointer
;
3544 endc
= get_symbol_end ();
3546 sym
= symbol_find_or_make (name
);
3548 *input_line_pointer
= endc
;
3550 symbol_get_tc (sym
)->output
= 1;
3552 demand_empty_rest_of_line ();
3555 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3556 although I don't know why it bothers. */
3559 ppc_rename (int ignore ATTRIBUTE_UNUSED
)
3566 name
= input_line_pointer
;
3567 endc
= get_symbol_end ();
3569 sym
= symbol_find_or_make (name
);
3571 *input_line_pointer
= endc
;
3573 if (*input_line_pointer
!= ',')
3575 as_bad (_("missing rename string"));
3576 ignore_rest_of_line ();
3579 ++input_line_pointer
;
3581 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3583 demand_empty_rest_of_line ();
3586 /* The .stabx pseudo-op. This is similar to a normal .stabs
3587 pseudo-op, but slightly different. A sample is
3588 .stabx "main:F-1",.main,142,0
3589 The first argument is the symbol name to create. The second is the
3590 value, and the third is the storage class. The fourth seems to be
3591 always zero, and I am assuming it is the type. */
3594 ppc_stabx (int ignore ATTRIBUTE_UNUSED
)
3601 name
= demand_copy_C_string (&len
);
3603 if (*input_line_pointer
!= ',')
3605 as_bad (_("missing value"));
3608 ++input_line_pointer
;
3610 ppc_stab_symbol
= TRUE
;
3611 sym
= symbol_make (name
);
3612 ppc_stab_symbol
= FALSE
;
3614 symbol_get_tc (sym
)->real_name
= name
;
3616 (void) expression (&exp
);
3623 as_bad (_("illegal .stabx expression; zero assumed"));
3624 exp
.X_add_number
= 0;
3627 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3628 symbol_set_frag (sym
, &zero_address_frag
);
3632 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3633 symbol_set_value_expression (sym
, &exp
);
3637 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3638 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3643 /* The value is some complex expression. This will probably
3644 fail at some later point, but this is probably the right
3645 thing to do here. */
3646 symbol_set_value_expression (sym
, &exp
);
3650 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3651 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3653 if (*input_line_pointer
!= ',')
3655 as_bad (_("missing class"));
3658 ++input_line_pointer
;
3660 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3662 if (*input_line_pointer
!= ',')
3664 as_bad (_("missing type"));
3667 ++input_line_pointer
;
3669 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3671 symbol_get_tc (sym
)->output
= 1;
3673 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3675 symbol_get_tc (sym
)->within
= ppc_current_block
;
3680 .stabx "z",arrays_,133,0
3683 .comm arrays_,13768,3
3685 resolve_symbol_value will copy the exp's "within" into sym's when the
3686 offset is 0. Since this seems to be corner case problem,
3687 only do the correction for storage class C_STSYM. A better solution
3688 would be to have the tc field updated in ppc_symbol_new_hook. */
3690 if (exp
.X_op
== O_symbol
)
3692 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3696 if (exp
.X_op
!= O_symbol
3697 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3698 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3699 ppc_frob_label (sym
);
3702 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3703 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3704 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3705 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3708 demand_empty_rest_of_line ();
3711 /* The .function pseudo-op. This takes several arguments. The first
3712 argument seems to be the external name of the symbol. The second
3713 argument seems to be the label for the start of the function. gcc
3714 uses the same name for both. I have no idea what the third and
3715 fourth arguments are meant to be. The optional fifth argument is
3716 an expression for the size of the function. In COFF this symbol
3717 gets an aux entry like that used for a csect. */
3720 ppc_function (int ignore ATTRIBUTE_UNUSED
)
3728 name
= input_line_pointer
;
3729 endc
= get_symbol_end ();
3731 /* Ignore any [PR] suffix. */
3732 name
= ppc_canonicalize_symbol_name (name
);
3733 s
= strchr (name
, '[');
3734 if (s
!= (char *) NULL
3735 && strcmp (s
+ 1, "PR]") == 0)
3738 ext_sym
= symbol_find_or_make (name
);
3740 *input_line_pointer
= endc
;
3742 if (*input_line_pointer
!= ',')
3744 as_bad (_("missing symbol name"));
3745 ignore_rest_of_line ();
3748 ++input_line_pointer
;
3750 name
= input_line_pointer
;
3751 endc
= get_symbol_end ();
3753 lab_sym
= symbol_find_or_make (name
);
3755 *input_line_pointer
= endc
;
3757 if (ext_sym
!= lab_sym
)
3761 exp
.X_op
= O_symbol
;
3762 exp
.X_add_symbol
= lab_sym
;
3763 exp
.X_op_symbol
= NULL
;
3764 exp
.X_add_number
= 0;
3766 symbol_set_value_expression (ext_sym
, &exp
);
3769 if (symbol_get_tc (ext_sym
)->symbol_class
== -1)
3770 symbol_get_tc (ext_sym
)->symbol_class
= XMC_PR
;
3771 symbol_get_tc (ext_sym
)->output
= 1;
3773 if (*input_line_pointer
== ',')
3777 /* Ignore the third argument. */
3778 ++input_line_pointer
;
3779 expression (&ignore
);
3780 if (*input_line_pointer
== ',')
3782 /* Ignore the fourth argument. */
3783 ++input_line_pointer
;
3784 expression (&ignore
);
3785 if (*input_line_pointer
== ',')
3787 /* The fifth argument is the function size. */
3788 ++input_line_pointer
;
3789 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3792 &zero_address_frag
);
3793 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3798 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3799 SF_SET_FUNCTION (ext_sym
);
3800 SF_SET_PROCESS (ext_sym
);
3801 coff_add_linesym (ext_sym
);
3803 demand_empty_rest_of_line ();
3806 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3807 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3808 with the correct line number */
3810 static symbolS
*saved_bi_sym
= 0;
3813 ppc_bf (int ignore ATTRIBUTE_UNUSED
)
3817 sym
= symbol_make (".bf");
3818 S_SET_SEGMENT (sym
, text_section
);
3819 symbol_set_frag (sym
, frag_now
);
3820 S_SET_VALUE (sym
, frag_now_fix ());
3821 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3823 coff_line_base
= get_absolute_expression ();
3825 S_SET_NUMBER_AUXILIARY (sym
, 1);
3826 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3828 /* Line number for bi. */
3831 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3836 symbol_get_tc (sym
)->output
= 1;
3838 ppc_frob_label (sym
);
3840 demand_empty_rest_of_line ();
3843 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3844 ".ef", except that the line number is absolute, not relative to the
3845 most recent ".bf" symbol. */
3848 ppc_ef (int ignore ATTRIBUTE_UNUSED
)
3852 sym
= symbol_make (".ef");
3853 S_SET_SEGMENT (sym
, text_section
);
3854 symbol_set_frag (sym
, frag_now
);
3855 S_SET_VALUE (sym
, frag_now_fix ());
3856 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3857 S_SET_NUMBER_AUXILIARY (sym
, 1);
3858 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3859 symbol_get_tc (sym
)->output
= 1;
3861 ppc_frob_label (sym
);
3863 demand_empty_rest_of_line ();
3866 /* The .bi and .ei pseudo-ops. These take a string argument and
3867 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3868 the symbol list. The value of .bi will be know when the next .bf
3874 static symbolS
*last_biei
;
3881 name
= demand_copy_C_string (&len
);
3883 /* The value of these symbols is actually file offset. Here we set
3884 the value to the index into the line number entries. In
3885 ppc_frob_symbols we set the fix_line field, which will cause BFD
3886 to do the right thing. */
3888 sym
= symbol_make (name
);
3889 /* obj-coff.c currently only handles line numbers correctly in the
3891 S_SET_SEGMENT (sym
, text_section
);
3892 S_SET_VALUE (sym
, coff_n_line_nos
);
3893 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3895 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3896 symbol_get_tc (sym
)->output
= 1;
3904 for (look
= last_biei
? last_biei
: symbol_rootP
;
3905 (look
!= (symbolS
*) NULL
3906 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3907 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3908 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3909 look
= symbol_next (look
))
3911 if (look
!= (symbolS
*) NULL
)
3913 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3914 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3918 demand_empty_rest_of_line ();
3921 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3922 There is one argument, which is a csect symbol. The value of the
3923 .bs symbol is the index of this csect symbol. */
3926 ppc_bs (int ignore ATTRIBUTE_UNUSED
)
3933 if (ppc_current_block
!= NULL
)
3934 as_bad (_("nested .bs blocks"));
3936 name
= input_line_pointer
;
3937 endc
= get_symbol_end ();
3939 csect
= symbol_find_or_make (name
);
3941 *input_line_pointer
= endc
;
3943 sym
= symbol_make (".bs");
3944 S_SET_SEGMENT (sym
, now_seg
);
3945 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3946 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3947 symbol_get_tc (sym
)->output
= 1;
3949 symbol_get_tc (sym
)->within
= csect
;
3951 ppc_frob_label (sym
);
3953 ppc_current_block
= sym
;
3955 demand_empty_rest_of_line ();
3958 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3961 ppc_es (int ignore ATTRIBUTE_UNUSED
)
3965 if (ppc_current_block
== NULL
)
3966 as_bad (_(".es without preceding .bs"));
3968 sym
= symbol_make (".es");
3969 S_SET_SEGMENT (sym
, now_seg
);
3970 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3971 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3972 symbol_get_tc (sym
)->output
= 1;
3974 ppc_frob_label (sym
);
3976 ppc_current_block
= NULL
;
3978 demand_empty_rest_of_line ();
3981 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3985 ppc_bb (int ignore ATTRIBUTE_UNUSED
)
3989 sym
= symbol_make (".bb");
3990 S_SET_SEGMENT (sym
, text_section
);
3991 symbol_set_frag (sym
, frag_now
);
3992 S_SET_VALUE (sym
, frag_now_fix ());
3993 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3995 S_SET_NUMBER_AUXILIARY (sym
, 1);
3996 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3998 symbol_get_tc (sym
)->output
= 1;
4000 SF_SET_PROCESS (sym
);
4002 ppc_frob_label (sym
);
4004 demand_empty_rest_of_line ();
4007 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4011 ppc_eb (int ignore ATTRIBUTE_UNUSED
)
4015 sym
= symbol_make (".eb");
4016 S_SET_SEGMENT (sym
, text_section
);
4017 symbol_set_frag (sym
, frag_now
);
4018 S_SET_VALUE (sym
, frag_now_fix ());
4019 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
4020 S_SET_NUMBER_AUXILIARY (sym
, 1);
4021 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
4022 symbol_get_tc (sym
)->output
= 1;
4024 SF_SET_PROCESS (sym
);
4026 ppc_frob_label (sym
);
4028 demand_empty_rest_of_line ();
4031 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4035 ppc_bc (int ignore ATTRIBUTE_UNUSED
)
4041 name
= demand_copy_C_string (&len
);
4042 sym
= symbol_make (name
);
4043 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4044 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4045 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
4046 S_SET_VALUE (sym
, 0);
4047 symbol_get_tc (sym
)->output
= 1;
4049 ppc_frob_label (sym
);
4051 demand_empty_rest_of_line ();
4054 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4057 ppc_ec (int ignore ATTRIBUTE_UNUSED
)
4061 sym
= symbol_make (".ec");
4062 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
4063 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
4064 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
4065 S_SET_VALUE (sym
, 0);
4066 symbol_get_tc (sym
)->output
= 1;
4068 ppc_frob_label (sym
);
4070 demand_empty_rest_of_line ();
4073 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4076 ppc_toc (int ignore ATTRIBUTE_UNUSED
)
4078 if (ppc_toc_csect
!= (symbolS
*) NULL
)
4079 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
4086 subseg
= ppc_data_subsegment
;
4087 ++ppc_data_subsegment
;
4089 subseg_new (segment_name (data_section
), subseg
);
4090 ppc_toc_frag
= frag_now
;
4092 sym
= symbol_find_or_make ("TOC[TC0]");
4093 symbol_set_frag (sym
, frag_now
);
4094 S_SET_SEGMENT (sym
, data_section
);
4095 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4096 symbol_get_tc (sym
)->subseg
= subseg
;
4097 symbol_get_tc (sym
)->output
= 1;
4098 symbol_get_tc (sym
)->within
= sym
;
4100 ppc_toc_csect
= sym
;
4102 for (list
= ppc_data_csects
;
4103 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
4104 list
= symbol_get_tc (list
)->next
)
4106 symbol_get_tc (list
)->next
= sym
;
4108 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4109 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
4113 ppc_current_csect
= ppc_toc_csect
;
4115 demand_empty_rest_of_line ();
4118 /* The AIX assembler automatically aligns the operands of a .long or
4119 .short pseudo-op, and we want to be compatible. */
4122 ppc_xcoff_cons (int log_size
)
4124 frag_align (log_size
, 0, 0);
4125 record_alignment (now_seg
, log_size
);
4126 cons (1 << log_size
);
4130 ppc_vbyte (int dummy ATTRIBUTE_UNUSED
)
4135 (void) expression (&exp
);
4137 if (exp
.X_op
!= O_constant
)
4139 as_bad (_("non-constant byte count"));
4143 byte_count
= exp
.X_add_number
;
4145 if (*input_line_pointer
!= ',')
4147 as_bad (_("missing value"));
4151 ++input_line_pointer
;
4155 #endif /* OBJ_XCOFF */
4156 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4158 /* The .tc pseudo-op. This is used when generating either XCOFF or
4159 ELF. This takes two or more arguments.
4161 When generating XCOFF output, the first argument is the name to
4162 give to this location in the toc; this will be a symbol with class
4163 TC. The rest of the arguments are N-byte values to actually put at
4164 this location in the TOC; often there is just one more argument, a
4165 relocatable symbol reference. The size of the value to store
4166 depends on target word size. A 32-bit target uses 4-byte values, a
4167 64-bit target uses 8-byte values.
4169 When not generating XCOFF output, the arguments are the same, but
4170 the first argument is simply ignored. */
4173 ppc_tc (int ignore ATTRIBUTE_UNUSED
)
4177 /* Define the TOC symbol name. */
4183 if (ppc_toc_csect
== (symbolS
*) NULL
4184 || ppc_toc_csect
!= ppc_current_csect
)
4186 as_bad (_(".tc not in .toc section"));
4187 ignore_rest_of_line ();
4191 name
= input_line_pointer
;
4192 endc
= get_symbol_end ();
4194 sym
= symbol_find_or_make (name
);
4196 *input_line_pointer
= endc
;
4198 if (S_IS_DEFINED (sym
))
4202 label
= symbol_get_tc (ppc_current_csect
)->within
;
4203 if (symbol_get_tc (label
)->symbol_class
!= XMC_TC0
)
4205 as_bad (_(".tc with no label"));
4206 ignore_rest_of_line ();
4210 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
4211 symbol_set_frag (label
, symbol_get_frag (sym
));
4212 S_SET_VALUE (label
, S_GET_VALUE (sym
));
4214 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4215 ++input_line_pointer
;
4220 S_SET_SEGMENT (sym
, now_seg
);
4221 symbol_set_frag (sym
, frag_now
);
4222 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
4223 symbol_get_tc (sym
)->symbol_class
= XMC_TC
;
4224 symbol_get_tc (sym
)->output
= 1;
4226 ppc_frob_label (sym
);
4229 #endif /* OBJ_XCOFF */
4233 /* Skip the TOC symbol name. */
4234 while (is_part_of_name (*input_line_pointer
)
4235 || *input_line_pointer
== ' '
4236 || *input_line_pointer
== '['
4237 || *input_line_pointer
== ']'
4238 || *input_line_pointer
== '{'
4239 || *input_line_pointer
== '}')
4240 ++input_line_pointer
;
4242 /* Align to a four/eight byte boundary. */
4243 align
= ppc_obj64
? 3 : 2;
4244 frag_align (align
, 0, 0);
4245 record_alignment (now_seg
, align
);
4246 #endif /* OBJ_ELF */
4248 if (*input_line_pointer
!= ',')
4249 demand_empty_rest_of_line ();
4252 ++input_line_pointer
;
4253 cons (ppc_obj64
? 8 : 4);
4257 /* Pseudo-op .machine. */
4260 ppc_machine (int ignore ATTRIBUTE_UNUSED
)
4263 #define MAX_HISTORY 100
4264 static ppc_cpu_t
*cpu_history
;
4265 static int curr_hist
;
4269 if (*input_line_pointer
== '"')
4272 cpu_string
= demand_copy_C_string (&len
);
4277 cpu_string
= input_line_pointer
;
4278 c
= get_symbol_end ();
4279 cpu_string
= xstrdup (cpu_string
);
4280 *input_line_pointer
= c
;
4283 if (cpu_string
!= NULL
)
4285 ppc_cpu_t old_cpu
= ppc_cpu
;
4289 for (p
= cpu_string
; *p
!= 0; p
++)
4292 if (strcmp (cpu_string
, "push") == 0)
4294 if (cpu_history
== NULL
)
4295 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4297 if (curr_hist
>= MAX_HISTORY
)
4298 as_bad (_(".machine stack overflow"));
4300 cpu_history
[curr_hist
++] = ppc_cpu
;
4302 else if (strcmp (cpu_string
, "pop") == 0)
4305 as_bad (_(".machine stack underflow"));
4307 ppc_cpu
= cpu_history
[--curr_hist
];
4309 else if ((new_cpu
= ppc_parse_cpu (ppc_cpu
, cpu_string
)) != 0)
4312 as_bad (_("invalid machine `%s'"), cpu_string
);
4314 if (ppc_cpu
!= old_cpu
)
4315 ppc_setup_opcodes ();
4318 demand_empty_rest_of_line ();
4321 /* See whether a symbol is in the TOC section. */
4324 ppc_is_toc_sym (symbolS
*sym
)
4327 return symbol_get_tc (sym
)->symbol_class
== XMC_TC
;
4330 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4332 return strcmp (sname
, ".toc") == 0;
4334 return strcmp (sname
, ".got") == 0;
4337 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4341 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4343 /* Set the current section. */
4345 ppc_set_current_section (segT
new)
4347 ppc_previous_section
= ppc_current_section
;
4348 ppc_current_section
= new;
4351 /* pseudo-op: .previous
4352 behaviour: toggles the current section with the previous section.
4354 warnings: "No previous section" */
4357 ppc_previous (int ignore ATTRIBUTE_UNUSED
)
4361 if (ppc_previous_section
== NULL
)
4363 as_warn (_("No previous section to return to. Directive ignored."));
4367 subseg_set (ppc_previous_section
, 0);
4369 ppc_set_current_section (ppc_previous_section
);
4372 /* pseudo-op: .pdata
4373 behaviour: predefined read only data section
4377 initial: .section .pdata "adr3"
4378 a - don't know -- maybe a misprint
4379 d - initialized data
4381 3 - double word aligned (that would be 4 byte boundary)
4384 Tag index tables (also known as the function table) for exception
4385 handling, debugging, etc. */
4388 ppc_pdata (int ignore ATTRIBUTE_UNUSED
)
4390 if (pdata_section
== 0)
4392 pdata_section
= subseg_new (".pdata", 0);
4394 bfd_set_section_flags (stdoutput
, pdata_section
,
4395 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4396 | SEC_READONLY
| SEC_DATA
));
4398 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4402 pdata_section
= subseg_new (".pdata", 0);
4404 ppc_set_current_section (pdata_section
);
4407 /* pseudo-op: .ydata
4408 behaviour: predefined read only data section
4412 initial: .section .ydata "drw3"
4413 a - don't know -- maybe a misprint
4414 d - initialized data
4416 3 - double word aligned (that would be 4 byte boundary)
4418 Tag tables (also known as the scope table) for exception handling,
4422 ppc_ydata (int ignore ATTRIBUTE_UNUSED
)
4424 if (ydata_section
== 0)
4426 ydata_section
= subseg_new (".ydata", 0);
4427 bfd_set_section_flags (stdoutput
, ydata_section
,
4428 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4429 | SEC_READONLY
| SEC_DATA
));
4431 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4435 ydata_section
= subseg_new (".ydata", 0);
4437 ppc_set_current_section (ydata_section
);
4440 /* pseudo-op: .reldata
4441 behaviour: predefined read write data section
4442 double word aligned (4-byte)
4443 FIXME: relocation is applied to it
4444 FIXME: what's the difference between this and .data?
4447 initial: .section .reldata "drw3"
4448 d - initialized data
4451 3 - double word aligned (that would be 8 byte boundary)
4454 Like .data, but intended to hold data subject to relocation, such as
4455 function descriptors, etc. */
4458 ppc_reldata (int ignore ATTRIBUTE_UNUSED
)
4460 if (reldata_section
== 0)
4462 reldata_section
= subseg_new (".reldata", 0);
4464 bfd_set_section_flags (stdoutput
, reldata_section
,
4465 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4468 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4472 reldata_section
= subseg_new (".reldata", 0);
4474 ppc_set_current_section (reldata_section
);
4477 /* pseudo-op: .rdata
4478 behaviour: predefined read only data section
4482 initial: .section .rdata "dr3"
4483 d - initialized data
4485 3 - double word aligned (that would be 4 byte boundary) */
4488 ppc_rdata (int ignore ATTRIBUTE_UNUSED
)
4490 if (rdata_section
== 0)
4492 rdata_section
= subseg_new (".rdata", 0);
4493 bfd_set_section_flags (stdoutput
, rdata_section
,
4494 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4495 | SEC_READONLY
| SEC_DATA
));
4497 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4501 rdata_section
= subseg_new (".rdata", 0);
4503 ppc_set_current_section (rdata_section
);
4506 /* pseudo-op: .ualong
4507 behaviour: much like .int, with the exception that no alignment is
4509 FIXME: test the alignment statement
4514 ppc_ualong (int ignore ATTRIBUTE_UNUSED
)
4520 /* pseudo-op: .znop <symbol name>
4521 behaviour: Issue a nop instruction
4522 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4523 the supplied symbol name.
4525 warnings: Missing symbol name */
4528 ppc_znop (int ignore ATTRIBUTE_UNUSED
)
4531 const struct powerpc_opcode
*opcode
;
4542 /* Strip out the symbol name. */
4543 symbol_name
= input_line_pointer
;
4544 c
= get_symbol_end ();
4546 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4547 strcpy (name
, symbol_name
);
4549 sym
= symbol_find_or_make (name
);
4551 *input_line_pointer
= c
;
4555 /* Look up the opcode in the hash table. */
4556 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4558 /* Stick in the nop. */
4559 insn
= opcode
->opcode
;
4561 /* Write out the instruction. */
4563 md_number_to_chars (f
, insn
, 4);
4565 f
- frag_now
->fr_literal
,
4570 BFD_RELOC_16_GOT_PCREL
);
4580 ppc_pe_comm (int lcomm
)
4589 name
= input_line_pointer
;
4590 c
= get_symbol_end ();
4592 /* just after name is now '\0'. */
4593 p
= input_line_pointer
;
4596 if (*input_line_pointer
!= ',')
4598 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4599 ignore_rest_of_line ();
4603 input_line_pointer
++; /* skip ',' */
4604 if ((temp
= get_absolute_expression ()) < 0)
4606 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4607 ignore_rest_of_line ();
4613 /* The third argument to .comm is the alignment. */
4614 if (*input_line_pointer
!= ',')
4618 ++input_line_pointer
;
4619 align
= get_absolute_expression ();
4622 as_warn (_("ignoring bad alignment"));
4629 symbolP
= symbol_find_or_make (name
);
4632 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4634 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4635 S_GET_NAME (symbolP
));
4636 ignore_rest_of_line ();
4640 if (S_GET_VALUE (symbolP
))
4642 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4643 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4644 S_GET_NAME (symbolP
),
4645 (long) S_GET_VALUE (symbolP
),
4650 S_SET_VALUE (symbolP
, (valueT
) temp
);
4651 S_SET_EXTERNAL (symbolP
);
4652 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
4655 demand_empty_rest_of_line ();
4659 * implement the .section pseudo op:
4660 * .section name {, "flags"}
4662 * | +--- optional flags: 'b' for bss
4664 * +-- section name 'l' for lib
4668 * 'd' (apparently m88k for data)
4670 * But if the argument is not a quoted string, treat it as a
4671 * subsegment number.
4673 * FIXME: this is a copy of the section processing from obj-coff.c, with
4674 * additions/changes for the moto-pas assembler support. There are three
4677 * FIXME: I just noticed this. This doesn't work at all really. It it
4678 * setting bits that bfd probably neither understands or uses. The
4679 * correct approach (?) will have to incorporate extra fields attached
4680 * to the section to hold the system specific stuff. (krk)
4683 * 'a' - unknown - referred to in documentation, but no definition supplied
4684 * 'c' - section has code
4685 * 'd' - section has initialized data
4686 * 'u' - section has uninitialized data
4687 * 'i' - section contains directives (info)
4688 * 'n' - section can be discarded
4689 * 'R' - remove section at link time
4691 * Section Protection:
4692 * 'r' - section is readable
4693 * 'w' - section is writeable
4694 * 'x' - section is executable
4695 * 's' - section is sharable
4697 * Section Alignment:
4698 * '0' - align to byte boundary
4699 * '1' - align to halfword undary
4700 * '2' - align to word boundary
4701 * '3' - align to doubleword boundary
4702 * '4' - align to quadword boundary
4703 * '5' - align to 32 byte boundary
4704 * '6' - align to 64 byte boundary
4709 ppc_pe_section (int ignore ATTRIBUTE_UNUSED
)
4711 /* Strip out the section name. */
4720 section_name
= input_line_pointer
;
4721 c
= get_symbol_end ();
4723 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4724 strcpy (name
, section_name
);
4726 *input_line_pointer
= c
;
4731 flags
= SEC_NO_FLAGS
;
4733 if (strcmp (name
, ".idata$2") == 0)
4737 else if (strcmp (name
, ".idata$3") == 0)
4741 else if (strcmp (name
, ".idata$4") == 0)
4745 else if (strcmp (name
, ".idata$5") == 0)
4749 else if (strcmp (name
, ".idata$6") == 0)
4754 /* Default alignment to 16 byte boundary. */
4757 if (*input_line_pointer
== ',')
4759 ++input_line_pointer
;
4761 if (*input_line_pointer
!= '"')
4762 exp
= get_absolute_expression ();
4765 ++input_line_pointer
;
4766 while (*input_line_pointer
!= '"'
4767 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4769 switch (*input_line_pointer
)
4771 /* Section Contents */
4772 case 'a': /* unknown */
4773 as_bad (_("Unsupported section attribute -- 'a'"));
4775 case 'c': /* code section */
4778 case 'd': /* section has initialized data */
4781 case 'u': /* section has uninitialized data */
4782 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4786 case 'i': /* section contains directives (info) */
4787 /* FIXME: This is IMAGE_SCN_LNK_INFO
4789 flags
|= SEC_HAS_CONTENTS
;
4791 case 'n': /* section can be discarded */
4794 case 'R': /* Remove section at link time */
4795 flags
|= SEC_NEVER_LOAD
;
4797 #if IFLICT_BRAIN_DAMAGE
4798 /* Section Protection */
4799 case 'r': /* section is readable */
4800 flags
|= IMAGE_SCN_MEM_READ
;
4802 case 'w': /* section is writeable */
4803 flags
|= IMAGE_SCN_MEM_WRITE
;
4805 case 'x': /* section is executable */
4806 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4808 case 's': /* section is sharable */
4809 flags
|= IMAGE_SCN_MEM_SHARED
;
4812 /* Section Alignment */
4813 case '0': /* align to byte boundary */
4814 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4817 case '1': /* align to halfword boundary */
4818 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4821 case '2': /* align to word boundary */
4822 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4825 case '3': /* align to doubleword boundary */
4826 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4829 case '4': /* align to quadword boundary */
4830 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4833 case '5': /* align to 32 byte boundary */
4834 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4837 case '6': /* align to 64 byte boundary */
4838 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4843 as_bad (_("unknown section attribute '%c'"),
4844 *input_line_pointer
);
4847 ++input_line_pointer
;
4849 if (*input_line_pointer
== '"')
4850 ++input_line_pointer
;
4854 sec
= subseg_new (name
, (subsegT
) exp
);
4856 ppc_set_current_section (sec
);
4858 if (flags
!= SEC_NO_FLAGS
)
4860 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4861 as_bad (_("error setting flags for \"%s\": %s"),
4862 bfd_section_name (stdoutput
, sec
),
4863 bfd_errmsg (bfd_get_error ()));
4866 bfd_set_section_alignment (stdoutput
, sec
, align
);
4870 ppc_pe_function (int ignore ATTRIBUTE_UNUSED
)
4876 name
= input_line_pointer
;
4877 endc
= get_symbol_end ();
4879 ext_sym
= symbol_find_or_make (name
);
4881 *input_line_pointer
= endc
;
4883 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4884 SF_SET_FUNCTION (ext_sym
);
4885 SF_SET_PROCESS (ext_sym
);
4886 coff_add_linesym (ext_sym
);
4888 demand_empty_rest_of_line ();
4892 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED
)
4894 if (tocdata_section
== 0)
4896 tocdata_section
= subseg_new (".tocd", 0);
4897 /* FIXME: section flags won't work. */
4898 bfd_set_section_flags (stdoutput
, tocdata_section
,
4899 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4900 | SEC_READONLY
| SEC_DATA
));
4902 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4906 rdata_section
= subseg_new (".tocd", 0);
4909 ppc_set_current_section (tocdata_section
);
4911 demand_empty_rest_of_line ();
4914 /* Don't adjust TOC relocs to use the section symbol. */
4917 ppc_pe_fix_adjustable (fixS
*fix
)
4919 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4926 /* XCOFF specific symbol and file handling. */
4928 /* Canonicalize the symbol name. We use the to force the suffix, if
4929 any, to use square brackets, and to be in upper case. */
4932 ppc_canonicalize_symbol_name (char *name
)
4936 if (ppc_stab_symbol
)
4939 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4953 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4956 if (*s
== '\0' || s
[1] != '\0')
4957 as_bad (_("bad symbol suffix"));
4965 /* Set the class of a symbol based on the suffix, if any. This is
4966 called whenever a new symbol is created. */
4969 ppc_symbol_new_hook (symbolS
*sym
)
4971 struct ppc_tc_sy
*tc
;
4974 tc
= symbol_get_tc (sym
);
4977 tc
->symbol_class
= -1;
4978 tc
->real_name
= NULL
;
4984 if (ppc_stab_symbol
)
4987 s
= strchr (S_GET_NAME (sym
), '[');
4988 if (s
== (const char *) NULL
)
4990 /* There is no suffix. */
4999 if (strcmp (s
, "BS]") == 0)
5000 tc
->symbol_class
= XMC_BS
;
5003 if (strcmp (s
, "DB]") == 0)
5004 tc
->symbol_class
= XMC_DB
;
5005 else if (strcmp (s
, "DS]") == 0)
5006 tc
->symbol_class
= XMC_DS
;
5009 if (strcmp (s
, "GL]") == 0)
5010 tc
->symbol_class
= XMC_GL
;
5013 if (strcmp (s
, "PR]") == 0)
5014 tc
->symbol_class
= XMC_PR
;
5017 if (strcmp (s
, "RO]") == 0)
5018 tc
->symbol_class
= XMC_RO
;
5019 else if (strcmp (s
, "RW]") == 0)
5020 tc
->symbol_class
= XMC_RW
;
5023 if (strcmp (s
, "SV]") == 0)
5024 tc
->symbol_class
= XMC_SV
;
5027 if (strcmp (s
, "TC]") == 0)
5028 tc
->symbol_class
= XMC_TC
;
5029 else if (strcmp (s
, "TI]") == 0)
5030 tc
->symbol_class
= XMC_TI
;
5031 else if (strcmp (s
, "TB]") == 0)
5032 tc
->symbol_class
= XMC_TB
;
5033 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
5034 tc
->symbol_class
= XMC_TC0
;
5037 if (strcmp (s
, "UA]") == 0)
5038 tc
->symbol_class
= XMC_UA
;
5039 else if (strcmp (s
, "UC]") == 0)
5040 tc
->symbol_class
= XMC_UC
;
5043 if (strcmp (s
, "XO]") == 0)
5044 tc
->symbol_class
= XMC_XO
;
5048 if (tc
->symbol_class
== -1)
5049 as_bad (_("Unrecognized symbol suffix"));
5052 /* Set the class of a label based on where it is defined. This
5053 handles symbols without suffixes. Also, move the symbol so that it
5054 follows the csect symbol. */
5057 ppc_frob_label (symbolS
*sym
)
5059 if (ppc_current_csect
!= (symbolS
*) NULL
)
5061 if (symbol_get_tc (sym
)->symbol_class
== -1)
5062 symbol_get_tc (sym
)->symbol_class
= symbol_get_tc (ppc_current_csect
)->symbol_class
;
5064 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
5065 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
5066 &symbol_rootP
, &symbol_lastP
);
5067 symbol_get_tc (ppc_current_csect
)->within
= sym
;
5071 dwarf2_emit_label (sym
);
5075 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5076 seen. It tells ppc_adjust_symtab whether it needs to look through
5079 static bfd_boolean ppc_saw_abs
;
5081 /* Change the name of a symbol just before writing it out. Set the
5082 real name if the .rename pseudo-op was used. Otherwise, remove any
5083 class suffix. Return 1 if the symbol should not be included in the
5087 ppc_frob_symbol (symbolS
*sym
)
5089 static symbolS
*ppc_last_function
;
5090 static symbolS
*set_end
;
5092 /* Discard symbols that should not be included in the output symbol
5094 if (! symbol_used_in_reloc_p (sym
)
5095 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
5096 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5097 && ! symbol_get_tc (sym
)->output
5098 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
5101 /* This one will disappear anyway. Don't make a csect sym for it. */
5102 if (sym
== abs_section_sym
)
5105 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
5106 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
5112 name
= S_GET_NAME (sym
);
5113 s
= strchr (name
, '[');
5114 if (s
!= (char *) NULL
)
5120 snew
= xmalloc (len
+ 1);
5121 memcpy (snew
, name
, len
);
5124 S_SET_NAME (sym
, snew
);
5128 if (set_end
!= (symbolS
*) NULL
)
5130 SA_SET_SYM_ENDNDX (set_end
, sym
);
5134 if (SF_GET_FUNCTION (sym
))
5136 if (ppc_last_function
!= (symbolS
*) NULL
)
5137 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5138 ppc_last_function
= sym
;
5139 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
5141 resolve_symbol_value (symbol_get_tc (sym
)->size
);
5142 SA_SET_SYM_FSIZE (sym
,
5143 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
5146 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
5147 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
5149 if (ppc_last_function
== (symbolS
*) NULL
)
5150 as_bad (_(".ef with no preceding .function"));
5153 set_end
= ppc_last_function
;
5154 ppc_last_function
= NULL
;
5156 /* We don't have a C_EFCN symbol, but we need to force the
5157 COFF backend to believe that it has seen one. */
5158 coff_last_function
= NULL
;
5162 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
5163 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
5164 && S_GET_STORAGE_CLASS (sym
) != C_FILE
5165 && S_GET_STORAGE_CLASS (sym
) != C_FCN
5166 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
5167 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
5168 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
5169 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
5170 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
5171 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
5172 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
5174 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
5175 || S_GET_STORAGE_CLASS (sym
) == C_AIX_WEAKEXT
5176 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
5179 union internal_auxent
*a
;
5181 /* Create a csect aux. */
5182 i
= S_GET_NUMBER_AUXILIARY (sym
);
5183 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
5184 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
5185 if (symbol_get_tc (sym
)->symbol_class
== XMC_TC0
)
5187 /* This is the TOC table. */
5188 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
5189 a
->x_csect
.x_scnlen
.l
= 0;
5190 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5192 else if (symbol_get_tc (sym
)->subseg
!= 0)
5194 /* This is a csect symbol. x_scnlen is the size of the
5196 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
5197 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5198 S_GET_SEGMENT (sym
))
5199 - S_GET_VALUE (sym
));
5202 resolve_symbol_value (symbol_get_tc (sym
)->next
);
5203 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
5204 - S_GET_VALUE (sym
));
5206 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
5208 else if (S_GET_SEGMENT (sym
) == bss_section
)
5210 /* This is a common symbol. */
5211 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
5212 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
5213 if (S_IS_EXTERNAL (sym
))
5214 symbol_get_tc (sym
)->symbol_class
= XMC_RW
;
5216 symbol_get_tc (sym
)->symbol_class
= XMC_BS
;
5218 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5220 /* This is an absolute symbol. The csect will be created by
5221 ppc_adjust_symtab. */
5223 a
->x_csect
.x_smtyp
= XTY_LD
;
5224 if (symbol_get_tc (sym
)->symbol_class
== -1)
5225 symbol_get_tc (sym
)->symbol_class
= XMC_XO
;
5227 else if (! S_IS_DEFINED (sym
))
5229 /* This is an external symbol. */
5230 a
->x_csect
.x_scnlen
.l
= 0;
5231 a
->x_csect
.x_smtyp
= XTY_ER
;
5233 else if (symbol_get_tc (sym
)->symbol_class
== XMC_TC
)
5237 /* This is a TOC definition. x_scnlen is the size of the
5239 next
= symbol_next (sym
);
5240 while (symbol_get_tc (next
)->symbol_class
== XMC_TC0
)
5241 next
= symbol_next (next
);
5242 if (next
== (symbolS
*) NULL
5243 || symbol_get_tc (next
)->symbol_class
!= XMC_TC
)
5245 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5246 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5248 - S_GET_VALUE (sym
));
5250 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5251 - S_GET_VALUE (sym
));
5255 resolve_symbol_value (next
);
5256 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5257 - S_GET_VALUE (sym
));
5259 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5265 /* This is a normal symbol definition. x_scnlen is the
5266 symbol index of the containing csect. */
5267 if (S_GET_SEGMENT (sym
) == text_section
)
5268 csect
= ppc_text_csects
;
5269 else if (S_GET_SEGMENT (sym
) == data_section
)
5270 csect
= ppc_data_csects
;
5274 /* Skip the initial dummy symbol. */
5275 csect
= symbol_get_tc (csect
)->next
;
5277 if (csect
== (symbolS
*) NULL
)
5279 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5280 a
->x_csect
.x_scnlen
.l
= 0;
5284 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5286 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5287 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5288 > S_GET_VALUE (sym
))
5290 csect
= symbol_get_tc (csect
)->next
;
5293 a
->x_csect
.x_scnlen
.p
=
5294 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5295 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5298 a
->x_csect
.x_smtyp
= XTY_LD
;
5301 a
->x_csect
.x_parmhash
= 0;
5302 a
->x_csect
.x_snhash
= 0;
5303 if (symbol_get_tc (sym
)->symbol_class
== -1)
5304 a
->x_csect
.x_smclas
= XMC_PR
;
5306 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->symbol_class
;
5307 a
->x_csect
.x_stab
= 0;
5308 a
->x_csect
.x_snstab
= 0;
5310 /* Don't let the COFF backend resort these symbols. */
5311 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5313 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5315 /* We want the value to be the symbol index of the referenced
5316 csect symbol. BFD will do that for us if we set the right
5318 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5319 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5321 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5322 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5324 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5329 /* The value is the offset from the enclosing csect. */
5330 block
= symbol_get_tc (sym
)->within
;
5331 csect
= symbol_get_tc (block
)->within
;
5332 resolve_symbol_value (csect
);
5333 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
5335 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5336 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5338 /* We want the value to be a file offset into the line numbers.
5339 BFD will do that for us if we set the right flags. We have
5340 already set the value correctly. */
5341 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5347 /* Adjust the symbol table. This creates csect symbols for all
5348 absolute symbols. */
5351 ppc_adjust_symtab (void)
5358 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5362 union internal_auxent
*a
;
5364 if (S_GET_SEGMENT (sym
) != absolute_section
)
5367 csect
= symbol_create (".abs[XO]", absolute_section
,
5368 S_GET_VALUE (sym
), &zero_address_frag
);
5369 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5370 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5371 i
= S_GET_NUMBER_AUXILIARY (csect
);
5372 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5373 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5374 a
->x_csect
.x_scnlen
.l
= 0;
5375 a
->x_csect
.x_smtyp
= XTY_SD
;
5376 a
->x_csect
.x_parmhash
= 0;
5377 a
->x_csect
.x_snhash
= 0;
5378 a
->x_csect
.x_smclas
= XMC_XO
;
5379 a
->x_csect
.x_stab
= 0;
5380 a
->x_csect
.x_snstab
= 0;
5382 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5384 i
= S_GET_NUMBER_AUXILIARY (sym
);
5385 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5386 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5387 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5390 ppc_saw_abs
= FALSE
;
5393 /* Set the VMA for a section. This is called on all the sections in
5397 ppc_frob_section (asection
*sec
)
5399 static bfd_vma vma
= 0;
5401 vma
= md_section_align (sec
, vma
);
5402 bfd_set_section_vma (stdoutput
, sec
, vma
);
5403 vma
+= bfd_section_size (stdoutput
, sec
);
5406 #endif /* OBJ_XCOFF */
5409 md_atof (int type
, char *litp
, int *sizep
)
5411 return ieee_md_atof (type
, litp
, sizep
, target_big_endian
);
5414 /* Write a value out to the object file, using the appropriate
5418 md_number_to_chars (char *buf
, valueT val
, int n
)
5420 if (target_big_endian
)
5421 number_to_chars_bigendian (buf
, val
, n
);
5423 number_to_chars_littleendian (buf
, val
, n
);
5426 /* Align a section (I don't know why this is machine dependent). */
5429 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5434 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5436 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5440 /* We don't have any form of relaxing. */
5443 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
5444 asection
*seg ATTRIBUTE_UNUSED
)
5450 /* Convert a machine dependent frag. We never generate these. */
5453 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
5454 asection
*sec ATTRIBUTE_UNUSED
,
5455 fragS
*fragp ATTRIBUTE_UNUSED
)
5460 /* We have no need to default values of symbols. */
5463 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
5468 /* Functions concerning relocs. */
5470 /* The location from which a PC relative jump should be calculated,
5471 given a PC relative reloc. */
5474 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
5476 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5481 /* This is called to see whether a fixup should be adjusted to use a
5482 section symbol. We take the opportunity to change a fixup against
5483 a symbol in the TOC subsegment into a reloc against the
5484 corresponding .tc symbol. */
5487 ppc_fix_adjustable (fixS
*fix
)
5489 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5490 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5491 TC_SYMFIELD_TYPE
*tc
;
5493 if (symseg
== absolute_section
)
5496 if (ppc_toc_csect
!= (symbolS
*) NULL
5497 && fix
->fx_addsy
!= ppc_toc_csect
5498 && symseg
== data_section
5499 && val
>= ppc_toc_frag
->fr_address
5500 && (ppc_after_toc_frag
== (fragS
*) NULL
5501 || val
< ppc_after_toc_frag
->fr_address
))
5505 for (sy
= symbol_next (ppc_toc_csect
);
5506 sy
!= (symbolS
*) NULL
;
5507 sy
= symbol_next (sy
))
5509 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5511 if (sy_tc
->symbol_class
== XMC_TC0
)
5513 if (sy_tc
->symbol_class
!= XMC_TC
)
5515 if (val
== resolve_symbol_value (sy
))
5518 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5523 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5524 _("symbol in .toc does not match any .tc"));
5527 /* Possibly adjust the reloc to be against the csect. */
5528 tc
= symbol_get_tc (fix
->fx_addsy
);
5530 && tc
->symbol_class
!= XMC_TC0
5531 && tc
->symbol_class
!= XMC_TC
5532 && symseg
!= bss_section
5533 /* Don't adjust if this is a reloc in the toc section. */
5534 && (symseg
!= data_section
5535 || ppc_toc_csect
== NULL
5536 || val
< ppc_toc_frag
->fr_address
5537 || (ppc_after_toc_frag
!= NULL
5538 && val
>= ppc_after_toc_frag
->fr_address
)))
5541 symbolS
*next_csect
;
5543 if (symseg
== text_section
)
5544 csect
= ppc_text_csects
;
5545 else if (symseg
== data_section
)
5546 csect
= ppc_data_csects
;
5550 /* Skip the initial dummy symbol. */
5551 csect
= symbol_get_tc (csect
)->next
;
5553 if (csect
!= (symbolS
*) NULL
)
5555 while ((next_csect
= symbol_get_tc (csect
)->next
) != (symbolS
*) NULL
5556 && (symbol_get_frag (next_csect
)->fr_address
<= val
))
5558 /* If the csect address equals the symbol value, then we
5559 have to look through the full symbol table to see
5560 whether this is the csect we want. Note that we will
5561 only get here if the csect has zero length. */
5562 if (symbol_get_frag (csect
)->fr_address
== val
5563 && S_GET_VALUE (csect
) == val
)
5567 for (scan
= symbol_next (csect
);
5569 scan
= symbol_next (scan
))
5571 if (symbol_get_tc (scan
)->subseg
!= 0)
5573 if (scan
== fix
->fx_addsy
)
5577 /* If we found the symbol before the next csect
5578 symbol, then this is the csect we want. */
5579 if (scan
== fix
->fx_addsy
)
5586 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5587 fix
->fx_addsy
= csect
;
5592 /* Adjust a reloc against a .lcomm symbol to be against the base
5594 if (symseg
== bss_section
5595 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5597 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5599 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5606 /* A reloc from one csect to another must be kept. The assembler
5607 will, of course, keep relocs between sections, and it will keep
5608 absolute relocs, but we need to force it to keep PC relative relocs
5609 between two csects in the same section. */
5612 ppc_force_relocation (fixS
*fix
)
5614 /* At this point fix->fx_addsy should already have been converted to
5615 a csect symbol. If the csect does not include the fragment, then
5616 we need to force the relocation. */
5618 && fix
->fx_addsy
!= NULL
5619 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5620 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5621 > fix
->fx_frag
->fr_address
)
5622 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5623 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5624 <= fix
->fx_frag
->fr_address
))))
5627 return generic_force_reloc (fix
);
5630 #endif /* OBJ_XCOFF */
5633 /* If this function returns non-zero, it guarantees that a relocation
5634 will be emitted for a fixup. */
5637 ppc_force_relocation (fixS
*fix
)
5639 /* Branch prediction relocations must force a relocation, as must
5640 the vtable description relocs. */
5641 switch (fix
->fx_r_type
)
5643 case BFD_RELOC_PPC_B16_BRTAKEN
:
5644 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5645 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5646 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5647 case BFD_RELOC_24_PLT_PCREL
:
5648 case BFD_RELOC_PPC64_TOC
:
5654 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5655 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5658 return generic_force_reloc (fix
);
5662 ppc_fix_adjustable (fixS
*fix
)
5664 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5665 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5666 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5667 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5668 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5669 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5670 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5671 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5672 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
5676 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
5677 rs_align_code frag. */
5680 ppc_handle_align (struct frag
*fragP
)
5682 valueT count
= (fragP
->fr_next
->fr_address
5683 - (fragP
->fr_address
+ fragP
->fr_fix
));
5685 if (count
!= 0 && (count
& 3) == 0)
5687 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
5690 md_number_to_chars (dest
, 0x60000000, 4);
5692 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0
5693 || (ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
5695 /* For power6 and power7, we want the last nop to be a group
5696 terminating one. Do this by inserting an rs_fill frag immediately
5697 after this one, with its address set to the last nop location.
5698 This will automatically reduce the number of nops in the current
5702 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
5704 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
5705 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
5706 group_nop
->fr_fix
= 0;
5707 group_nop
->fr_offset
= 1;
5708 group_nop
->fr_type
= rs_fill
;
5709 fragP
->fr_next
= group_nop
;
5710 dest
= group_nop
->fr_literal
;
5713 if ((ppc_cpu
& PPC_OPCODE_POWER7
) != 0)
5714 /* power7 group terminating nop: "ori 2,2,0". */
5715 md_number_to_chars (dest
, 0x60420000, 4);
5717 /* power6 group terminating nop: "ori 1,1,0". */
5718 md_number_to_chars (dest
, 0x60210000, 4);
5723 /* Apply a fixup to the object code. This is called for all the
5724 fixups we generated by the call to fix_new_exp, above. In the call
5725 above we used a reloc code which was the largest legal reloc code
5726 plus the operand index. Here we undo that to recover the operand
5727 index. At this point all symbol values should be fully resolved,
5728 and we attempt to completely resolve the reloc. If we can not do
5729 that, we determine the correct reloc code and put it back in the
5733 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
5735 valueT value
= * valP
;
5738 if (fixP
->fx_addsy
!= NULL
)
5740 /* Hack around bfd_install_relocation brain damage. */
5742 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5747 /* FIXME FIXME FIXME: The value we are passed in *valP includes
5748 the symbol values. If we are doing this relocation the code in
5749 write.c is going to call bfd_install_relocation, which is also
5750 going to use the symbol value. That means that if the reloc is
5751 fully resolved we want to use *valP since bfd_install_relocation is
5753 However, if the reloc is not fully resolved we do not want to
5754 use *valP, and must use fx_offset instead. If the relocation
5755 is PC-relative, we then need to re-apply md_pcrel_from_section
5756 to this new relocation value. */
5757 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5762 value
= fixP
->fx_offset
;
5764 value
-= md_pcrel_from_section (fixP
, seg
);
5768 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5770 /* We can't actually support subtracting a symbol. */
5771 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
5774 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5777 const struct powerpc_operand
*operand
;
5781 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5783 operand
= &powerpc_operands
[opindex
];
5786 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5787 does not generate a reloc. It uses the offset of `sym' within its
5788 csect. Other usages, such as `.long sym', generate relocs. This
5789 is the documented behaviour of non-TOC symbols. */
5790 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5791 && (operand
->bitm
& 0xfff0) == 0xfff0
5792 && operand
->shift
== 0
5793 && (operand
->insert
== NULL
|| ppc_obj64
)
5794 && fixP
->fx_addsy
!= NULL
5795 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5796 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC
5797 && symbol_get_tc (fixP
->fx_addsy
)->symbol_class
!= XMC_TC0
5798 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5800 value
= fixP
->fx_offset
;
5805 /* Fetch the instruction, insert the fully resolved operand
5806 value, and stuff the instruction back again. */
5807 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5808 if (target_big_endian
)
5809 insn
= bfd_getb32 ((unsigned char *) where
);
5811 insn
= bfd_getl32 ((unsigned char *) where
);
5812 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5813 fixP
->tc_fix_data
.ppc_cpu
,
5814 fixP
->fx_file
, fixP
->fx_line
);
5815 if (target_big_endian
)
5816 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5818 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5821 /* Nothing else to do here. */
5824 gas_assert (fixP
->fx_addsy
!= NULL
);
5826 /* Determine a BFD reloc value based on the operand information.
5827 We are only prepared to turn a few of the operands into
5829 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5830 && operand
->bitm
== 0x3fffffc
5831 && operand
->shift
== 0)
5832 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5833 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5834 && operand
->bitm
== 0xfffc
5835 && operand
->shift
== 0)
5837 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5840 if (target_big_endian
)
5841 fixP
->fx_where
+= 2;
5844 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5845 && operand
->bitm
== 0x3fffffc
5846 && operand
->shift
== 0)
5847 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5848 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5849 && operand
->bitm
== 0xfffc
5850 && operand
->shift
== 0)
5852 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5855 if (target_big_endian
)
5856 fixP
->fx_where
+= 2;
5859 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5860 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5861 && (operand
->bitm
& 0xfff0) == 0xfff0
5862 && operand
->shift
== 0)
5864 if (ppc_is_toc_sym (fixP
->fx_addsy
))
5866 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5869 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5870 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5875 fixP
->fx_r_type
= BFD_RELOC_16
;
5878 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5879 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
5883 if (target_big_endian
)
5884 fixP
->fx_where
+= 2;
5886 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5892 /* Use expr_symbol_where to see if this is an expression
5894 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5895 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5896 _("unresolved expression that must be resolved"));
5898 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5899 _("unsupported relocation against %s"),
5900 S_GET_NAME (fixP
->fx_addsy
));
5908 ppc_elf_validate_fix (fixP
, seg
);
5910 switch (fixP
->fx_r_type
)
5912 case BFD_RELOC_CTOR
:
5919 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5923 case BFD_RELOC_32_PCREL
:
5924 case BFD_RELOC_PPC_EMB_NADDR32
:
5925 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5932 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5935 case BFD_RELOC_64_PCREL
:
5936 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5940 case BFD_RELOC_GPREL16
:
5941 case BFD_RELOC_16_GOT_PCREL
:
5942 case BFD_RELOC_16_GOTOFF
:
5943 case BFD_RELOC_LO16_GOTOFF
:
5944 case BFD_RELOC_HI16_GOTOFF
:
5945 case BFD_RELOC_HI16_S_GOTOFF
:
5946 case BFD_RELOC_16_BASEREL
:
5947 case BFD_RELOC_LO16_BASEREL
:
5948 case BFD_RELOC_HI16_BASEREL
:
5949 case BFD_RELOC_HI16_S_BASEREL
:
5950 case BFD_RELOC_PPC_EMB_NADDR16
:
5951 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5952 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5953 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5954 case BFD_RELOC_PPC_EMB_SDAI16
:
5955 case BFD_RELOC_PPC_EMB_SDA2REL
:
5956 case BFD_RELOC_PPC_EMB_SDA2I16
:
5957 case BFD_RELOC_PPC_EMB_RELSEC16
:
5958 case BFD_RELOC_PPC_EMB_RELST_LO
:
5959 case BFD_RELOC_PPC_EMB_RELST_HI
:
5960 case BFD_RELOC_PPC_EMB_RELST_HA
:
5961 case BFD_RELOC_PPC_EMB_RELSDA
:
5962 case BFD_RELOC_PPC_TOC16
:
5964 case BFD_RELOC_PPC64_TOC16_LO
:
5965 case BFD_RELOC_PPC64_TOC16_HI
:
5966 case BFD_RELOC_PPC64_TOC16_HA
:
5970 if (fixP
->fx_addsy
!= NULL
)
5971 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5972 _("cannot emit PC relative %s relocation against %s"),
5973 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5974 S_GET_NAME (fixP
->fx_addsy
));
5976 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5977 _("cannot emit PC relative %s relocation"),
5978 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5981 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5987 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5990 case BFD_RELOC_16_PCREL
:
5991 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5995 case BFD_RELOC_LO16
:
5997 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
6000 case BFD_RELOC_LO16_PCREL
:
6001 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6005 /* This case happens when you write, for example,
6007 where L1 and L2 are defined later. */
6008 case BFD_RELOC_HI16
:
6010 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
6013 case BFD_RELOC_HI16_PCREL
:
6014 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6018 case BFD_RELOC_HI16_S
:
6020 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
6023 case BFD_RELOC_HI16_S_PCREL
:
6024 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6029 case BFD_RELOC_PPC64_HIGHER
:
6032 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6033 PPC_HIGHER (value
), 2);
6036 case BFD_RELOC_PPC64_HIGHER_S
:
6039 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6040 PPC_HIGHERA (value
), 2);
6043 case BFD_RELOC_PPC64_HIGHEST
:
6046 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6047 PPC_HIGHEST (value
), 2);
6050 case BFD_RELOC_PPC64_HIGHEST_S
:
6053 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6054 PPC_HIGHESTA (value
), 2);
6057 case BFD_RELOC_PPC64_ADDR16_DS
:
6058 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
6059 case BFD_RELOC_PPC64_GOT16_DS
:
6060 case BFD_RELOC_PPC64_GOT16_LO_DS
:
6061 case BFD_RELOC_PPC64_PLT16_LO_DS
:
6062 case BFD_RELOC_PPC64_SECTOFF_DS
:
6063 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
6064 case BFD_RELOC_PPC64_TOC16_DS
:
6065 case BFD_RELOC_PPC64_TOC16_LO_DS
:
6066 case BFD_RELOC_PPC64_PLTGOT16_DS
:
6067 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
6071 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6072 unsigned long val
, mask
;
6074 if (target_big_endian
)
6075 val
= bfd_getb32 (where
- 2);
6077 val
= bfd_getl32 (where
);
6079 /* lq insns reserve the four lsbs. */
6080 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
6081 && (val
& (0x3f << 26)) == (56u << 26))
6083 val
|= value
& mask
;
6084 if (target_big_endian
)
6085 bfd_putb16 ((bfd_vma
) val
, where
);
6087 bfd_putl16 ((bfd_vma
) val
, where
);
6091 case BFD_RELOC_PPC_B16_BRTAKEN
:
6092 case BFD_RELOC_PPC_B16_BRNTAKEN
:
6093 case BFD_RELOC_PPC_BA16_BRTAKEN
:
6094 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
6097 case BFD_RELOC_PPC_TLS
:
6098 case BFD_RELOC_PPC_TLSGD
:
6099 case BFD_RELOC_PPC_TLSLD
:
6102 case BFD_RELOC_PPC_DTPMOD
:
6103 case BFD_RELOC_PPC_TPREL16
:
6104 case BFD_RELOC_PPC_TPREL16_LO
:
6105 case BFD_RELOC_PPC_TPREL16_HI
:
6106 case BFD_RELOC_PPC_TPREL16_HA
:
6107 case BFD_RELOC_PPC_TPREL
:
6108 case BFD_RELOC_PPC_DTPREL16
:
6109 case BFD_RELOC_PPC_DTPREL16_LO
:
6110 case BFD_RELOC_PPC_DTPREL16_HI
:
6111 case BFD_RELOC_PPC_DTPREL16_HA
:
6112 case BFD_RELOC_PPC_DTPREL
:
6113 case BFD_RELOC_PPC_GOT_TLSGD16
:
6114 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
6115 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
6116 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
6117 case BFD_RELOC_PPC_GOT_TLSLD16
:
6118 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
6119 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
6120 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
6121 case BFD_RELOC_PPC_GOT_TPREL16
:
6122 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
6123 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
6124 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
6125 case BFD_RELOC_PPC_GOT_DTPREL16
:
6126 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
6127 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
6128 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
6129 case BFD_RELOC_PPC64_TPREL16_DS
:
6130 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
6131 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
6132 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
6133 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
6134 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
6135 case BFD_RELOC_PPC64_DTPREL16_DS
:
6136 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
6137 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
6138 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
6139 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
6140 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
6141 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
6144 /* Because SDA21 modifies the register field, the size is set to 4
6145 bytes, rather than 2, so offset it here appropriately. */
6146 case BFD_RELOC_PPC_EMB_SDA21
:
6150 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
6151 + ((target_big_endian
) ? 2 : 0),
6158 /* This can occur if there is a bug in the input assembler, eg:
6159 ".byte <undefined_symbol> - ." */
6161 as_bad (_("Unable to handle reference to symbol %s"),
6162 S_GET_NAME (fixP
->fx_addsy
));
6164 as_bad (_("Unable to resolve expression"));
6168 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6172 case BFD_RELOC_24_PLT_PCREL
:
6173 case BFD_RELOC_PPC_LOCAL24PC
:
6174 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
6182 /* Fetch the instruction, insert the fully resolved operand
6183 value, and stuff the instruction back again. */
6184 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6185 if (target_big_endian
)
6186 insn
= bfd_getb32 ((unsigned char *) where
);
6188 insn
= bfd_getl32 ((unsigned char *) where
);
6189 if ((value
& 3) != 0)
6190 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6191 _("must branch to an address a multiple of 4"));
6192 if ((offsetT
) value
< -0x40000000
6193 || (offsetT
) value
>= 0x40000000)
6194 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6195 _("@local or @plt branch destination is too far away, %ld bytes"),
6197 insn
= insn
| (value
& 0x03fffffc);
6198 if (target_big_endian
)
6199 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6201 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6205 case BFD_RELOC_VTABLE_INHERIT
:
6208 && !S_IS_DEFINED (fixP
->fx_addsy
)
6209 && !S_IS_WEAK (fixP
->fx_addsy
))
6210 S_SET_WEAK (fixP
->fx_addsy
);
6213 case BFD_RELOC_VTABLE_ENTRY
:
6218 /* Generated by reference to `sym@tocbase'. The sym is
6219 ignored by the linker. */
6220 case BFD_RELOC_PPC64_TOC
:
6226 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6233 fixP
->fx_addnumber
= value
;
6235 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6236 from the section contents. If we are going to be emitting a reloc
6237 then the section contents are immaterial, so don't warn if they
6238 happen to overflow. Leave such warnings to ld. */
6240 fixP
->fx_no_overflow
= 1;
6242 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6243 fixP
->fx_addnumber
= 0;
6247 fixP
->fx_addnumber
= 0;
6249 /* We want to use the offset within the toc, not the actual VMA
6251 fixP
->fx_addnumber
=
6252 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
))
6253 - S_GET_VALUE (ppc_toc_csect
);
6259 /* Generate a reloc for a fixup. */
6262 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
6266 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6268 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6269 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6270 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6271 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6272 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6274 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6275 _("reloc %d not supported by object file format"),
6276 (int) fixp
->fx_r_type
);
6279 reloc
->addend
= fixp
->fx_addnumber
;
6285 ppc_cfi_frame_initial_instructions (void)
6287 cfi_add_CFA_def_cfa (1, 0);
6291 tc_ppc_regname_to_dw2regnum (char *regname
)
6293 unsigned int regnum
= -1;
6297 static struct { char *name
; int dw2regnum
; } regnames
[] =
6299 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6300 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6301 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6302 { "spe_acc", 111 }, { "spefscr", 112 }
6305 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6306 if (strcmp (regnames
[i
].name
, regname
) == 0)
6307 return regnames
[i
].dw2regnum
;
6309 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6311 p
= regname
+ 1 + (regname
[1] == '.');
6312 regnum
= strtoul (p
, &q
, 10);
6313 if (p
== q
|| *q
|| regnum
>= 32)
6315 if (regname
[0] == 'f')
6317 else if (regname
[0] == 'v')
6320 else if (regname
[0] == 'c' && regname
[1] == 'r')
6322 p
= regname
+ 2 + (regname
[2] == '.');
6323 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6325 regnum
= p
[0] - '0' + 68;