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 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 unsigned long 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 */
403 /* Quantization registers used with pair single instructions. */
421 { "lr", 8 }, /* Link Register */
425 { "r.0", 0 }, /* General Purpose Registers */
458 { "r.sp", 1 }, /* Stack Pointer */
460 { "r.toc", 2 }, /* Pointer to the table of contents */
462 { "r0", 0 }, /* More general purpose registers */
495 { "rtoc", 2 }, /* Table of contents */
497 { "sdr1", 25 }, /* Storage Description Register 1 */
501 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
502 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
504 { "v.0", 0 }, /* Vector registers */
574 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
576 /* Given NAME, find the register number associated with that name, return
577 the integer value associated with the given name or -1 on failure. */
580 reg_name_search (const struct pd_reg *regs, int regcount, const char *name)
582 int middle, low, high;
590 middle = (low + high) / 2;
591 cmp = strcasecmp (name, regs[middle].name);
597 return regs[middle].value;
605 * Summary of register_name.
607 * in: Input_line_pointer points to 1st char of operand.
609 * out: A expressionS.
610 * The operand may have been a register: in this case, X_op == O_register,
611 * X_add_number is set to the register number, and truth is returned.
612 * Input_line_pointer->(next non-blank) char after operand, or is in its
617 register_name (expressionS *expressionP)
624 /* Find the spelling of the operand. */
625 start = name = input_line_pointer;
626 if (name[0] == '%' && ISALPHA (name[1]))
627 name = ++input_line_pointer;
629 else if (!reg_names_p || !ISALPHA (name[0]))
632 c = get_symbol_end ();
633 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
635 /* Put back the delimiting char. */
636 *input_line_pointer = c;
638 /* Look to see if it's in the register table. */
641 expressionP->X_op = O_register;
642 expressionP->X_add_number = reg_number;
644 /* Make the rest nice. */
645 expressionP->X_add_symbol = NULL;
646 expressionP->X_op_symbol = NULL;
650 /* Reset the line as if we had not done anything. */
651 input_line_pointer = start;
655 /* This function is called for each symbol seen in an expression. It
656 handles the special parsing which PowerPC assemblers are supposed
657 to use for condition codes. */
659 /* Whether to do the special parsing. */
660 static bfd_boolean cr_operand;
662 /* Names to recognize in a condition code. This table is sorted. */
663 static const struct pd_reg cr_names[] =
680 /* Parsing function. This returns non-zero if it recognized an
684 ppc_parse_name (const char *name, expressionS *expr)
693 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
698 expr->X_op = O_constant;
699 expr->X_add_number = val;
704 /* Local variables. */
706 /* Whether to target xcoff64/elf64. */
707 static unsigned int ppc_obj64 = BFD_DEFAULT_TARGET_SIZE == 64;
709 /* Opcode hash table. */
710 static struct hash_control *ppc_hash;
712 /* Macro hash table. */
713 static struct hash_control *ppc_macro_hash;
716 /* What type of shared library support to use. */
717 static enum { SHLIB_NONE, SHLIB_PIC, SHLIB_MRELOCATABLE } shlib = SHLIB_NONE;
719 /* Flags to set in the elf header. */
720 static flagword ppc_flags = 0;
722 /* Whether this is Solaris or not. */
723 #ifdef TARGET_SOLARIS_COMMENT
724 #define SOLARIS_P TRUE
726 #define SOLARIS_P FALSE
729 static bfd_boolean msolaris = SOLARIS_P;
734 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
735 using a bunch of different sections. These assembler sections,
736 however, are all encompassed within the .text or .data sections of
737 the final output file. We handle this by using different
738 subsegments within these main segments. */
740 /* Next subsegment to allocate within the .text segment. */
741 static subsegT ppc_text_subsegment = 2;
743 /* Linked list of csects in the text section. */
744 static symbolS *ppc_text_csects;
746 /* Next subsegment to allocate within the .data segment. */
747 static subsegT ppc_data_subsegment = 2;
749 /* Linked list of csects in the data section. */
750 static symbolS *ppc_data_csects;
752 /* The current csect. */
753 static symbolS *ppc_current_csect;
755 /* The RS/6000 assembler uses a TOC which holds addresses of functions
756 and variables. Symbols are put in the TOC with the .tc pseudo-op.
757 A special relocation is used when accessing TOC entries. We handle
758 the TOC as a subsegment within the .data segment. We set it up if
759 we see a .toc pseudo-op, and save the csect symbol here. */
760 static symbolS *ppc_toc_csect;
762 /* The first frag in the TOC subsegment. */
763 static fragS *ppc_toc_frag;
765 /* The first frag in the first subsegment after the TOC in the .data
766 segment. NULL if there are no subsegments after the TOC. */
767 static fragS *ppc_after_toc_frag;
769 /* The current static block. */
770 static symbolS *ppc_current_block;
772 /* The COFF debugging section; set by md_begin. This is not the
773 .debug section, but is instead the secret BFD section which will
774 cause BFD to set the section number of a symbol to N_DEBUG. */
775 static asection *ppc_coff_debug_section;
777 #endif /* OBJ_XCOFF */
781 /* Various sections that we need for PE coff support. */
782 static segT ydata_section;
783 static segT pdata_section;
784 static segT reldata_section;
785 static segT rdata_section;
786 static segT tocdata_section;
788 /* The current section and the previous section. See ppc_previous. */
789 static segT ppc_previous_section;
790 static segT ppc_current_section;
795 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
796 #define PPC_APUINFO_ISEL 0x40
797 #define PPC_APUINFO_PMR 0x41
798 #define PPC_APUINFO_RFMCI 0x42
799 #define PPC_APUINFO_CACHELCK 0x43
800 #define PPC_APUINFO_SPE 0x100
801 #define PPC_APUINFO_EFS 0x101
802 #define PPC_APUINFO_BRLOCK 0x102
805 * We keep a list of APUinfo
807 unsigned long *ppc_apuinfo_list;
808 unsigned int ppc_apuinfo_num;
809 unsigned int ppc_apuinfo_num_alloc;
813 const char *const md_shortopts = "b:l:usm:K:VQ:";
815 const char *const md_shortopts = "um:";
817 const struct option md_longopts[] = {
818 {NULL, no_argument, NULL, 0}
820 const size_t md_longopts_size = sizeof (md_longopts);
823 /* Handle -m options that set cpu type, and .machine arg. */
826 parse_cpu (const char *arg)
828 unsigned long altivec_or_spe = ppc_cpu & (PPC_OPCODE_ALTIVEC | PPC_OPCODE_SPE);
830 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
832 if (strcmp (arg, "pwrx") == 0 || strcmp (arg, "pwr2") == 0)
833 ppc_cpu = PPC_OPCODE_POWER | PPC_OPCODE_POWER2 | PPC_OPCODE_32;
834 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
835 else if (strcmp (arg, "pwr") == 0)
836 ppc_cpu = PPC_OPCODE_POWER | PPC_OPCODE_32;
837 /* -m601 means to assemble for the PowerPC 601, which includes
838 instructions that are holdovers from the Power. */
839 else if (strcmp (arg, "601") == 0)
840 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
841 | PPC_OPCODE_601 | PPC_OPCODE_32);
842 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
844 else if (strcmp (arg, "ppc") == 0
845 || strcmp (arg, "ppc32") == 0
846 || strcmp (arg, "603") == 0
847 || strcmp (arg, "604") == 0)
848 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC | PPC_OPCODE_32;
849 /* Do all PPC750s have paired single ops? */
850 else if (strcmp (arg, "750cl") == 0)
851 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_PPCPS;
852 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
853 else if (strcmp (arg, "403") == 0
854 || strcmp (arg, "405") == 0)
855 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
856 | PPC_OPCODE_403 | PPC_OPCODE_32);
857 else if (strcmp (arg, "440") == 0)
858 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_BOOKE | PPC_OPCODE_32
859 | PPC_OPCODE_440 | PPC_OPCODE_ISEL | PPC_OPCODE_RFMCI);
860 else if (strcmp (arg, "7400") == 0
861 || strcmp (arg, "7410") == 0
862 || strcmp (arg, "7450") == 0
863 || strcmp (arg, "7455") == 0)
864 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
865 | PPC_OPCODE_ALTIVEC | PPC_OPCODE_32);
866 else if (strcmp (arg, "e300") == 0)
867 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC | PPC_OPCODE_32
869 else if (strcmp (arg, "altivec") == 0)
872 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC;
874 altivec_or_spe |= PPC_OPCODE_ALTIVEC;
876 else if (strcmp (arg, "e500") == 0 || strcmp (arg, "e500x2") == 0)
878 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_BOOKE | PPC_OPCODE_SPE
879 | PPC_OPCODE_ISEL | PPC_OPCODE_EFS | PPC_OPCODE_BRLOCK
880 | PPC_OPCODE_PMR | PPC_OPCODE_CACHELCK
883 else if (strcmp (arg, "spe") == 0)
886 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_EFS;
888 altivec_or_spe |= PPC_OPCODE_SPE;
890 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
892 else if (strcmp (arg, "ppc64") == 0 || strcmp (arg, "620") == 0)
894 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC | PPC_OPCODE_64;
896 else if (strcmp (arg, "ppc64bridge") == 0)
898 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
899 | PPC_OPCODE_64_BRIDGE | PPC_OPCODE_64);
901 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
902 else if (strcmp (arg, "booke") == 0 || strcmp (arg, "booke32") == 0)
904 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_BOOKE | PPC_OPCODE_32;
906 /* -mbooke64 means enable 64-bit BookE support. */
907 else if (strcmp (arg, "booke64") == 0)
909 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_BOOKE
910 | PPC_OPCODE_BOOKE64 | PPC_OPCODE_64);
912 else if (strcmp (arg, "power4") == 0)
914 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
915 | PPC_OPCODE_64 | PPC_OPCODE_POWER4);
917 else if (strcmp (arg, "power5") == 0)
919 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
920 | PPC_OPCODE_64 | PPC_OPCODE_POWER4
921 | PPC_OPCODE_POWER5);
923 else if (strcmp (arg, "power6") == 0)
925 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
926 | PPC_OPCODE_64 | PPC_OPCODE_POWER4
927 | PPC_OPCODE_POWER5 | PPC_OPCODE_POWER6);
929 else if (strcmp (arg, "cell") == 0)
931 ppc_cpu = (PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC
932 | PPC_OPCODE_64 | PPC_OPCODE_POWER4
935 /* -mcom means assemble for the common intersection between Power
936 and PowerPC. At present, we just allow the union, rather
937 than the intersection. */
938 else if (strcmp (arg, "com") == 0)
939 ppc_cpu = PPC_OPCODE_COMMON | PPC_OPCODE_32;
940 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
941 else if (strcmp (arg, "any") == 0)
942 ppc_cpu |= PPC_OPCODE_ANY;
946 /* Make sure the the Altivec and SPE bits are not lost. */
947 ppc_cpu |= altivec_or_spe;
952 md_parse_option (int c, char *arg)
957 /* -u means that any undefined symbols should be treated as
958 external, which is the default for gas anyhow. */
963 /* Solaris as takes -le (presumably for little endian). For completeness
964 sake, recognize -be also. */
965 if (strcmp (arg, "e") == 0)
967 target_big_endian = 0;
968 set_target_endian = 1;
976 if (strcmp (arg, "e") == 0)
978 target_big_endian = 1;
979 set_target_endian = 1;
987 /* Recognize -K PIC. */
988 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
991 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
999 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1001 if (strcmp (arg, "64") == 0)
1006 as_fatal (_("%s unsupported"), "-a64");
1009 else if (strcmp (arg, "32") == 0)
1016 if (parse_cpu (arg))
1019 else if (strcmp (arg, "regnames") == 0)
1022 else if (strcmp (arg, "no-regnames") == 0)
1023 reg_names_p = FALSE;
1026 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1027 that require relocation. */
1028 else if (strcmp (arg, "relocatable") == 0)
1030 shlib = SHLIB_MRELOCATABLE;
1031 ppc_flags |= EF_PPC_RELOCATABLE;
1034 else if (strcmp (arg, "relocatable-lib") == 0)
1036 shlib = SHLIB_MRELOCATABLE;
1037 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1040 /* -memb, set embedded bit. */
1041 else if (strcmp (arg, "emb") == 0)
1042 ppc_flags |= EF_PPC_EMB;
1044 /* -mlittle/-mbig set the endianess. */
1045 else if (strcmp (arg, "little") == 0
1046 || strcmp (arg, "little-endian") == 0)
1048 target_big_endian = 0;
1049 set_target_endian = 1;
1052 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
1054 target_big_endian = 1;
1055 set_target_endian = 1;
1058 else if (strcmp (arg, "solaris") == 0)
1061 ppc_comment_chars = ppc_solaris_comment_chars;
1064 else if (strcmp (arg, "no-solaris") == 0)
1067 ppc_comment_chars = ppc_eabi_comment_chars;
1072 as_bad (_("invalid switch -m%s"), arg);
1078 /* -V: SVR4 argument to print version ID. */
1080 print_version_id ();
1083 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1084 should be emitted or not. FIXME: Not implemented. */
1088 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1089 rather than .stabs.excl, which is ignored by the linker.
1090 FIXME: Not implemented. */
1106 md_show_usage (FILE *stream)
1108 fprintf (stream, _("\
1110 -a32 generate ELF32/XCOFF32\n\
1111 -a64 generate ELF64/XCOFF64\n\
1113 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1114 -mpwr generate code for POWER (RIOS1)\n\
1115 -m601 generate code for PowerPC 601\n\
1116 -mppc, -mppc32, -m603, -m604\n\
1117 generate code for PowerPC 603/604\n\
1118 -m403, -m405 generate code for PowerPC 403/405\n\
1119 -m440 generate code for PowerPC 440\n\
1120 -m7400, -m7410, -m7450, -m7455\n\
1121 generate code for PowerPC 7400/7410/7450/7455\n\
1122 -m750cl generate code for PowerPC 750cl\n"));
1123 fprintf (stream, _("\
1124 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1125 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1126 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1127 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1128 -mpower4 generate code for Power4 architecture\n\
1129 -mpower5 generate code for Power5 architecture\n\
1130 -mpower6 generate code for Power6 architecture\n\
1131 -mcell generate code for Cell Broadband Engine architecture\n\
1132 -mcom generate code Power/PowerPC common instructions\n\
1133 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1134 fprintf (stream, _("\
1135 -maltivec generate code for AltiVec\n\
1136 -me300 generate code for PowerPC e300 family\n\
1137 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1138 -mspe generate code for Motorola SPE instructions\n\
1139 -mregnames Allow symbolic names for registers\n\
1140 -mno-regnames Do not allow symbolic names for registers\n"));
1142 fprintf (stream, _("\
1143 -mrelocatable support for GCC's -mrelocatble option\n\
1144 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1145 -memb set PPC_EMB bit in ELF flags\n\
1146 -mlittle, -mlittle-endian, -l, -le\n\
1147 generate code for a little endian machine\n\
1148 -mbig, -mbig-endian, -b, -be\n\
1149 generate code for a big endian machine\n\
1150 -msolaris generate code for Solaris\n\
1151 -mno-solaris do not generate code for Solaris\n\
1152 -V print assembler version number\n\
1153 -Qy, -Qn ignored\n"));
1157 /* Set ppc_cpu if it is not already set. */
1162 const char *default_os = TARGET_OS;
1163 const char *default_cpu = TARGET_CPU;
1165 if ((ppc_cpu & ~PPC_OPCODE_ANY) == 0)
1168 ppc_cpu |= PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC | PPC_OPCODE_64;
1169 else if (strncmp (default_os, "aix", 3) == 0
1170 && default_os[3] >= '4' && default_os[3] <= '9')
1171 ppc_cpu |= PPC_OPCODE_COMMON | PPC_OPCODE_32;
1172 else if (strncmp (default_os, "aix3", 4) == 0)
1173 ppc_cpu |= PPC_OPCODE_POWER | PPC_OPCODE_32;
1174 else if (strcmp (default_cpu, "rs6000") == 0)
1175 ppc_cpu |= PPC_OPCODE_POWER | PPC_OPCODE_32;
1176 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1177 ppc_cpu |= PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC | PPC_OPCODE_32;
1179 as_fatal (_("Unknown default cpu = %s, os = %s"),
1180 default_cpu, default_os);
1184 /* Figure out the BFD architecture to use. This function and ppc_mach
1185 are called well before md_begin, when the output file is opened. */
1187 enum bfd_architecture
1190 const char *default_cpu = TARGET_CPU;
1193 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
1194 return bfd_arch_powerpc;
1195 else if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
1196 return bfd_arch_rs6000;
1197 else if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
1199 if (strcmp (default_cpu, "rs6000") == 0)
1200 return bfd_arch_rs6000;
1201 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1202 return bfd_arch_powerpc;
1205 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1206 return bfd_arch_unknown;
1213 return bfd_mach_ppc64;
1214 else if (ppc_arch () == bfd_arch_rs6000)
1215 return bfd_mach_rs6k;
1217 return bfd_mach_ppc;
1221 ppc_target_format (void)
1225 return target_big_endian ? "pe-powerpc" : "pe-powerpcle";
1227 return "xcoff-powermac";
1230 return (ppc_obj64 ? "aix5coff64-rs6000" : "aixcoff-rs6000");
1232 return (ppc_obj64 ? "aixcoff64-rs6000" : "aixcoff-rs6000");
1238 return "elf32-powerpc-vxworks";
1240 return (target_big_endian
1241 ? (ppc_obj64 ? "elf64-powerpc" : "elf32-powerpc")
1242 : (ppc_obj64 ? "elf64-powerpcle" : "elf32-powerpcle"));
1247 /* Insert opcodes and macros into hash tables. Called at startup and
1251 ppc_setup_opcodes (void)
1253 const struct powerpc_opcode *op;
1254 const struct powerpc_opcode *op_end;
1255 const struct powerpc_macro *macro;
1256 const struct powerpc_macro *macro_end;
1257 bfd_boolean bad_insn = FALSE;
1258 unsigned long prev_opcode = 0;
1260 if (ppc_hash != NULL)
1261 hash_die (ppc_hash);
1262 if (ppc_macro_hash != NULL)
1263 hash_die (ppc_macro_hash);
1265 /* Insert the opcodes into a hash table. */
1266 ppc_hash = hash_new ();
1268 if (ENABLE_CHECKING)
1272 /* Check operand masks. Code here and in the disassembler assumes
1273 all the 1's in the mask are contiguous. */
1274 for (i = 0; i < num_powerpc_operands; ++i)
1276 unsigned long mask = powerpc_operands[i].bitm;
1277 unsigned long right_bit;
1280 right_bit = mask & -mask;
1282 right_bit = mask & -mask;
1283 if (mask != right_bit)
1285 as_bad (_("powerpc_operands[%d].bitm invalid"), i);
1288 for (j = i + 1; j < num_powerpc_operands; ++j)
1289 if (memcmp (&powerpc_operands[i], &powerpc_operands[j],
1290 sizeof (powerpc_operands[0])) == 0)
1292 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1299 op_end = powerpc_opcodes + powerpc_num_opcodes;
1300 for (op = powerpc_opcodes; op < op_end; op++)
1302 if (ENABLE_CHECKING)
1304 const unsigned char *o;
1305 unsigned long omask = op->mask;
1306 unsigned long major_opcode = PPC_OP (op->opcode);
1308 /* The major opcodes had better be sorted. Code in the disassembler
1309 assumes the insns are sorted according to major opcode. */
1310 if (major_opcode < prev_opcode)
1312 as_bad (_("major opcode is not sorted for %s"),
1316 prev_opcode = major_opcode;
1318 /* The mask had better not trim off opcode bits. */
1319 if ((op->opcode & omask) != op->opcode)
1321 as_bad (_("mask trims opcode bits for %s"),
1326 /* The operands must not overlap the opcode or each other. */
1327 for (o = op->operands; *o; ++o)
1328 if (*o >= num_powerpc_operands)
1330 as_bad (_("operand index error for %s"),
1336 const struct powerpc_operand *operand = &powerpc_operands[*o];
1337 if (operand->shift >= 0)
1339 unsigned long mask = operand->bitm << operand->shift;
1342 as_bad (_("operand %d overlap in %s"),
1343 (int) (o - op->operands), op->name);
1351 if ((op->flags & ppc_cpu & ~(PPC_OPCODE_32 | PPC_OPCODE_64)) != 0
1352 && ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == 0
1353 || ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64))
1354 == (ppc_cpu & (PPC_OPCODE_32 | PPC_OPCODE_64)))
1355 || (ppc_cpu & PPC_OPCODE_64_BRIDGE) != 0)
1356 /* Certain instructions (eg: extsw) do not exist in the
1357 32-bit BookE instruction set, but they do exist in the
1358 64-bit BookE instruction set, and other PPC instruction
1359 sets. Check to see if the opcode has the BOOKE64 flag set.
1360 If it does make sure that the target CPU is not the BookE32. */
1361 && ((op->flags & PPC_OPCODE_BOOKE64) == 0
1362 || (ppc_cpu & PPC_OPCODE_BOOKE64) == PPC_OPCODE_BOOKE64
1363 || (ppc_cpu & PPC_OPCODE_BOOKE) == 0)
1364 && ((op->flags & (PPC_OPCODE_POWER4 | PPC_OPCODE_NOPOWER4)) == 0
1365 || ((op->flags & PPC_OPCODE_POWER4)
1366 == (ppc_cpu & PPC_OPCODE_POWER4)))
1367 && ((op->flags & PPC_OPCODE_POWER5) == 0
1368 || ((op->flags & PPC_OPCODE_POWER5)
1369 == (ppc_cpu & PPC_OPCODE_POWER5)))
1370 && ((op->flags & PPC_OPCODE_POWER6) == 0
1371 || ((op->flags & PPC_OPCODE_POWER6)
1372 == (ppc_cpu & PPC_OPCODE_POWER6))))
1376 retval = hash_insert (ppc_hash, op->name, (void *) op);
1379 /* Ignore Power duplicates for -m601. */
1380 if ((ppc_cpu & PPC_OPCODE_601) != 0
1381 && (op->flags & PPC_OPCODE_POWER) != 0)
1384 as_bad (_("duplicate instruction %s"),
1391 if ((ppc_cpu & PPC_OPCODE_ANY) != 0)
1392 for (op = powerpc_opcodes; op < op_end; op++)
1393 hash_insert (ppc_hash, op->name, (void *) op);
1395 /* Insert the macros into a hash table. */
1396 ppc_macro_hash = hash_new ();
1398 macro_end = powerpc_macros + powerpc_num_macros;
1399 for (macro = powerpc_macros; macro < macro_end; macro++)
1401 if ((macro->flags & ppc_cpu) != 0)
1405 retval = hash_insert (ppc_macro_hash, macro->name, (void *) macro);
1406 if (retval != (const char *) NULL)
1408 as_bad (_("duplicate macro %s"), macro->name);
1418 /* This function is called when the assembler starts up. It is called
1419 after the options have been parsed and the output file has been
1427 ppc_cie_data_alignment = ppc_obj64 ? -8 : -4;
1430 /* Set the ELF flags if desired. */
1431 if (ppc_flags && !msolaris)
1432 bfd_set_private_flags (stdoutput, ppc_flags);
1435 ppc_setup_opcodes ();
1437 /* Tell the main code what the endianness is if it is not overridden
1439 if (!set_target_endian)
1441 set_target_endian = 1;
1442 target_big_endian = PPC_BIG_ENDIAN;
1446 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1448 /* Create dummy symbols to serve as initial csects. This forces the
1449 text csects to precede the data csects. These symbols will not
1451 ppc_text_csects = symbol_make ("dummy\001");
1452 symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
1453 ppc_data_csects = symbol_make ("dummy\001");
1454 symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
1459 ppc_current_section = text_section;
1460 ppc_previous_section = 0;
1469 if (ppc_apuinfo_list == NULL)
1472 /* Ok, so write the section info out. We have this layout:
1476 0 8 length of "APUinfo\0"
1477 4 (n*4) number of APU's (4 bytes each)
1480 20 APU#1 first APU's info
1481 24 APU#2 second APU's info
1486 asection *seg = now_seg;
1487 subsegT subseg = now_subseg;
1488 asection *apuinfo_secp = (asection *) NULL;
1491 /* Create the .PPC.EMB.apuinfo section. */
1492 apuinfo_secp = subseg_new (".PPC.EMB.apuinfo", 0);
1493 bfd_set_section_flags (stdoutput,
1495 SEC_HAS_CONTENTS | SEC_READONLY);
1498 md_number_to_chars (p, (valueT) 8, 4);
1501 md_number_to_chars (p, (valueT) ppc_apuinfo_num * 4, 4);
1504 md_number_to_chars (p, (valueT) 2, 4);
1507 strcpy (p, "APUinfo");
1509 for (i = 0; i < ppc_apuinfo_num; i++)
1512 md_number_to_chars (p, (valueT) ppc_apuinfo_list[i], 4);
1515 frag_align (2, 0, 0);
1517 /* We probably can't restore the current segment, for there likely
1520 subseg_set (seg, subseg);
1525 /* Insert an operand value into an instruction. */
1527 static unsigned long
1528 ppc_insert_operand (unsigned long insn,
1529 const struct powerpc_operand *operand,
1531 unsigned long ppc_cpu,
1535 long min, max, right;
1537 max = operand->bitm;
1541 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1543 if ((operand->flags & PPC_OPERAND_SIGNOPT) == 0)
1544 max = (max >> 1) & -right;
1545 min = ~max & -right;
1548 if ((operand->flags & PPC_OPERAND_PLUS1) != 0)
1551 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1560 /* Some people write constants with the sign extension done by
1561 hand but only up to 32 bits. This shouldn't really be valid,
1562 but, to permit this code to assemble on a 64-bit host, we
1563 sign extend the 32-bit value to 64 bits if so doing makes the
1566 && (offsetT) (val - 0x80000000 - 0x80000000) >= min
1567 && (offsetT) (val - 0x80000000 - 0x80000000) <= max
1568 && ((val - 0x80000000 - 0x80000000) & (right - 1)) == 0)
1569 val = val - 0x80000000 - 0x80000000;
1571 /* Similarly, people write expressions like ~(1<<15), and expect
1572 this to be OK for a 32-bit unsigned value. */
1574 && (offsetT) (val + 0x80000000 + 0x80000000) >= min
1575 && (offsetT) (val + 0x80000000 + 0x80000000) <= max
1576 && ((val + 0x80000000 + 0x80000000) & (right - 1)) == 0)
1577 val = val + 0x80000000 + 0x80000000;
1581 || (val & (right - 1)) != 0)
1582 as_bad_value_out_of_range (_("operand"), val, min, max, file, line);
1585 if (operand->insert)
1590 insn = (*operand->insert) (insn, (long) val, ppc_cpu, &errmsg);
1591 if (errmsg != (const char *) NULL)
1592 as_bad_where (file, line, errmsg);
1595 insn |= ((long) val & operand->bitm) << operand->shift;
1602 /* Parse @got, etc. and return the desired relocation. */
1603 static bfd_reloc_code_real_type
1604 ppc_elf_suffix (char **str_p, expressionS *exp_p)
1608 unsigned int length : 8;
1609 unsigned int valid32 : 1;
1610 unsigned int valid64 : 1;
1619 const struct map_bfd *ptr;
1621 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1622 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1623 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1625 static const struct map_bfd mapping[] = {
1626 MAP ("l", BFD_RELOC_LO16),
1627 MAP ("h", BFD_RELOC_HI16),
1628 MAP ("ha", BFD_RELOC_HI16_S),
1629 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1630 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1631 MAP ("got", BFD_RELOC_16_GOTOFF),
1632 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1633 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1634 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1635 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1636 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1637 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1638 MAP ("copy", BFD_RELOC_PPC_COPY),
1639 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1640 MAP ("sectoff", BFD_RELOC_16_BASEREL),
1641 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1642 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1643 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1644 MAP ("tls", BFD_RELOC_PPC_TLS),
1645 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD),
1646 MAP ("dtprel", BFD_RELOC_PPC_DTPREL),
1647 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO),
1648 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI),
1649 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA),
1650 MAP ("tprel", BFD_RELOC_PPC_TPREL),
1651 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO),
1652 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI),
1653 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA),
1654 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16),
1655 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO),
1656 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI),
1657 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA),
1658 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16),
1659 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO),
1660 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI),
1661 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA),
1662 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16),
1663 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO),
1664 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI),
1665 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA),
1666 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16),
1667 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO),
1668 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI),
1669 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA),
1670 MAP32 ("fixup", BFD_RELOC_CTOR),
1671 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL),
1672 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1673 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1674 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC),
1675 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL),
1676 MAP32 ("sdarel", BFD_RELOC_GPREL16),
1677 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1678 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1679 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1680 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1681 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1682 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1683 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1684 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1685 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1686 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1687 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1688 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1689 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1690 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1691 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1692 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1693 MAP32 ("xgot", BFD_RELOC_PPC_TOC16),
1694 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER),
1695 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S),
1696 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST),
1697 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S),
1698 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC),
1699 MAP64 ("toc", BFD_RELOC_PPC_TOC16),
1700 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO),
1701 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI),
1702 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA),
1703 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER),
1704 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA),
1705 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST),
1706 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA),
1707 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER),
1708 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA),
1709 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST),
1710 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA),
1711 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED }
1715 return BFD_RELOC_UNUSED;
1717 for (ch = *str, str2 = ident;
1718 (str2 < ident + sizeof (ident) - 1
1719 && (ISALNUM (ch) || ch == '@'));
1722 *str2++ = TOLOWER (ch);
1729 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1730 if (ch == ptr->string[0]
1731 && len == ptr->length
1732 && memcmp (ident, ptr->string, ptr->length) == 0
1733 && (ppc_obj64 ? ptr->valid64 : ptr->valid32))
1735 int reloc = ptr->reloc;
1738 if (exp_p->X_add_number != 0
1739 && (reloc == (int) BFD_RELOC_16_GOTOFF
1740 || reloc == (int) BFD_RELOC_LO16_GOTOFF
1741 || reloc == (int) BFD_RELOC_HI16_GOTOFF
1742 || reloc == (int) BFD_RELOC_HI16_S_GOTOFF))
1743 as_warn (_("identifier+constant@got means identifier@got+constant"));
1745 /* Now check for identifier@suffix+constant. */
1746 if (*str == '-' || *str == '+')
1748 char *orig_line = input_line_pointer;
1749 expressionS new_exp;
1751 input_line_pointer = str;
1752 expression (&new_exp);
1753 if (new_exp.X_op == O_constant)
1755 exp_p->X_add_number += new_exp.X_add_number;
1756 str = input_line_pointer;
1759 if (&input_line_pointer != str_p)
1760 input_line_pointer = orig_line;
1764 if (reloc == (int) BFD_RELOC_PPC64_TOC
1765 && exp_p->X_op == O_symbol
1766 && strcmp (S_GET_NAME (exp_p->X_add_symbol), ".TOC.") == 0)
1768 /* Change the symbol so that the dummy .TOC. symbol can be
1769 omitted from the object file. */
1770 exp_p->X_add_symbol = &abs_symbol;
1773 return (bfd_reloc_code_real_type) reloc;
1776 return BFD_RELOC_UNUSED;
1779 /* Like normal .long/.short/.word, except support @got, etc.
1780 Clobbers input_line_pointer, checks end-of-line. */
1782 ppc_elf_cons (int nbytes /* 1=.byte, 2=.word, 4=.long, 8=.llong */)
1785 bfd_reloc_code_real_type reloc;
1787 if (is_it_end_of_statement ())
1789 demand_empty_rest_of_line ();
1796 if (exp.X_op == O_symbol
1797 && *input_line_pointer == '@'
1798 && (reloc = ppc_elf_suffix (&input_line_pointer,
1799 &exp)) != BFD_RELOC_UNUSED)
1801 reloc_howto_type *reloc_howto;
1804 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
1805 size = bfd_get_reloc_size (reloc_howto);
1809 as_bad (_("%s relocations do not fit in %d bytes\n"),
1810 reloc_howto->name, nbytes);
1817 p = frag_more (nbytes);
1819 if (target_big_endian)
1820 offset = nbytes - size;
1821 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
1826 emit_expr (&exp, (unsigned int) nbytes);
1828 while (*input_line_pointer++ == ',');
1830 /* Put terminator back into stream. */
1831 input_line_pointer--;
1832 demand_empty_rest_of_line ();
1835 /* Solaris pseduo op to change to the .rodata section. */
1837 ppc_elf_rdata (int xxx)
1839 char *save_line = input_line_pointer;
1840 static char section[] = ".rodata\n";
1842 /* Just pretend this is .section .rodata */
1843 input_line_pointer = section;
1844 obj_elf_section (xxx);
1846 input_line_pointer = save_line;
1849 /* Pseudo op to make file scope bss items. */
1851 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED)
1864 name = input_line_pointer;
1865 c = get_symbol_end ();
1867 /* just after name is now '\0'. */
1868 p = input_line_pointer;
1871 if (*input_line_pointer != ',')
1873 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1874 ignore_rest_of_line ();
1878 input_line_pointer++; /* skip ',' */
1879 if ((size = get_absolute_expression ()) < 0)
1881 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
1882 ignore_rest_of_line ();
1886 /* The third argument to .lcomm is the alignment. */
1887 if (*input_line_pointer != ',')
1891 ++input_line_pointer;
1892 align = get_absolute_expression ();
1895 as_warn (_("ignoring bad alignment"));
1901 symbolP = symbol_find_or_make (name);
1904 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1906 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1907 S_GET_NAME (symbolP));
1908 ignore_rest_of_line ();
1912 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1914 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1915 S_GET_NAME (symbolP),
1916 (long) S_GET_VALUE (symbolP),
1919 ignore_rest_of_line ();
1925 old_subsec = now_subseg;
1928 /* Convert to a power of 2 alignment. */
1929 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
1932 as_bad (_("Common alignment not a power of 2"));
1933 ignore_rest_of_line ();
1940 record_alignment (bss_section, align2);
1941 subseg_set (bss_section, 0);
1943 frag_align (align2, 0, 0);
1944 if (S_GET_SEGMENT (symbolP) == bss_section)
1945 symbol_get_frag (symbolP)->fr_symbol = 0;
1946 symbol_set_frag (symbolP, frag_now);
1947 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1950 S_SET_SIZE (symbolP, size);
1951 S_SET_SEGMENT (symbolP, bss_section);
1952 subseg_set (old_sec, old_subsec);
1953 demand_empty_rest_of_line ();
1956 /* Validate any relocations emitted for -mrelocatable, possibly adding
1957 fixups for word relocations in writable segments, so we can adjust
1960 ppc_elf_validate_fix (fixS *fixp, segT seg)
1962 if (fixp->fx_done || fixp->fx_pcrel)
1971 case SHLIB_MRELOCATABLE:
1972 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1973 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1974 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1975 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1976 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1977 && fixp->fx_r_type != BFD_RELOC_16_BASEREL
1978 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1979 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1980 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1981 && (seg->flags & SEC_LOAD) != 0
1982 && strcmp (segment_name (seg), ".got2") != 0
1983 && strcmp (segment_name (seg), ".dtors") != 0
1984 && strcmp (segment_name (seg), ".ctors") != 0
1985 && strcmp (segment_name (seg), ".fixup") != 0
1986 && strcmp (segment_name (seg), ".gcc_except_table") != 0
1987 && strcmp (segment_name (seg), ".eh_frame") != 0
1988 && strcmp (segment_name (seg), ".ex_shared") != 0)
1990 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1991 || fixp->fx_r_type != BFD_RELOC_CTOR)
1993 as_bad_where (fixp->fx_file, fixp->fx_line,
1994 _("Relocation cannot be done when using -mrelocatable"));
2001 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2002 function descriptor sym if the corresponding code sym is used. */
2005 ppc_frob_file_before_adjust (void)
2013 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2020 name = S_GET_NAME (symp);
2024 if (! S_IS_WEAK (symp)
2025 || S_IS_DEFINED (symp))
2028 len = strlen (name) + 1;
2029 dotname = xmalloc (len + 1);
2031 memcpy (dotname + 1, name, len);
2032 dotsym = symbol_find_noref (dotname, 1);
2034 if (dotsym != NULL && (symbol_used_p (dotsym)
2035 || symbol_used_in_reloc_p (dotsym)))
2036 symbol_mark_used (symp);
2040 toc = bfd_get_section_by_name (stdoutput, ".toc");
2042 && bfd_section_size (stdoutput, toc) > 0x10000)
2043 as_warn (_("TOC section size exceeds 64k"));
2045 /* Don't emit .TOC. symbol. */
2046 symp = symbol_find (".TOC.");
2048 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2050 #endif /* OBJ_ELF */
2055 * Summary of parse_toc_entry.
2057 * in: Input_line_pointer points to the '[' in one of:
2059 * [toc] [tocv] [toc32] [toc64]
2061 * Anything else is an error of one kind or another.
2064 * return value: success or failure
2065 * toc_kind: kind of toc reference
2066 * input_line_pointer:
2067 * success: first char after the ']'
2068 * failure: unchanged
2072 * [toc] - rv == success, toc_kind = default_toc
2073 * [tocv] - rv == success, toc_kind = data_in_toc
2074 * [toc32] - rv == success, toc_kind = must_be_32
2075 * [toc64] - rv == success, toc_kind = must_be_64
2079 enum toc_size_qualifier
2081 default_toc, /* The toc cell constructed should be the system default size */
2082 data_in_toc, /* This is a direct reference to a toc cell */
2083 must_be_32, /* The toc cell constructed must be 32 bits wide */
2084 must_be_64 /* The toc cell constructed must be 64 bits wide */
2088 parse_toc_entry (enum toc_size_qualifier *toc_kind)
2093 enum toc_size_qualifier t;
2095 /* Save the input_line_pointer. */
2096 start = input_line_pointer;
2098 /* Skip over the '[' , and whitespace. */
2099 ++input_line_pointer;
2102 /* Find the spelling of the operand. */
2103 toc_spec = input_line_pointer;
2104 c = get_symbol_end ();
2106 if (strcmp (toc_spec, "toc") == 0)
2110 else if (strcmp (toc_spec, "tocv") == 0)
2114 else if (strcmp (toc_spec, "toc32") == 0)
2118 else if (strcmp (toc_spec, "toc64") == 0)
2124 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
2125 *input_line_pointer = c;
2126 input_line_pointer = start;
2130 /* Now find the ']'. */
2131 *input_line_pointer = c;
2133 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2134 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
2138 as_bad (_("syntax error: expected `]', found `%c'"), c);
2139 input_line_pointer = start;
2150 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2152 ppc_apuinfo_section_add (unsigned int apu, unsigned int version)
2156 /* Check we don't already exist. */
2157 for (i = 0; i < ppc_apuinfo_num; i++)
2158 if (ppc_apuinfo_list[i] == APUID (apu, version))
2161 if (ppc_apuinfo_num == ppc_apuinfo_num_alloc)
2163 if (ppc_apuinfo_num_alloc == 0)
2165 ppc_apuinfo_num_alloc = 4;
2166 ppc_apuinfo_list = (unsigned long *)
2167 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2171 ppc_apuinfo_num_alloc += 4;
2172 ppc_apuinfo_list = (unsigned long *) xrealloc (ppc_apuinfo_list,
2173 sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2176 ppc_apuinfo_list[ppc_apuinfo_num++] = APUID (apu, version);
2182 /* We need to keep a list of fixups. We can't simply generate them as
2183 we go, because that would require us to first create the frag, and
2184 that would screw up references to ``.''. */
2190 bfd_reloc_code_real_type reloc;
2193 #define MAX_INSN_FIXUPS (5)
2195 /* This routine is called for each instruction to be assembled. */
2198 md_assemble (char *str)
2201 const struct powerpc_opcode *opcode;
2203 const unsigned char *opindex_ptr;
2207 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
2213 bfd_reloc_code_real_type reloc;
2216 /* Get the opcode. */
2217 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
2222 /* Look up the opcode in the hash table. */
2223 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
2224 if (opcode == (const struct powerpc_opcode *) NULL)
2226 const struct powerpc_macro *macro;
2228 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
2229 if (macro == (const struct powerpc_macro *) NULL)
2230 as_bad (_("Unrecognized opcode: `%s'"), str);
2232 ppc_macro (s, macro);
2237 insn = opcode->opcode;
2240 while (ISSPACE (*str))
2243 /* PowerPC operands are just expressions. The only real issue is
2244 that a few operand types are optional. All cases which might use
2245 an optional operand separate the operands only with commas (in some
2246 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2247 have optional operands). Most instructions with optional operands
2248 have only one. Those that have more than one optional operand can
2249 take either all their operands or none. So, before we start seriously
2250 parsing the operands, we check to see if we have optional operands,
2251 and if we do, we count the number of commas to see which operands
2252 have been omitted. */
2254 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2256 const struct powerpc_operand *operand;
2258 operand = &powerpc_operands[*opindex_ptr];
2259 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
2261 unsigned int opcount;
2262 unsigned int num_operands_expected;
2265 /* There is an optional operand. Count the number of
2266 commas in the input line. */
2273 while ((s = strchr (s, ',')) != (char *) NULL)
2280 /* Compute the number of expected operands.
2281 Do not count fake operands. */
2282 for (num_operands_expected = 0, i = 0; opcode->operands[i]; i ++)
2283 if ((powerpc_operands [opcode->operands[i]].flags & PPC_OPERAND_FAKE) == 0)
2284 ++ num_operands_expected;
2286 /* If there are fewer operands in the line then are called
2287 for by the instruction, we want to skip the optional
2289 if (opcount < num_operands_expected)
2296 /* Gather the operands. */
2300 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2302 const struct powerpc_operand *operand;
2308 if (next_opindex == 0)
2309 operand = &powerpc_operands[*opindex_ptr];
2312 operand = &powerpc_operands[next_opindex];
2317 /* If this is a fake operand, then we do not expect anything
2319 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
2321 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2322 if (errmsg != (const char *) NULL)
2327 /* If this is an optional operand, and we are skipping it, just
2329 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
2332 if (operand->insert)
2334 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2335 if (errmsg != (const char *) NULL)
2338 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
2339 next_opindex = *opindex_ptr + 1;
2343 /* Gather the operand. */
2344 hold = input_line_pointer;
2345 input_line_pointer = str;
2348 if (*input_line_pointer == '[')
2350 /* We are expecting something like the second argument here:
2352 * lwz r4,[toc].GS.0.static_int(rtoc)
2353 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2354 * The argument following the `]' must be a symbol name, and the
2355 * register must be the toc register: 'rtoc' or '2'
2357 * The effect is to 0 as the displacement field
2358 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2359 * the appropriate variation) reloc against it based on the symbol.
2360 * The linker will build the toc, and insert the resolved toc offset.
2363 * o The size of the toc entry is currently assumed to be
2364 * 32 bits. This should not be assumed to be a hard coded
2366 * o In an effort to cope with a change from 32 to 64 bits,
2367 * there are also toc entries that are specified to be
2368 * either 32 or 64 bits:
2369 * lwz r4,[toc32].GS.0.static_int(rtoc)
2370 * lwz r4,[toc64].GS.0.static_int(rtoc)
2371 * These demand toc entries of the specified size, and the
2372 * instruction probably requires it.
2376 enum toc_size_qualifier toc_kind;
2377 bfd_reloc_code_real_type toc_reloc;
2379 /* Go parse off the [tocXX] part. */
2380 valid_toc = parse_toc_entry (&toc_kind);
2384 /* Note: message has already been issued.
2385 FIXME: what sort of recovery should we do?
2386 demand_rest_of_line (); return; ? */
2389 /* Now get the symbol following the ']'. */
2395 /* In this case, we may not have seen the symbol yet,
2396 since it is allowed to appear on a .extern or .globl
2397 or just be a label in the .data section. */
2398 toc_reloc = BFD_RELOC_PPC_TOC16;
2401 /* 1. The symbol must be defined and either in the toc
2402 section, or a global.
2403 2. The reloc generated must have the TOCDEFN flag set
2404 in upper bit mess of the reloc type.
2405 FIXME: It's a little confusing what the tocv
2406 qualifier can be used for. At the very least, I've
2407 seen three uses, only one of which I'm sure I can
2409 if (ex.X_op == O_symbol)
2411 assert (ex.X_add_symbol != NULL);
2412 if (symbol_get_bfdsym (ex.X_add_symbol)->section
2415 as_bad (_("[tocv] symbol is not a toc symbol"));
2419 toc_reloc = BFD_RELOC_PPC_TOC16;
2422 /* FIXME: these next two specifically specify 32/64 bit
2423 toc entries. We don't support them today. Is this
2424 the right way to say that? */
2425 toc_reloc = BFD_RELOC_UNUSED;
2426 as_bad (_("Unimplemented toc32 expression modifier"));
2429 /* FIXME: see above. */
2430 toc_reloc = BFD_RELOC_UNUSED;
2431 as_bad (_("Unimplemented toc64 expression modifier"));
2435 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2441 /* We need to generate a fixup for this expression. */
2442 if (fc >= MAX_INSN_FIXUPS)
2443 as_fatal (_("too many fixups"));
2445 fixups[fc].reloc = toc_reloc;
2446 fixups[fc].exp = ex;
2447 fixups[fc].opindex = *opindex_ptr;
2450 /* Ok. We've set up the fixup for the instruction. Now make it
2451 look like the constant 0 was found here. */
2453 ex.X_op = O_constant;
2454 ex.X_add_number = 0;
2455 ex.X_add_symbol = NULL;
2456 ex.X_op_symbol = NULL;
2462 if ((reg_names_p && (operand->flags & PPC_OPERAND_CR) != 0)
2463 || !register_name (&ex))
2465 char save_lex = lex_type['%'];
2467 if ((operand->flags & PPC_OPERAND_CR) != 0)
2470 lex_type['%'] |= LEX_BEGIN_NAME;
2474 lex_type['%'] = save_lex;
2478 str = input_line_pointer;
2479 input_line_pointer = hold;
2481 if (ex.X_op == O_illegal)
2482 as_bad (_("illegal operand"));
2483 else if (ex.X_op == O_absent)
2484 as_bad (_("missing operand"));
2485 else if (ex.X_op == O_register)
2487 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2488 ppc_cpu, (char *) NULL, 0);
2490 else if (ex.X_op == O_constant)
2493 /* Allow @HA, @L, @H on constants. */
2494 char *orig_str = str;
2496 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2503 case BFD_RELOC_LO16:
2504 /* X_unsigned is the default, so if the user has done
2505 something which cleared it, we always produce a
2507 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2508 ex.X_add_number &= 0xffff;
2510 ex.X_add_number = SEX16 (ex.X_add_number);
2513 case BFD_RELOC_HI16:
2514 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2515 ex.X_add_number = PPC_HI (ex.X_add_number);
2517 ex.X_add_number = SEX16 (PPC_HI (ex.X_add_number));
2520 case BFD_RELOC_HI16_S:
2521 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2522 ex.X_add_number = PPC_HA (ex.X_add_number);
2524 ex.X_add_number = SEX16 (PPC_HA (ex.X_add_number));
2527 case BFD_RELOC_PPC64_HIGHER:
2528 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2529 ex.X_add_number = PPC_HIGHER (ex.X_add_number);
2531 ex.X_add_number = SEX16 (PPC_HIGHER (ex.X_add_number));
2534 case BFD_RELOC_PPC64_HIGHER_S:
2535 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2536 ex.X_add_number = PPC_HIGHERA (ex.X_add_number);
2538 ex.X_add_number = SEX16 (PPC_HIGHERA (ex.X_add_number));
2541 case BFD_RELOC_PPC64_HIGHEST:
2542 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2543 ex.X_add_number = PPC_HIGHEST (ex.X_add_number);
2545 ex.X_add_number = SEX16 (PPC_HIGHEST (ex.X_add_number));
2548 case BFD_RELOC_PPC64_HIGHEST_S:
2549 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2550 ex.X_add_number = PPC_HIGHESTA (ex.X_add_number);
2552 ex.X_add_number = SEX16 (PPC_HIGHESTA (ex.X_add_number));
2555 #endif /* OBJ_ELF */
2556 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2557 ppc_cpu, (char *) NULL, 0);
2560 else if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2562 /* Some TLS tweaks. */
2567 case BFD_RELOC_PPC_TLS:
2568 insn = ppc_insert_operand (insn, operand, ppc_obj64 ? 13 : 2,
2569 ppc_cpu, (char *) NULL, 0);
2571 /* We'll only use the 32 (or 64) bit form of these relocations
2572 in constants. Instructions get the 16 bit form. */
2573 case BFD_RELOC_PPC_DTPREL:
2574 reloc = BFD_RELOC_PPC_DTPREL16;
2576 case BFD_RELOC_PPC_TPREL:
2577 reloc = BFD_RELOC_PPC_TPREL16;
2581 /* For the absolute forms of branches, convert the PC
2582 relative form back into the absolute. */
2583 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
2587 case BFD_RELOC_PPC_B26:
2588 reloc = BFD_RELOC_PPC_BA26;
2590 case BFD_RELOC_PPC_B16:
2591 reloc = BFD_RELOC_PPC_BA16;
2593 case BFD_RELOC_PPC_B16_BRTAKEN:
2594 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
2596 case BFD_RELOC_PPC_B16_BRNTAKEN:
2597 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
2605 && (operand->flags & (PPC_OPERAND_DS | PPC_OPERAND_DQ)) != 0)
2610 reloc = BFD_RELOC_PPC64_ADDR16_DS;
2612 case BFD_RELOC_LO16:
2613 reloc = BFD_RELOC_PPC64_ADDR16_LO_DS;
2615 case BFD_RELOC_16_GOTOFF:
2616 reloc = BFD_RELOC_PPC64_GOT16_DS;
2618 case BFD_RELOC_LO16_GOTOFF:
2619 reloc = BFD_RELOC_PPC64_GOT16_LO_DS;
2621 case BFD_RELOC_LO16_PLTOFF:
2622 reloc = BFD_RELOC_PPC64_PLT16_LO_DS;
2624 case BFD_RELOC_16_BASEREL:
2625 reloc = BFD_RELOC_PPC64_SECTOFF_DS;
2627 case BFD_RELOC_LO16_BASEREL:
2628 reloc = BFD_RELOC_PPC64_SECTOFF_LO_DS;
2630 case BFD_RELOC_PPC_TOC16:
2631 reloc = BFD_RELOC_PPC64_TOC16_DS;
2633 case BFD_RELOC_PPC64_TOC16_LO:
2634 reloc = BFD_RELOC_PPC64_TOC16_LO_DS;
2636 case BFD_RELOC_PPC64_PLTGOT16:
2637 reloc = BFD_RELOC_PPC64_PLTGOT16_DS;
2639 case BFD_RELOC_PPC64_PLTGOT16_LO:
2640 reloc = BFD_RELOC_PPC64_PLTGOT16_LO_DS;
2642 case BFD_RELOC_PPC_DTPREL16:
2643 reloc = BFD_RELOC_PPC64_DTPREL16_DS;
2645 case BFD_RELOC_PPC_DTPREL16_LO:
2646 reloc = BFD_RELOC_PPC64_DTPREL16_LO_DS;
2648 case BFD_RELOC_PPC_TPREL16:
2649 reloc = BFD_RELOC_PPC64_TPREL16_DS;
2651 case BFD_RELOC_PPC_TPREL16_LO:
2652 reloc = BFD_RELOC_PPC64_TPREL16_LO_DS;
2654 case BFD_RELOC_PPC_GOT_DTPREL16:
2655 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
2656 case BFD_RELOC_PPC_GOT_TPREL16:
2657 case BFD_RELOC_PPC_GOT_TPREL16_LO:
2660 as_bad (_("unsupported relocation for DS offset field"));
2665 /* We need to generate a fixup for this expression. */
2666 if (fc >= MAX_INSN_FIXUPS)
2667 as_fatal (_("too many fixups"));
2668 fixups[fc].exp = ex;
2669 fixups[fc].opindex = 0;
2670 fixups[fc].reloc = reloc;
2673 #endif /* OBJ_ELF */
2677 /* We need to generate a fixup for this expression. */
2678 if (fc >= MAX_INSN_FIXUPS)
2679 as_fatal (_("too many fixups"));
2680 fixups[fc].exp = ex;
2681 fixups[fc].opindex = *opindex_ptr;
2682 fixups[fc].reloc = BFD_RELOC_UNUSED;
2690 /* If expecting more operands, then we want to see "),". */
2691 if (*str == endc && opindex_ptr[1] != 0)
2695 while (ISSPACE (*str));
2699 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
2707 /* The call to expression should have advanced str past any
2710 && (endc != ',' || *str != '\0'))
2712 as_bad (_("syntax error; found `%c' but expected `%c'"), *str, endc);
2720 while (ISSPACE (*str))
2724 as_bad (_("junk at end of line: `%s'"), str);
2727 /* Do we need/want a APUinfo section? */
2728 if (ppc_cpu & (PPC_OPCODE_SPE
2729 | PPC_OPCODE_ISEL | PPC_OPCODE_EFS
2730 | PPC_OPCODE_BRLOCK | PPC_OPCODE_PMR | PPC_OPCODE_CACHELCK
2731 | PPC_OPCODE_RFMCI))
2733 /* These are all version "1". */
2734 if (opcode->flags & PPC_OPCODE_SPE)
2735 ppc_apuinfo_section_add (PPC_APUINFO_SPE, 1);
2736 if (opcode->flags & PPC_OPCODE_ISEL)
2737 ppc_apuinfo_section_add (PPC_APUINFO_ISEL, 1);
2738 if (opcode->flags & PPC_OPCODE_EFS)
2739 ppc_apuinfo_section_add (PPC_APUINFO_EFS, 1);
2740 if (opcode->flags & PPC_OPCODE_BRLOCK)
2741 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK, 1);
2742 if (opcode->flags & PPC_OPCODE_PMR)
2743 ppc_apuinfo_section_add (PPC_APUINFO_PMR, 1);
2744 if (opcode->flags & PPC_OPCODE_CACHELCK)
2745 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK, 1);
2746 if (opcode->flags & PPC_OPCODE_RFMCI)
2747 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI, 1);
2751 /* Write out the instruction. */
2753 addr_mod = frag_now_fix () & 3;
2754 if (frag_now->has_code && frag_now->insn_addr != addr_mod)
2755 as_bad (_("instruction address is not a multiple of 4"));
2756 frag_now->insn_addr = addr_mod;
2757 frag_now->has_code = 1;
2758 md_number_to_chars (f, insn, 4);
2761 dwarf2_emit_insn (4);
2764 /* Create any fixups. At this point we do not use a
2765 bfd_reloc_code_real_type, but instead just use the
2766 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2767 handle fixups for any operand type, although that is admittedly
2768 not a very exciting feature. We pick a BFD reloc type in
2770 for (i = 0; i < fc; i++)
2772 const struct powerpc_operand *operand;
2774 operand = &powerpc_operands[fixups[i].opindex];
2775 if (fixups[i].reloc != BFD_RELOC_UNUSED)
2777 reloc_howto_type *reloc_howto;
2782 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
2786 size = bfd_get_reloc_size (reloc_howto);
2787 offset = target_big_endian ? (4 - size) : 0;
2789 if (size < 1 || size > 4)
2792 fixP = fix_new_exp (frag_now,
2793 f - frag_now->fr_literal + offset,
2796 reloc_howto->pc_relative,
2799 /* Turn off complaints that the addend is too large for things like
2801 switch (fixups[i].reloc)
2803 case BFD_RELOC_16_GOTOFF:
2804 case BFD_RELOC_PPC_TOC16:
2805 case BFD_RELOC_LO16:
2806 case BFD_RELOC_HI16:
2807 case BFD_RELOC_HI16_S:
2809 case BFD_RELOC_PPC64_HIGHER:
2810 case BFD_RELOC_PPC64_HIGHER_S:
2811 case BFD_RELOC_PPC64_HIGHEST:
2812 case BFD_RELOC_PPC64_HIGHEST_S:
2814 fixP->fx_no_overflow = 1;
2821 fix_new_exp (frag_now,
2822 f - frag_now->fr_literal,
2825 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
2826 ((bfd_reloc_code_real_type)
2827 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2831 /* Handle a macro. Gather all the operands, transform them as
2832 described by the macro, and call md_assemble recursively. All the
2833 operands are separated by commas; we don't accept parentheses
2834 around operands here. */
2837 ppc_macro (char *str, const struct powerpc_macro *macro)
2848 /* Gather the users operands into the operands array. */
2853 if (count >= sizeof operands / sizeof operands[0])
2855 operands[count++] = s;
2856 s = strchr (s, ',');
2857 if (s == (char *) NULL)
2862 if (count != macro->operands)
2864 as_bad (_("wrong number of operands"));
2868 /* Work out how large the string must be (the size is unbounded
2869 because it includes user input). */
2871 format = macro->format;
2872 while (*format != '\0')
2881 arg = strtol (format + 1, &send, 10);
2882 know (send != format && arg < count);
2883 len += strlen (operands[arg]);
2888 /* Put the string together. */
2889 complete = s = (char *) alloca (len + 1);
2890 format = macro->format;
2891 while (*format != '\0')
2897 arg = strtol (format + 1, &send, 10);
2898 strcpy (s, operands[arg]);
2905 /* Assemble the constructed instruction. */
2906 md_assemble (complete);
2910 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2913 ppc_section_letter (int letter, char **ptr_msg)
2918 *ptr_msg = _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2923 ppc_section_word (char *str, size_t len)
2925 if (len == 7 && strncmp (str, "exclude", 7) == 0)
2932 ppc_section_type (char *str, size_t len)
2934 if (len == 7 && strncmp (str, "ordered", 7) == 0)
2941 ppc_section_flags (int flags, int attr, int type)
2943 if (type == SHT_ORDERED)
2944 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
2946 if (attr & SHF_EXCLUDE)
2947 flags |= SEC_EXCLUDE;
2951 #endif /* OBJ_ELF */
2954 /* Pseudo-op handling. */
2956 /* The .byte pseudo-op. This is similar to the normal .byte
2957 pseudo-op, but it can also take a single ASCII string. */
2960 ppc_byte (int ignore ATTRIBUTE_UNUSED)
2962 if (*input_line_pointer != '\"')
2968 /* Gather characters. A real double quote is doubled. Unusual
2969 characters are not permitted. */
2970 ++input_line_pointer;
2975 c = *input_line_pointer++;
2979 if (*input_line_pointer != '\"')
2981 ++input_line_pointer;
2984 FRAG_APPEND_1_CHAR (c);
2987 demand_empty_rest_of_line ();
2992 /* XCOFF specific pseudo-op handling. */
2994 /* This is set if we are creating a .stabx symbol, since we don't want
2995 to handle symbol suffixes for such symbols. */
2996 static bfd_boolean ppc_stab_symbol;
2998 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2999 symbols in the .bss segment as though they were local common
3000 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3001 aligns .comm and .lcomm to 4 bytes. */
3004 ppc_comm (int lcomm)
3006 asection *current_seg = now_seg;
3007 subsegT current_subseg = now_subseg;
3013 symbolS *lcomm_sym = NULL;
3017 name = input_line_pointer;
3018 endc = get_symbol_end ();
3019 end_name = input_line_pointer;
3022 if (*input_line_pointer != ',')
3024 as_bad (_("missing size"));
3025 ignore_rest_of_line ();
3028 ++input_line_pointer;
3030 size = get_absolute_expression ();
3033 as_bad (_("negative size"));
3034 ignore_rest_of_line ();
3040 /* The third argument to .comm is the alignment. */
3041 if (*input_line_pointer != ',')
3045 ++input_line_pointer;
3046 align = get_absolute_expression ();
3049 as_warn (_("ignoring bad alignment"));
3064 /* The third argument to .lcomm appears to be the real local
3065 common symbol to create. References to the symbol named in
3066 the first argument are turned into references to the third
3068 if (*input_line_pointer != ',')
3070 as_bad (_("missing real symbol name"));
3071 ignore_rest_of_line ();
3074 ++input_line_pointer;
3076 lcomm_name = input_line_pointer;
3077 lcomm_endc = get_symbol_end ();
3079 lcomm_sym = symbol_find_or_make (lcomm_name);
3081 *input_line_pointer = lcomm_endc;
3085 sym = symbol_find_or_make (name);
3088 if (S_IS_DEFINED (sym)
3089 || S_GET_VALUE (sym) != 0)
3091 as_bad (_("attempt to redefine symbol"));
3092 ignore_rest_of_line ();
3096 record_alignment (bss_section, align);
3099 || ! S_IS_DEFINED (lcomm_sym))
3108 S_SET_EXTERNAL (sym);
3112 symbol_get_tc (lcomm_sym)->output = 1;
3113 def_sym = lcomm_sym;
3117 subseg_set (bss_section, 1);
3118 frag_align (align, 0, 0);
3120 symbol_set_frag (def_sym, frag_now);
3121 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
3122 def_size, (char *) NULL);
3124 S_SET_SEGMENT (def_sym, bss_section);
3125 symbol_get_tc (def_sym)->align = align;
3129 /* Align the size of lcomm_sym. */
3130 symbol_get_frag (lcomm_sym)->fr_offset =
3131 ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
3132 &~ ((1 << align) - 1));
3133 if (align > symbol_get_tc (lcomm_sym)->align)
3134 symbol_get_tc (lcomm_sym)->align = align;
3139 /* Make sym an offset from lcomm_sym. */
3140 S_SET_SEGMENT (sym, bss_section);
3141 symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
3142 S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
3143 symbol_get_frag (lcomm_sym)->fr_offset += size;
3146 subseg_set (current_seg, current_subseg);
3148 demand_empty_rest_of_line ();
3151 /* The .csect pseudo-op. This switches us into a different
3152 subsegment. The first argument is a symbol whose value is the
3153 start of the .csect. In COFF, csect symbols get special aux
3154 entries defined by the x_csect field of union internal_auxent. The
3155 optional second argument is the alignment (the default is 2). */
3158 ppc_csect (int ignore ATTRIBUTE_UNUSED)
3165 name = input_line_pointer;
3166 endc = get_symbol_end ();
3168 sym = symbol_find_or_make (name);
3170 *input_line_pointer = endc;
3172 if (S_GET_NAME (sym)[0] == '\0')
3174 /* An unnamed csect is assumed to be [PR]. */
3175 symbol_get_tc (sym)->class = XMC_PR;
3179 if (*input_line_pointer == ',')
3181 ++input_line_pointer;
3182 align = get_absolute_expression ();
3185 ppc_change_csect (sym, align);
3187 demand_empty_rest_of_line ();
3190 /* Change to a different csect. */
3193 ppc_change_csect (symbolS *sym, offsetT align)
3195 if (S_IS_DEFINED (sym))
3196 subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
3206 /* This is a new csect. We need to look at the symbol class to
3207 figure out whether it should go in the text section or the
3211 switch (symbol_get_tc (sym)->class)
3221 S_SET_SEGMENT (sym, text_section);
3222 symbol_get_tc (sym)->subseg = ppc_text_subsegment;
3223 ++ppc_text_subsegment;
3224 list_ptr = &ppc_text_csects;
3234 if (ppc_toc_csect != NULL
3235 && (symbol_get_tc (ppc_toc_csect)->subseg + 1
3236 == ppc_data_subsegment))
3238 S_SET_SEGMENT (sym, data_section);
3239 symbol_get_tc (sym)->subseg = ppc_data_subsegment;
3240 ++ppc_data_subsegment;
3241 list_ptr = &ppc_data_csects;
3247 /* We set the obstack chunk size to a small value before
3248 changing subsegments, so that we don't use a lot of memory
3249 space for what may be a small section. */
3250 hold_chunksize = chunksize;
3253 sec = subseg_new (segment_name (S_GET_SEGMENT (sym)),
3254 symbol_get_tc (sym)->subseg);
3256 chunksize = hold_chunksize;
3259 ppc_after_toc_frag = frag_now;
3261 record_alignment (sec, align);
3263 frag_align_code (align, 0);
3265 frag_align (align, 0, 0);
3267 symbol_set_frag (sym, frag_now);
3268 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3270 symbol_get_tc (sym)->align = align;
3271 symbol_get_tc (sym)->output = 1;
3272 symbol_get_tc (sym)->within = sym;
3274 for (list = *list_ptr;
3275 symbol_get_tc (list)->next != (symbolS *) NULL;
3276 list = symbol_get_tc (list)->next)
3278 symbol_get_tc (list)->next = sym;
3280 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3281 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3285 ppc_current_csect = sym;
3288 /* This function handles the .text and .data pseudo-ops. These
3289 pseudo-ops aren't really used by XCOFF; we implement them for the
3290 convenience of people who aren't used to XCOFF. */
3293 ppc_section (int type)
3300 else if (type == 'd')
3305 sym = symbol_find_or_make (name);
3307 ppc_change_csect (sym, 2);
3309 demand_empty_rest_of_line ();
3312 /* This function handles the .section pseudo-op. This is mostly to
3313 give an error, since XCOFF only supports .text, .data and .bss, but
3314 we do permit the user to name the text or data section. */
3317 ppc_named_section (int ignore ATTRIBUTE_UNUSED)
3320 const char *real_name;
3324 user_name = input_line_pointer;
3325 c = get_symbol_end ();
3327 if (strcmp (user_name, ".text") == 0)
3328 real_name = ".text[PR]";
3329 else if (strcmp (user_name, ".data") == 0)
3330 real_name = ".data[RW]";
3333 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3334 *input_line_pointer = c;
3335 ignore_rest_of_line ();
3339 *input_line_pointer = c;
3341 sym = symbol_find_or_make (real_name);
3343 ppc_change_csect (sym, 2);
3345 demand_empty_rest_of_line ();
3348 /* The .extern pseudo-op. We create an undefined symbol. */
3351 ppc_extern (int ignore ATTRIBUTE_UNUSED)
3356 name = input_line_pointer;
3357 endc = get_symbol_end ();
3359 (void) symbol_find_or_make (name);
3361 *input_line_pointer = endc;
3363 demand_empty_rest_of_line ();
3366 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3369 ppc_lglobl (int ignore ATTRIBUTE_UNUSED)
3375 name = input_line_pointer;
3376 endc = get_symbol_end ();
3378 sym = symbol_find_or_make (name);
3380 *input_line_pointer = endc;
3382 symbol_get_tc (sym)->output = 1;
3384 demand_empty_rest_of_line ();
3387 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3388 although I don't know why it bothers. */
3391 ppc_rename (int ignore ATTRIBUTE_UNUSED)
3398 name = input_line_pointer;
3399 endc = get_symbol_end ();
3401 sym = symbol_find_or_make (name);
3403 *input_line_pointer = endc;
3405 if (*input_line_pointer != ',')
3407 as_bad (_("missing rename string"));
3408 ignore_rest_of_line ();
3411 ++input_line_pointer;
3413 symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
3415 demand_empty_rest_of_line ();
3418 /* The .stabx pseudo-op. This is similar to a normal .stabs
3419 pseudo-op, but slightly different. A sample is
3420 .stabx "main:F-1",.main,142,0
3421 The first argument is the symbol name to create. The second is the
3422 value, and the third is the storage class. The fourth seems to be
3423 always zero, and I am assuming it is the type. */
3426 ppc_stabx (int ignore ATTRIBUTE_UNUSED)
3433 name = demand_copy_C_string (&len);
3435 if (*input_line_pointer != ',')
3437 as_bad (_("missing value"));
3440 ++input_line_pointer;
3442 ppc_stab_symbol = TRUE;
3443 sym = symbol_make (name);
3444 ppc_stab_symbol = FALSE;
3446 symbol_get_tc (sym)->real_name = name;
3448 (void) expression (&exp);
3455 as_bad (_("illegal .stabx expression; zero assumed"));
3456 exp.X_add_number = 0;
3459 S_SET_VALUE (sym, (valueT) exp.X_add_number);
3460 symbol_set_frag (sym, &zero_address_frag);
3464 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
3465 symbol_set_value_expression (sym, &exp);
3469 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
3470 symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
3475 /* The value is some complex expression. This will probably
3476 fail at some later point, but this is probably the right
3477 thing to do here. */
3478 symbol_set_value_expression (sym, &exp);
3482 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3483 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3485 if (*input_line_pointer != ',')
3487 as_bad (_("missing class"));
3490 ++input_line_pointer;
3492 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
3494 if (*input_line_pointer != ',')
3496 as_bad (_("missing type"));
3499 ++input_line_pointer;
3501 S_SET_DATA_TYPE (sym, get_absolute_expression ());
3503 symbol_get_tc (sym)->output = 1;
3505 if (S_GET_STORAGE_CLASS (sym) == C_STSYM) {
3507 symbol_get_tc (sym)->within = ppc_current_block;
3512 .stabx "z",arrays_,133,0
3515 .comm arrays_,13768,3
3517 resolve_symbol_value will copy the exp's "within" into sym's when the
3518 offset is 0. Since this seems to be corner case problem,
3519 only do the correction for storage class C_STSYM. A better solution
3520 would be to have the tc field updated in ppc_symbol_new_hook. */
3522 if (exp.X_op == O_symbol)
3524 symbol_get_tc (exp.X_add_symbol)->within = ppc_current_block;
3528 if (exp.X_op != O_symbol
3529 || ! S_IS_EXTERNAL (exp.X_add_symbol)
3530 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
3531 ppc_frob_label (sym);
3534 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3535 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
3536 if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
3537 symbol_get_tc (ppc_current_csect)->within = sym;
3540 demand_empty_rest_of_line ();
3543 /* The .function pseudo-op. This takes several arguments. The first
3544 argument seems to be the external name of the symbol. The second
3545 argument seems to be the label for the start of the function. gcc
3546 uses the same name for both. I have no idea what the third and
3547 fourth arguments are meant to be. The optional fifth argument is
3548 an expression for the size of the function. In COFF this symbol
3549 gets an aux entry like that used for a csect. */
3552 ppc_function (int ignore ATTRIBUTE_UNUSED)
3560 name = input_line_pointer;
3561 endc = get_symbol_end ();
3563 /* Ignore any [PR] suffix. */
3564 name = ppc_canonicalize_symbol_name (name);
3565 s = strchr (name, '[');
3566 if (s != (char *) NULL
3567 && strcmp (s + 1, "PR]") == 0)
3570 ext_sym = symbol_find_or_make (name);
3572 *input_line_pointer = endc;
3574 if (*input_line_pointer != ',')
3576 as_bad (_("missing symbol name"));
3577 ignore_rest_of_line ();
3580 ++input_line_pointer;
3582 name = input_line_pointer;
3583 endc = get_symbol_end ();
3585 lab_sym = symbol_find_or_make (name);
3587 *input_line_pointer = endc;
3589 if (ext_sym != lab_sym)
3593 exp.X_op = O_symbol;
3594 exp.X_add_symbol = lab_sym;
3595 exp.X_op_symbol = NULL;
3596 exp.X_add_number = 0;
3598 symbol_set_value_expression (ext_sym, &exp);
3601 if (symbol_get_tc (ext_sym)->class == -1)
3602 symbol_get_tc (ext_sym)->class = XMC_PR;
3603 symbol_get_tc (ext_sym)->output = 1;
3605 if (*input_line_pointer == ',')
3609 /* Ignore the third argument. */
3610 ++input_line_pointer;
3611 expression (&ignore);
3612 if (*input_line_pointer == ',')
3614 /* Ignore the fourth argument. */
3615 ++input_line_pointer;
3616 expression (&ignore);
3617 if (*input_line_pointer == ',')
3619 /* The fifth argument is the function size. */
3620 ++input_line_pointer;
3621 symbol_get_tc (ext_sym)->size = symbol_new ("L0\001",
3624 &zero_address_frag);
3625 pseudo_set (symbol_get_tc (ext_sym)->size);
3630 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3631 SF_SET_FUNCTION (ext_sym);
3632 SF_SET_PROCESS (ext_sym);
3633 coff_add_linesym (ext_sym);
3635 demand_empty_rest_of_line ();
3638 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3639 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3640 with the correct line number */
3642 static symbolS *saved_bi_sym = 0;
3645 ppc_bf (int ignore ATTRIBUTE_UNUSED)
3649 sym = symbol_make (".bf");
3650 S_SET_SEGMENT (sym, text_section);
3651 symbol_set_frag (sym, frag_now);
3652 S_SET_VALUE (sym, frag_now_fix ());
3653 S_SET_STORAGE_CLASS (sym, C_FCN);
3655 coff_line_base = get_absolute_expression ();
3657 S_SET_NUMBER_AUXILIARY (sym, 1);
3658 SA_SET_SYM_LNNO (sym, coff_line_base);
3660 /* Line number for bi. */
3663 S_SET_VALUE (saved_bi_sym, coff_n_line_nos);
3668 symbol_get_tc (sym)->output = 1;
3670 ppc_frob_label (sym);
3672 demand_empty_rest_of_line ();
3675 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3676 ".ef", except that the line number is absolute, not relative to the
3677 most recent ".bf" symbol. */
3680 ppc_ef (int ignore ATTRIBUTE_UNUSED)
3684 sym = symbol_make (".ef");
3685 S_SET_SEGMENT (sym, text_section);
3686 symbol_set_frag (sym, frag_now);
3687 S_SET_VALUE (sym, frag_now_fix ());
3688 S_SET_STORAGE_CLASS (sym, C_FCN);
3689 S_SET_NUMBER_AUXILIARY (sym, 1);
3690 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3691 symbol_get_tc (sym)->output = 1;
3693 ppc_frob_label (sym);
3695 demand_empty_rest_of_line ();
3698 /* The .bi and .ei pseudo-ops. These take a string argument and
3699 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3700 the symbol list. The value of .bi will be know when the next .bf
3706 static symbolS *last_biei;
3713 name = demand_copy_C_string (&len);
3715 /* The value of these symbols is actually file offset. Here we set
3716 the value to the index into the line number entries. In
3717 ppc_frob_symbols we set the fix_line field, which will cause BFD
3718 to do the right thing. */
3720 sym = symbol_make (name);
3721 /* obj-coff.c currently only handles line numbers correctly in the
3723 S_SET_SEGMENT (sym, text_section);
3724 S_SET_VALUE (sym, coff_n_line_nos);
3725 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3727 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
3728 symbol_get_tc (sym)->output = 1;
3736 for (look = last_biei ? last_biei : symbol_rootP;
3737 (look != (symbolS *) NULL
3738 && (S_GET_STORAGE_CLASS (look) == C_FILE
3739 || S_GET_STORAGE_CLASS (look) == C_BINCL
3740 || S_GET_STORAGE_CLASS (look) == C_EINCL));
3741 look = symbol_next (look))
3743 if (look != (symbolS *) NULL)
3745 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3746 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
3750 demand_empty_rest_of_line ();
3753 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3754 There is one argument, which is a csect symbol. The value of the
3755 .bs symbol is the index of this csect symbol. */
3758 ppc_bs (int ignore ATTRIBUTE_UNUSED)
3765 if (ppc_current_block != NULL)
3766 as_bad (_("nested .bs blocks"));
3768 name = input_line_pointer;
3769 endc = get_symbol_end ();
3771 csect = symbol_find_or_make (name);
3773 *input_line_pointer = endc;
3775 sym = symbol_make (".bs");
3776 S_SET_SEGMENT (sym, now_seg);
3777 S_SET_STORAGE_CLASS (sym, C_BSTAT);
3778 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3779 symbol_get_tc (sym)->output = 1;
3781 symbol_get_tc (sym)->within = csect;
3783 ppc_frob_label (sym);
3785 ppc_current_block = sym;
3787 demand_empty_rest_of_line ();
3790 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3793 ppc_es (int ignore ATTRIBUTE_UNUSED)
3797 if (ppc_current_block == NULL)
3798 as_bad (_(".es without preceding .bs"));
3800 sym = symbol_make (".es");
3801 S_SET_SEGMENT (sym, now_seg);
3802 S_SET_STORAGE_CLASS (sym, C_ESTAT);
3803 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3804 symbol_get_tc (sym)->output = 1;
3806 ppc_frob_label (sym);
3808 ppc_current_block = NULL;
3810 demand_empty_rest_of_line ();
3813 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3817 ppc_bb (int ignore ATTRIBUTE_UNUSED)
3821 sym = symbol_make (".bb");
3822 S_SET_SEGMENT (sym, text_section);
3823 symbol_set_frag (sym, frag_now);
3824 S_SET_VALUE (sym, frag_now_fix ());
3825 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3827 S_SET_NUMBER_AUXILIARY (sym, 1);
3828 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3830 symbol_get_tc (sym)->output = 1;
3832 SF_SET_PROCESS (sym);
3834 ppc_frob_label (sym);
3836 demand_empty_rest_of_line ();
3839 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3843 ppc_eb (int ignore ATTRIBUTE_UNUSED)
3847 sym = symbol_make (".eb");
3848 S_SET_SEGMENT (sym, text_section);
3849 symbol_set_frag (sym, frag_now);
3850 S_SET_VALUE (sym, frag_now_fix ());
3851 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3852 S_SET_NUMBER_AUXILIARY (sym, 1);
3853 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3854 symbol_get_tc (sym)->output = 1;
3856 SF_SET_PROCESS (sym);
3858 ppc_frob_label (sym);
3860 demand_empty_rest_of_line ();
3863 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3867 ppc_bc (int ignore ATTRIBUTE_UNUSED)
3873 name = demand_copy_C_string (&len);
3874 sym = symbol_make (name);
3875 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3876 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3877 S_SET_STORAGE_CLASS (sym, C_BCOMM);
3878 S_SET_VALUE (sym, 0);
3879 symbol_get_tc (sym)->output = 1;
3881 ppc_frob_label (sym);
3883 demand_empty_rest_of_line ();
3886 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3889 ppc_ec (int ignore ATTRIBUTE_UNUSED)
3893 sym = symbol_make (".ec");
3894 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3895 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3896 S_SET_STORAGE_CLASS (sym, C_ECOMM);
3897 S_SET_VALUE (sym, 0);
3898 symbol_get_tc (sym)->output = 1;
3900 ppc_frob_label (sym);
3902 demand_empty_rest_of_line ();
3905 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3908 ppc_toc (int ignore ATTRIBUTE_UNUSED)
3910 if (ppc_toc_csect != (symbolS *) NULL)
3911 subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
3918 subseg = ppc_data_subsegment;
3919 ++ppc_data_subsegment;
3921 subseg_new (segment_name (data_section), subseg);
3922 ppc_toc_frag = frag_now;
3924 sym = symbol_find_or_make ("TOC[TC0]");
3925 symbol_set_frag (sym, frag_now);
3926 S_SET_SEGMENT (sym, data_section);
3927 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3928 symbol_get_tc (sym)->subseg = subseg;
3929 symbol_get_tc (sym)->output = 1;
3930 symbol_get_tc (sym)->within = sym;
3932 ppc_toc_csect = sym;
3934 for (list = ppc_data_csects;
3935 symbol_get_tc (list)->next != (symbolS *) NULL;
3936 list = symbol_get_tc (list)->next)
3938 symbol_get_tc (list)->next = sym;
3940 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3941 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3945 ppc_current_csect = ppc_toc_csect;
3947 demand_empty_rest_of_line ();
3950 /* The AIX assembler automatically aligns the operands of a .long or
3951 .short pseudo-op, and we want to be compatible. */
3954 ppc_xcoff_cons (int log_size)
3956 frag_align (log_size, 0, 0);
3957 record_alignment (now_seg, log_size);
3958 cons (1 << log_size);
3962 ppc_vbyte (int dummy ATTRIBUTE_UNUSED)
3967 (void) expression (&exp);
3969 if (exp.X_op != O_constant)
3971 as_bad (_("non-constant byte count"));
3975 byte_count = exp.X_add_number;
3977 if (*input_line_pointer != ',')
3979 as_bad (_("missing value"));
3983 ++input_line_pointer;
3987 #endif /* OBJ_XCOFF */
3988 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3990 /* The .tc pseudo-op. This is used when generating either XCOFF or
3991 ELF. This takes two or more arguments.
3993 When generating XCOFF output, the first argument is the name to
3994 give to this location in the toc; this will be a symbol with class
3995 TC. The rest of the arguments are N-byte values to actually put at
3996 this location in the TOC; often there is just one more argument, a
3997 relocatable symbol reference. The size of the value to store
3998 depends on target word size. A 32-bit target uses 4-byte values, a
3999 64-bit target uses 8-byte values.
4001 When not generating XCOFF output, the arguments are the same, but
4002 the first argument is simply ignored. */
4005 ppc_tc (int ignore ATTRIBUTE_UNUSED)
4009 /* Define the TOC symbol name. */
4015 if (ppc_toc_csect == (symbolS *) NULL
4016 || ppc_toc_csect != ppc_current_csect)
4018 as_bad (_(".tc not in .toc section"));
4019 ignore_rest_of_line ();
4023 name = input_line_pointer;
4024 endc = get_symbol_end ();
4026 sym = symbol_find_or_make (name);
4028 *input_line_pointer = endc;
4030 if (S_IS_DEFINED (sym))
4034 label = symbol_get_tc (ppc_current_csect)->within;
4035 if (symbol_get_tc (label)->class != XMC_TC0)
4037 as_bad (_(".tc with no label"));
4038 ignore_rest_of_line ();
4042 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
4043 symbol_set_frag (label, symbol_get_frag (sym));
4044 S_SET_VALUE (label, S_GET_VALUE (sym));
4046 while (! is_end_of_line[(unsigned char) *input_line_pointer])
4047 ++input_line_pointer;
4052 S_SET_SEGMENT (sym, now_seg);
4053 symbol_set_frag (sym, frag_now);
4054 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4055 symbol_get_tc (sym)->class = XMC_TC;
4056 symbol_get_tc (sym)->output = 1;
4058 ppc_frob_label (sym);
4061 #endif /* OBJ_XCOFF */
4065 /* Skip the TOC symbol name. */
4066 while (is_part_of_name (*input_line_pointer)
4067 || *input_line_pointer == ' '
4068 || *input_line_pointer == '['
4069 || *input_line_pointer == ']'
4070 || *input_line_pointer == '{'
4071 || *input_line_pointer == '}')
4072 ++input_line_pointer;
4074 /* Align to a four/eight byte boundary. */
4075 align = ppc_obj64 ? 3 : 2;
4076 frag_align (align, 0, 0);
4077 record_alignment (now_seg, align);
4078 #endif /* OBJ_ELF */
4080 if (*input_line_pointer != ',')
4081 demand_empty_rest_of_line ();
4084 ++input_line_pointer;
4085 cons (ppc_obj64 ? 8 : 4);
4089 /* Pseudo-op .machine. */
4092 ppc_machine (int ignore ATTRIBUTE_UNUSED)
4095 #define MAX_HISTORY 100
4096 static unsigned long *cpu_history;
4097 static int curr_hist;
4101 if (*input_line_pointer == '"')
4104 cpu_string = demand_copy_C_string (&len);
4109 cpu_string = input_line_pointer;
4110 c = get_symbol_end ();
4111 cpu_string = xstrdup (cpu_string);
4112 *input_line_pointer = c;
4115 if (cpu_string != NULL)
4117 unsigned long old_cpu = ppc_cpu;
4120 for (p = cpu_string; *p != 0; p++)
4123 if (strcmp (cpu_string, "push") == 0)
4125 if (cpu_history == NULL)
4126 cpu_history = xmalloc (MAX_HISTORY * sizeof (*cpu_history));
4128 if (curr_hist >= MAX_HISTORY)
4129 as_bad (_(".machine stack overflow"));
4131 cpu_history[curr_hist++] = ppc_cpu;
4133 else if (strcmp (cpu_string, "pop") == 0)
4136 as_bad (_(".machine stack underflow"));
4138 ppc_cpu = cpu_history[--curr_hist];
4140 else if (parse_cpu (cpu_string))
4143 as_bad (_("invalid machine `%s'"), cpu_string);
4145 if (ppc_cpu != old_cpu)
4146 ppc_setup_opcodes ();
4149 demand_empty_rest_of_line ();
4152 /* See whether a symbol is in the TOC section. */
4155 ppc_is_toc_sym (symbolS *sym)
4158 return symbol_get_tc (sym)->class == XMC_TC;
4161 const char *sname = segment_name (S_GET_SEGMENT (sym));
4163 return strcmp (sname, ".toc") == 0;
4165 return strcmp (sname, ".got") == 0;
4168 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4172 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4174 /* Set the current section. */
4176 ppc_set_current_section (segT new)
4178 ppc_previous_section = ppc_current_section;
4179 ppc_current_section = new;
4182 /* pseudo-op: .previous
4183 behaviour: toggles the current section with the previous section.
4185 warnings: "No previous section" */
4188 ppc_previous (int ignore ATTRIBUTE_UNUSED)
4192 if (ppc_previous_section == NULL)
4194 as_warn (_("No previous section to return to. Directive ignored."));
4198 subseg_set (ppc_previous_section, 0);
4200 ppc_set_current_section (ppc_previous_section);
4203 /* pseudo-op: .pdata
4204 behaviour: predefined read only data section
4208 initial: .section .pdata "adr3"
4209 a - don't know -- maybe a misprint
4210 d - initialized data
4212 3 - double word aligned (that would be 4 byte boundary)
4215 Tag index tables (also known as the function table) for exception
4216 handling, debugging, etc. */
4219 ppc_pdata (int ignore ATTRIBUTE_UNUSED)
4221 if (pdata_section == 0)
4223 pdata_section = subseg_new (".pdata", 0);
4225 bfd_set_section_flags (stdoutput, pdata_section,
4226 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4227 | SEC_READONLY | SEC_DATA ));
4229 bfd_set_section_alignment (stdoutput, pdata_section, 2);
4233 pdata_section = subseg_new (".pdata", 0);
4235 ppc_set_current_section (pdata_section);
4238 /* pseudo-op: .ydata
4239 behaviour: predefined read only data section
4243 initial: .section .ydata "drw3"
4244 a - don't know -- maybe a misprint
4245 d - initialized data
4247 3 - double word aligned (that would be 4 byte boundary)
4249 Tag tables (also known as the scope table) for exception handling,
4253 ppc_ydata (int ignore ATTRIBUTE_UNUSED)
4255 if (ydata_section == 0)
4257 ydata_section = subseg_new (".ydata", 0);
4258 bfd_set_section_flags (stdoutput, ydata_section,
4259 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4260 | SEC_READONLY | SEC_DATA ));
4262 bfd_set_section_alignment (stdoutput, ydata_section, 3);
4266 ydata_section = subseg_new (".ydata", 0);
4268 ppc_set_current_section (ydata_section);
4271 /* pseudo-op: .reldata
4272 behaviour: predefined read write data section
4273 double word aligned (4-byte)
4274 FIXME: relocation is applied to it
4275 FIXME: what's the difference between this and .data?
4278 initial: .section .reldata "drw3"
4279 d - initialized data
4282 3 - double word aligned (that would be 8 byte boundary)
4285 Like .data, but intended to hold data subject to relocation, such as
4286 function descriptors, etc. */
4289 ppc_reldata (int ignore ATTRIBUTE_UNUSED)
4291 if (reldata_section == 0)
4293 reldata_section = subseg_new (".reldata", 0);
4295 bfd_set_section_flags (stdoutput, reldata_section,
4296 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4299 bfd_set_section_alignment (stdoutput, reldata_section, 2);
4303 reldata_section = subseg_new (".reldata", 0);
4305 ppc_set_current_section (reldata_section);
4308 /* pseudo-op: .rdata
4309 behaviour: predefined read only data section
4313 initial: .section .rdata "dr3"
4314 d - initialized data
4316 3 - double word aligned (that would be 4 byte boundary) */
4319 ppc_rdata (int ignore ATTRIBUTE_UNUSED)
4321 if (rdata_section == 0)
4323 rdata_section = subseg_new (".rdata", 0);
4324 bfd_set_section_flags (stdoutput, rdata_section,
4325 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4326 | SEC_READONLY | SEC_DATA ));
4328 bfd_set_section_alignment (stdoutput, rdata_section, 2);
4332 rdata_section = subseg_new (".rdata", 0);
4334 ppc_set_current_section (rdata_section);
4337 /* pseudo-op: .ualong
4338 behaviour: much like .int, with the exception that no alignment is
4340 FIXME: test the alignment statement
4345 ppc_ualong (int ignore ATTRIBUTE_UNUSED)
4351 /* pseudo-op: .znop <symbol name>
4352 behaviour: Issue a nop instruction
4353 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4354 the supplied symbol name.
4356 warnings: Missing symbol name */
4359 ppc_znop (int ignore ATTRIBUTE_UNUSED)
4362 const struct powerpc_opcode *opcode;
4373 /* Strip out the symbol name. */
4374 symbol_name = input_line_pointer;
4375 c = get_symbol_end ();
4377 name = xmalloc (input_line_pointer - symbol_name + 1);
4378 strcpy (name, symbol_name);
4380 sym = symbol_find_or_make (name);
4382 *input_line_pointer = c;
4386 /* Look up the opcode in the hash table. */
4387 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
4389 /* Stick in the nop. */
4390 insn = opcode->opcode;
4392 /* Write out the instruction. */
4394 md_number_to_chars (f, insn, 4);
4396 f - frag_now->fr_literal,
4401 BFD_RELOC_16_GOT_PCREL);
4411 ppc_pe_comm (int lcomm)
4420 name = input_line_pointer;
4421 c = get_symbol_end ();
4423 /* just after name is now '\0'. */
4424 p = input_line_pointer;
4427 if (*input_line_pointer != ',')
4429 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4430 ignore_rest_of_line ();
4434 input_line_pointer++; /* skip ',' */
4435 if ((temp = get_absolute_expression ()) < 0)
4437 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
4438 ignore_rest_of_line ();
4444 /* The third argument to .comm is the alignment. */
4445 if (*input_line_pointer != ',')
4449 ++input_line_pointer;
4450 align = get_absolute_expression ();
4453 as_warn (_("ignoring bad alignment"));
4460 symbolP = symbol_find_or_make (name);
4463 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
4465 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4466 S_GET_NAME (symbolP));
4467 ignore_rest_of_line ();
4471 if (S_GET_VALUE (symbolP))
4473 if (S_GET_VALUE (symbolP) != (valueT) temp)
4474 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4475 S_GET_NAME (symbolP),
4476 (long) S_GET_VALUE (symbolP),
4481 S_SET_VALUE (symbolP, (valueT) temp);
4482 S_SET_EXTERNAL (symbolP);
4483 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
4486 demand_empty_rest_of_line ();
4490 * implement the .section pseudo op:
4491 * .section name {, "flags"}
4493 * | +--- optional flags: 'b' for bss
4495 * +-- section name 'l' for lib
4499 * 'd' (apparently m88k for data)
4501 * But if the argument is not a quoted string, treat it as a
4502 * subsegment number.
4504 * FIXME: this is a copy of the section processing from obj-coff.c, with
4505 * additions/changes for the moto-pas assembler support. There are three
4508 * FIXME: I just noticed this. This doesn't work at all really. It it
4509 * setting bits that bfd probably neither understands or uses. The
4510 * correct approach (?) will have to incorporate extra fields attached
4511 * to the section to hold the system specific stuff. (krk)
4514 * 'a' - unknown - referred to in documentation, but no definition supplied
4515 * 'c' - section has code
4516 * 'd' - section has initialized data
4517 * 'u' - section has uninitialized data
4518 * 'i' - section contains directives (info)
4519 * 'n' - section can be discarded
4520 * 'R' - remove section at link time
4522 * Section Protection:
4523 * 'r' - section is readable
4524 * 'w' - section is writeable
4525 * 'x' - section is executable
4526 * 's' - section is sharable
4528 * Section Alignment:
4529 * '0' - align to byte boundary
4530 * '1' - align to halfword undary
4531 * '2' - align to word boundary
4532 * '3' - align to doubleword boundary
4533 * '4' - align to quadword boundary
4534 * '5' - align to 32 byte boundary
4535 * '6' - align to 64 byte boundary
4540 ppc_pe_section (int ignore ATTRIBUTE_UNUSED)
4542 /* Strip out the section name. */
4551 section_name = input_line_pointer;
4552 c = get_symbol_end ();
4554 name = xmalloc (input_line_pointer - section_name + 1);
4555 strcpy (name, section_name);
4557 *input_line_pointer = c;
4562 flags = SEC_NO_FLAGS;
4564 if (strcmp (name, ".idata$2") == 0)
4568 else if (strcmp (name, ".idata$3") == 0)
4572 else if (strcmp (name, ".idata$4") == 0)
4576 else if (strcmp (name, ".idata$5") == 0)
4580 else if (strcmp (name, ".idata$6") == 0)
4585 /* Default alignment to 16 byte boundary. */
4588 if (*input_line_pointer == ',')
4590 ++input_line_pointer;
4592 if (*input_line_pointer != '"')
4593 exp = get_absolute_expression ();
4596 ++input_line_pointer;
4597 while (*input_line_pointer != '"'
4598 && ! is_end_of_line[(unsigned char) *input_line_pointer])
4600 switch (*input_line_pointer)
4602 /* Section Contents */
4603 case 'a': /* unknown */
4604 as_bad (_("Unsupported section attribute -- 'a'"));
4606 case 'c': /* code section */
4609 case 'd': /* section has initialized data */
4612 case 'u': /* section has uninitialized data */
4613 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4617 case 'i': /* section contains directives (info) */
4618 /* FIXME: This is IMAGE_SCN_LNK_INFO
4620 flags |= SEC_HAS_CONTENTS;
4622 case 'n': /* section can be discarded */
4625 case 'R': /* Remove section at link time */
4626 flags |= SEC_NEVER_LOAD;
4628 #if IFLICT_BRAIN_DAMAGE
4629 /* Section Protection */
4630 case 'r': /* section is readable */
4631 flags |= IMAGE_SCN_MEM_READ;
4633 case 'w': /* section is writeable */
4634 flags |= IMAGE_SCN_MEM_WRITE;
4636 case 'x': /* section is executable */
4637 flags |= IMAGE_SCN_MEM_EXECUTE;
4639 case 's': /* section is sharable */
4640 flags |= IMAGE_SCN_MEM_SHARED;
4643 /* Section Alignment */
4644 case '0': /* align to byte boundary */
4645 flags |= IMAGE_SCN_ALIGN_1BYTES;
4648 case '1': /* align to halfword boundary */
4649 flags |= IMAGE_SCN_ALIGN_2BYTES;
4652 case '2': /* align to word boundary */
4653 flags |= IMAGE_SCN_ALIGN_4BYTES;
4656 case '3': /* align to doubleword boundary */
4657 flags |= IMAGE_SCN_ALIGN_8BYTES;
4660 case '4': /* align to quadword boundary */
4661 flags |= IMAGE_SCN_ALIGN_16BYTES;
4664 case '5': /* align to 32 byte boundary */
4665 flags |= IMAGE_SCN_ALIGN_32BYTES;
4668 case '6': /* align to 64 byte boundary */
4669 flags |= IMAGE_SCN_ALIGN_64BYTES;
4674 as_bad (_("unknown section attribute '%c'"),
4675 *input_line_pointer);
4678 ++input_line_pointer;
4680 if (*input_line_pointer == '"')
4681 ++input_line_pointer;
4685 sec = subseg_new (name, (subsegT) exp);
4687 ppc_set_current_section (sec);
4689 if (flags != SEC_NO_FLAGS)
4691 if (! bfd_set_section_flags (stdoutput, sec, flags))
4692 as_bad (_("error setting flags for \"%s\": %s"),
4693 bfd_section_name (stdoutput, sec),
4694 bfd_errmsg (bfd_get_error ()));
4697 bfd_set_section_alignment (stdoutput, sec, align);
4701 ppc_pe_function (int ignore ATTRIBUTE_UNUSED)
4707 name = input_line_pointer;
4708 endc = get_symbol_end ();
4710 ext_sym = symbol_find_or_make (name);
4712 *input_line_pointer = endc;
4714 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
4715 SF_SET_FUNCTION (ext_sym);
4716 SF_SET_PROCESS (ext_sym);
4717 coff_add_linesym (ext_sym);
4719 demand_empty_rest_of_line ();
4723 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED)
4725 if (tocdata_section == 0)
4727 tocdata_section = subseg_new (".tocd", 0);
4728 /* FIXME: section flags won't work. */
4729 bfd_set_section_flags (stdoutput, tocdata_section,
4730 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4731 | SEC_READONLY | SEC_DATA));
4733 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
4737 rdata_section = subseg_new (".tocd", 0);
4740 ppc_set_current_section (tocdata_section);
4742 demand_empty_rest_of_line ();
4745 /* Don't adjust TOC relocs to use the section symbol. */
4748 ppc_pe_fix_adjustable (fixS *fix)
4750 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
4757 /* XCOFF specific symbol and file handling. */
4759 /* Canonicalize the symbol name. We use the to force the suffix, if
4760 any, to use square brackets, and to be in upper case. */
4763 ppc_canonicalize_symbol_name (char *name)
4767 if (ppc_stab_symbol)
4770 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
4784 for (s++; *s != '\0' && *s != brac; s++)
4787 if (*s == '\0' || s[1] != '\0')
4788 as_bad (_("bad symbol suffix"));
4796 /* Set the class of a symbol based on the suffix, if any. This is
4797 called whenever a new symbol is created. */
4800 ppc_symbol_new_hook (symbolS *sym)
4802 struct ppc_tc_sy *tc;
4805 tc = symbol_get_tc (sym);
4809 tc->real_name = NULL;
4815 if (ppc_stab_symbol)
4818 s = strchr (S_GET_NAME (sym), '[');
4819 if (s == (const char *) NULL)
4821 /* There is no suffix. */
4830 if (strcmp (s, "BS]") == 0)
4834 if (strcmp (s, "DB]") == 0)
4836 else if (strcmp (s, "DS]") == 0)
4840 if (strcmp (s, "GL]") == 0)
4844 if (strcmp (s, "PR]") == 0)
4848 if (strcmp (s, "RO]") == 0)
4850 else if (strcmp (s, "RW]") == 0)
4854 if (strcmp (s, "SV]") == 0)
4858 if (strcmp (s, "TC]") == 0)
4860 else if (strcmp (s, "TI]") == 0)
4862 else if (strcmp (s, "TB]") == 0)
4864 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
4865 tc->class = XMC_TC0;
4868 if (strcmp (s, "UA]") == 0)
4870 else if (strcmp (s, "UC]") == 0)
4874 if (strcmp (s, "XO]") == 0)
4879 if (tc->class == -1)
4880 as_bad (_("Unrecognized symbol suffix"));
4883 /* Set the class of a label based on where it is defined. This
4884 handles symbols without suffixes. Also, move the symbol so that it
4885 follows the csect symbol. */
4888 ppc_frob_label (symbolS *sym)
4890 if (ppc_current_csect != (symbolS *) NULL)
4892 if (symbol_get_tc (sym)->class == -1)
4893 symbol_get_tc (sym)->class = symbol_get_tc (ppc_current_csect)->class;
4895 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4896 symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
4897 &symbol_rootP, &symbol_lastP);
4898 symbol_get_tc (ppc_current_csect)->within = sym;
4902 dwarf2_emit_label (sym);
4906 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4907 seen. It tells ppc_adjust_symtab whether it needs to look through
4910 static bfd_boolean ppc_saw_abs;
4912 /* Change the name of a symbol just before writing it out. Set the
4913 real name if the .rename pseudo-op was used. Otherwise, remove any
4914 class suffix. Return 1 if the symbol should not be included in the
4918 ppc_frob_symbol (symbolS *sym)
4920 static symbolS *ppc_last_function;
4921 static symbolS *set_end;
4923 /* Discard symbols that should not be included in the output symbol
4925 if (! symbol_used_in_reloc_p (sym)
4926 && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
4927 || (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
4928 && ! symbol_get_tc (sym)->output
4929 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
4932 /* This one will disappear anyway. Don't make a csect sym for it. */
4933 if (sym == abs_section_sym)
4936 if (symbol_get_tc (sym)->real_name != (char *) NULL)
4937 S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
4943 name = S_GET_NAME (sym);
4944 s = strchr (name, '[');
4945 if (s != (char *) NULL)
4951 snew = xmalloc (len + 1);
4952 memcpy (snew, name, len);
4955 S_SET_NAME (sym, snew);
4959 if (set_end != (symbolS *) NULL)
4961 SA_SET_SYM_ENDNDX (set_end, sym);
4965 if (SF_GET_FUNCTION (sym))
4967 if (ppc_last_function != (symbolS *) NULL)
4968 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4969 ppc_last_function = sym;
4970 if (symbol_get_tc (sym)->size != (symbolS *) NULL)
4972 resolve_symbol_value (symbol_get_tc (sym)->size);
4973 SA_SET_SYM_FSIZE (sym,
4974 (long) S_GET_VALUE (symbol_get_tc (sym)->size));
4977 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4978 && strcmp (S_GET_NAME (sym), ".ef") == 0)
4980 if (ppc_last_function == (symbolS *) NULL)
4981 as_bad (_(".ef with no preceding .function"));
4984 set_end = ppc_last_function;
4985 ppc_last_function = NULL;
4987 /* We don't have a C_EFCN symbol, but we need to force the
4988 COFF backend to believe that it has seen one. */
4989 coff_last_function = NULL;
4993 if (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
4994 && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
4995 && S_GET_STORAGE_CLASS (sym) != C_FILE
4996 && S_GET_STORAGE_CLASS (sym) != C_FCN
4997 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4998 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4999 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
5000 && S_GET_STORAGE_CLASS (sym) != C_BINCL
5001 && S_GET_STORAGE_CLASS (sym) != C_EINCL
5002 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
5003 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
5005 if (S_GET_STORAGE_CLASS (sym) == C_EXT
5006 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
5009 union internal_auxent *a;
5011 /* Create a csect aux. */
5012 i = S_GET_NUMBER_AUXILIARY (sym);
5013 S_SET_NUMBER_AUXILIARY (sym, i + 1);
5014 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
5015 if (symbol_get_tc (sym)->class == XMC_TC0)
5017 /* This is the TOC table. */
5018 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
5019 a->x_csect.x_scnlen.l = 0;
5020 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5022 else if (symbol_get_tc (sym)->subseg != 0)
5024 /* This is a csect symbol. x_scnlen is the size of the
5026 if (symbol_get_tc (sym)->next == (symbolS *) NULL)
5027 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5028 S_GET_SEGMENT (sym))
5029 - S_GET_VALUE (sym));
5032 resolve_symbol_value (symbol_get_tc (sym)->next);
5033 a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
5034 - S_GET_VALUE (sym));
5036 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
5038 else if (S_GET_SEGMENT (sym) == bss_section)
5040 /* This is a common symbol. */
5041 a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
5042 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
5043 if (S_IS_EXTERNAL (sym))
5044 symbol_get_tc (sym)->class = XMC_RW;
5046 symbol_get_tc (sym)->class = XMC_BS;
5048 else if (S_GET_SEGMENT (sym) == absolute_section)
5050 /* This is an absolute symbol. The csect will be created by
5051 ppc_adjust_symtab. */
5053 a->x_csect.x_smtyp = XTY_LD;
5054 if (symbol_get_tc (sym)->class == -1)
5055 symbol_get_tc (sym)->class = XMC_XO;
5057 else if (! S_IS_DEFINED (sym))
5059 /* This is an external symbol. */
5060 a->x_csect.x_scnlen.l = 0;
5061 a->x_csect.x_smtyp = XTY_ER;
5063 else if (symbol_get_tc (sym)->class == XMC_TC)
5067 /* This is a TOC definition. x_scnlen is the size of the
5069 next = symbol_next (sym);
5070 while (symbol_get_tc (next)->class == XMC_TC0)
5071 next = symbol_next (next);
5072 if (next == (symbolS *) NULL
5073 || symbol_get_tc (next)->class != XMC_TC)
5075 if (ppc_after_toc_frag == (fragS *) NULL)
5076 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5078 - S_GET_VALUE (sym));
5080 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
5081 - S_GET_VALUE (sym));
5085 resolve_symbol_value (next);
5086 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
5087 - S_GET_VALUE (sym));
5089 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5095 /* This is a normal symbol definition. x_scnlen is the
5096 symbol index of the containing csect. */
5097 if (S_GET_SEGMENT (sym) == text_section)
5098 csect = ppc_text_csects;
5099 else if (S_GET_SEGMENT (sym) == data_section)
5100 csect = ppc_data_csects;
5104 /* Skip the initial dummy symbol. */
5105 csect = symbol_get_tc (csect)->next;
5107 if (csect == (symbolS *) NULL)
5109 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
5110 a->x_csect.x_scnlen.l = 0;
5114 while (symbol_get_tc (csect)->next != (symbolS *) NULL)
5116 resolve_symbol_value (symbol_get_tc (csect)->next);
5117 if (S_GET_VALUE (symbol_get_tc (csect)->next)
5118 > S_GET_VALUE (sym))
5120 csect = symbol_get_tc (csect)->next;
5123 a->x_csect.x_scnlen.p =
5124 coffsymbol (symbol_get_bfdsym (csect))->native;
5125 coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
5128 a->x_csect.x_smtyp = XTY_LD;
5131 a->x_csect.x_parmhash = 0;
5132 a->x_csect.x_snhash = 0;
5133 if (symbol_get_tc (sym)->class == -1)
5134 a->x_csect.x_smclas = XMC_PR;
5136 a->x_csect.x_smclas = symbol_get_tc (sym)->class;
5137 a->x_csect.x_stab = 0;
5138 a->x_csect.x_snstab = 0;
5140 /* Don't let the COFF backend resort these symbols. */
5141 symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
5143 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
5145 /* We want the value to be the symbol index of the referenced
5146 csect symbol. BFD will do that for us if we set the right
5148 asymbol *bsym = symbol_get_bfdsym (symbol_get_tc (sym)->within);
5149 combined_entry_type *c = coffsymbol (bsym)->native;
5151 S_SET_VALUE (sym, (valueT) (size_t) c);
5152 coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
5154 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
5159 /* The value is the offset from the enclosing csect. */
5160 block = symbol_get_tc (sym)->within;
5161 csect = symbol_get_tc (block)->within;
5162 resolve_symbol_value (csect);
5163 S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
5165 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
5166 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
5168 /* We want the value to be a file offset into the line numbers.
5169 BFD will do that for us if we set the right flags. We have
5170 already set the value correctly. */
5171 coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
5177 /* Adjust the symbol table. This creates csect symbols for all
5178 absolute symbols. */
5181 ppc_adjust_symtab (void)
5188 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
5192 union internal_auxent *a;
5194 if (S_GET_SEGMENT (sym) != absolute_section)
5197 csect = symbol_create (".abs[XO]", absolute_section,
5198 S_GET_VALUE (sym), &zero_address_frag);
5199 symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
5200 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
5201 i = S_GET_NUMBER_AUXILIARY (csect);
5202 S_SET_NUMBER_AUXILIARY (csect, i + 1);
5203 a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
5204 a->x_csect.x_scnlen.l = 0;
5205 a->x_csect.x_smtyp = XTY_SD;
5206 a->x_csect.x_parmhash = 0;
5207 a->x_csect.x_snhash = 0;
5208 a->x_csect.x_smclas = XMC_XO;
5209 a->x_csect.x_stab = 0;
5210 a->x_csect.x_snstab = 0;
5212 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
5214 i = S_GET_NUMBER_AUXILIARY (sym);
5215 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
5216 a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
5217 coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
5220 ppc_saw_abs = FALSE;
5223 /* Set the VMA for a section. This is called on all the sections in
5227 ppc_frob_section (asection *sec)
5229 static bfd_vma vma = 0;
5231 vma = md_section_align (sec, vma);
5232 bfd_set_section_vma (stdoutput, sec, vma);
5233 vma += bfd_section_size (stdoutput, sec);
5236 #endif /* OBJ_XCOFF */
5239 md_atof (int type, char *litp, int *sizep)
5241 return ieee_md_atof (type, litp, sizep, target_big_endian);
5244 /* Write a value out to the object file, using the appropriate
5248 md_number_to_chars (char *buf, valueT val, int n)
5250 if (target_big_endian)
5251 number_to_chars_bigendian (buf, val, n);
5253 number_to_chars_littleendian (buf, val, n);
5256 /* Align a section (I don't know why this is machine dependent). */
5259 md_section_align (asection *seg ATTRIBUTE_UNUSED, valueT addr)
5264 int align = bfd_get_section_alignment (stdoutput, seg);
5266 return ((addr + (1 << align) - 1) & (-1 << align));
5270 /* We don't have any form of relaxing. */
5273 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
5274 asection *seg ATTRIBUTE_UNUSED)
5280 /* Convert a machine dependent frag. We never generate these. */
5283 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
5284 asection *sec ATTRIBUTE_UNUSED,
5285 fragS *fragp ATTRIBUTE_UNUSED)
5290 /* We have no need to default values of symbols. */
5293 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5298 /* Functions concerning relocs. */
5300 /* The location from which a PC relative jump should be calculated,
5301 given a PC relative reloc. */
5304 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
5306 return fixp->fx_frag->fr_address + fixp->fx_where;
5311 /* This is called to see whether a fixup should be adjusted to use a
5312 section symbol. We take the opportunity to change a fixup against
5313 a symbol in the TOC subsegment into a reloc against the
5314 corresponding .tc symbol. */
5317 ppc_fix_adjustable (fixS *fix)
5319 valueT val = resolve_symbol_value (fix->fx_addsy);
5320 segT symseg = S_GET_SEGMENT (fix->fx_addsy);
5321 TC_SYMFIELD_TYPE *tc;
5323 if (symseg == absolute_section)
5326 if (ppc_toc_csect != (symbolS *) NULL
5327 && fix->fx_addsy != ppc_toc_csect
5328 && symseg == data_section
5329 && val >= ppc_toc_frag->fr_address
5330 && (ppc_after_toc_frag == (fragS *) NULL
5331 || val < ppc_after_toc_frag->fr_address))
5335 for (sy = symbol_next (ppc_toc_csect);
5336 sy != (symbolS *) NULL;
5337 sy = symbol_next (sy))
5339 TC_SYMFIELD_TYPE *sy_tc = symbol_get_tc (sy);
5341 if (sy_tc->class == XMC_TC0)
5343 if (sy_tc->class != XMC_TC)
5345 if (val == resolve_symbol_value (sy))
5348 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
5353 as_bad_where (fix->fx_file, fix->fx_line,
5354 _("symbol in .toc does not match any .tc"));
5357 /* Possibly adjust the reloc to be against the csect. */
5358 tc = symbol_get_tc (fix->fx_addsy);
5360 && tc->class != XMC_TC0
5361 && tc->class != XMC_TC
5362 && symseg != bss_section
5363 /* Don't adjust if this is a reloc in the toc section. */
5364 && (symseg != data_section
5365 || ppc_toc_csect == NULL
5366 || val < ppc_toc_frag->fr_address
5367 || (ppc_after_toc_frag != NULL
5368 && val >= ppc_after_toc_frag->fr_address)))
5371 symbolS *next_csect;
5373 if (symseg == text_section)
5374 csect = ppc_text_csects;
5375 else if (symseg == data_section)
5376 csect = ppc_data_csects;
5380 /* Skip the initial dummy symbol. */
5381 csect = symbol_get_tc (csect)->next;
5383 if (csect != (symbolS *) NULL)
5385 while ((next_csect = symbol_get_tc (csect)->next) != (symbolS *) NULL
5386 && (symbol_get_frag (next_csect)->fr_address <= val))
5388 /* If the csect address equals the symbol value, then we
5389 have to look through the full symbol table to see
5390 whether this is the csect we want. Note that we will
5391 only get here if the csect has zero length. */
5392 if (symbol_get_frag (csect)->fr_address == val
5393 && S_GET_VALUE (csect) == val)
5397 for (scan = symbol_next (csect);
5399 scan = symbol_next (scan))
5401 if (symbol_get_tc (scan)->subseg != 0)
5403 if (scan == fix->fx_addsy)
5407 /* If we found the symbol before the next csect
5408 symbol, then this is the csect we want. */
5409 if (scan == fix->fx_addsy)
5416 fix->fx_offset += val - symbol_get_frag (csect)->fr_address;
5417 fix->fx_addsy = csect;
5422 /* Adjust a reloc against a .lcomm symbol to be against the base
5424 if (symseg == bss_section
5425 && ! S_IS_EXTERNAL (fix->fx_addsy))
5427 symbolS *sy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
5429 fix->fx_offset += val - resolve_symbol_value (sy);
5436 /* A reloc from one csect to another must be kept. The assembler
5437 will, of course, keep relocs between sections, and it will keep
5438 absolute relocs, but we need to force it to keep PC relative relocs
5439 between two csects in the same section. */
5442 ppc_force_relocation (fixS *fix)
5444 /* At this point fix->fx_addsy should already have been converted to
5445 a csect symbol. If the csect does not include the fragment, then
5446 we need to force the relocation. */
5448 && fix->fx_addsy != NULL
5449 && symbol_get_tc (fix->fx_addsy)->subseg != 0
5450 && ((symbol_get_frag (fix->fx_addsy)->fr_address
5451 > fix->fx_frag->fr_address)
5452 || (symbol_get_tc (fix->fx_addsy)->next != NULL
5453 && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
5454 <= fix->fx_frag->fr_address))))
5457 return generic_force_reloc (fix);
5460 #endif /* OBJ_XCOFF */
5463 /* If this function returns non-zero, it guarantees that a relocation
5464 will be emitted for a fixup. */
5467 ppc_force_relocation (fixS *fix)
5469 /* Branch prediction relocations must force a relocation, as must
5470 the vtable description relocs. */
5471 switch (fix->fx_r_type)
5473 case BFD_RELOC_PPC_B16_BRTAKEN:
5474 case BFD_RELOC_PPC_B16_BRNTAKEN:
5475 case BFD_RELOC_PPC_BA16_BRTAKEN:
5476 case BFD_RELOC_PPC_BA16_BRNTAKEN:
5477 case BFD_RELOC_24_PLT_PCREL:
5478 case BFD_RELOC_PPC64_TOC:
5484 if (fix->fx_r_type >= BFD_RELOC_PPC_TLS
5485 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA)
5488 return generic_force_reloc (fix);
5492 ppc_fix_adjustable (fixS *fix)
5494 return (fix->fx_r_type != BFD_RELOC_16_GOTOFF
5495 && fix->fx_r_type != BFD_RELOC_LO16_GOTOFF
5496 && fix->fx_r_type != BFD_RELOC_HI16_GOTOFF
5497 && fix->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
5498 && fix->fx_r_type != BFD_RELOC_GPREL16
5499 && fix->fx_r_type != BFD_RELOC_VTABLE_INHERIT
5500 && fix->fx_r_type != BFD_RELOC_VTABLE_ENTRY
5501 && !(fix->fx_r_type >= BFD_RELOC_PPC_TLS
5502 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA));
5506 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
5507 rs_align_code frag. */
5510 ppc_handle_align (struct frag *fragP)
5512 valueT count = (fragP->fr_next->fr_address
5513 - (fragP->fr_address + fragP->fr_fix));
5515 if (count != 0 && (count & 3) == 0)
5517 char *dest = fragP->fr_literal + fragP->fr_fix;
5520 md_number_to_chars (dest, 0x60000000, 4);
5522 if ((ppc_cpu & PPC_OPCODE_POWER6) != 0)
5524 /* For power6, we want the last nop to be a group terminating
5525 one, "ori 1,1,0". Do this by inserting an rs_fill frag
5526 immediately after this one, with its address set to the last
5527 nop location. This will automatically reduce the number of
5528 nops in the current frag by one. */
5531 struct frag *group_nop = xmalloc (SIZEOF_STRUCT_FRAG + 4);
5533 memcpy (group_nop, fragP, SIZEOF_STRUCT_FRAG);
5534 group_nop->fr_address = group_nop->fr_next->fr_address - 4;
5535 group_nop->fr_fix = 0;
5536 group_nop->fr_offset = 1;
5537 group_nop->fr_type = rs_fill;
5538 fragP->fr_next = group_nop;
5539 dest = group_nop->fr_literal;
5542 md_number_to_chars (dest, 0x60210000, 4);
5547 /* Apply a fixup to the object code. This is called for all the
5548 fixups we generated by the call to fix_new_exp, above. In the call
5549 above we used a reloc code which was the largest legal reloc code
5550 plus the operand index. Here we undo that to recover the operand
5551 index. At this point all symbol values should be fully resolved,
5552 and we attempt to completely resolve the reloc. If we can not do
5553 that, we determine the correct reloc code and put it back in the
5557 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
5559 valueT value = * valP;
5562 if (fixP->fx_addsy != NULL)
5564 /* Hack around bfd_install_relocation brain damage. */
5566 value += fixP->fx_frag->fr_address + fixP->fx_where;
5571 /* FIXME FIXME FIXME: The value we are passed in *valP includes
5572 the symbol values. If we are doing this relocation the code in
5573 write.c is going to call bfd_install_relocation, which is also
5574 going to use the symbol value. That means that if the reloc is
5575 fully resolved we want to use *valP since bfd_install_relocation is
5577 However, if the reloc is not fully resolved we do not want to use
5578 *valP, and must use fx_offset instead. However, if the reloc
5579 is PC relative, we do want to use *valP since it includes the
5580 result of md_pcrel_from. This is confusing. */
5581 if (fixP->fx_addsy == (symbolS *) NULL)
5584 else if (fixP->fx_pcrel)
5588 value = fixP->fx_offset;
5591 if (fixP->fx_subsy != (symbolS *) NULL)
5593 /* We can't actually support subtracting a symbol. */
5594 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
5597 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
5600 const struct powerpc_operand *operand;
5604 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
5606 operand = &powerpc_operands[opindex];
5609 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5610 does not generate a reloc. It uses the offset of `sym' within its
5611 csect. Other usages, such as `.long sym', generate relocs. This
5612 is the documented behaviour of non-TOC symbols. */
5613 if ((operand->flags & PPC_OPERAND_PARENS) != 0
5614 && (operand->bitm & 0xfff0) == 0xfff0
5615 && operand->shift == 0
5616 && (operand->insert == NULL || ppc_obj64)
5617 && fixP->fx_addsy != NULL
5618 && symbol_get_tc (fixP->fx_addsy)->subseg != 0
5619 && symbol_get_tc (fixP->fx_addsy)->class != XMC_TC
5620 && symbol_get_tc (fixP->fx_addsy)->class != XMC_TC0
5621 && S_GET_SEGMENT (fixP->fx_addsy) != bss_section)
5623 value = fixP->fx_offset;
5628 /* Fetch the instruction, insert the fully resolved operand
5629 value, and stuff the instruction back again. */
5630 where = fixP->fx_frag->fr_literal + fixP->fx_where;
5631 if (target_big_endian)
5632 insn = bfd_getb32 ((unsigned char *) where);
5634 insn = bfd_getl32 ((unsigned char *) where);
5635 insn = ppc_insert_operand (insn, operand, (offsetT) value,
5636 fixP->tc_fix_data.ppc_cpu,
5637 fixP->fx_file, fixP->fx_line);
5638 if (target_big_endian)
5639 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
5641 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
5644 /* Nothing else to do here. */
5647 assert (fixP->fx_addsy != NULL);
5649 /* Determine a BFD reloc value based on the operand information.
5650 We are only prepared to turn a few of the operands into
5652 if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
5653 && operand->bitm == 0x3fffffc
5654 && operand->shift == 0)
5655 fixP->fx_r_type = BFD_RELOC_PPC_B26;
5656 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
5657 && operand->bitm == 0xfffc
5658 && operand->shift == 0)
5660 fixP->fx_r_type = BFD_RELOC_PPC_B16;
5663 if (target_big_endian)
5664 fixP->fx_where += 2;
5667 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
5668 && operand->bitm == 0x3fffffc
5669 && operand->shift == 0)
5670 fixP->fx_r_type = BFD_RELOC_PPC_BA26;
5671 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
5672 && operand->bitm == 0xfffc
5673 && operand->shift == 0)
5675 fixP->fx_r_type = BFD_RELOC_PPC_BA16;
5678 if (target_big_endian)
5679 fixP->fx_where += 2;
5682 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5683 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
5684 && (operand->bitm & 0xfff0) == 0xfff0
5685 && operand->shift == 0)
5687 if (ppc_is_toc_sym (fixP->fx_addsy))
5689 fixP->fx_r_type = BFD_RELOC_PPC_TOC16;
5692 && (operand->flags & PPC_OPERAND_DS) != 0)
5693 fixP->fx_r_type = BFD_RELOC_PPC64_TOC16_DS;
5698 fixP->fx_r_type = BFD_RELOC_16;
5701 && (operand->flags & PPC_OPERAND_DS) != 0)
5702 fixP->fx_r_type = BFD_RELOC_PPC64_ADDR16_DS;
5706 if (target_big_endian)
5707 fixP->fx_where += 2;
5709 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5715 /* Use expr_symbol_where to see if this is an expression
5717 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
5718 as_bad_where (fixP->fx_file, fixP->fx_line,
5719 _("unresolved expression that must be resolved"));
5721 as_bad_where (fixP->fx_file, fixP->fx_line,
5722 _("unsupported relocation against %s"),
5723 S_GET_NAME (fixP->fx_addsy));
5731 ppc_elf_validate_fix (fixP, seg);
5733 switch (fixP->fx_r_type)
5735 case BFD_RELOC_CTOR:
5742 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5746 case BFD_RELOC_32_PCREL:
5747 case BFD_RELOC_PPC_EMB_NADDR32:
5748 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5755 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5758 case BFD_RELOC_64_PCREL:
5759 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5763 case BFD_RELOC_GPREL16:
5764 case BFD_RELOC_16_GOT_PCREL:
5765 case BFD_RELOC_16_GOTOFF:
5766 case BFD_RELOC_LO16_GOTOFF:
5767 case BFD_RELOC_HI16_GOTOFF:
5768 case BFD_RELOC_HI16_S_GOTOFF:
5769 case BFD_RELOC_16_BASEREL:
5770 case BFD_RELOC_LO16_BASEREL:
5771 case BFD_RELOC_HI16_BASEREL:
5772 case BFD_RELOC_HI16_S_BASEREL:
5773 case BFD_RELOC_PPC_EMB_NADDR16:
5774 case BFD_RELOC_PPC_EMB_NADDR16_LO:
5775 case BFD_RELOC_PPC_EMB_NADDR16_HI:
5776 case BFD_RELOC_PPC_EMB_NADDR16_HA:
5777 case BFD_RELOC_PPC_EMB_SDAI16:
5778 case BFD_RELOC_PPC_EMB_SDA2REL:
5779 case BFD_RELOC_PPC_EMB_SDA2I16:
5780 case BFD_RELOC_PPC_EMB_RELSEC16:
5781 case BFD_RELOC_PPC_EMB_RELST_LO:
5782 case BFD_RELOC_PPC_EMB_RELST_HI:
5783 case BFD_RELOC_PPC_EMB_RELST_HA:
5784 case BFD_RELOC_PPC_EMB_RELSDA:
5785 case BFD_RELOC_PPC_TOC16:
5787 case BFD_RELOC_PPC64_TOC16_LO:
5788 case BFD_RELOC_PPC64_TOC16_HI:
5789 case BFD_RELOC_PPC64_TOC16_HA:
5793 if (fixP->fx_addsy != NULL)
5794 as_bad_where (fixP->fx_file, fixP->fx_line,
5795 _("cannot emit PC relative %s relocation against %s"),
5796 bfd_get_reloc_code_name (fixP->fx_r_type),
5797 S_GET_NAME (fixP->fx_addsy));
5799 as_bad_where (fixP->fx_file, fixP->fx_line,
5800 _("cannot emit PC relative %s relocation"),
5801 bfd_get_reloc_code_name (fixP->fx_r_type));
5804 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5810 fixP->fx_r_type = BFD_RELOC_16_PCREL;
5813 case BFD_RELOC_16_PCREL:
5814 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5818 case BFD_RELOC_LO16:
5820 fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
5823 case BFD_RELOC_LO16_PCREL:
5824 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5828 /* This case happens when you write, for example,
5830 where L1 and L2 are defined later. */
5831 case BFD_RELOC_HI16:
5833 fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
5836 case BFD_RELOC_HI16_PCREL:
5837 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5841 case BFD_RELOC_HI16_S:
5843 fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
5846 case BFD_RELOC_HI16_S_PCREL:
5847 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5852 case BFD_RELOC_PPC64_HIGHER:
5855 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5856 PPC_HIGHER (value), 2);
5859 case BFD_RELOC_PPC64_HIGHER_S:
5862 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5863 PPC_HIGHERA (value), 2);
5866 case BFD_RELOC_PPC64_HIGHEST:
5869 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5870 PPC_HIGHEST (value), 2);
5873 case BFD_RELOC_PPC64_HIGHEST_S:
5876 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5877 PPC_HIGHESTA (value), 2);
5880 case BFD_RELOC_PPC64_ADDR16_DS:
5881 case BFD_RELOC_PPC64_ADDR16_LO_DS:
5882 case BFD_RELOC_PPC64_GOT16_DS:
5883 case BFD_RELOC_PPC64_GOT16_LO_DS:
5884 case BFD_RELOC_PPC64_PLT16_LO_DS:
5885 case BFD_RELOC_PPC64_SECTOFF_DS:
5886 case BFD_RELOC_PPC64_SECTOFF_LO_DS:
5887 case BFD_RELOC_PPC64_TOC16_DS:
5888 case BFD_RELOC_PPC64_TOC16_LO_DS:
5889 case BFD_RELOC_PPC64_PLTGOT16_DS:
5890 case BFD_RELOC_PPC64_PLTGOT16_LO_DS:
5894 char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
5895 unsigned long val, mask;
5897 if (target_big_endian)
5898 val = bfd_getb32 (where - 2);
5900 val = bfd_getl32 (where);
5902 /* lq insns reserve the four lsbs. */
5903 if ((ppc_cpu & PPC_OPCODE_POWER4) != 0
5904 && (val & (0x3f << 26)) == (56u << 26))
5906 val |= value & mask;
5907 if (target_big_endian)
5908 bfd_putb16 ((bfd_vma) val, where);
5910 bfd_putl16 ((bfd_vma) val, where);
5914 case BFD_RELOC_PPC_B16_BRTAKEN:
5915 case BFD_RELOC_PPC_B16_BRNTAKEN:
5916 case BFD_RELOC_PPC_BA16_BRTAKEN:
5917 case BFD_RELOC_PPC_BA16_BRNTAKEN:
5920 case BFD_RELOC_PPC_TLS:
5923 case BFD_RELOC_PPC_DTPMOD:
5924 case BFD_RELOC_PPC_TPREL16:
5925 case BFD_RELOC_PPC_TPREL16_LO:
5926 case BFD_RELOC_PPC_TPREL16_HI:
5927 case BFD_RELOC_PPC_TPREL16_HA:
5928 case BFD_RELOC_PPC_TPREL:
5929 case BFD_RELOC_PPC_DTPREL16:
5930 case BFD_RELOC_PPC_DTPREL16_LO:
5931 case BFD_RELOC_PPC_DTPREL16_HI:
5932 case BFD_RELOC_PPC_DTPREL16_HA:
5933 case BFD_RELOC_PPC_DTPREL:
5934 case BFD_RELOC_PPC_GOT_TLSGD16:
5935 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
5936 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
5937 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
5938 case BFD_RELOC_PPC_GOT_TLSLD16:
5939 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
5940 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
5941 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
5942 case BFD_RELOC_PPC_GOT_TPREL16:
5943 case BFD_RELOC_PPC_GOT_TPREL16_LO:
5944 case BFD_RELOC_PPC_GOT_TPREL16_HI:
5945 case BFD_RELOC_PPC_GOT_TPREL16_HA:
5946 case BFD_RELOC_PPC_GOT_DTPREL16:
5947 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
5948 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
5949 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
5950 case BFD_RELOC_PPC64_TPREL16_DS:
5951 case BFD_RELOC_PPC64_TPREL16_LO_DS:
5952 case BFD_RELOC_PPC64_TPREL16_HIGHER:
5953 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
5954 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
5955 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
5956 case BFD_RELOC_PPC64_DTPREL16_DS:
5957 case BFD_RELOC_PPC64_DTPREL16_LO_DS:
5958 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
5959 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
5960 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
5961 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
5962 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5965 /* Because SDA21 modifies the register field, the size is set to 4
5966 bytes, rather than 2, so offset it here appropriately. */
5967 case BFD_RELOC_PPC_EMB_SDA21:
5971 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where
5972 + ((target_big_endian) ? 2 : 0),
5979 /* This can occur if there is a bug in the input assembler, eg:
5980 ".byte <undefined_symbol> - ." */
5982 as_bad (_("Unable to handle reference to symbol %s"),
5983 S_GET_NAME (fixP->fx_addsy));
5985 as_bad (_("Unable to resolve expression"));
5989 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5993 case BFD_RELOC_24_PLT_PCREL:
5994 case BFD_RELOC_PPC_LOCAL24PC:
5995 if (!fixP->fx_pcrel && !fixP->fx_done)
6003 /* Fetch the instruction, insert the fully resolved operand
6004 value, and stuff the instruction back again. */
6005 where = fixP->fx_frag->fr_literal + fixP->fx_where;
6006 if (target_big_endian)
6007 insn = bfd_getb32 ((unsigned char *) where);
6009 insn = bfd_getl32 ((unsigned char *) where);
6010 if ((value & 3) != 0)
6011 as_bad_where (fixP->fx_file, fixP->fx_line,
6012 _("must branch to an address a multiple of 4"));
6013 if ((offsetT) value < -0x40000000
6014 || (offsetT) value >= 0x40000000)
6015 as_bad_where (fixP->fx_file, fixP->fx_line,
6016 _("@local or @plt branch destination is too far away, %ld bytes"),
6018 insn = insn | (value & 0x03fffffc);
6019 if (target_big_endian)
6020 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
6022 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
6026 case BFD_RELOC_VTABLE_INHERIT:
6029 && !S_IS_DEFINED (fixP->fx_addsy)
6030 && !S_IS_WEAK (fixP->fx_addsy))
6031 S_SET_WEAK (fixP->fx_addsy);
6034 case BFD_RELOC_VTABLE_ENTRY:
6039 /* Generated by reference to `sym@tocbase'. The sym is
6040 ignored by the linker. */
6041 case BFD_RELOC_PPC64_TOC:
6047 _("Gas failure, reloc value %d\n"), fixP->fx_r_type);
6054 fixP->fx_addnumber = value;
6056 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6057 from the section contents. If we are going to be emitting a reloc
6058 then the section contents are immaterial, so don't warn if they
6059 happen to overflow. Leave such warnings to ld. */
6061 fixP->fx_no_overflow = 1;
6063 if (fixP->fx_r_type != BFD_RELOC_PPC_TOC16)
6064 fixP->fx_addnumber = 0;
6068 fixP->fx_addnumber = 0;
6070 /* We want to use the offset within the toc, not the actual VMA
6072 fixP->fx_addnumber =
6073 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixP->fx_addsy))
6074 - S_GET_VALUE (ppc_toc_csect);
6080 /* Generate a reloc for a fixup. */
6083 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
6087 reloc = (arelent *) xmalloc (sizeof (arelent));
6089 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6090 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6091 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6092 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6093 if (reloc->howto == (reloc_howto_type *) NULL)
6095 as_bad_where (fixp->fx_file, fixp->fx_line,
6096 _("reloc %d not supported by object file format"),
6097 (int) fixp->fx_r_type);
6100 reloc->addend = fixp->fx_addnumber;
6106 ppc_cfi_frame_initial_instructions (void)
6108 cfi_add_CFA_def_cfa (1, 0);
6112 tc_ppc_regname_to_dw2regnum (char *regname)
6114 unsigned int regnum = -1;
6118 static struct { char *name; int dw2regnum; } regnames[] =
6120 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6121 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6122 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6123 { "spe_acc", 111 }, { "spefscr", 112 }
6126 for (i = 0; i < ARRAY_SIZE (regnames); ++i)
6127 if (strcmp (regnames[i].name, regname) == 0)
6128 return regnames[i].dw2regnum;
6130 if (regname[0] == 'r' || regname[0] == 'f' || regname[0] == 'v')
6132 p = regname + 1 + (regname[1] == '.');
6133 regnum = strtoul (p, &q, 10);
6134 if (p == q || *q || regnum >= 32)
6136 if (regname[0] == 'f')
6138 else if (regname[0] == 'v')
6141 else if (regname[0] == 'c' && regname[1] == 'r')
6143 p = regname + 2 + (regname[2] == '.');
6144 if (p[0] < '0' || p[0] > '7' || p[1])
6146 regnum = p[0] - '0' + 68;