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 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 2, 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 bfd_boolean register_name
PARAMS ((expressionS
*));
88 static void ppc_set_cpu
PARAMS ((void));
89 static unsigned long ppc_insert_operand
90 PARAMS ((unsigned long insn
, const struct powerpc_operand
*operand
,
91 offsetT val
, char *file
, unsigned int line
));
92 static void ppc_macro
PARAMS ((char *str
, const struct powerpc_macro
*macro
));
93 static void ppc_byte
PARAMS ((int));
95 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
96 static int ppc_is_toc_sym
PARAMS ((symbolS
*sym
));
97 static void ppc_tc
PARAMS ((int));
98 static void ppc_machine
PARAMS ((int));
102 static void ppc_comm
PARAMS ((int));
103 static void ppc_bb
PARAMS ((int));
104 static void ppc_bc
PARAMS ((int));
105 static void ppc_bf
PARAMS ((int));
106 static void ppc_biei
PARAMS ((int));
107 static void ppc_bs
PARAMS ((int));
108 static void ppc_eb
PARAMS ((int));
109 static void ppc_ec
PARAMS ((int));
110 static void ppc_ef
PARAMS ((int));
111 static void ppc_es
PARAMS ((int));
112 static void ppc_csect
PARAMS ((int));
113 static void ppc_change_csect
PARAMS ((symbolS
*, offsetT
));
114 static void ppc_function
PARAMS ((int));
115 static void ppc_extern
PARAMS ((int));
116 static void ppc_lglobl
PARAMS ((int));
117 static void ppc_section
PARAMS ((int));
118 static void ppc_named_section
PARAMS ((int));
119 static void ppc_stabx
PARAMS ((int));
120 static void ppc_rename
PARAMS ((int));
121 static void ppc_toc
PARAMS ((int));
122 static void ppc_xcoff_cons
PARAMS ((int));
123 static void ppc_vbyte
PARAMS ((int));
127 static bfd_reloc_code_real_type ppc_elf_suffix
PARAMS ((char **, expressionS
*));
128 static void ppc_elf_cons
PARAMS ((int));
129 static void ppc_elf_rdata
PARAMS ((int));
130 static void ppc_elf_lcomm
PARAMS ((int));
131 static void ppc_elf_validate_fix
PARAMS ((fixS
*, segT
));
132 static void ppc_apuinfo_section_add
PARAMS ((unsigned int apu
, unsigned int version
));
136 static void ppc_set_current_section
PARAMS ((segT
));
137 static void ppc_previous
PARAMS ((int));
138 static void ppc_pdata
PARAMS ((int));
139 static void ppc_ydata
PARAMS ((int));
140 static void ppc_reldata
PARAMS ((int));
141 static void ppc_rdata
PARAMS ((int));
142 static void ppc_ualong
PARAMS ((int));
143 static void ppc_znop
PARAMS ((int));
144 static void ppc_pe_comm
PARAMS ((int));
145 static void ppc_pe_section
PARAMS ((int));
146 static void ppc_pe_function
PARAMS ((int));
147 static void ppc_pe_tocd
PARAMS ((int));
150 /* Generic assembler global variables which must be defined by all
154 /* This string holds the chars that always start a comment. If the
155 pre-processor is disabled, these aren't very useful. The macro
156 tc_comment_chars points to this. We use this, rather than the
157 usual comment_chars, so that we can switch for Solaris conventions. */
158 static const char ppc_solaris_comment_chars
[] = "#!";
159 static const char ppc_eabi_comment_chars
[] = "#";
161 #ifdef TARGET_SOLARIS_COMMENT
162 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
164 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
167 const char comment_chars
[] = "#";
170 /* Characters which start a comment at the beginning of a line. */
171 const char line_comment_chars
[] = "#";
173 /* Characters which may be used to separate multiple commands on a
175 const char line_separator_chars
[] = ";";
177 /* Characters which are used to indicate an exponent in a floating
179 const char EXP_CHARS
[] = "eE";
181 /* Characters which mean that a number is a floating point constant,
183 const char FLT_CHARS
[] = "dD";
185 /* '+' and '-' can be used as postfix predicate predictors for conditional
186 branches. So they need to be accepted as symbol characters.
187 Also, anything that can start an operand needs to be mentioned here,
188 to stop the input scrubber eating whitespace. */
189 const char ppc_symbol_chars
[] = "+-%[";
191 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
192 int ppc_cie_data_alignment
;
194 /* The target specific pseudo-ops which we support. */
196 const pseudo_typeS md_pseudo_table
[] =
198 /* Pseudo-ops which must be overridden. */
199 { "byte", ppc_byte
, 0 },
202 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
203 legitimately belong in the obj-*.c file. However, XCOFF is based
204 on COFF, and is only implemented for the RS/6000. We just use
205 obj-coff.c, and add what we need here. */
206 { "comm", ppc_comm
, 0 },
207 { "lcomm", ppc_comm
, 1 },
211 { "bi", ppc_biei
, 0 },
213 { "csect", ppc_csect
, 0 },
214 { "data", ppc_section
, 'd' },
218 { "ei", ppc_biei
, 1 },
220 { "extern", ppc_extern
, 0 },
221 { "function", ppc_function
, 0 },
222 { "lglobl", ppc_lglobl
, 0 },
223 { "rename", ppc_rename
, 0 },
224 { "section", ppc_named_section
, 0 },
225 { "stabx", ppc_stabx
, 0 },
226 { "text", ppc_section
, 't' },
227 { "toc", ppc_toc
, 0 },
228 { "long", ppc_xcoff_cons
, 2 },
229 { "llong", ppc_xcoff_cons
, 3 },
230 { "word", ppc_xcoff_cons
, 1 },
231 { "short", ppc_xcoff_cons
, 1 },
232 { "vbyte", ppc_vbyte
, 0 },
236 { "llong", ppc_elf_cons
, 8 },
237 { "quad", ppc_elf_cons
, 8 },
238 { "long", ppc_elf_cons
, 4 },
239 { "word", ppc_elf_cons
, 2 },
240 { "short", ppc_elf_cons
, 2 },
241 { "rdata", ppc_elf_rdata
, 0 },
242 { "rodata", ppc_elf_rdata
, 0 },
243 { "lcomm", ppc_elf_lcomm
, 0 },
247 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
248 { "previous", ppc_previous
, 0 },
249 { "pdata", ppc_pdata
, 0 },
250 { "ydata", ppc_ydata
, 0 },
251 { "reldata", ppc_reldata
, 0 },
252 { "rdata", ppc_rdata
, 0 },
253 { "ualong", ppc_ualong
, 0 },
254 { "znop", ppc_znop
, 0 },
255 { "comm", ppc_pe_comm
, 0 },
256 { "lcomm", ppc_pe_comm
, 1 },
257 { "section", ppc_pe_section
, 0 },
258 { "function", ppc_pe_function
,0 },
259 { "tocd", ppc_pe_tocd
, 0 },
262 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
264 { "machine", ppc_machine
, 0 },
271 /* Predefined register names if -mregnames (or default for Windows NT).
272 In general, there are lots of them, in an attempt to be compatible
273 with a number of other Windows NT assemblers. */
275 /* Structure to hold information about predefined registers. */
282 /* List of registers that are pre-defined:
284 Each general register has predefined names of the form:
285 1. r<reg_num> which has the value <reg_num>.
286 2. r.<reg_num> which has the value <reg_num>.
288 Each floating point register has predefined names of the form:
289 1. f<reg_num> which has the value <reg_num>.
290 2. f.<reg_num> which has the value <reg_num>.
292 Each vector unit register has predefined names of the form:
293 1. v<reg_num> which has the value <reg_num>.
294 2. v.<reg_num> which has the value <reg_num>.
296 Each condition register has predefined names of the form:
297 1. cr<reg_num> which has the value <reg_num>.
298 2. cr.<reg_num> which has the value <reg_num>.
300 There are individual registers as well:
301 sp or r.sp has the value 1
302 rtoc or r.toc has the value 2
303 fpscr has the value 0
309 dsisr has the value 18
311 sdr1 has the value 25
312 srr0 has the value 26
313 srr1 has the value 27
315 The table is sorted. Suitable for searching by a binary search. */
317 static const struct pd_reg pre_defined_registers
[] =
319 { "cr.0", 0 }, /* Condition Registers */
339 { "dar", 19 }, /* Data Access Register */
340 { "dec", 22 }, /* Decrementer */
341 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
343 { "f.0", 0 }, /* Floating point registers */
411 { "lr", 8 }, /* Link Register */
415 { "r.0", 0 }, /* General Purpose Registers */
448 { "r.sp", 1 }, /* Stack Pointer */
450 { "r.toc", 2 }, /* Pointer to the table of contents */
452 { "r0", 0 }, /* More general purpose registers */
485 { "rtoc", 2 }, /* Table of contents */
487 { "sdr1", 25 }, /* Storage Description Register 1 */
491 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
492 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
494 { "v.0", 0 }, /* Vector registers */
564 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
566 /* Given NAME, find the register number associated with that name, return
567 the integer value associated with the given name or -1 on failure. */
569 static int reg_name_search
570 PARAMS ((const struct pd_reg
*, int, const char * name
));
573 reg_name_search (regs
, regcount
, name
)
574 const struct pd_reg
*regs
;
578 int middle
, low
, high
;
586 middle
= (low
+ high
) / 2;
587 cmp
= strcasecmp (name
, regs
[middle
].name
);
593 return regs
[middle
].value
;
601 * Summary of register_name.
603 * in: Input_line_pointer points to 1st char of operand.
605 * out: A expressionS.
606 * The operand may have been a register: in this case, X_op == O_register,
607 * X_add_number is set to the register number, and truth is returned.
608 * Input_line_pointer->(next non-blank) char after operand, or is in its
613 register_name (expressionP
)
614 expressionS
*expressionP
;
621 /* Find the spelling of the operand. */
622 start
= name
= input_line_pointer
;
623 if (name
[0] == '%' && ISALPHA (name
[1]))
624 name
= ++input_line_pointer
;
626 else if (!reg_names_p
|| !ISALPHA (name
[0]))
629 c
= get_symbol_end ();
630 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
632 /* Put back the delimiting char. */
633 *input_line_pointer
= c
;
635 /* Look to see if it's in the register table. */
638 expressionP
->X_op
= O_register
;
639 expressionP
->X_add_number
= reg_number
;
641 /* Make the rest nice. */
642 expressionP
->X_add_symbol
= NULL
;
643 expressionP
->X_op_symbol
= NULL
;
647 /* Reset the line as if we had not done anything. */
648 input_line_pointer
= start
;
652 /* This function is called for each symbol seen in an expression. It
653 handles the special parsing which PowerPC assemblers are supposed
654 to use for condition codes. */
656 /* Whether to do the special parsing. */
657 static bfd_boolean cr_operand
;
659 /* Names to recognize in a condition code. This table is sorted. */
660 static const struct pd_reg cr_names
[] =
677 /* Parsing function. This returns non-zero if it recognized an
681 ppc_parse_name (name
, expr
)
690 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
695 expr
->X_op
= O_constant
;
696 expr
->X_add_number
= val
;
701 /* Local variables. */
703 /* The type of processor we are assembling for. This is one or more
704 of the PPC_OPCODE flags defined in opcode/ppc.h. */
705 static unsigned long ppc_cpu
= 0;
707 /* Whether to target xcoff64/elf64. */
708 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
710 /* Opcode hash table. */
711 static struct hash_control
*ppc_hash
;
713 /* Macro hash table. */
714 static struct hash_control
*ppc_macro_hash
;
717 /* What type of shared library support to use. */
718 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
720 /* Flags to set in the elf header. */
721 static flagword ppc_flags
= 0;
723 /* Whether this is Solaris or not. */
724 #ifdef TARGET_SOLARIS_COMMENT
725 #define SOLARIS_P TRUE
727 #define SOLARIS_P FALSE
730 static bfd_boolean msolaris
= SOLARIS_P
;
735 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
736 using a bunch of different sections. These assembler sections,
737 however, are all encompassed within the .text or .data sections of
738 the final output file. We handle this by using different
739 subsegments within these main segments. */
741 /* Next subsegment to allocate within the .text segment. */
742 static subsegT ppc_text_subsegment
= 2;
744 /* Linked list of csects in the text section. */
745 static symbolS
*ppc_text_csects
;
747 /* Next subsegment to allocate within the .data segment. */
748 static subsegT ppc_data_subsegment
= 2;
750 /* Linked list of csects in the data section. */
751 static symbolS
*ppc_data_csects
;
753 /* The current csect. */
754 static symbolS
*ppc_current_csect
;
756 /* The RS/6000 assembler uses a TOC which holds addresses of functions
757 and variables. Symbols are put in the TOC with the .tc pseudo-op.
758 A special relocation is used when accessing TOC entries. We handle
759 the TOC as a subsegment within the .data segment. We set it up if
760 we see a .toc pseudo-op, and save the csect symbol here. */
761 static symbolS
*ppc_toc_csect
;
763 /* The first frag in the TOC subsegment. */
764 static fragS
*ppc_toc_frag
;
766 /* The first frag in the first subsegment after the TOC in the .data
767 segment. NULL if there are no subsegments after the TOC. */
768 static fragS
*ppc_after_toc_frag
;
770 /* The current static block. */
771 static symbolS
*ppc_current_block
;
773 /* The COFF debugging section; set by md_begin. This is not the
774 .debug section, but is instead the secret BFD section which will
775 cause BFD to set the section number of a symbol to N_DEBUG. */
776 static asection
*ppc_coff_debug_section
;
778 #endif /* OBJ_XCOFF */
782 /* Various sections that we need for PE coff support. */
783 static segT ydata_section
;
784 static segT pdata_section
;
785 static segT reldata_section
;
786 static segT rdata_section
;
787 static segT tocdata_section
;
789 /* The current section and the previous section. See ppc_previous. */
790 static segT ppc_previous_section
;
791 static segT ppc_current_section
;
796 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
797 #define PPC_APUINFO_ISEL 0x40
798 #define PPC_APUINFO_PMR 0x41
799 #define PPC_APUINFO_RFMCI 0x42
800 #define PPC_APUINFO_CACHELCK 0x43
801 #define PPC_APUINFO_SPE 0x100
802 #define PPC_APUINFO_EFS 0x101
803 #define PPC_APUINFO_BRLOCK 0x102
806 * We keep a list of APUinfo
808 unsigned long *ppc_apuinfo_list
;
809 unsigned int ppc_apuinfo_num
;
810 unsigned int ppc_apuinfo_num_alloc
;
814 const char *const md_shortopts
= "b:l:usm:K:VQ:";
816 const char *const md_shortopts
= "um:";
818 const struct option md_longopts
[] = {
819 {NULL
, no_argument
, NULL
, 0}
821 const size_t md_longopts_size
= sizeof (md_longopts
);
824 /* Handle -m options that set cpu type, and .machine arg. */
827 parse_cpu (const char *arg
)
829 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
831 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
832 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
| PPC_OPCODE_32
;
833 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
834 else if (strcmp (arg
, "pwr") == 0)
835 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
836 /* -m601 means to assemble for the PowerPC 601, which includes
837 instructions that are holdovers from the Power. */
838 else if (strcmp (arg
, "601") == 0)
839 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
840 | PPC_OPCODE_601
| PPC_OPCODE_32
);
841 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
843 else if (strcmp (arg
, "ppc") == 0
844 || strcmp (arg
, "ppc32") == 0
845 || strcmp (arg
, "603") == 0
846 || strcmp (arg
, "604") == 0)
847 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
848 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
849 else if (strcmp (arg
, "403") == 0
850 || strcmp (arg
, "405") == 0)
851 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
852 | PPC_OPCODE_403
| PPC_OPCODE_32
);
853 else if (strcmp (arg
, "440") == 0)
854 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
855 | PPC_OPCODE_440
| PPC_OPCODE_ISEL
| PPC_OPCODE_RFMCI
);
856 else if (strcmp (arg
, "7400") == 0
857 || strcmp (arg
, "7410") == 0
858 || strcmp (arg
, "7450") == 0
859 || strcmp (arg
, "7455") == 0)
860 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
861 | PPC_OPCODE_ALTIVEC
| PPC_OPCODE_32
);
862 else if (strcmp (arg
, "e300") == 0)
863 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
865 else if (strcmp (arg
, "altivec") == 0)
868 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_ALTIVEC
;
870 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
872 else if (strcmp (arg
, "e500") == 0 || strcmp (arg
, "e500x2") == 0)
874 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_SPE
875 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
| PPC_OPCODE_BRLOCK
876 | PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
879 else if (strcmp (arg
, "spe") == 0)
882 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_SPE
| PPC_OPCODE_EFS
;
884 ppc_cpu
|= PPC_OPCODE_SPE
;
886 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
888 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
890 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
892 else if (strcmp (arg
, "ppc64bridge") == 0)
894 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
895 | PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
);
897 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
898 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
900 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
;
902 /* -mbooke64 means enable 64-bit BookE support. */
903 else if (strcmp (arg
, "booke64") == 0)
905 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
906 | PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
);
908 else if (strcmp (arg
, "power4") == 0)
910 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
911 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
);
913 else if (strcmp (arg
, "power5") == 0)
915 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
916 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
917 | PPC_OPCODE_POWER5
);
919 else if (strcmp (arg
, "power6") == 0)
921 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
922 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
923 | PPC_OPCODE_POWER5
| PPC_OPCODE_POWER6
);
925 /* -mcom means assemble for the common intersection between Power
926 and PowerPC. At present, we just allow the union, rather
927 than the intersection. */
928 else if (strcmp (arg
, "com") == 0)
929 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
930 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
931 else if (strcmp (arg
, "any") == 0)
932 ppc_cpu
|= PPC_OPCODE_ANY
;
940 md_parse_option (c
, arg
)
947 /* -u means that any undefined symbols should be treated as
948 external, which is the default for gas anyhow. */
953 /* Solaris as takes -le (presumably for little endian). For completeness
954 sake, recognize -be also. */
955 if (strcmp (arg
, "e") == 0)
957 target_big_endian
= 0;
958 set_target_endian
= 1;
966 if (strcmp (arg
, "e") == 0)
968 target_big_endian
= 1;
969 set_target_endian
= 1;
977 /* Recognize -K PIC. */
978 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
981 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
989 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
991 if (strcmp (arg
, "64") == 0)
996 as_fatal (_("%s unsupported"), "-a64");
999 else if (strcmp (arg
, "32") == 0)
1006 if (parse_cpu (arg
))
1009 else if (strcmp (arg
, "regnames") == 0)
1012 else if (strcmp (arg
, "no-regnames") == 0)
1013 reg_names_p
= FALSE
;
1016 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1017 that require relocation. */
1018 else if (strcmp (arg
, "relocatable") == 0)
1020 shlib
= SHLIB_MRELOCATABLE
;
1021 ppc_flags
|= EF_PPC_RELOCATABLE
;
1024 else if (strcmp (arg
, "relocatable-lib") == 0)
1026 shlib
= SHLIB_MRELOCATABLE
;
1027 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1030 /* -memb, set embedded bit. */
1031 else if (strcmp (arg
, "emb") == 0)
1032 ppc_flags
|= EF_PPC_EMB
;
1034 /* -mlittle/-mbig set the endianess. */
1035 else if (strcmp (arg
, "little") == 0
1036 || strcmp (arg
, "little-endian") == 0)
1038 target_big_endian
= 0;
1039 set_target_endian
= 1;
1042 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1044 target_big_endian
= 1;
1045 set_target_endian
= 1;
1048 else if (strcmp (arg
, "solaris") == 0)
1051 ppc_comment_chars
= ppc_solaris_comment_chars
;
1054 else if (strcmp (arg
, "no-solaris") == 0)
1057 ppc_comment_chars
= ppc_eabi_comment_chars
;
1062 as_bad (_("invalid switch -m%s"), arg
);
1068 /* -V: SVR4 argument to print version ID. */
1070 print_version_id ();
1073 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1074 should be emitted or not. FIXME: Not implemented. */
1078 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1079 rather than .stabs.excl, which is ignored by the linker.
1080 FIXME: Not implemented. */
1096 md_show_usage (stream
)
1099 fprintf (stream
, _("\
1101 -a32 generate ELF32/XCOFF32\n\
1102 -a64 generate ELF64/XCOFF64\n\
1104 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1105 -mpwr generate code for POWER (RIOS1)\n\
1106 -m601 generate code for PowerPC 601\n\
1107 -mppc, -mppc32, -m603, -m604\n\
1108 generate code for PowerPC 603/604\n\
1109 -m403, -m405 generate code for PowerPC 403/405\n\
1110 -m440 generate code for PowerPC 440\n\
1111 -m7400, -m7410, -m7450, -m7455\n\
1112 generate code For PowerPC 7400/7410/7450/7455\n"));
1113 fprintf (stream
, _("\
1114 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1115 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1116 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1117 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1118 -mpower4 generate code for Power4 architecture\n\
1119 -mpower5 generate code for Power5 architecture\n\
1120 -mpower6 generate code for Power6 architecture\n\
1121 -mcom generate code Power/PowerPC common instructions\n\
1122 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1123 fprintf (stream
, _("\
1124 -maltivec generate code for AltiVec\n\
1125 -me300 generate code for PowerPC e300 family\n\
1126 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1127 -mspe generate code for Motorola SPE instructions\n\
1128 -mregnames Allow symbolic names for registers\n\
1129 -mno-regnames Do not allow symbolic names for registers\n"));
1131 fprintf (stream
, _("\
1132 -mrelocatable support for GCC's -mrelocatble option\n\
1133 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1134 -memb set PPC_EMB bit in ELF flags\n\
1135 -mlittle, -mlittle-endian, -l, -le\n\
1136 generate code for a little endian machine\n\
1137 -mbig, -mbig-endian, -b, -be\n\
1138 generate code for a big endian machine\n\
1139 -msolaris generate code for Solaris\n\
1140 -mno-solaris do not generate code for Solaris\n\
1141 -V print assembler version number\n\
1142 -Qy, -Qn ignored\n"));
1146 /* Set ppc_cpu if it is not already set. */
1151 const char *default_os
= TARGET_OS
;
1152 const char *default_cpu
= TARGET_CPU
;
1154 if ((ppc_cpu
& ~PPC_OPCODE_ANY
) == 0)
1157 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1158 else if (strncmp (default_os
, "aix", 3) == 0
1159 && default_os
[3] >= '4' && default_os
[3] <= '9')
1160 ppc_cpu
|= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1161 else if (strncmp (default_os
, "aix3", 4) == 0)
1162 ppc_cpu
|= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1163 else if (strcmp (default_cpu
, "rs6000") == 0)
1164 ppc_cpu
|= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1165 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1166 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
1168 as_fatal (_("Unknown default cpu = %s, os = %s"),
1169 default_cpu
, default_os
);
1173 /* Figure out the BFD architecture to use. This function and ppc_mach
1174 are called well before md_begin, when the output file is opened. */
1176 enum bfd_architecture
1179 const char *default_cpu
= TARGET_CPU
;
1182 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1183 return bfd_arch_powerpc
;
1184 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1185 return bfd_arch_rs6000
;
1186 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1188 if (strcmp (default_cpu
, "rs6000") == 0)
1189 return bfd_arch_rs6000
;
1190 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1191 return bfd_arch_powerpc
;
1194 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1195 return bfd_arch_unknown
;
1202 return bfd_mach_ppc64
;
1203 else if (ppc_arch () == bfd_arch_rs6000
)
1204 return bfd_mach_rs6k
;
1206 return bfd_mach_ppc
;
1210 ppc_target_format ()
1214 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1216 return "xcoff-powermac";
1219 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1221 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1227 return "elf32-powerpc-vxworks";
1229 return (target_big_endian
1230 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1231 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1236 /* Insert opcodes and macros into hash tables. Called at startup and
1240 ppc_setup_opcodes (void)
1242 register const struct powerpc_opcode
*op
;
1243 const struct powerpc_opcode
*op_end
;
1244 const struct powerpc_macro
*macro
;
1245 const struct powerpc_macro
*macro_end
;
1246 bfd_boolean dup_insn
= FALSE
;
1248 if (ppc_hash
!= NULL
)
1249 hash_die (ppc_hash
);
1250 if (ppc_macro_hash
!= NULL
)
1251 hash_die (ppc_macro_hash
);
1253 /* Insert the opcodes into a hash table. */
1254 ppc_hash
= hash_new ();
1256 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1257 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1259 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1261 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1262 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1263 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1264 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1265 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1266 /* Certain instructions (eg: extsw) do not exist in the
1267 32-bit BookE instruction set, but they do exist in the
1268 64-bit BookE instruction set, and other PPC instruction
1269 sets. Check to see if the opcode has the BOOKE64 flag set.
1270 If it does make sure that the target CPU is not the BookE32. */
1271 && ((op
->flags
& PPC_OPCODE_BOOKE64
) == 0
1272 || (ppc_cpu
& PPC_OPCODE_BOOKE64
) == PPC_OPCODE_BOOKE64
1273 || (ppc_cpu
& PPC_OPCODE_BOOKE
) == 0)
1274 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1275 || ((op
->flags
& PPC_OPCODE_POWER4
)
1276 == (ppc_cpu
& PPC_OPCODE_POWER4
)))
1277 && ((op
->flags
& PPC_OPCODE_POWER5
) == 0
1278 || ((op
->flags
& PPC_OPCODE_POWER5
)
1279 == (ppc_cpu
& PPC_OPCODE_POWER5
)))
1280 && ((op
->flags
& PPC_OPCODE_POWER6
) == 0
1281 || ((op
->flags
& PPC_OPCODE_POWER6
)
1282 == (ppc_cpu
& PPC_OPCODE_POWER6
))))
1286 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1289 /* Ignore Power duplicates for -m601. */
1290 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1291 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1294 as_bad (_("Internal assembler error for instruction %s"),
1301 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1302 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1303 hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1305 /* Insert the macros into a hash table. */
1306 ppc_macro_hash
= hash_new ();
1308 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1309 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1311 if ((macro
->flags
& ppc_cpu
) != 0)
1315 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1316 if (retval
!= (const char *) NULL
)
1318 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1328 /* This function is called when the assembler starts up. It is called
1329 after the options have been parsed and the output file has been
1337 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1340 /* Set the ELF flags if desired. */
1341 if (ppc_flags
&& !msolaris
)
1342 bfd_set_private_flags (stdoutput
, ppc_flags
);
1345 ppc_setup_opcodes ();
1347 /* Tell the main code what the endianness is if it is not overridden
1349 if (!set_target_endian
)
1351 set_target_endian
= 1;
1352 target_big_endian
= PPC_BIG_ENDIAN
;
1356 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1358 /* Create dummy symbols to serve as initial csects. This forces the
1359 text csects to precede the data csects. These symbols will not
1361 ppc_text_csects
= symbol_make ("dummy\001");
1362 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1363 ppc_data_csects
= symbol_make ("dummy\001");
1364 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1369 ppc_current_section
= text_section
;
1370 ppc_previous_section
= 0;
1379 if (ppc_apuinfo_list
== NULL
)
1382 /* Ok, so write the section info out. We have this layout:
1386 0 8 length of "APUinfo\0"
1387 4 (n*4) number of APU's (4 bytes each)
1390 20 APU#1 first APU's info
1391 24 APU#2 second APU's info
1396 asection
*seg
= now_seg
;
1397 subsegT subseg
= now_subseg
;
1398 asection
*apuinfo_secp
= (asection
*) NULL
;
1401 /* Create the .PPC.EMB.apuinfo section. */
1402 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1403 bfd_set_section_flags (stdoutput
,
1405 SEC_HAS_CONTENTS
| SEC_READONLY
);
1408 md_number_to_chars (p
, (valueT
) 8, 4);
1411 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1414 md_number_to_chars (p
, (valueT
) 2, 4);
1417 strcpy (p
, "APUinfo");
1419 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1422 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1425 frag_align (2, 0, 0);
1427 /* We probably can't restore the current segment, for there likely
1430 subseg_set (seg
, subseg
);
1435 /* Insert an operand value into an instruction. */
1437 static unsigned long
1438 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1440 const struct powerpc_operand
*operand
;
1445 if (operand
->bits
!= 32)
1450 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1452 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1453 max
= (1 << operand
->bits
) - 1;
1455 max
= (1 << (operand
->bits
- 1)) - 1;
1456 min
= - (1 << (operand
->bits
- 1));
1460 /* Some people write 32 bit hex constants with the sign
1461 extension done by hand. This shouldn't really be
1462 valid, but, to permit this code to assemble on a 64
1463 bit host, we sign extend the 32 bit value. */
1465 && (val
& (offsetT
) 0x80000000) != 0
1466 && (val
& (offsetT
) 0xffffffff) == val
)
1475 max
= (1 << operand
->bits
) - 1;
1479 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1484 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1485 as_bad_value_out_of_range (_("operand"), test
, (offsetT
) min
, (offsetT
) max
, file
, line
);
1488 if (operand
->insert
)
1493 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1494 if (errmsg
!= (const char *) NULL
)
1495 as_bad_where (file
, line
, errmsg
);
1498 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1506 /* Parse @got, etc. and return the desired relocation. */
1507 static bfd_reloc_code_real_type
1508 ppc_elf_suffix (str_p
, exp_p
)
1514 unsigned int length
: 8;
1515 unsigned int valid32
: 1;
1516 unsigned int valid64
: 1;
1525 const struct map_bfd
*ptr
;
1527 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1528 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1529 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1531 static const struct map_bfd mapping
[] = {
1532 MAP ("l", BFD_RELOC_LO16
),
1533 MAP ("h", BFD_RELOC_HI16
),
1534 MAP ("ha", BFD_RELOC_HI16_S
),
1535 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1536 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1537 MAP ("got", BFD_RELOC_16_GOTOFF
),
1538 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1539 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1540 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1541 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1542 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1543 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1544 MAP ("copy", BFD_RELOC_PPC_COPY
),
1545 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1546 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1547 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1548 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1549 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1550 MAP ("tls", BFD_RELOC_PPC_TLS
),
1551 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1552 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1553 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1554 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1555 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1556 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1557 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1558 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1559 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1560 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1561 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1562 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1563 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1564 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1565 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1566 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1567 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1568 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1569 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1570 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1571 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1572 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1573 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1574 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1575 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1576 MAP32 ("fixup", BFD_RELOC_CTOR
),
1577 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1578 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1579 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1580 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1581 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1582 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1583 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1584 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1585 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1586 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1587 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1588 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1589 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1590 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1591 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1592 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1593 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1594 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1595 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1596 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1597 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1598 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1599 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1600 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1601 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1602 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1603 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1604 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1605 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1606 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1607 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1608 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1609 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1610 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1611 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1612 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1613 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1614 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1615 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1616 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1617 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1621 return BFD_RELOC_UNUSED
;
1623 for (ch
= *str
, str2
= ident
;
1624 (str2
< ident
+ sizeof (ident
) - 1
1625 && (ISALNUM (ch
) || ch
== '@'));
1628 *str2
++ = TOLOWER (ch
);
1635 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1636 if (ch
== ptr
->string
[0]
1637 && len
== ptr
->length
1638 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1639 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1641 int reloc
= ptr
->reloc
;
1644 if (exp_p
->X_add_number
!= 0
1645 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1646 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1647 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1648 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1649 as_warn (_("identifier+constant@got means identifier@got+constant"));
1651 /* Now check for identifier@suffix+constant. */
1652 if (*str
== '-' || *str
== '+')
1654 char *orig_line
= input_line_pointer
;
1655 expressionS new_exp
;
1657 input_line_pointer
= str
;
1658 expression (&new_exp
);
1659 if (new_exp
.X_op
== O_constant
)
1661 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1662 str
= input_line_pointer
;
1665 if (&input_line_pointer
!= str_p
)
1666 input_line_pointer
= orig_line
;
1670 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1671 && exp_p
->X_op
== O_symbol
1672 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
1674 /* Change the symbol so that the dummy .TOC. symbol can be
1675 omitted from the object file. */
1676 exp_p
->X_add_symbol
= &abs_symbol
;
1679 return (bfd_reloc_code_real_type
) reloc
;
1682 return BFD_RELOC_UNUSED
;
1685 /* Like normal .long/.short/.word, except support @got, etc.
1686 Clobbers input_line_pointer, checks end-of-line. */
1688 ppc_elf_cons (nbytes
)
1689 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1692 bfd_reloc_code_real_type reloc
;
1694 if (is_it_end_of_statement ())
1696 demand_empty_rest_of_line ();
1703 if (exp
.X_op
== O_symbol
1704 && *input_line_pointer
== '@'
1705 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1706 &exp
)) != BFD_RELOC_UNUSED
)
1708 reloc_howto_type
*reloc_howto
;
1711 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1712 size
= bfd_get_reloc_size (reloc_howto
);
1716 as_bad (_("%s relocations do not fit in %d bytes\n"),
1717 reloc_howto
->name
, nbytes
);
1724 p
= frag_more (nbytes
);
1726 if (target_big_endian
)
1727 offset
= nbytes
- size
;
1728 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1733 emit_expr (&exp
, (unsigned int) nbytes
);
1735 while (*input_line_pointer
++ == ',');
1737 /* Put terminator back into stream. */
1738 input_line_pointer
--;
1739 demand_empty_rest_of_line ();
1742 /* Solaris pseduo op to change to the .rodata section. */
1747 char *save_line
= input_line_pointer
;
1748 static char section
[] = ".rodata\n";
1750 /* Just pretend this is .section .rodata */
1751 input_line_pointer
= section
;
1752 obj_elf_section (xxx
);
1754 input_line_pointer
= save_line
;
1757 /* Pseudo op to make file scope bss items. */
1760 int xxx ATTRIBUTE_UNUSED
;
1762 register char *name
;
1766 register symbolS
*symbolP
;
1773 name
= input_line_pointer
;
1774 c
= get_symbol_end ();
1776 /* just after name is now '\0'. */
1777 p
= input_line_pointer
;
1780 if (*input_line_pointer
!= ',')
1782 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1783 ignore_rest_of_line ();
1787 input_line_pointer
++; /* skip ',' */
1788 if ((size
= get_absolute_expression ()) < 0)
1790 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1791 ignore_rest_of_line ();
1795 /* The third argument to .lcomm is the alignment. */
1796 if (*input_line_pointer
!= ',')
1800 ++input_line_pointer
;
1801 align
= get_absolute_expression ();
1804 as_warn (_("ignoring bad alignment"));
1810 symbolP
= symbol_find_or_make (name
);
1813 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1815 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1816 S_GET_NAME (symbolP
));
1817 ignore_rest_of_line ();
1821 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1823 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1824 S_GET_NAME (symbolP
),
1825 (long) S_GET_VALUE (symbolP
),
1828 ignore_rest_of_line ();
1834 old_subsec
= now_subseg
;
1837 /* Convert to a power of 2 alignment. */
1838 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1841 as_bad (_("Common alignment not a power of 2"));
1842 ignore_rest_of_line ();
1849 record_alignment (bss_section
, align2
);
1850 subseg_set (bss_section
, 0);
1852 frag_align (align2
, 0, 0);
1853 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1854 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1855 symbol_set_frag (symbolP
, frag_now
);
1856 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1859 S_SET_SIZE (symbolP
, size
);
1860 S_SET_SEGMENT (symbolP
, bss_section
);
1861 subseg_set (old_sec
, old_subsec
);
1862 demand_empty_rest_of_line ();
1865 /* Validate any relocations emitted for -mrelocatable, possibly adding
1866 fixups for word relocations in writable segments, so we can adjust
1869 ppc_elf_validate_fix (fixp
, seg
)
1873 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1882 case SHLIB_MRELOCATABLE
:
1883 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1884 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1885 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1886 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1887 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1888 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1889 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1890 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1891 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1892 && (seg
->flags
& SEC_LOAD
) != 0
1893 && strcmp (segment_name (seg
), ".got2") != 0
1894 && strcmp (segment_name (seg
), ".dtors") != 0
1895 && strcmp (segment_name (seg
), ".ctors") != 0
1896 && strcmp (segment_name (seg
), ".fixup") != 0
1897 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1898 && strcmp (segment_name (seg
), ".eh_frame") != 0
1899 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1901 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1902 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1904 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1905 _("Relocation cannot be done when using -mrelocatable"));
1912 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1913 function descriptor sym if the corresponding code sym is used. */
1916 ppc_frob_file_before_adjust ()
1924 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1931 name
= S_GET_NAME (symp
);
1935 if (! S_IS_WEAK (symp
)
1936 || S_IS_DEFINED (symp
))
1939 len
= strlen (name
) + 1;
1940 dotname
= xmalloc (len
+ 1);
1942 memcpy (dotname
+ 1, name
, len
);
1943 dotsym
= symbol_find_noref (dotname
, 1);
1945 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1946 || symbol_used_in_reloc_p (dotsym
)))
1947 symbol_mark_used (symp
);
1951 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
1953 && bfd_section_size (stdoutput
, toc
) > 0x10000)
1954 as_warn (_("TOC section size exceeds 64k"));
1956 /* Don't emit .TOC. symbol. */
1957 symp
= symbol_find (".TOC.");
1959 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1961 #endif /* OBJ_ELF */
1966 * Summary of parse_toc_entry.
1968 * in: Input_line_pointer points to the '[' in one of:
1970 * [toc] [tocv] [toc32] [toc64]
1972 * Anything else is an error of one kind or another.
1975 * return value: success or failure
1976 * toc_kind: kind of toc reference
1977 * input_line_pointer:
1978 * success: first char after the ']'
1979 * failure: unchanged
1983 * [toc] - rv == success, toc_kind = default_toc
1984 * [tocv] - rv == success, toc_kind = data_in_toc
1985 * [toc32] - rv == success, toc_kind = must_be_32
1986 * [toc64] - rv == success, toc_kind = must_be_64
1990 enum toc_size_qualifier
1992 default_toc
, /* The toc cell constructed should be the system default size */
1993 data_in_toc
, /* This is a direct reference to a toc cell */
1994 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1995 must_be_64
/* The toc cell constructed must be 64 bits wide */
1999 parse_toc_entry (toc_kind
)
2000 enum toc_size_qualifier
*toc_kind
;
2005 enum toc_size_qualifier t
;
2007 /* Save the input_line_pointer. */
2008 start
= input_line_pointer
;
2010 /* Skip over the '[' , and whitespace. */
2011 ++input_line_pointer
;
2014 /* Find the spelling of the operand. */
2015 toc_spec
= input_line_pointer
;
2016 c
= get_symbol_end ();
2018 if (strcmp (toc_spec
, "toc") == 0)
2022 else if (strcmp (toc_spec
, "tocv") == 0)
2026 else if (strcmp (toc_spec
, "toc32") == 0)
2030 else if (strcmp (toc_spec
, "toc64") == 0)
2036 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2037 *input_line_pointer
= c
;
2038 input_line_pointer
= start
;
2042 /* Now find the ']'. */
2043 *input_line_pointer
= c
;
2045 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2046 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2050 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2051 input_line_pointer
= start
;
2062 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2064 ppc_apuinfo_section_add (apu
, version
)
2065 unsigned int apu
, version
;
2069 /* Check we don't already exist. */
2070 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2071 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2074 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2076 if (ppc_apuinfo_num_alloc
== 0)
2078 ppc_apuinfo_num_alloc
= 4;
2079 ppc_apuinfo_list
= (unsigned long *)
2080 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2084 ppc_apuinfo_num_alloc
+= 4;
2085 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2086 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2089 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2095 /* We need to keep a list of fixups. We can't simply generate them as
2096 we go, because that would require us to first create the frag, and
2097 that would screw up references to ``.''. */
2103 bfd_reloc_code_real_type reloc
;
2106 #define MAX_INSN_FIXUPS (5)
2108 /* This routine is called for each instruction to be assembled. */
2115 const struct powerpc_opcode
*opcode
;
2117 const unsigned char *opindex_ptr
;
2121 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2127 bfd_reloc_code_real_type reloc
;
2130 /* Get the opcode. */
2131 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2136 /* Look up the opcode in the hash table. */
2137 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2138 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2140 const struct powerpc_macro
*macro
;
2142 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2143 if (macro
== (const struct powerpc_macro
*) NULL
)
2144 as_bad (_("Unrecognized opcode: `%s'"), str
);
2146 ppc_macro (s
, macro
);
2151 insn
= opcode
->opcode
;
2154 while (ISSPACE (*str
))
2157 /* PowerPC operands are just expressions. The only real issue is
2158 that a few operand types are optional. All cases which might use
2159 an optional operand separate the operands only with commas (in some
2160 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2161 have optional operands). Most instructions with optional operands
2162 have only one. Those that have more than one optional operand can
2163 take either all their operands or none. So, before we start seriously
2164 parsing the operands, we check to see if we have optional operands,
2165 and if we do, we count the number of commas to see which operands
2166 have been omitted. */
2168 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2170 const struct powerpc_operand
*operand
;
2172 operand
= &powerpc_operands
[*opindex_ptr
];
2173 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2175 unsigned int opcount
;
2176 unsigned int num_operands_expected
;
2179 /* There is an optional operand. Count the number of
2180 commas in the input line. */
2187 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2194 /* Compute the number of expected operands.
2195 Do not count fake operands. */
2196 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2197 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2198 ++ num_operands_expected
;
2200 /* If there are fewer operands in the line then are called
2201 for by the instruction, we want to skip the optional
2203 if (opcount
< num_operands_expected
)
2210 /* Gather the operands. */
2214 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2216 const struct powerpc_operand
*operand
;
2222 if (next_opindex
== 0)
2223 operand
= &powerpc_operands
[*opindex_ptr
];
2226 operand
= &powerpc_operands
[next_opindex
];
2231 /* If this is a fake operand, then we do not expect anything
2233 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2235 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2236 if (errmsg
!= (const char *) NULL
)
2241 /* If this is an optional operand, and we are skipping it, just
2243 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2246 if (operand
->insert
)
2248 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2249 if (errmsg
!= (const char *) NULL
)
2252 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2253 next_opindex
= *opindex_ptr
+ 1;
2257 /* Gather the operand. */
2258 hold
= input_line_pointer
;
2259 input_line_pointer
= str
;
2262 if (*input_line_pointer
== '[')
2264 /* We are expecting something like the second argument here:
2266 * lwz r4,[toc].GS.0.static_int(rtoc)
2267 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2268 * The argument following the `]' must be a symbol name, and the
2269 * register must be the toc register: 'rtoc' or '2'
2271 * The effect is to 0 as the displacement field
2272 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2273 * the appropriate variation) reloc against it based on the symbol.
2274 * The linker will build the toc, and insert the resolved toc offset.
2277 * o The size of the toc entry is currently assumed to be
2278 * 32 bits. This should not be assumed to be a hard coded
2280 * o In an effort to cope with a change from 32 to 64 bits,
2281 * there are also toc entries that are specified to be
2282 * either 32 or 64 bits:
2283 * lwz r4,[toc32].GS.0.static_int(rtoc)
2284 * lwz r4,[toc64].GS.0.static_int(rtoc)
2285 * These demand toc entries of the specified size, and the
2286 * instruction probably requires it.
2290 enum toc_size_qualifier toc_kind
;
2291 bfd_reloc_code_real_type toc_reloc
;
2293 /* Go parse off the [tocXX] part. */
2294 valid_toc
= parse_toc_entry (&toc_kind
);
2298 /* Note: message has already been issued.
2299 FIXME: what sort of recovery should we do?
2300 demand_rest_of_line (); return; ? */
2303 /* Now get the symbol following the ']'. */
2309 /* In this case, we may not have seen the symbol yet,
2310 since it is allowed to appear on a .extern or .globl
2311 or just be a label in the .data section. */
2312 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2315 /* 1. The symbol must be defined and either in the toc
2316 section, or a global.
2317 2. The reloc generated must have the TOCDEFN flag set
2318 in upper bit mess of the reloc type.
2319 FIXME: It's a little confusing what the tocv
2320 qualifier can be used for. At the very least, I've
2321 seen three uses, only one of which I'm sure I can
2323 if (ex
.X_op
== O_symbol
)
2325 assert (ex
.X_add_symbol
!= NULL
);
2326 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2329 as_bad (_("[tocv] symbol is not a toc symbol"));
2333 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2336 /* FIXME: these next two specifically specify 32/64 bit
2337 toc entries. We don't support them today. Is this
2338 the right way to say that? */
2339 toc_reloc
= BFD_RELOC_UNUSED
;
2340 as_bad (_("Unimplemented toc32 expression modifier"));
2343 /* FIXME: see above. */
2344 toc_reloc
= BFD_RELOC_UNUSED
;
2345 as_bad (_("Unimplemented toc64 expression modifier"));
2349 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2355 /* We need to generate a fixup for this expression. */
2356 if (fc
>= MAX_INSN_FIXUPS
)
2357 as_fatal (_("too many fixups"));
2359 fixups
[fc
].reloc
= toc_reloc
;
2360 fixups
[fc
].exp
= ex
;
2361 fixups
[fc
].opindex
= *opindex_ptr
;
2364 /* Ok. We've set up the fixup for the instruction. Now make it
2365 look like the constant 0 was found here. */
2367 ex
.X_op
= O_constant
;
2368 ex
.X_add_number
= 0;
2369 ex
.X_add_symbol
= NULL
;
2370 ex
.X_op_symbol
= NULL
;
2376 if (! register_name (&ex
))
2378 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2385 str
= input_line_pointer
;
2386 input_line_pointer
= hold
;
2388 if (ex
.X_op
== O_illegal
)
2389 as_bad (_("illegal operand"));
2390 else if (ex
.X_op
== O_absent
)
2391 as_bad (_("missing operand"));
2392 else if (ex
.X_op
== O_register
)
2394 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2397 else if (ex
.X_op
== O_constant
)
2400 /* Allow @HA, @L, @H on constants. */
2401 char *orig_str
= str
;
2403 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2410 case BFD_RELOC_LO16
:
2411 /* X_unsigned is the default, so if the user has done
2412 something which cleared it, we always produce a
2414 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2415 ex
.X_add_number
&= 0xffff;
2417 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2420 case BFD_RELOC_HI16
:
2421 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2422 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2424 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2427 case BFD_RELOC_HI16_S
:
2428 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2429 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2431 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2434 case BFD_RELOC_PPC64_HIGHER
:
2435 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2436 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2438 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2441 case BFD_RELOC_PPC64_HIGHER_S
:
2442 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2443 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2445 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2448 case BFD_RELOC_PPC64_HIGHEST
:
2449 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2450 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2452 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2455 case BFD_RELOC_PPC64_HIGHEST_S
:
2456 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2457 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2459 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2462 #endif /* OBJ_ELF */
2463 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2467 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2469 /* Some TLS tweaks. */
2474 case BFD_RELOC_PPC_TLS
:
2475 insn
= ppc_insert_operand (insn
, operand
, ppc_obj64
? 13 : 2,
2478 /* We'll only use the 32 (or 64) bit form of these relocations
2479 in constants. Instructions get the 16 bit form. */
2480 case BFD_RELOC_PPC_DTPREL
:
2481 reloc
= BFD_RELOC_PPC_DTPREL16
;
2483 case BFD_RELOC_PPC_TPREL
:
2484 reloc
= BFD_RELOC_PPC_TPREL16
;
2488 /* For the absolute forms of branches, convert the PC
2489 relative form back into the absolute. */
2490 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2494 case BFD_RELOC_PPC_B26
:
2495 reloc
= BFD_RELOC_PPC_BA26
;
2497 case BFD_RELOC_PPC_B16
:
2498 reloc
= BFD_RELOC_PPC_BA16
;
2500 case BFD_RELOC_PPC_B16_BRTAKEN
:
2501 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2503 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2504 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2512 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
2517 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2519 case BFD_RELOC_LO16
:
2520 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2522 case BFD_RELOC_16_GOTOFF
:
2523 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2525 case BFD_RELOC_LO16_GOTOFF
:
2526 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2528 case BFD_RELOC_LO16_PLTOFF
:
2529 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2531 case BFD_RELOC_16_BASEREL
:
2532 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2534 case BFD_RELOC_LO16_BASEREL
:
2535 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2537 case BFD_RELOC_PPC_TOC16
:
2538 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2540 case BFD_RELOC_PPC64_TOC16_LO
:
2541 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2543 case BFD_RELOC_PPC64_PLTGOT16
:
2544 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2546 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2547 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2549 case BFD_RELOC_PPC_DTPREL16
:
2550 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2552 case BFD_RELOC_PPC_DTPREL16_LO
:
2553 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2555 case BFD_RELOC_PPC_TPREL16
:
2556 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2558 case BFD_RELOC_PPC_TPREL16_LO
:
2559 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2561 case BFD_RELOC_PPC_GOT_DTPREL16
:
2562 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2563 case BFD_RELOC_PPC_GOT_TPREL16
:
2564 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2567 as_bad (_("unsupported relocation for DS offset field"));
2572 /* We need to generate a fixup for this expression. */
2573 if (fc
>= MAX_INSN_FIXUPS
)
2574 as_fatal (_("too many fixups"));
2575 fixups
[fc
].exp
= ex
;
2576 fixups
[fc
].opindex
= 0;
2577 fixups
[fc
].reloc
= reloc
;
2580 #endif /* OBJ_ELF */
2584 /* We need to generate a fixup for this expression. */
2585 if (fc
>= MAX_INSN_FIXUPS
)
2586 as_fatal (_("too many fixups"));
2587 fixups
[fc
].exp
= ex
;
2588 fixups
[fc
].opindex
= *opindex_ptr
;
2589 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2598 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2606 /* The call to expression should have advanced str past any
2609 && (endc
!= ',' || *str
!= '\0'))
2611 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2619 while (ISSPACE (*str
))
2623 as_bad (_("junk at end of line: `%s'"), str
);
2626 /* Do we need/want a APUinfo section? */
2627 if (ppc_cpu
& (PPC_OPCODE_SPE
2628 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
2629 | PPC_OPCODE_BRLOCK
| PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
2630 | PPC_OPCODE_RFMCI
))
2632 /* These are all version "1". */
2633 if (opcode
->flags
& PPC_OPCODE_SPE
)
2634 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2635 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2636 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2637 if (opcode
->flags
& PPC_OPCODE_EFS
)
2638 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2639 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2640 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2641 if (opcode
->flags
& PPC_OPCODE_PMR
)
2642 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2643 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2644 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2645 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2646 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2650 /* Write out the instruction. */
2652 addr_mod
= frag_now_fix () & 3;
2653 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
2654 as_bad (_("instruction address is not a multiple of 4"));
2655 frag_now
->insn_addr
= addr_mod
;
2656 frag_now
->has_code
= 1;
2657 md_number_to_chars (f
, insn
, 4);
2660 dwarf2_emit_insn (4);
2663 /* Create any fixups. At this point we do not use a
2664 bfd_reloc_code_real_type, but instead just use the
2665 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2666 handle fixups for any operand type, although that is admittedly
2667 not a very exciting feature. We pick a BFD reloc type in
2669 for (i
= 0; i
< fc
; i
++)
2671 const struct powerpc_operand
*operand
;
2673 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2674 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2676 reloc_howto_type
*reloc_howto
;
2681 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2685 size
= bfd_get_reloc_size (reloc_howto
);
2686 offset
= target_big_endian
? (4 - size
) : 0;
2688 if (size
< 1 || size
> 4)
2691 fixP
= fix_new_exp (frag_now
,
2692 f
- frag_now
->fr_literal
+ offset
,
2695 reloc_howto
->pc_relative
,
2698 /* Turn off complaints that the addend is too large for things like
2700 switch (fixups
[i
].reloc
)
2702 case BFD_RELOC_16_GOTOFF
:
2703 case BFD_RELOC_PPC_TOC16
:
2704 case BFD_RELOC_LO16
:
2705 case BFD_RELOC_HI16
:
2706 case BFD_RELOC_HI16_S
:
2708 case BFD_RELOC_PPC64_HIGHER
:
2709 case BFD_RELOC_PPC64_HIGHER_S
:
2710 case BFD_RELOC_PPC64_HIGHEST
:
2711 case BFD_RELOC_PPC64_HIGHEST_S
:
2713 fixP
->fx_no_overflow
= 1;
2720 fix_new_exp (frag_now
,
2721 f
- frag_now
->fr_literal
,
2724 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2725 ((bfd_reloc_code_real_type
)
2726 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2730 /* Handle a macro. Gather all the operands, transform them as
2731 described by the macro, and call md_assemble recursively. All the
2732 operands are separated by commas; we don't accept parentheses
2733 around operands here. */
2736 ppc_macro (str
, macro
)
2738 const struct powerpc_macro
*macro
;
2749 /* Gather the users operands into the operands array. */
2754 if (count
>= sizeof operands
/ sizeof operands
[0])
2756 operands
[count
++] = s
;
2757 s
= strchr (s
, ',');
2758 if (s
== (char *) NULL
)
2763 if (count
!= macro
->operands
)
2765 as_bad (_("wrong number of operands"));
2769 /* Work out how large the string must be (the size is unbounded
2770 because it includes user input). */
2772 format
= macro
->format
;
2773 while (*format
!= '\0')
2782 arg
= strtol (format
+ 1, &send
, 10);
2783 know (send
!= format
&& arg
>= 0 && arg
< count
);
2784 len
+= strlen (operands
[arg
]);
2789 /* Put the string together. */
2790 complete
= s
= (char *) alloca (len
+ 1);
2791 format
= macro
->format
;
2792 while (*format
!= '\0')
2798 arg
= strtol (format
+ 1, &send
, 10);
2799 strcpy (s
, operands
[arg
]);
2806 /* Assemble the constructed instruction. */
2807 md_assemble (complete
);
2811 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2814 ppc_section_letter (letter
, ptr_msg
)
2821 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2826 ppc_section_word (str
, len
)
2830 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2837 ppc_section_type (str
, len
)
2841 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2848 ppc_section_flags (flags
, attr
, type
)
2853 if (type
== SHT_ORDERED
)
2854 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2856 if (attr
& SHF_EXCLUDE
)
2857 flags
|= SEC_EXCLUDE
;
2861 #endif /* OBJ_ELF */
2864 /* Pseudo-op handling. */
2866 /* The .byte pseudo-op. This is similar to the normal .byte
2867 pseudo-op, but it can also take a single ASCII string. */
2871 int ignore ATTRIBUTE_UNUSED
;
2873 if (*input_line_pointer
!= '\"')
2879 /* Gather characters. A real double quote is doubled. Unusual
2880 characters are not permitted. */
2881 ++input_line_pointer
;
2886 c
= *input_line_pointer
++;
2890 if (*input_line_pointer
!= '\"')
2892 ++input_line_pointer
;
2895 FRAG_APPEND_1_CHAR (c
);
2898 demand_empty_rest_of_line ();
2903 /* XCOFF specific pseudo-op handling. */
2905 /* This is set if we are creating a .stabx symbol, since we don't want
2906 to handle symbol suffixes for such symbols. */
2907 static bfd_boolean ppc_stab_symbol
;
2909 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2910 symbols in the .bss segment as though they were local common
2911 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
2912 aligns .comm and .lcomm to 4 bytes. */
2918 asection
*current_seg
= now_seg
;
2919 subsegT current_subseg
= now_subseg
;
2925 symbolS
*lcomm_sym
= NULL
;
2929 name
= input_line_pointer
;
2930 endc
= get_symbol_end ();
2931 end_name
= input_line_pointer
;
2934 if (*input_line_pointer
!= ',')
2936 as_bad (_("missing size"));
2937 ignore_rest_of_line ();
2940 ++input_line_pointer
;
2942 size
= get_absolute_expression ();
2945 as_bad (_("negative size"));
2946 ignore_rest_of_line ();
2952 /* The third argument to .comm is the alignment. */
2953 if (*input_line_pointer
!= ',')
2957 ++input_line_pointer
;
2958 align
= get_absolute_expression ();
2961 as_warn (_("ignoring bad alignment"));
2976 /* The third argument to .lcomm appears to be the real local
2977 common symbol to create. References to the symbol named in
2978 the first argument are turned into references to the third
2980 if (*input_line_pointer
!= ',')
2982 as_bad (_("missing real symbol name"));
2983 ignore_rest_of_line ();
2986 ++input_line_pointer
;
2988 lcomm_name
= input_line_pointer
;
2989 lcomm_endc
= get_symbol_end ();
2991 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2993 *input_line_pointer
= lcomm_endc
;
2997 sym
= symbol_find_or_make (name
);
3000 if (S_IS_DEFINED (sym
)
3001 || S_GET_VALUE (sym
) != 0)
3003 as_bad (_("attempt to redefine symbol"));
3004 ignore_rest_of_line ();
3008 record_alignment (bss_section
, align
);
3011 || ! S_IS_DEFINED (lcomm_sym
))
3020 S_SET_EXTERNAL (sym
);
3024 symbol_get_tc (lcomm_sym
)->output
= 1;
3025 def_sym
= lcomm_sym
;
3029 subseg_set (bss_section
, 1);
3030 frag_align (align
, 0, 0);
3032 symbol_set_frag (def_sym
, frag_now
);
3033 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3034 def_size
, (char *) NULL
);
3036 S_SET_SEGMENT (def_sym
, bss_section
);
3037 symbol_get_tc (def_sym
)->align
= align
;
3041 /* Align the size of lcomm_sym. */
3042 symbol_get_frag (lcomm_sym
)->fr_offset
=
3043 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3044 &~ ((1 << align
) - 1));
3045 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3046 symbol_get_tc (lcomm_sym
)->align
= align
;
3051 /* Make sym an offset from lcomm_sym. */
3052 S_SET_SEGMENT (sym
, bss_section
);
3053 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3054 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3055 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3058 subseg_set (current_seg
, current_subseg
);
3060 demand_empty_rest_of_line ();
3063 /* The .csect pseudo-op. This switches us into a different
3064 subsegment. The first argument is a symbol whose value is the
3065 start of the .csect. In COFF, csect symbols get special aux
3066 entries defined by the x_csect field of union internal_auxent. The
3067 optional second argument is the alignment (the default is 2). */
3071 int ignore ATTRIBUTE_UNUSED
;
3078 name
= input_line_pointer
;
3079 endc
= get_symbol_end ();
3081 sym
= symbol_find_or_make (name
);
3083 *input_line_pointer
= endc
;
3085 if (S_GET_NAME (sym
)[0] == '\0')
3087 /* An unnamed csect is assumed to be [PR]. */
3088 symbol_get_tc (sym
)->class = XMC_PR
;
3092 if (*input_line_pointer
== ',')
3094 ++input_line_pointer
;
3095 align
= get_absolute_expression ();
3098 ppc_change_csect (sym
, align
);
3100 demand_empty_rest_of_line ();
3103 /* Change to a different csect. */
3106 ppc_change_csect (sym
, align
)
3110 if (S_IS_DEFINED (sym
))
3111 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3121 /* This is a new csect. We need to look at the symbol class to
3122 figure out whether it should go in the text section or the
3126 switch (symbol_get_tc (sym
)->class)
3136 S_SET_SEGMENT (sym
, text_section
);
3137 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3138 ++ppc_text_subsegment
;
3139 list_ptr
= &ppc_text_csects
;
3149 if (ppc_toc_csect
!= NULL
3150 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3151 == ppc_data_subsegment
))
3153 S_SET_SEGMENT (sym
, data_section
);
3154 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3155 ++ppc_data_subsegment
;
3156 list_ptr
= &ppc_data_csects
;
3162 /* We set the obstack chunk size to a small value before
3163 changing subsegments, so that we don't use a lot of memory
3164 space for what may be a small section. */
3165 hold_chunksize
= chunksize
;
3168 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3169 symbol_get_tc (sym
)->subseg
);
3171 chunksize
= hold_chunksize
;
3174 ppc_after_toc_frag
= frag_now
;
3176 record_alignment (sec
, align
);
3178 frag_align_code (align
, 0);
3180 frag_align (align
, 0, 0);
3182 symbol_set_frag (sym
, frag_now
);
3183 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3185 symbol_get_tc (sym
)->align
= align
;
3186 symbol_get_tc (sym
)->output
= 1;
3187 symbol_get_tc (sym
)->within
= sym
;
3189 for (list
= *list_ptr
;
3190 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3191 list
= symbol_get_tc (list
)->next
)
3193 symbol_get_tc (list
)->next
= sym
;
3195 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3196 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3200 ppc_current_csect
= sym
;
3203 /* This function handles the .text and .data pseudo-ops. These
3204 pseudo-ops aren't really used by XCOFF; we implement them for the
3205 convenience of people who aren't used to XCOFF. */
3216 else if (type
== 'd')
3221 sym
= symbol_find_or_make (name
);
3223 ppc_change_csect (sym
, 2);
3225 demand_empty_rest_of_line ();
3228 /* This function handles the .section pseudo-op. This is mostly to
3229 give an error, since XCOFF only supports .text, .data and .bss, but
3230 we do permit the user to name the text or data section. */
3233 ppc_named_section (ignore
)
3234 int ignore ATTRIBUTE_UNUSED
;
3237 const char *real_name
;
3241 user_name
= input_line_pointer
;
3242 c
= get_symbol_end ();
3244 if (strcmp (user_name
, ".text") == 0)
3245 real_name
= ".text[PR]";
3246 else if (strcmp (user_name
, ".data") == 0)
3247 real_name
= ".data[RW]";
3250 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3251 *input_line_pointer
= c
;
3252 ignore_rest_of_line ();
3256 *input_line_pointer
= c
;
3258 sym
= symbol_find_or_make (real_name
);
3260 ppc_change_csect (sym
, 2);
3262 demand_empty_rest_of_line ();
3265 /* The .extern pseudo-op. We create an undefined symbol. */
3269 int ignore ATTRIBUTE_UNUSED
;
3274 name
= input_line_pointer
;
3275 endc
= get_symbol_end ();
3277 (void) symbol_find_or_make (name
);
3279 *input_line_pointer
= endc
;
3281 demand_empty_rest_of_line ();
3284 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3288 int ignore ATTRIBUTE_UNUSED
;
3294 name
= input_line_pointer
;
3295 endc
= get_symbol_end ();
3297 sym
= symbol_find_or_make (name
);
3299 *input_line_pointer
= endc
;
3301 symbol_get_tc (sym
)->output
= 1;
3303 demand_empty_rest_of_line ();
3306 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3307 although I don't know why it bothers. */
3311 int ignore ATTRIBUTE_UNUSED
;
3318 name
= input_line_pointer
;
3319 endc
= get_symbol_end ();
3321 sym
= symbol_find_or_make (name
);
3323 *input_line_pointer
= endc
;
3325 if (*input_line_pointer
!= ',')
3327 as_bad (_("missing rename string"));
3328 ignore_rest_of_line ();
3331 ++input_line_pointer
;
3333 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3335 demand_empty_rest_of_line ();
3338 /* The .stabx pseudo-op. This is similar to a normal .stabs
3339 pseudo-op, but slightly different. A sample is
3340 .stabx "main:F-1",.main,142,0
3341 The first argument is the symbol name to create. The second is the
3342 value, and the third is the storage class. The fourth seems to be
3343 always zero, and I am assuming it is the type. */
3347 int ignore ATTRIBUTE_UNUSED
;
3354 name
= demand_copy_C_string (&len
);
3356 if (*input_line_pointer
!= ',')
3358 as_bad (_("missing value"));
3361 ++input_line_pointer
;
3363 ppc_stab_symbol
= TRUE
;
3364 sym
= symbol_make (name
);
3365 ppc_stab_symbol
= FALSE
;
3367 symbol_get_tc (sym
)->real_name
= name
;
3369 (void) expression (&exp
);
3376 as_bad (_("illegal .stabx expression; zero assumed"));
3377 exp
.X_add_number
= 0;
3380 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3381 symbol_set_frag (sym
, &zero_address_frag
);
3385 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3386 symbol_set_value_expression (sym
, &exp
);
3390 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3391 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3396 /* The value is some complex expression. This will probably
3397 fail at some later point, but this is probably the right
3398 thing to do here. */
3399 symbol_set_value_expression (sym
, &exp
);
3403 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3404 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3406 if (*input_line_pointer
!= ',')
3408 as_bad (_("missing class"));
3411 ++input_line_pointer
;
3413 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3415 if (*input_line_pointer
!= ',')
3417 as_bad (_("missing type"));
3420 ++input_line_pointer
;
3422 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3424 symbol_get_tc (sym
)->output
= 1;
3426 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3428 symbol_get_tc (sym
)->within
= ppc_current_block
;
3433 .stabx "z",arrays_,133,0
3436 .comm arrays_,13768,3
3438 resolve_symbol_value will copy the exp's "within" into sym's when the
3439 offset is 0. Since this seems to be corner case problem,
3440 only do the correction for storage class C_STSYM. A better solution
3441 would be to have the tc field updated in ppc_symbol_new_hook. */
3443 if (exp
.X_op
== O_symbol
)
3445 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3449 if (exp
.X_op
!= O_symbol
3450 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3451 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3452 ppc_frob_label (sym
);
3455 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3456 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3457 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3458 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3461 demand_empty_rest_of_line ();
3464 /* The .function pseudo-op. This takes several arguments. The first
3465 argument seems to be the external name of the symbol. The second
3466 argument seems to be the label for the start of the function. gcc
3467 uses the same name for both. I have no idea what the third and
3468 fourth arguments are meant to be. The optional fifth argument is
3469 an expression for the size of the function. In COFF this symbol
3470 gets an aux entry like that used for a csect. */
3473 ppc_function (ignore
)
3474 int ignore ATTRIBUTE_UNUSED
;
3482 name
= input_line_pointer
;
3483 endc
= get_symbol_end ();
3485 /* Ignore any [PR] suffix. */
3486 name
= ppc_canonicalize_symbol_name (name
);
3487 s
= strchr (name
, '[');
3488 if (s
!= (char *) NULL
3489 && strcmp (s
+ 1, "PR]") == 0)
3492 ext_sym
= symbol_find_or_make (name
);
3494 *input_line_pointer
= endc
;
3496 if (*input_line_pointer
!= ',')
3498 as_bad (_("missing symbol name"));
3499 ignore_rest_of_line ();
3502 ++input_line_pointer
;
3504 name
= input_line_pointer
;
3505 endc
= get_symbol_end ();
3507 lab_sym
= symbol_find_or_make (name
);
3509 *input_line_pointer
= endc
;
3511 if (ext_sym
!= lab_sym
)
3515 exp
.X_op
= O_symbol
;
3516 exp
.X_add_symbol
= lab_sym
;
3517 exp
.X_op_symbol
= NULL
;
3518 exp
.X_add_number
= 0;
3520 symbol_set_value_expression (ext_sym
, &exp
);
3523 if (symbol_get_tc (ext_sym
)->class == -1)
3524 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3525 symbol_get_tc (ext_sym
)->output
= 1;
3527 if (*input_line_pointer
== ',')
3531 /* Ignore the third argument. */
3532 ++input_line_pointer
;
3533 expression (&ignore
);
3534 if (*input_line_pointer
== ',')
3536 /* Ignore the fourth argument. */
3537 ++input_line_pointer
;
3538 expression (&ignore
);
3539 if (*input_line_pointer
== ',')
3541 /* The fifth argument is the function size. */
3542 ++input_line_pointer
;
3543 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3546 &zero_address_frag
);
3547 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3552 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3553 SF_SET_FUNCTION (ext_sym
);
3554 SF_SET_PROCESS (ext_sym
);
3555 coff_add_linesym (ext_sym
);
3557 demand_empty_rest_of_line ();
3560 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3561 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3562 with the correct line number */
3564 static symbolS
*saved_bi_sym
= 0;
3568 int ignore ATTRIBUTE_UNUSED
;
3572 sym
= symbol_make (".bf");
3573 S_SET_SEGMENT (sym
, text_section
);
3574 symbol_set_frag (sym
, frag_now
);
3575 S_SET_VALUE (sym
, frag_now_fix ());
3576 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3578 coff_line_base
= get_absolute_expression ();
3580 S_SET_NUMBER_AUXILIARY (sym
, 1);
3581 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3583 /* Line number for bi. */
3586 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3591 symbol_get_tc (sym
)->output
= 1;
3593 ppc_frob_label (sym
);
3595 demand_empty_rest_of_line ();
3598 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3599 ".ef", except that the line number is absolute, not relative to the
3600 most recent ".bf" symbol. */
3604 int ignore ATTRIBUTE_UNUSED
;
3608 sym
= symbol_make (".ef");
3609 S_SET_SEGMENT (sym
, text_section
);
3610 symbol_set_frag (sym
, frag_now
);
3611 S_SET_VALUE (sym
, frag_now_fix ());
3612 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3613 S_SET_NUMBER_AUXILIARY (sym
, 1);
3614 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3615 symbol_get_tc (sym
)->output
= 1;
3617 ppc_frob_label (sym
);
3619 demand_empty_rest_of_line ();
3622 /* The .bi and .ei pseudo-ops. These take a string argument and
3623 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3624 the symbol list. The value of .bi will be know when the next .bf
3631 static symbolS
*last_biei
;
3638 name
= demand_copy_C_string (&len
);
3640 /* The value of these symbols is actually file offset. Here we set
3641 the value to the index into the line number entries. In
3642 ppc_frob_symbols we set the fix_line field, which will cause BFD
3643 to do the right thing. */
3645 sym
= symbol_make (name
);
3646 /* obj-coff.c currently only handles line numbers correctly in the
3648 S_SET_SEGMENT (sym
, text_section
);
3649 S_SET_VALUE (sym
, coff_n_line_nos
);
3650 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3652 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3653 symbol_get_tc (sym
)->output
= 1;
3661 for (look
= last_biei
? last_biei
: symbol_rootP
;
3662 (look
!= (symbolS
*) NULL
3663 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3664 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3665 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3666 look
= symbol_next (look
))
3668 if (look
!= (symbolS
*) NULL
)
3670 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3671 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3675 demand_empty_rest_of_line ();
3678 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3679 There is one argument, which is a csect symbol. The value of the
3680 .bs symbol is the index of this csect symbol. */
3684 int ignore ATTRIBUTE_UNUSED
;
3691 if (ppc_current_block
!= NULL
)
3692 as_bad (_("nested .bs blocks"));
3694 name
= input_line_pointer
;
3695 endc
= get_symbol_end ();
3697 csect
= symbol_find_or_make (name
);
3699 *input_line_pointer
= endc
;
3701 sym
= symbol_make (".bs");
3702 S_SET_SEGMENT (sym
, now_seg
);
3703 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3704 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3705 symbol_get_tc (sym
)->output
= 1;
3707 symbol_get_tc (sym
)->within
= csect
;
3709 ppc_frob_label (sym
);
3711 ppc_current_block
= sym
;
3713 demand_empty_rest_of_line ();
3716 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3720 int ignore ATTRIBUTE_UNUSED
;
3724 if (ppc_current_block
== NULL
)
3725 as_bad (_(".es without preceding .bs"));
3727 sym
= symbol_make (".es");
3728 S_SET_SEGMENT (sym
, now_seg
);
3729 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3730 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3731 symbol_get_tc (sym
)->output
= 1;
3733 ppc_frob_label (sym
);
3735 ppc_current_block
= NULL
;
3737 demand_empty_rest_of_line ();
3740 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3745 int ignore ATTRIBUTE_UNUSED
;
3749 sym
= symbol_make (".bb");
3750 S_SET_SEGMENT (sym
, text_section
);
3751 symbol_set_frag (sym
, frag_now
);
3752 S_SET_VALUE (sym
, frag_now_fix ());
3753 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3755 S_SET_NUMBER_AUXILIARY (sym
, 1);
3756 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3758 symbol_get_tc (sym
)->output
= 1;
3760 SF_SET_PROCESS (sym
);
3762 ppc_frob_label (sym
);
3764 demand_empty_rest_of_line ();
3767 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3772 int ignore ATTRIBUTE_UNUSED
;
3776 sym
= symbol_make (".eb");
3777 S_SET_SEGMENT (sym
, text_section
);
3778 symbol_set_frag (sym
, frag_now
);
3779 S_SET_VALUE (sym
, frag_now_fix ());
3780 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3781 S_SET_NUMBER_AUXILIARY (sym
, 1);
3782 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3783 symbol_get_tc (sym
)->output
= 1;
3785 SF_SET_PROCESS (sym
);
3787 ppc_frob_label (sym
);
3789 demand_empty_rest_of_line ();
3792 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3797 int ignore ATTRIBUTE_UNUSED
;
3803 name
= demand_copy_C_string (&len
);
3804 sym
= symbol_make (name
);
3805 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3806 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3807 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3808 S_SET_VALUE (sym
, 0);
3809 symbol_get_tc (sym
)->output
= 1;
3811 ppc_frob_label (sym
);
3813 demand_empty_rest_of_line ();
3816 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3820 int ignore ATTRIBUTE_UNUSED
;
3824 sym
= symbol_make (".ec");
3825 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3826 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3827 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3828 S_SET_VALUE (sym
, 0);
3829 symbol_get_tc (sym
)->output
= 1;
3831 ppc_frob_label (sym
);
3833 demand_empty_rest_of_line ();
3836 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3840 int ignore ATTRIBUTE_UNUSED
;
3842 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3843 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3850 subseg
= ppc_data_subsegment
;
3851 ++ppc_data_subsegment
;
3853 subseg_new (segment_name (data_section
), subseg
);
3854 ppc_toc_frag
= frag_now
;
3856 sym
= symbol_find_or_make ("TOC[TC0]");
3857 symbol_set_frag (sym
, frag_now
);
3858 S_SET_SEGMENT (sym
, data_section
);
3859 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3860 symbol_get_tc (sym
)->subseg
= subseg
;
3861 symbol_get_tc (sym
)->output
= 1;
3862 symbol_get_tc (sym
)->within
= sym
;
3864 ppc_toc_csect
= sym
;
3866 for (list
= ppc_data_csects
;
3867 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3868 list
= symbol_get_tc (list
)->next
)
3870 symbol_get_tc (list
)->next
= sym
;
3872 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3873 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3877 ppc_current_csect
= ppc_toc_csect
;
3879 demand_empty_rest_of_line ();
3882 /* The AIX assembler automatically aligns the operands of a .long or
3883 .short pseudo-op, and we want to be compatible. */
3886 ppc_xcoff_cons (log_size
)
3889 frag_align (log_size
, 0, 0);
3890 record_alignment (now_seg
, log_size
);
3891 cons (1 << log_size
);
3896 int dummy ATTRIBUTE_UNUSED
;
3901 (void) expression (&exp
);
3903 if (exp
.X_op
!= O_constant
)
3905 as_bad (_("non-constant byte count"));
3909 byte_count
= exp
.X_add_number
;
3911 if (*input_line_pointer
!= ',')
3913 as_bad (_("missing value"));
3917 ++input_line_pointer
;
3921 #endif /* OBJ_XCOFF */
3922 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3924 /* The .tc pseudo-op. This is used when generating either XCOFF or
3925 ELF. This takes two or more arguments.
3927 When generating XCOFF output, the first argument is the name to
3928 give to this location in the toc; this will be a symbol with class
3929 TC. The rest of the arguments are N-byte values to actually put at
3930 this location in the TOC; often there is just one more argument, a
3931 relocatable symbol reference. The size of the value to store
3932 depends on target word size. A 32-bit target uses 4-byte values, a
3933 64-bit target uses 8-byte values.
3935 When not generating XCOFF output, the arguments are the same, but
3936 the first argument is simply ignored. */
3940 int ignore ATTRIBUTE_UNUSED
;
3944 /* Define the TOC symbol name. */
3950 if (ppc_toc_csect
== (symbolS
*) NULL
3951 || ppc_toc_csect
!= ppc_current_csect
)
3953 as_bad (_(".tc not in .toc section"));
3954 ignore_rest_of_line ();
3958 name
= input_line_pointer
;
3959 endc
= get_symbol_end ();
3961 sym
= symbol_find_or_make (name
);
3963 *input_line_pointer
= endc
;
3965 if (S_IS_DEFINED (sym
))
3969 label
= symbol_get_tc (ppc_current_csect
)->within
;
3970 if (symbol_get_tc (label
)->class != XMC_TC0
)
3972 as_bad (_(".tc with no label"));
3973 ignore_rest_of_line ();
3977 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3978 symbol_set_frag (label
, symbol_get_frag (sym
));
3979 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3981 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3982 ++input_line_pointer
;
3987 S_SET_SEGMENT (sym
, now_seg
);
3988 symbol_set_frag (sym
, frag_now
);
3989 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3990 symbol_get_tc (sym
)->class = XMC_TC
;
3991 symbol_get_tc (sym
)->output
= 1;
3993 ppc_frob_label (sym
);
3996 #endif /* OBJ_XCOFF */
4000 /* Skip the TOC symbol name. */
4001 while (is_part_of_name (*input_line_pointer
)
4002 || *input_line_pointer
== '['
4003 || *input_line_pointer
== ']'
4004 || *input_line_pointer
== '{'
4005 || *input_line_pointer
== '}')
4006 ++input_line_pointer
;
4008 /* Align to a four/eight byte boundary. */
4009 align
= ppc_obj64
? 3 : 2;
4010 frag_align (align
, 0, 0);
4011 record_alignment (now_seg
, align
);
4012 #endif /* OBJ_ELF */
4014 if (*input_line_pointer
!= ',')
4015 demand_empty_rest_of_line ();
4018 ++input_line_pointer
;
4019 cons (ppc_obj64
? 8 : 4);
4023 /* Pseudo-op .machine. */
4026 ppc_machine (ignore
)
4027 int ignore ATTRIBUTE_UNUSED
;
4030 #define MAX_HISTORY 100
4031 static unsigned long *cpu_history
;
4032 static int curr_hist
;
4036 if (*input_line_pointer
== '"')
4039 cpu_string
= demand_copy_C_string (&len
);
4044 cpu_string
= input_line_pointer
;
4045 c
= get_symbol_end ();
4046 cpu_string
= xstrdup (cpu_string
);
4047 *input_line_pointer
= c
;
4050 if (cpu_string
!= NULL
)
4052 unsigned long old_cpu
= ppc_cpu
;
4055 for (p
= cpu_string
; *p
!= 0; p
++)
4058 if (strcmp (cpu_string
, "push") == 0)
4060 if (cpu_history
== NULL
)
4061 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4063 if (curr_hist
>= MAX_HISTORY
)
4064 as_bad (_(".machine stack overflow"));
4066 cpu_history
[curr_hist
++] = ppc_cpu
;
4068 else if (strcmp (cpu_string
, "pop") == 0)
4071 as_bad (_(".machine stack underflow"));
4073 ppc_cpu
= cpu_history
[--curr_hist
];
4075 else if (parse_cpu (cpu_string
))
4078 as_bad (_("invalid machine `%s'"), cpu_string
);
4080 if (ppc_cpu
!= old_cpu
)
4081 ppc_setup_opcodes ();
4084 demand_empty_rest_of_line ();
4087 /* See whether a symbol is in the TOC section. */
4090 ppc_is_toc_sym (sym
)
4094 return symbol_get_tc (sym
)->class == XMC_TC
;
4097 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4099 return strcmp (sname
, ".toc") == 0;
4101 return strcmp (sname
, ".got") == 0;
4104 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4108 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4110 /* Set the current section. */
4112 ppc_set_current_section (new)
4115 ppc_previous_section
= ppc_current_section
;
4116 ppc_current_section
= new;
4119 /* pseudo-op: .previous
4120 behaviour: toggles the current section with the previous section.
4122 warnings: "No previous section" */
4125 ppc_previous (ignore
)
4126 int ignore ATTRIBUTE_UNUSED
;
4130 if (ppc_previous_section
== NULL
)
4132 as_warn (_("No previous section to return to. Directive ignored."));
4136 subseg_set (ppc_previous_section
, 0);
4138 ppc_set_current_section (ppc_previous_section
);
4141 /* pseudo-op: .pdata
4142 behaviour: predefined read only data section
4146 initial: .section .pdata "adr3"
4147 a - don't know -- maybe a misprint
4148 d - initialized data
4150 3 - double word aligned (that would be 4 byte boundary)
4153 Tag index tables (also known as the function table) for exception
4154 handling, debugging, etc. */
4158 int ignore ATTRIBUTE_UNUSED
;
4160 if (pdata_section
== 0)
4162 pdata_section
= subseg_new (".pdata", 0);
4164 bfd_set_section_flags (stdoutput
, pdata_section
,
4165 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4166 | SEC_READONLY
| SEC_DATA
));
4168 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4172 pdata_section
= subseg_new (".pdata", 0);
4174 ppc_set_current_section (pdata_section
);
4177 /* pseudo-op: .ydata
4178 behaviour: predefined read only data section
4182 initial: .section .ydata "drw3"
4183 a - don't know -- maybe a misprint
4184 d - initialized data
4186 3 - double word aligned (that would be 4 byte boundary)
4188 Tag tables (also known as the scope table) for exception handling,
4193 int ignore ATTRIBUTE_UNUSED
;
4195 if (ydata_section
== 0)
4197 ydata_section
= subseg_new (".ydata", 0);
4198 bfd_set_section_flags (stdoutput
, ydata_section
,
4199 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4200 | SEC_READONLY
| SEC_DATA
));
4202 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4206 ydata_section
= subseg_new (".ydata", 0);
4208 ppc_set_current_section (ydata_section
);
4211 /* pseudo-op: .reldata
4212 behaviour: predefined read write data section
4213 double word aligned (4-byte)
4214 FIXME: relocation is applied to it
4215 FIXME: what's the difference between this and .data?
4218 initial: .section .reldata "drw3"
4219 d - initialized data
4222 3 - double word aligned (that would be 8 byte boundary)
4225 Like .data, but intended to hold data subject to relocation, such as
4226 function descriptors, etc. */
4229 ppc_reldata (ignore
)
4230 int ignore ATTRIBUTE_UNUSED
;
4232 if (reldata_section
== 0)
4234 reldata_section
= subseg_new (".reldata", 0);
4236 bfd_set_section_flags (stdoutput
, reldata_section
,
4237 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4240 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4244 reldata_section
= subseg_new (".reldata", 0);
4246 ppc_set_current_section (reldata_section
);
4249 /* pseudo-op: .rdata
4250 behaviour: predefined read only data section
4254 initial: .section .rdata "dr3"
4255 d - initialized data
4257 3 - double word aligned (that would be 4 byte boundary) */
4261 int ignore ATTRIBUTE_UNUSED
;
4263 if (rdata_section
== 0)
4265 rdata_section
= subseg_new (".rdata", 0);
4266 bfd_set_section_flags (stdoutput
, rdata_section
,
4267 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4268 | SEC_READONLY
| SEC_DATA
));
4270 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4274 rdata_section
= subseg_new (".rdata", 0);
4276 ppc_set_current_section (rdata_section
);
4279 /* pseudo-op: .ualong
4280 behaviour: much like .int, with the exception that no alignment is
4282 FIXME: test the alignment statement
4288 int ignore ATTRIBUTE_UNUSED
;
4294 /* pseudo-op: .znop <symbol name>
4295 behaviour: Issue a nop instruction
4296 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4297 the supplied symbol name.
4299 warnings: Missing symbol name */
4303 int ignore ATTRIBUTE_UNUSED
;
4306 const struct powerpc_opcode
*opcode
;
4317 /* Strip out the symbol name. */
4318 symbol_name
= input_line_pointer
;
4319 c
= get_symbol_end ();
4321 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4322 strcpy (name
, symbol_name
);
4324 sym
= symbol_find_or_make (name
);
4326 *input_line_pointer
= c
;
4330 /* Look up the opcode in the hash table. */
4331 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4333 /* Stick in the nop. */
4334 insn
= opcode
->opcode
;
4336 /* Write out the instruction. */
4338 md_number_to_chars (f
, insn
, 4);
4340 f
- frag_now
->fr_literal
,
4345 BFD_RELOC_16_GOT_PCREL
);
4358 register char *name
;
4362 register symbolS
*symbolP
;
4365 name
= input_line_pointer
;
4366 c
= get_symbol_end ();
4368 /* just after name is now '\0'. */
4369 p
= input_line_pointer
;
4372 if (*input_line_pointer
!= ',')
4374 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4375 ignore_rest_of_line ();
4379 input_line_pointer
++; /* skip ',' */
4380 if ((temp
= get_absolute_expression ()) < 0)
4382 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4383 ignore_rest_of_line ();
4389 /* The third argument to .comm is the alignment. */
4390 if (*input_line_pointer
!= ',')
4394 ++input_line_pointer
;
4395 align
= get_absolute_expression ();
4398 as_warn (_("ignoring bad alignment"));
4405 symbolP
= symbol_find_or_make (name
);
4408 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4410 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4411 S_GET_NAME (symbolP
));
4412 ignore_rest_of_line ();
4416 if (S_GET_VALUE (symbolP
))
4418 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4419 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4420 S_GET_NAME (symbolP
),
4421 (long) S_GET_VALUE (symbolP
),
4426 S_SET_VALUE (symbolP
, (valueT
) temp
);
4427 S_SET_EXTERNAL (symbolP
);
4428 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
4431 demand_empty_rest_of_line ();
4435 * implement the .section pseudo op:
4436 * .section name {, "flags"}
4438 * | +--- optional flags: 'b' for bss
4440 * +-- section name 'l' for lib
4444 * 'd' (apparently m88k for data)
4446 * But if the argument is not a quoted string, treat it as a
4447 * subsegment number.
4449 * FIXME: this is a copy of the section processing from obj-coff.c, with
4450 * additions/changes for the moto-pas assembler support. There are three
4453 * FIXME: I just noticed this. This doesn't work at all really. It it
4454 * setting bits that bfd probably neither understands or uses. The
4455 * correct approach (?) will have to incorporate extra fields attached
4456 * to the section to hold the system specific stuff. (krk)
4459 * 'a' - unknown - referred to in documentation, but no definition supplied
4460 * 'c' - section has code
4461 * 'd' - section has initialized data
4462 * 'u' - section has uninitialized data
4463 * 'i' - section contains directives (info)
4464 * 'n' - section can be discarded
4465 * 'R' - remove section at link time
4467 * Section Protection:
4468 * 'r' - section is readable
4469 * 'w' - section is writeable
4470 * 'x' - section is executable
4471 * 's' - section is sharable
4473 * Section Alignment:
4474 * '0' - align to byte boundary
4475 * '1' - align to halfword undary
4476 * '2' - align to word boundary
4477 * '3' - align to doubleword boundary
4478 * '4' - align to quadword boundary
4479 * '5' - align to 32 byte boundary
4480 * '6' - align to 64 byte boundary
4485 ppc_pe_section (ignore
)
4486 int ignore ATTRIBUTE_UNUSED
;
4488 /* Strip out the section name. */
4497 section_name
= input_line_pointer
;
4498 c
= get_symbol_end ();
4500 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4501 strcpy (name
, section_name
);
4503 *input_line_pointer
= c
;
4508 flags
= SEC_NO_FLAGS
;
4510 if (strcmp (name
, ".idata$2") == 0)
4514 else if (strcmp (name
, ".idata$3") == 0)
4518 else if (strcmp (name
, ".idata$4") == 0)
4522 else if (strcmp (name
, ".idata$5") == 0)
4526 else if (strcmp (name
, ".idata$6") == 0)
4531 /* Default alignment to 16 byte boundary. */
4534 if (*input_line_pointer
== ',')
4536 ++input_line_pointer
;
4538 if (*input_line_pointer
!= '"')
4539 exp
= get_absolute_expression ();
4542 ++input_line_pointer
;
4543 while (*input_line_pointer
!= '"'
4544 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4546 switch (*input_line_pointer
)
4548 /* Section Contents */
4549 case 'a': /* unknown */
4550 as_bad (_("Unsupported section attribute -- 'a'"));
4552 case 'c': /* code section */
4555 case 'd': /* section has initialized data */
4558 case 'u': /* section has uninitialized data */
4559 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4563 case 'i': /* section contains directives (info) */
4564 /* FIXME: This is IMAGE_SCN_LNK_INFO
4566 flags
|= SEC_HAS_CONTENTS
;
4568 case 'n': /* section can be discarded */
4571 case 'R': /* Remove section at link time */
4572 flags
|= SEC_NEVER_LOAD
;
4575 /* Section Protection */
4576 case 'r': /* section is readable */
4577 flags
|= IMAGE_SCN_MEM_READ
;
4579 case 'w': /* section is writeable */
4580 flags
|= IMAGE_SCN_MEM_WRITE
;
4582 case 'x': /* section is executable */
4583 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4585 case 's': /* section is sharable */
4586 flags
|= IMAGE_SCN_MEM_SHARED
;
4589 /* Section Alignment */
4590 case '0': /* align to byte boundary */
4591 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4594 case '1': /* align to halfword boundary */
4595 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4598 case '2': /* align to word boundary */
4599 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4602 case '3': /* align to doubleword boundary */
4603 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4606 case '4': /* align to quadword boundary */
4607 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4610 case '5': /* align to 32 byte boundary */
4611 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4614 case '6': /* align to 64 byte boundary */
4615 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4620 as_bad (_("unknown section attribute '%c'"),
4621 *input_line_pointer
);
4624 ++input_line_pointer
;
4626 if (*input_line_pointer
== '"')
4627 ++input_line_pointer
;
4631 sec
= subseg_new (name
, (subsegT
) exp
);
4633 ppc_set_current_section (sec
);
4635 if (flags
!= SEC_NO_FLAGS
)
4637 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4638 as_bad (_("error setting flags for \"%s\": %s"),
4639 bfd_section_name (stdoutput
, sec
),
4640 bfd_errmsg (bfd_get_error ()));
4643 bfd_set_section_alignment (stdoutput
, sec
, align
);
4648 ppc_pe_function (ignore
)
4649 int ignore ATTRIBUTE_UNUSED
;
4655 name
= input_line_pointer
;
4656 endc
= get_symbol_end ();
4658 ext_sym
= symbol_find_or_make (name
);
4660 *input_line_pointer
= endc
;
4662 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4663 SF_SET_FUNCTION (ext_sym
);
4664 SF_SET_PROCESS (ext_sym
);
4665 coff_add_linesym (ext_sym
);
4667 demand_empty_rest_of_line ();
4671 ppc_pe_tocd (ignore
)
4672 int ignore ATTRIBUTE_UNUSED
;
4674 if (tocdata_section
== 0)
4676 tocdata_section
= subseg_new (".tocd", 0);
4677 /* FIXME: section flags won't work. */
4678 bfd_set_section_flags (stdoutput
, tocdata_section
,
4679 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4680 | SEC_READONLY
| SEC_DATA
));
4682 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4686 rdata_section
= subseg_new (".tocd", 0);
4689 ppc_set_current_section (tocdata_section
);
4691 demand_empty_rest_of_line ();
4694 /* Don't adjust TOC relocs to use the section symbol. */
4697 ppc_pe_fix_adjustable (fix
)
4700 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4707 /* XCOFF specific symbol and file handling. */
4709 /* Canonicalize the symbol name. We use the to force the suffix, if
4710 any, to use square brackets, and to be in upper case. */
4713 ppc_canonicalize_symbol_name (name
)
4718 if (ppc_stab_symbol
)
4721 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4735 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4738 if (*s
== '\0' || s
[1] != '\0')
4739 as_bad (_("bad symbol suffix"));
4747 /* Set the class of a symbol based on the suffix, if any. This is
4748 called whenever a new symbol is created. */
4751 ppc_symbol_new_hook (sym
)
4754 struct ppc_tc_sy
*tc
;
4757 tc
= symbol_get_tc (sym
);
4761 tc
->real_name
= NULL
;
4767 if (ppc_stab_symbol
)
4770 s
= strchr (S_GET_NAME (sym
), '[');
4771 if (s
== (const char *) NULL
)
4773 /* There is no suffix. */
4782 if (strcmp (s
, "BS]") == 0)
4786 if (strcmp (s
, "DB]") == 0)
4788 else if (strcmp (s
, "DS]") == 0)
4792 if (strcmp (s
, "GL]") == 0)
4796 if (strcmp (s
, "PR]") == 0)
4800 if (strcmp (s
, "RO]") == 0)
4802 else if (strcmp (s
, "RW]") == 0)
4806 if (strcmp (s
, "SV]") == 0)
4810 if (strcmp (s
, "TC]") == 0)
4812 else if (strcmp (s
, "TI]") == 0)
4814 else if (strcmp (s
, "TB]") == 0)
4816 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4817 tc
->class = XMC_TC0
;
4820 if (strcmp (s
, "UA]") == 0)
4822 else if (strcmp (s
, "UC]") == 0)
4826 if (strcmp (s
, "XO]") == 0)
4831 if (tc
->class == -1)
4832 as_bad (_("Unrecognized symbol suffix"));
4835 /* Set the class of a label based on where it is defined. This
4836 handles symbols without suffixes. Also, move the symbol so that it
4837 follows the csect symbol. */
4840 ppc_frob_label (sym
)
4843 if (ppc_current_csect
!= (symbolS
*) NULL
)
4845 if (symbol_get_tc (sym
)->class == -1)
4846 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4848 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4849 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4850 &symbol_rootP
, &symbol_lastP
);
4851 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4855 dwarf2_emit_label (sym
);
4859 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4860 seen. It tells ppc_adjust_symtab whether it needs to look through
4863 static bfd_boolean ppc_saw_abs
;
4865 /* Change the name of a symbol just before writing it out. Set the
4866 real name if the .rename pseudo-op was used. Otherwise, remove any
4867 class suffix. Return 1 if the symbol should not be included in the
4871 ppc_frob_symbol (sym
)
4874 static symbolS
*ppc_last_function
;
4875 static symbolS
*set_end
;
4877 /* Discard symbols that should not be included in the output symbol
4879 if (! symbol_used_in_reloc_p (sym
)
4880 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4881 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
4882 && ! symbol_get_tc (sym
)->output
4883 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4886 /* This one will disappear anyway. Don't make a csect sym for it. */
4887 if (sym
== abs_section_sym
)
4890 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4891 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4897 name
= S_GET_NAME (sym
);
4898 s
= strchr (name
, '[');
4899 if (s
!= (char *) NULL
)
4905 snew
= xmalloc (len
+ 1);
4906 memcpy (snew
, name
, len
);
4909 S_SET_NAME (sym
, snew
);
4913 if (set_end
!= (symbolS
*) NULL
)
4915 SA_SET_SYM_ENDNDX (set_end
, sym
);
4919 if (SF_GET_FUNCTION (sym
))
4921 if (ppc_last_function
!= (symbolS
*) NULL
)
4922 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4923 ppc_last_function
= sym
;
4924 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4926 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4927 SA_SET_SYM_FSIZE (sym
,
4928 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4931 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4932 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4934 if (ppc_last_function
== (symbolS
*) NULL
)
4935 as_bad (_(".ef with no preceding .function"));
4938 set_end
= ppc_last_function
;
4939 ppc_last_function
= NULL
;
4941 /* We don't have a C_EFCN symbol, but we need to force the
4942 COFF backend to believe that it has seen one. */
4943 coff_last_function
= NULL
;
4947 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
4948 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4949 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4950 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4951 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4952 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4953 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4954 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4955 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4956 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4957 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4959 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4960 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4963 union internal_auxent
*a
;
4965 /* Create a csect aux. */
4966 i
= S_GET_NUMBER_AUXILIARY (sym
);
4967 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4968 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4969 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4971 /* This is the TOC table. */
4972 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4973 a
->x_csect
.x_scnlen
.l
= 0;
4974 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4976 else if (symbol_get_tc (sym
)->subseg
!= 0)
4978 /* This is a csect symbol. x_scnlen is the size of the
4980 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4981 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4982 S_GET_SEGMENT (sym
))
4983 - S_GET_VALUE (sym
));
4986 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4987 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4988 - S_GET_VALUE (sym
));
4990 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4992 else if (S_GET_SEGMENT (sym
) == bss_section
)
4994 /* This is a common symbol. */
4995 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4996 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4997 if (S_IS_EXTERNAL (sym
))
4998 symbol_get_tc (sym
)->class = XMC_RW
;
5000 symbol_get_tc (sym
)->class = XMC_BS
;
5002 else if (S_GET_SEGMENT (sym
) == absolute_section
)
5004 /* This is an absolute symbol. The csect will be created by
5005 ppc_adjust_symtab. */
5007 a
->x_csect
.x_smtyp
= XTY_LD
;
5008 if (symbol_get_tc (sym
)->class == -1)
5009 symbol_get_tc (sym
)->class = XMC_XO
;
5011 else if (! S_IS_DEFINED (sym
))
5013 /* This is an external symbol. */
5014 a
->x_csect
.x_scnlen
.l
= 0;
5015 a
->x_csect
.x_smtyp
= XTY_ER
;
5017 else if (symbol_get_tc (sym
)->class == XMC_TC
)
5021 /* This is a TOC definition. x_scnlen is the size of the
5023 next
= symbol_next (sym
);
5024 while (symbol_get_tc (next
)->class == XMC_TC0
)
5025 next
= symbol_next (next
);
5026 if (next
== (symbolS
*) NULL
5027 || symbol_get_tc (next
)->class != XMC_TC
)
5029 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5030 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5032 - S_GET_VALUE (sym
));
5034 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5035 - S_GET_VALUE (sym
));
5039 resolve_symbol_value (next
);
5040 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5041 - S_GET_VALUE (sym
));
5043 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5049 /* This is a normal symbol definition. x_scnlen is the
5050 symbol index of the containing csect. */
5051 if (S_GET_SEGMENT (sym
) == text_section
)
5052 csect
= ppc_text_csects
;
5053 else if (S_GET_SEGMENT (sym
) == data_section
)
5054 csect
= ppc_data_csects
;
5058 /* Skip the initial dummy symbol. */
5059 csect
= symbol_get_tc (csect
)->next
;
5061 if (csect
== (symbolS
*) NULL
)
5063 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5064 a
->x_csect
.x_scnlen
.l
= 0;
5068 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5070 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5071 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5072 > S_GET_VALUE (sym
))
5074 csect
= symbol_get_tc (csect
)->next
;
5077 a
->x_csect
.x_scnlen
.p
=
5078 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5079 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5082 a
->x_csect
.x_smtyp
= XTY_LD
;
5085 a
->x_csect
.x_parmhash
= 0;
5086 a
->x_csect
.x_snhash
= 0;
5087 if (symbol_get_tc (sym
)->class == -1)
5088 a
->x_csect
.x_smclas
= XMC_PR
;
5090 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
5091 a
->x_csect
.x_stab
= 0;
5092 a
->x_csect
.x_snstab
= 0;
5094 /* Don't let the COFF backend resort these symbols. */
5095 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5097 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5099 /* We want the value to be the symbol index of the referenced
5100 csect symbol. BFD will do that for us if we set the right
5102 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5103 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5105 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5106 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5108 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5113 /* The value is the offset from the enclosing csect. */
5114 block
= symbol_get_tc (sym
)->within
;
5115 csect
= symbol_get_tc (block
)->within
;
5116 resolve_symbol_value (csect
);
5117 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
5119 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5120 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5122 /* We want the value to be a file offset into the line numbers.
5123 BFD will do that for us if we set the right flags. We have
5124 already set the value correctly. */
5125 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5131 /* Adjust the symbol table. This creates csect symbols for all
5132 absolute symbols. */
5135 ppc_adjust_symtab ()
5142 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5146 union internal_auxent
*a
;
5148 if (S_GET_SEGMENT (sym
) != absolute_section
)
5151 csect
= symbol_create (".abs[XO]", absolute_section
,
5152 S_GET_VALUE (sym
), &zero_address_frag
);
5153 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5154 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5155 i
= S_GET_NUMBER_AUXILIARY (csect
);
5156 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5157 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5158 a
->x_csect
.x_scnlen
.l
= 0;
5159 a
->x_csect
.x_smtyp
= XTY_SD
;
5160 a
->x_csect
.x_parmhash
= 0;
5161 a
->x_csect
.x_snhash
= 0;
5162 a
->x_csect
.x_smclas
= XMC_XO
;
5163 a
->x_csect
.x_stab
= 0;
5164 a
->x_csect
.x_snstab
= 0;
5166 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5168 i
= S_GET_NUMBER_AUXILIARY (sym
);
5169 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5170 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5171 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5174 ppc_saw_abs
= FALSE
;
5177 /* Set the VMA for a section. This is called on all the sections in
5181 ppc_frob_section (sec
)
5184 static bfd_vma vma
= 0;
5186 vma
= md_section_align (sec
, vma
);
5187 bfd_set_section_vma (stdoutput
, sec
, vma
);
5188 vma
+= bfd_section_size (stdoutput
, sec
);
5191 #endif /* OBJ_XCOFF */
5193 /* Turn a string in input_line_pointer into a floating point constant
5194 of type TYPE, and store the appropriate bytes in *LITP. The number
5195 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5196 returned, or NULL on OK. */
5199 md_atof (type
, litp
, sizep
)
5205 LITTLENUM_TYPE words
[4];
5221 return _("bad call to md_atof");
5224 t
= atof_ieee (input_line_pointer
, type
, words
);
5226 input_line_pointer
= t
;
5230 if (target_big_endian
)
5232 for (i
= 0; i
< prec
; i
++)
5234 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5240 for (i
= prec
- 1; i
>= 0; i
--)
5242 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5250 /* Write a value out to the object file, using the appropriate
5254 md_number_to_chars (buf
, val
, n
)
5259 if (target_big_endian
)
5260 number_to_chars_bigendian (buf
, val
, n
);
5262 number_to_chars_littleendian (buf
, val
, n
);
5265 /* Align a section (I don't know why this is machine dependent). */
5268 md_section_align (asection
*seg ATTRIBUTE_UNUSED
, valueT addr
)
5273 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5275 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5279 /* We don't have any form of relaxing. */
5282 md_estimate_size_before_relax (fragp
, seg
)
5283 fragS
*fragp ATTRIBUTE_UNUSED
;
5284 asection
*seg ATTRIBUTE_UNUSED
;
5290 /* Convert a machine dependent frag. We never generate these. */
5293 md_convert_frag (abfd
, sec
, fragp
)
5294 bfd
*abfd ATTRIBUTE_UNUSED
;
5295 asection
*sec ATTRIBUTE_UNUSED
;
5296 fragS
*fragp ATTRIBUTE_UNUSED
;
5301 /* We have no need to default values of symbols. */
5304 md_undefined_symbol (name
)
5305 char *name ATTRIBUTE_UNUSED
;
5310 /* Functions concerning relocs. */
5312 /* The location from which a PC relative jump should be calculated,
5313 given a PC relative reloc. */
5316 md_pcrel_from_section (fixp
, sec
)
5318 segT sec ATTRIBUTE_UNUSED
;
5320 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5325 /* This is called to see whether a fixup should be adjusted to use a
5326 section symbol. We take the opportunity to change a fixup against
5327 a symbol in the TOC subsegment into a reloc against the
5328 corresponding .tc symbol. */
5331 ppc_fix_adjustable (fix
)
5334 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5335 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5336 TC_SYMFIELD_TYPE
*tc
;
5338 if (symseg
== absolute_section
)
5341 if (ppc_toc_csect
!= (symbolS
*) NULL
5342 && fix
->fx_addsy
!= ppc_toc_csect
5343 && symseg
== data_section
5344 && val
>= ppc_toc_frag
->fr_address
5345 && (ppc_after_toc_frag
== (fragS
*) NULL
5346 || val
< ppc_after_toc_frag
->fr_address
))
5350 for (sy
= symbol_next (ppc_toc_csect
);
5351 sy
!= (symbolS
*) NULL
;
5352 sy
= symbol_next (sy
))
5354 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5356 if (sy_tc
->class == XMC_TC0
)
5358 if (sy_tc
->class != XMC_TC
)
5360 if (val
== resolve_symbol_value (sy
))
5363 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5368 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5369 _("symbol in .toc does not match any .tc"));
5372 /* Possibly adjust the reloc to be against the csect. */
5373 tc
= symbol_get_tc (fix
->fx_addsy
);
5375 && tc
->class != XMC_TC0
5376 && tc
->class != XMC_TC
5377 && symseg
!= bss_section
5378 /* Don't adjust if this is a reloc in the toc section. */
5379 && (symseg
!= data_section
5380 || ppc_toc_csect
== NULL
5381 || val
< ppc_toc_frag
->fr_address
5382 || (ppc_after_toc_frag
!= NULL
5383 && val
>= ppc_after_toc_frag
->fr_address
)))
5386 symbolS
*next_csect
;
5388 if (symseg
== text_section
)
5389 csect
= ppc_text_csects
;
5390 else if (symseg
== data_section
)
5391 csect
= ppc_data_csects
;
5395 /* Skip the initial dummy symbol. */
5396 csect
= symbol_get_tc (csect
)->next
;
5398 if (csect
!= (symbolS
*) NULL
)
5400 while ((next_csect
= symbol_get_tc (csect
)->next
) != (symbolS
*) NULL
5401 && (symbol_get_frag (next_csect
)->fr_address
<= val
))
5403 /* If the csect address equals the symbol value, then we
5404 have to look through the full symbol table to see
5405 whether this is the csect we want. Note that we will
5406 only get here if the csect has zero length. */
5407 if (symbol_get_frag (csect
)->fr_address
== val
5408 && S_GET_VALUE (csect
) == val
)
5412 for (scan
= symbol_next (csect
);
5414 scan
= symbol_next (scan
))
5416 if (symbol_get_tc (scan
)->subseg
!= 0)
5418 if (scan
== fix
->fx_addsy
)
5422 /* If we found the symbol before the next csect
5423 symbol, then this is the csect we want. */
5424 if (scan
== fix
->fx_addsy
)
5431 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5432 fix
->fx_addsy
= csect
;
5437 /* Adjust a reloc against a .lcomm symbol to be against the base
5439 if (symseg
== bss_section
5440 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5442 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5444 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5451 /* A reloc from one csect to another must be kept. The assembler
5452 will, of course, keep relocs between sections, and it will keep
5453 absolute relocs, but we need to force it to keep PC relative relocs
5454 between two csects in the same section. */
5457 ppc_force_relocation (fix
)
5460 /* At this point fix->fx_addsy should already have been converted to
5461 a csect symbol. If the csect does not include the fragment, then
5462 we need to force the relocation. */
5464 && fix
->fx_addsy
!= NULL
5465 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5466 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5467 > fix
->fx_frag
->fr_address
)
5468 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5469 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5470 <= fix
->fx_frag
->fr_address
))))
5473 return generic_force_reloc (fix
);
5476 #endif /* OBJ_XCOFF */
5479 /* If this function returns non-zero, it guarantees that a relocation
5480 will be emitted for a fixup. */
5483 ppc_force_relocation (fix
)
5486 /* Branch prediction relocations must force a relocation, as must
5487 the vtable description relocs. */
5488 switch (fix
->fx_r_type
)
5490 case BFD_RELOC_PPC_B16_BRTAKEN
:
5491 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5492 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5493 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5494 case BFD_RELOC_24_PLT_PCREL
:
5495 case BFD_RELOC_PPC64_TOC
:
5501 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5502 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5505 return generic_force_reloc (fix
);
5509 ppc_fix_adjustable (fix
)
5512 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5513 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5514 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5515 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5516 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5517 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5518 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5519 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5520 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
5524 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
5525 rs_align_code frag. */
5528 ppc_handle_align (struct frag
*fragP
)
5530 valueT count
= (fragP
->fr_next
->fr_address
5531 - (fragP
->fr_address
+ fragP
->fr_fix
));
5533 if (count
!= 0 && (count
& 3) == 0)
5535 char *dest
= fragP
->fr_literal
+ fragP
->fr_fix
;
5538 md_number_to_chars (dest
, 0x60000000, 4);
5540 if ((ppc_cpu
& PPC_OPCODE_POWER6
) != 0)
5542 /* For power6, we want the last nop to be a group terminating
5543 one, "ori 1,1,0". Do this by inserting an rs_fill frag
5544 immediately after this one, with its address set to the last
5545 nop location. This will automatically reduce the number of
5546 nops in the current frag by one. */
5549 struct frag
*group_nop
= xmalloc (SIZEOF_STRUCT_FRAG
+ 4);
5551 memcpy (group_nop
, fragP
, SIZEOF_STRUCT_FRAG
);
5552 group_nop
->fr_address
= group_nop
->fr_next
->fr_address
- 4;
5553 group_nop
->fr_fix
= 0;
5554 group_nop
->fr_offset
= 1;
5555 group_nop
->fr_type
= rs_fill
;
5556 fragP
->fr_next
= group_nop
;
5557 dest
= group_nop
->fr_literal
;
5560 md_number_to_chars (dest
, 0x60210000, 4);
5565 /* Apply a fixup to the object code. This is called for all the
5566 fixups we generated by the call to fix_new_exp, above. In the call
5567 above we used a reloc code which was the largest legal reloc code
5568 plus the operand index. Here we undo that to recover the operand
5569 index. At this point all symbol values should be fully resolved,
5570 and we attempt to completely resolve the reloc. If we can not do
5571 that, we determine the correct reloc code and put it back in the
5575 md_apply_fix (fixP
, valP
, seg
)
5578 segT seg ATTRIBUTE_UNUSED
;
5580 valueT value
= * valP
;
5583 if (fixP
->fx_addsy
!= NULL
)
5585 /* Hack around bfd_install_relocation brain damage. */
5587 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5592 /* FIXME FIXME FIXME: The value we are passed in *valP includes
5593 the symbol values. If we are doing this relocation the code in
5594 write.c is going to call bfd_install_relocation, which is also
5595 going to use the symbol value. That means that if the reloc is
5596 fully resolved we want to use *valP since bfd_install_relocation is
5598 However, if the reloc is not fully resolved we do not want to use
5599 *valP, and must use fx_offset instead. However, if the reloc
5600 is PC relative, we do want to use *valP since it includes the
5601 result of md_pcrel_from. This is confusing. */
5602 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5605 else if (fixP
->fx_pcrel
)
5609 value
= fixP
->fx_offset
;
5612 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5614 /* We can't actually support subtracting a symbol. */
5615 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
5618 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5621 const struct powerpc_operand
*operand
;
5625 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5627 operand
= &powerpc_operands
[opindex
];
5630 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5631 does not generate a reloc. It uses the offset of `sym' within its
5632 csect. Other usages, such as `.long sym', generate relocs. This
5633 is the documented behaviour of non-TOC symbols. */
5634 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5635 && operand
->bits
== 16
5636 && operand
->shift
== 0
5637 && (operand
->insert
== NULL
|| ppc_obj64
)
5638 && fixP
->fx_addsy
!= NULL
5639 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5640 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5641 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5642 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5644 value
= fixP
->fx_offset
;
5649 /* Fetch the instruction, insert the fully resolved operand
5650 value, and stuff the instruction back again. */
5651 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5652 if (target_big_endian
)
5653 insn
= bfd_getb32 ((unsigned char *) where
);
5655 insn
= bfd_getl32 ((unsigned char *) where
);
5656 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5657 fixP
->fx_file
, fixP
->fx_line
);
5658 if (target_big_endian
)
5659 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5661 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5664 /* Nothing else to do here. */
5667 assert (fixP
->fx_addsy
!= NULL
);
5669 /* Determine a BFD reloc value based on the operand information.
5670 We are only prepared to turn a few of the operands into
5672 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5673 && operand
->bits
== 26
5674 && operand
->shift
== 0)
5675 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5676 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5677 && operand
->bits
== 16
5678 && operand
->shift
== 0)
5680 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5683 if (target_big_endian
)
5684 fixP
->fx_where
+= 2;
5687 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5688 && operand
->bits
== 26
5689 && operand
->shift
== 0)
5690 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5691 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5692 && operand
->bits
== 16
5693 && operand
->shift
== 0)
5695 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5698 if (target_big_endian
)
5699 fixP
->fx_where
+= 2;
5702 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5703 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5704 && operand
->bits
== 16
5705 && operand
->shift
== 0)
5707 if (ppc_is_toc_sym (fixP
->fx_addsy
))
5709 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5712 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5713 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5718 fixP
->fx_r_type
= BFD_RELOC_16
;
5721 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5722 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
5726 if (target_big_endian
)
5727 fixP
->fx_where
+= 2;
5729 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5735 /* Use expr_symbol_where to see if this is an expression
5737 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5738 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5739 _("unresolved expression that must be resolved"));
5741 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5742 _("unsupported relocation against %s"),
5743 S_GET_NAME (fixP
->fx_addsy
));
5751 ppc_elf_validate_fix (fixP
, seg
);
5753 switch (fixP
->fx_r_type
)
5755 case BFD_RELOC_CTOR
:
5762 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5766 case BFD_RELOC_32_PCREL
:
5767 case BFD_RELOC_PPC_EMB_NADDR32
:
5768 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5775 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5778 case BFD_RELOC_64_PCREL
:
5779 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5783 case BFD_RELOC_GPREL16
:
5784 case BFD_RELOC_16_GOT_PCREL
:
5785 case BFD_RELOC_16_GOTOFF
:
5786 case BFD_RELOC_LO16_GOTOFF
:
5787 case BFD_RELOC_HI16_GOTOFF
:
5788 case BFD_RELOC_HI16_S_GOTOFF
:
5789 case BFD_RELOC_16_BASEREL
:
5790 case BFD_RELOC_LO16_BASEREL
:
5791 case BFD_RELOC_HI16_BASEREL
:
5792 case BFD_RELOC_HI16_S_BASEREL
:
5793 case BFD_RELOC_PPC_EMB_NADDR16
:
5794 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5795 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5796 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5797 case BFD_RELOC_PPC_EMB_SDAI16
:
5798 case BFD_RELOC_PPC_EMB_SDA2REL
:
5799 case BFD_RELOC_PPC_EMB_SDA2I16
:
5800 case BFD_RELOC_PPC_EMB_RELSEC16
:
5801 case BFD_RELOC_PPC_EMB_RELST_LO
:
5802 case BFD_RELOC_PPC_EMB_RELST_HI
:
5803 case BFD_RELOC_PPC_EMB_RELST_HA
:
5804 case BFD_RELOC_PPC_EMB_RELSDA
:
5805 case BFD_RELOC_PPC_TOC16
:
5807 case BFD_RELOC_PPC64_TOC16_LO
:
5808 case BFD_RELOC_PPC64_TOC16_HI
:
5809 case BFD_RELOC_PPC64_TOC16_HA
:
5813 if (fixP
->fx_addsy
!= NULL
)
5814 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5815 _("cannot emit PC relative %s relocation against %s"),
5816 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5817 S_GET_NAME (fixP
->fx_addsy
));
5819 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5820 _("cannot emit PC relative %s relocation"),
5821 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5824 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5830 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5833 case BFD_RELOC_16_PCREL
:
5834 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5838 case BFD_RELOC_LO16
:
5840 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
5843 case BFD_RELOC_LO16_PCREL
:
5844 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5848 /* This case happens when you write, for example,
5850 where L1 and L2 are defined later. */
5851 case BFD_RELOC_HI16
:
5853 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
5856 case BFD_RELOC_HI16_PCREL
:
5857 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5861 case BFD_RELOC_HI16_S
:
5863 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
5866 case BFD_RELOC_HI16_S_PCREL
:
5867 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5872 case BFD_RELOC_PPC64_HIGHER
:
5875 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5876 PPC_HIGHER (value
), 2);
5879 case BFD_RELOC_PPC64_HIGHER_S
:
5882 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5883 PPC_HIGHERA (value
), 2);
5886 case BFD_RELOC_PPC64_HIGHEST
:
5889 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5890 PPC_HIGHEST (value
), 2);
5893 case BFD_RELOC_PPC64_HIGHEST_S
:
5896 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5897 PPC_HIGHESTA (value
), 2);
5900 case BFD_RELOC_PPC64_ADDR16_DS
:
5901 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5902 case BFD_RELOC_PPC64_GOT16_DS
:
5903 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5904 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5905 case BFD_RELOC_PPC64_SECTOFF_DS
:
5906 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5907 case BFD_RELOC_PPC64_TOC16_DS
:
5908 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5909 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5910 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5914 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5915 unsigned long val
, mask
;
5917 if (target_big_endian
)
5918 val
= bfd_getb32 (where
- 2);
5920 val
= bfd_getl32 (where
);
5922 /* lq insns reserve the four lsbs. */
5923 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
5924 && (val
& (0x3f << 26)) == (56u << 26))
5926 val
|= value
& mask
;
5927 if (target_big_endian
)
5928 bfd_putb16 ((bfd_vma
) val
, where
);
5930 bfd_putl16 ((bfd_vma
) val
, where
);
5934 case BFD_RELOC_PPC_B16_BRTAKEN
:
5935 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5936 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5937 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5940 case BFD_RELOC_PPC_TLS
:
5943 case BFD_RELOC_PPC_DTPMOD
:
5944 case BFD_RELOC_PPC_TPREL16
:
5945 case BFD_RELOC_PPC_TPREL16_LO
:
5946 case BFD_RELOC_PPC_TPREL16_HI
:
5947 case BFD_RELOC_PPC_TPREL16_HA
:
5948 case BFD_RELOC_PPC_TPREL
:
5949 case BFD_RELOC_PPC_DTPREL16
:
5950 case BFD_RELOC_PPC_DTPREL16_LO
:
5951 case BFD_RELOC_PPC_DTPREL16_HI
:
5952 case BFD_RELOC_PPC_DTPREL16_HA
:
5953 case BFD_RELOC_PPC_DTPREL
:
5954 case BFD_RELOC_PPC_GOT_TLSGD16
:
5955 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
5956 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
5957 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
5958 case BFD_RELOC_PPC_GOT_TLSLD16
:
5959 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
5960 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
5961 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
5962 case BFD_RELOC_PPC_GOT_TPREL16
:
5963 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
5964 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
5965 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
5966 case BFD_RELOC_PPC_GOT_DTPREL16
:
5967 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
5968 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
5969 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
5970 case BFD_RELOC_PPC64_TPREL16_DS
:
5971 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
5972 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
5973 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
5974 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
5975 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
5976 case BFD_RELOC_PPC64_DTPREL16_DS
:
5977 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
5978 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
5979 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
5980 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
5981 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
5982 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
5985 /* Because SDA21 modifies the register field, the size is set to 4
5986 bytes, rather than 2, so offset it here appropriately. */
5987 case BFD_RELOC_PPC_EMB_SDA21
:
5991 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5992 + ((target_big_endian
) ? 2 : 0),
5999 /* This can occur if there is a bug in the input assembler, eg:
6000 ".byte <undefined_symbol> - ." */
6002 as_bad (_("Unable to handle reference to symbol %s"),
6003 S_GET_NAME (fixP
->fx_addsy
));
6005 as_bad (_("Unable to resolve expression"));
6009 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
6013 case BFD_RELOC_24_PLT_PCREL
:
6014 case BFD_RELOC_PPC_LOCAL24PC
:
6015 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
6023 /* Fetch the instruction, insert the fully resolved operand
6024 value, and stuff the instruction back again. */
6025 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
6026 if (target_big_endian
)
6027 insn
= bfd_getb32 ((unsigned char *) where
);
6029 insn
= bfd_getl32 ((unsigned char *) where
);
6030 if ((value
& 3) != 0)
6031 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6032 _("must branch to an address a multiple of 4"));
6033 if ((offsetT
) value
< -0x40000000
6034 || (offsetT
) value
>= 0x40000000)
6035 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
6036 _("@local or @plt branch destination is too far away, %ld bytes"),
6038 insn
= insn
| (value
& 0x03fffffc);
6039 if (target_big_endian
)
6040 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
6042 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
6046 case BFD_RELOC_VTABLE_INHERIT
:
6049 && !S_IS_DEFINED (fixP
->fx_addsy
)
6050 && !S_IS_WEAK (fixP
->fx_addsy
))
6051 S_SET_WEAK (fixP
->fx_addsy
);
6054 case BFD_RELOC_VTABLE_ENTRY
:
6059 /* Generated by reference to `sym@tocbase'. The sym is
6060 ignored by the linker. */
6061 case BFD_RELOC_PPC64_TOC
:
6067 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6074 fixP
->fx_addnumber
= value
;
6076 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6077 from the section contents. If we are going to be emitting a reloc
6078 then the section contents are immaterial, so don't warn if they
6079 happen to overflow. Leave such warnings to ld. */
6081 fixP
->fx_no_overflow
= 1;
6083 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6084 fixP
->fx_addnumber
= 0;
6088 fixP
->fx_addnumber
= 0;
6090 /* We want to use the offset within the data segment of the
6091 symbol, not the actual VMA of the symbol. */
6092 fixP
->fx_addnumber
=
6093 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
6099 /* Generate a reloc for a fixup. */
6102 tc_gen_reloc (seg
, fixp
)
6103 asection
*seg ATTRIBUTE_UNUSED
;
6108 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6110 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6111 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6112 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6113 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6114 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6116 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6117 _("reloc %d not supported by object file format"),
6118 (int) fixp
->fx_r_type
);
6121 reloc
->addend
= fixp
->fx_addnumber
;
6127 ppc_cfi_frame_initial_instructions ()
6129 cfi_add_CFA_def_cfa (1, 0);
6133 tc_ppc_regname_to_dw2regnum (char *regname
)
6135 unsigned int regnum
= -1;
6139 static struct { char *name
; int dw2regnum
; } regnames
[] =
6141 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6142 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6143 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6144 { "spe_acc", 111 }, { "spefscr", 112 }
6147 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6148 if (strcmp (regnames
[i
].name
, regname
) == 0)
6149 return regnames
[i
].dw2regnum
;
6151 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6153 p
= regname
+ 1 + (regname
[1] == '.');
6154 regnum
= strtoul (p
, &q
, 10);
6155 if (p
== q
|| *q
|| regnum
>= 32)
6157 if (regname
[0] == 'f')
6159 else if (regname
[0] == 'v')
6162 else if (regname
[0] == 'c' && regname
[1] == 'r')
6164 p
= regname
+ 2 + (regname
[2] == '.');
6165 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6167 regnum
= p
[0] - '0' + 68;