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 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
25 #include "safe-ctype.h"
27 #include "dw2gencfi.h"
28 #include "opcode/ppc.h"
32 #include "dwarf2dbg.h"
39 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
41 /* Tell the main code what the endianness is. */
42 extern int target_big_endian
;
44 /* Whether or not, we've set target_big_endian. */
45 static int set_target_endian
= 0;
47 /* Whether to use user friendly register names. */
48 #ifndef TARGET_REG_NAMES_P
50 #define TARGET_REG_NAMES_P TRUE
52 #define TARGET_REG_NAMES_P FALSE
56 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
59 /* #lo(value) denotes the least significant 16 bits of the indicated. */
60 #define PPC_LO(v) ((v) & 0xffff)
62 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
63 #define PPC_HI(v) (((v) >> 16) & 0xffff)
65 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
66 the indicated value, compensating for #lo() being treated as a
68 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
70 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
71 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
73 /* #highera(value) denotes bits 32 through 47 of the indicated value,
74 compensating for #lo() being treated as a signed number. */
75 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
77 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
78 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
80 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
81 compensating for #lo being treated as a signed number. */
82 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
84 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
86 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
88 static bfd_boolean register_name
PARAMS ((expressionS
*));
89 static void ppc_set_cpu
PARAMS ((void));
90 static unsigned long ppc_insert_operand
91 PARAMS ((unsigned long insn
, const struct powerpc_operand
*operand
,
92 offsetT val
, char *file
, unsigned int line
));
93 static void ppc_macro
PARAMS ((char *str
, const struct powerpc_macro
*macro
));
94 static void ppc_byte
PARAMS ((int));
96 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
97 static int ppc_is_toc_sym
PARAMS ((symbolS
*sym
));
98 static void ppc_tc
PARAMS ((int));
99 static void ppc_machine
PARAMS ((int));
103 static void ppc_comm
PARAMS ((int));
104 static void ppc_bb
PARAMS ((int));
105 static void ppc_bc
PARAMS ((int));
106 static void ppc_bf
PARAMS ((int));
107 static void ppc_biei
PARAMS ((int));
108 static void ppc_bs
PARAMS ((int));
109 static void ppc_eb
PARAMS ((int));
110 static void ppc_ec
PARAMS ((int));
111 static void ppc_ef
PARAMS ((int));
112 static void ppc_es
PARAMS ((int));
113 static void ppc_csect
PARAMS ((int));
114 static void ppc_change_csect
PARAMS ((symbolS
*, offsetT
));
115 static void ppc_function
PARAMS ((int));
116 static void ppc_extern
PARAMS ((int));
117 static void ppc_lglobl
PARAMS ((int));
118 static void ppc_section
PARAMS ((int));
119 static void ppc_named_section
PARAMS ((int));
120 static void ppc_stabx
PARAMS ((int));
121 static void ppc_rename
PARAMS ((int));
122 static void ppc_toc
PARAMS ((int));
123 static void ppc_xcoff_cons
PARAMS ((int));
124 static void ppc_vbyte
PARAMS ((int));
128 static bfd_reloc_code_real_type ppc_elf_suffix
PARAMS ((char **, expressionS
*));
129 static void ppc_elf_cons
PARAMS ((int));
130 static void ppc_elf_rdata
PARAMS ((int));
131 static void ppc_elf_lcomm
PARAMS ((int));
132 static void ppc_elf_validate_fix
PARAMS ((fixS
*, segT
));
133 static void ppc_apuinfo_section_add
PARAMS ((unsigned int apu
, unsigned int version
));
137 static void ppc_set_current_section
PARAMS ((segT
));
138 static void ppc_previous
PARAMS ((int));
139 static void ppc_pdata
PARAMS ((int));
140 static void ppc_ydata
PARAMS ((int));
141 static void ppc_reldata
PARAMS ((int));
142 static void ppc_rdata
PARAMS ((int));
143 static void ppc_ualong
PARAMS ((int));
144 static void ppc_znop
PARAMS ((int));
145 static void ppc_pe_comm
PARAMS ((int));
146 static void ppc_pe_section
PARAMS ((int));
147 static void ppc_pe_function
PARAMS ((int));
148 static void ppc_pe_tocd
PARAMS ((int));
151 /* Generic assembler global variables which must be defined by all
155 /* This string holds the chars that always start a comment. If the
156 pre-processor is disabled, these aren't very useful. The macro
157 tc_comment_chars points to this. We use this, rather than the
158 usual comment_chars, so that we can switch for Solaris conventions. */
159 static const char ppc_solaris_comment_chars
[] = "#!";
160 static const char ppc_eabi_comment_chars
[] = "#";
162 #ifdef TARGET_SOLARIS_COMMENT
163 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
165 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
168 const char comment_chars
[] = "#";
171 /* Characters which start a comment at the beginning of a line. */
172 const char line_comment_chars
[] = "#";
174 /* Characters which may be used to separate multiple commands on a
176 const char line_separator_chars
[] = ";";
178 /* Characters which are used to indicate an exponent in a floating
180 const char EXP_CHARS
[] = "eE";
182 /* Characters which mean that a number is a floating point constant,
184 const char FLT_CHARS
[] = "dD";
186 /* '+' and '-' can be used as postfix predicate predictors for conditional
187 branches. So they need to be accepted as symbol characters. */
188 const char ppc_symbol_chars
[] = "+-";
190 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
191 int ppc_cie_data_alignment
;
193 /* The target specific pseudo-ops which we support. */
195 const pseudo_typeS md_pseudo_table
[] =
197 /* Pseudo-ops which must be overridden. */
198 { "byte", ppc_byte
, 0 },
201 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
202 legitimately belong in the obj-*.c file. However, XCOFF is based
203 on COFF, and is only implemented for the RS/6000. We just use
204 obj-coff.c, and add what we need here. */
205 { "comm", ppc_comm
, 0 },
206 { "lcomm", ppc_comm
, 1 },
210 { "bi", ppc_biei
, 0 },
212 { "csect", ppc_csect
, 0 },
213 { "data", ppc_section
, 'd' },
217 { "ei", ppc_biei
, 1 },
219 { "extern", ppc_extern
, 0 },
220 { "function", ppc_function
, 0 },
221 { "lglobl", ppc_lglobl
, 0 },
222 { "rename", ppc_rename
, 0 },
223 { "section", ppc_named_section
, 0 },
224 { "stabx", ppc_stabx
, 0 },
225 { "text", ppc_section
, 't' },
226 { "toc", ppc_toc
, 0 },
227 { "long", ppc_xcoff_cons
, 2 },
228 { "llong", ppc_xcoff_cons
, 3 },
229 { "word", ppc_xcoff_cons
, 1 },
230 { "short", ppc_xcoff_cons
, 1 },
231 { "vbyte", ppc_vbyte
, 0 },
235 { "llong", ppc_elf_cons
, 8 },
236 { "quad", ppc_elf_cons
, 8 },
237 { "long", ppc_elf_cons
, 4 },
238 { "word", ppc_elf_cons
, 2 },
239 { "short", ppc_elf_cons
, 2 },
240 { "rdata", ppc_elf_rdata
, 0 },
241 { "rodata", ppc_elf_rdata
, 0 },
242 { "lcomm", ppc_elf_lcomm
, 0 },
246 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
247 { "previous", ppc_previous
, 0 },
248 { "pdata", ppc_pdata
, 0 },
249 { "ydata", ppc_ydata
, 0 },
250 { "reldata", ppc_reldata
, 0 },
251 { "rdata", ppc_rdata
, 0 },
252 { "ualong", ppc_ualong
, 0 },
253 { "znop", ppc_znop
, 0 },
254 { "comm", ppc_pe_comm
, 0 },
255 { "lcomm", ppc_pe_comm
, 1 },
256 { "section", ppc_pe_section
, 0 },
257 { "function", ppc_pe_function
,0 },
258 { "tocd", ppc_pe_tocd
, 0 },
261 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
263 { "machine", ppc_machine
, 0 },
270 /* Predefined register names if -mregnames (or default for Windows NT).
271 In general, there are lots of them, in an attempt to be compatible
272 with a number of other Windows NT assemblers. */
274 /* Structure to hold information about predefined registers. */
281 /* List of registers that are pre-defined:
283 Each general register has predefined names of the form:
284 1. r<reg_num> which has the value <reg_num>.
285 2. r.<reg_num> which has the value <reg_num>.
287 Each floating point register has predefined names of the form:
288 1. f<reg_num> which has the value <reg_num>.
289 2. f.<reg_num> which has the value <reg_num>.
291 Each vector unit register has predefined names of the form:
292 1. v<reg_num> which has the value <reg_num>.
293 2. v.<reg_num> which has the value <reg_num>.
295 Each condition register has predefined names of the form:
296 1. cr<reg_num> which has the value <reg_num>.
297 2. cr.<reg_num> which has the value <reg_num>.
299 There are individual registers as well:
300 sp or r.sp has the value 1
301 rtoc or r.toc has the value 2
302 fpscr has the value 0
308 dsisr has the value 18
310 sdr1 has the value 25
311 srr0 has the value 26
312 srr1 has the value 27
314 The table is sorted. Suitable for searching by a binary search. */
316 static const struct pd_reg pre_defined_registers
[] =
318 { "cr.0", 0 }, /* Condition Registers */
338 { "dar", 19 }, /* Data Access Register */
339 { "dec", 22 }, /* Decrementer */
340 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
342 { "f.0", 0 }, /* Floating point registers */
410 { "lr", 8 }, /* Link Register */
414 { "r.0", 0 }, /* General Purpose Registers */
447 { "r.sp", 1 }, /* Stack Pointer */
449 { "r.toc", 2 }, /* Pointer to the table of contents */
451 { "r0", 0 }, /* More general purpose registers */
484 { "rtoc", 2 }, /* Table of contents */
486 { "sdr1", 25 }, /* Storage Description Register 1 */
490 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
491 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
493 { "v.0", 0 }, /* Vector registers */
563 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
565 /* Given NAME, find the register number associated with that name, return
566 the integer value associated with the given name or -1 on failure. */
568 static int reg_name_search
569 PARAMS ((const struct pd_reg
*, int, const char * name
));
572 reg_name_search (regs
, regcount
, name
)
573 const struct pd_reg
*regs
;
577 int middle
, low
, high
;
585 middle
= (low
+ high
) / 2;
586 cmp
= strcasecmp (name
, regs
[middle
].name
);
592 return regs
[middle
].value
;
600 * Summary of register_name.
602 * in: Input_line_pointer points to 1st char of operand.
604 * out: A expressionS.
605 * The operand may have been a register: in this case, X_op == O_register,
606 * X_add_number is set to the register number, and truth is returned.
607 * Input_line_pointer->(next non-blank) char after operand, or is in its
612 register_name (expressionP
)
613 expressionS
*expressionP
;
620 /* Find the spelling of the operand. */
621 start
= name
= input_line_pointer
;
622 if (name
[0] == '%' && ISALPHA (name
[1]))
623 name
= ++input_line_pointer
;
625 else if (!reg_names_p
|| !ISALPHA (name
[0]))
628 c
= get_symbol_end ();
629 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
631 /* Put back the delimiting char. */
632 *input_line_pointer
= c
;
634 /* Look to see if it's in the register table. */
637 expressionP
->X_op
= O_register
;
638 expressionP
->X_add_number
= reg_number
;
640 /* Make the rest nice. */
641 expressionP
->X_add_symbol
= NULL
;
642 expressionP
->X_op_symbol
= NULL
;
646 /* Reset the line as if we had not done anything. */
647 input_line_pointer
= start
;
651 /* This function is called for each symbol seen in an expression. It
652 handles the special parsing which PowerPC assemblers are supposed
653 to use for condition codes. */
655 /* Whether to do the special parsing. */
656 static bfd_boolean cr_operand
;
658 /* Names to recognize in a condition code. This table is sorted. */
659 static const struct pd_reg cr_names
[] =
676 /* Parsing function. This returns non-zero if it recognized an
680 ppc_parse_name (name
, expr
)
689 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
694 expr
->X_op
= O_constant
;
695 expr
->X_add_number
= val
;
700 /* Local variables. */
702 /* The type of processor we are assembling for. This is one or more
703 of the PPC_OPCODE flags defined in opcode/ppc.h. */
704 static unsigned long ppc_cpu
= 0;
706 /* Whether to target xcoff64/elf64. */
707 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
709 /* Opcode hash table. */
710 static struct hash_control
*ppc_hash
;
712 /* Macro hash table. */
713 static struct hash_control
*ppc_macro_hash
;
716 /* What type of shared library support to use. */
717 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
719 /* Flags to set in the elf header. */
720 static flagword ppc_flags
= 0;
722 /* Whether this is Solaris or not. */
723 #ifdef TARGET_SOLARIS_COMMENT
724 #define SOLARIS_P TRUE
726 #define SOLARIS_P FALSE
729 static bfd_boolean msolaris
= SOLARIS_P
;
734 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
735 using a bunch of different sections. These assembler sections,
736 however, are all encompassed within the .text or .data sections of
737 the final output file. We handle this by using different
738 subsegments within these main segments. */
740 /* Next subsegment to allocate within the .text segment. */
741 static subsegT ppc_text_subsegment
= 2;
743 /* Linked list of csects in the text section. */
744 static symbolS
*ppc_text_csects
;
746 /* Next subsegment to allocate within the .data segment. */
747 static subsegT ppc_data_subsegment
= 2;
749 /* Linked list of csects in the data section. */
750 static symbolS
*ppc_data_csects
;
752 /* The current csect. */
753 static symbolS
*ppc_current_csect
;
755 /* The RS/6000 assembler uses a TOC which holds addresses of functions
756 and variables. Symbols are put in the TOC with the .tc pseudo-op.
757 A special relocation is used when accessing TOC entries. We handle
758 the TOC as a subsegment within the .data segment. We set it up if
759 we see a .toc pseudo-op, and save the csect symbol here. */
760 static symbolS
*ppc_toc_csect
;
762 /* The first frag in the TOC subsegment. */
763 static fragS
*ppc_toc_frag
;
765 /* The first frag in the first subsegment after the TOC in the .data
766 segment. NULL if there are no subsegments after the TOC. */
767 static fragS
*ppc_after_toc_frag
;
769 /* The current static block. */
770 static symbolS
*ppc_current_block
;
772 /* The COFF debugging section; set by md_begin. This is not the
773 .debug section, but is instead the secret BFD section which will
774 cause BFD to set the section number of a symbol to N_DEBUG. */
775 static asection
*ppc_coff_debug_section
;
777 #endif /* OBJ_XCOFF */
781 /* Various sections that we need for PE coff support. */
782 static segT ydata_section
;
783 static segT pdata_section
;
784 static segT reldata_section
;
785 static segT rdata_section
;
786 static segT tocdata_section
;
788 /* The current section and the previous section. See ppc_previous. */
789 static segT ppc_previous_section
;
790 static segT ppc_current_section
;
795 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
796 #define PPC_APUINFO_ISEL 0x40
797 #define PPC_APUINFO_PMR 0x41
798 #define PPC_APUINFO_RFMCI 0x42
799 #define PPC_APUINFO_CACHELCK 0x43
800 #define PPC_APUINFO_SPE 0x100
801 #define PPC_APUINFO_EFS 0x101
802 #define PPC_APUINFO_BRLOCK 0x102
805 * We keep a list of APUinfo
807 unsigned long *ppc_apuinfo_list
;
808 unsigned int ppc_apuinfo_num
;
809 unsigned int ppc_apuinfo_num_alloc
;
813 const char *const md_shortopts
= "b:l:usm:K:VQ:";
815 const char *const md_shortopts
= "um:";
817 const struct option md_longopts
[] = {
818 {NULL
, no_argument
, NULL
, 0}
820 const size_t md_longopts_size
= sizeof (md_longopts
);
823 /* Handle -m options that set cpu type, and .machine arg. */
826 parse_cpu (const char *arg
)
828 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
830 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
831 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
| PPC_OPCODE_32
;
832 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
833 else if (strcmp (arg
, "pwr") == 0)
834 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
835 /* -m601 means to assemble for the PowerPC 601, which includes
836 instructions that are holdovers from the Power. */
837 else if (strcmp (arg
, "601") == 0)
838 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
839 | PPC_OPCODE_601
| PPC_OPCODE_32
);
840 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
842 else if (strcmp (arg
, "ppc") == 0
843 || strcmp (arg
, "ppc32") == 0
844 || strcmp (arg
, "603") == 0
845 || strcmp (arg
, "604") == 0)
846 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
847 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
848 else if (strcmp (arg
, "403") == 0
849 || strcmp (arg
, "405") == 0)
850 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
851 | PPC_OPCODE_403
| PPC_OPCODE_32
);
852 else if (strcmp (arg
, "440") == 0)
853 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
854 | PPC_OPCODE_440
| PPC_OPCODE_ISEL
| PPC_OPCODE_RFMCI
);
855 else if (strcmp (arg
, "7400") == 0
856 || strcmp (arg
, "7410") == 0
857 || strcmp (arg
, "7450") == 0
858 || strcmp (arg
, "7455") == 0)
859 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
860 | PPC_OPCODE_ALTIVEC
| PPC_OPCODE_32
);
861 else if (strcmp (arg
, "altivec") == 0)
864 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_ALTIVEC
;
866 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
868 else if (strcmp (arg
, "e500") == 0 || strcmp (arg
, "e500x2") == 0)
870 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_SPE
871 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
| PPC_OPCODE_BRLOCK
872 | PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
875 else if (strcmp (arg
, "spe") == 0)
878 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_SPE
| PPC_OPCODE_EFS
;
880 ppc_cpu
|= PPC_OPCODE_SPE
;
882 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
884 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
886 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
888 else if (strcmp (arg
, "ppc64bridge") == 0)
890 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
891 | PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
);
893 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
894 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
896 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
;
898 /* -mbooke64 means enable 64-bit BookE support. */
899 else if (strcmp (arg
, "booke64") == 0)
901 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
902 | PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
);
904 else if (strcmp (arg
, "power4") == 0)
906 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
907 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
);
909 else if (strcmp (arg
, "power5") == 0)
911 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
912 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
913 | PPC_OPCODE_POWER5
);
915 /* -mcom means assemble for the common intersection between Power
916 and PowerPC. At present, we just allow the union, rather
917 than the intersection. */
918 else if (strcmp (arg
, "com") == 0)
919 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
920 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
921 else if (strcmp (arg
, "any") == 0)
922 ppc_cpu
|= PPC_OPCODE_ANY
;
930 md_parse_option (c
, arg
)
937 /* -u means that any undefined symbols should be treated as
938 external, which is the default for gas anyhow. */
943 /* Solaris as takes -le (presumably for little endian). For completeness
944 sake, recognize -be also. */
945 if (strcmp (arg
, "e") == 0)
947 target_big_endian
= 0;
948 set_target_endian
= 1;
956 if (strcmp (arg
, "e") == 0)
958 target_big_endian
= 1;
959 set_target_endian
= 1;
967 /* Recognize -K PIC. */
968 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
971 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
979 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
981 if (strcmp (arg
, "64") == 0)
986 as_fatal (_("%s unsupported"), "-a64");
989 else if (strcmp (arg
, "32") == 0)
999 else if (strcmp (arg
, "regnames") == 0)
1002 else if (strcmp (arg
, "no-regnames") == 0)
1003 reg_names_p
= FALSE
;
1006 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1007 that require relocation. */
1008 else if (strcmp (arg
, "relocatable") == 0)
1010 shlib
= SHLIB_MRELOCATABLE
;
1011 ppc_flags
|= EF_PPC_RELOCATABLE
;
1014 else if (strcmp (arg
, "relocatable-lib") == 0)
1016 shlib
= SHLIB_MRELOCATABLE
;
1017 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
1020 /* -memb, set embedded bit. */
1021 else if (strcmp (arg
, "emb") == 0)
1022 ppc_flags
|= EF_PPC_EMB
;
1024 /* -mlittle/-mbig set the endianess. */
1025 else if (strcmp (arg
, "little") == 0
1026 || strcmp (arg
, "little-endian") == 0)
1028 target_big_endian
= 0;
1029 set_target_endian
= 1;
1032 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1034 target_big_endian
= 1;
1035 set_target_endian
= 1;
1038 else if (strcmp (arg
, "solaris") == 0)
1041 ppc_comment_chars
= ppc_solaris_comment_chars
;
1044 else if (strcmp (arg
, "no-solaris") == 0)
1047 ppc_comment_chars
= ppc_eabi_comment_chars
;
1052 as_bad (_("invalid switch -m%s"), arg
);
1058 /* -V: SVR4 argument to print version ID. */
1060 print_version_id ();
1063 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1064 should be emitted or not. FIXME: Not implemented. */
1068 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1069 rather than .stabs.excl, which is ignored by the linker.
1070 FIXME: Not implemented. */
1086 md_show_usage (stream
)
1089 fprintf (stream
, _("\
1091 -a32 generate ELF32/XCOFF32\n\
1092 -a64 generate ELF64/XCOFF64\n\
1094 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1095 -mpwr generate code for POWER (RIOS1)\n\
1096 -m601 generate code for PowerPC 601\n\
1097 -mppc, -mppc32, -m603, -m604\n\
1098 generate code for PowerPC 603/604\n\
1099 -m403, -m405 generate code for PowerPC 403/405\n\
1100 -m440 generate code for PowerPC 440\n\
1101 -m7400, -m7410, -m7450, -m7455\n\
1102 generate code For PowerPC 7400/7410/7450/7455\n"));
1103 fprintf (stream
, _("\
1104 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1105 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1106 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1107 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1108 -mpower4 generate code for Power4 architecture\n\
1109 -mpower5 generate code for Power5 architecture\n\
1110 -mcom generate code Power/PowerPC common instructions\n\
1111 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1112 fprintf (stream
, _("\
1113 -maltivec generate code for AltiVec\n\
1114 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1115 -mspe generate code for Motorola SPE instructions\n\
1116 -mregnames Allow symbolic names for registers\n\
1117 -mno-regnames Do not allow symbolic names for registers\n"));
1119 fprintf (stream
, _("\
1120 -mrelocatable support for GCC's -mrelocatble option\n\
1121 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1122 -memb set PPC_EMB bit in ELF flags\n\
1123 -mlittle, -mlittle-endian, -l, -le\n\
1124 generate code for a little endian machine\n\
1125 -mbig, -mbig-endian, -b, -be\n\
1126 generate code for a big endian machine\n\
1127 -msolaris generate code for Solaris\n\
1128 -mno-solaris do not generate code for Solaris\n\
1129 -V print assembler version number\n\
1130 -Qy, -Qn ignored\n"));
1134 /* Set ppc_cpu if it is not already set. */
1139 const char *default_os
= TARGET_OS
;
1140 const char *default_cpu
= TARGET_CPU
;
1142 if ((ppc_cpu
& ~PPC_OPCODE_ANY
) == 0)
1145 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1146 else if (strncmp (default_os
, "aix", 3) == 0
1147 && default_os
[3] >= '4' && default_os
[3] <= '9')
1148 ppc_cpu
|= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1149 else if (strncmp (default_os
, "aix3", 4) == 0)
1150 ppc_cpu
|= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1151 else if (strcmp (default_cpu
, "rs6000") == 0)
1152 ppc_cpu
|= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1153 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1155 if (default_cpu
[7] == '6' && default_cpu
[8] == '4')
1156 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1158 ppc_cpu
|= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
1161 as_fatal (_("Unknown default cpu = %s, os = %s"),
1162 default_cpu
, default_os
);
1166 /* Figure out the BFD architecture to use. This function and ppc_mach
1167 are called well before md_begin, when the output file is opened. */
1169 enum bfd_architecture
1172 const char *default_cpu
= TARGET_CPU
;
1175 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1176 return bfd_arch_powerpc
;
1177 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1178 return bfd_arch_rs6000
;
1179 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1181 if (strcmp (default_cpu
, "rs6000") == 0)
1182 return bfd_arch_rs6000
;
1183 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1184 return bfd_arch_powerpc
;
1187 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1188 return bfd_arch_unknown
;
1195 return bfd_mach_ppc64
;
1196 else if (ppc_arch () == bfd_arch_rs6000
)
1197 return bfd_mach_rs6k
;
1199 return bfd_mach_ppc
;
1203 ppc_target_format ()
1207 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1209 return "xcoff-powermac";
1212 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1214 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1219 return (target_big_endian
1220 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1221 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1225 /* Insert opcodes and macros into hash tables. Called at startup and
1229 ppc_setup_opcodes (void)
1231 register const struct powerpc_opcode
*op
;
1232 const struct powerpc_opcode
*op_end
;
1233 const struct powerpc_macro
*macro
;
1234 const struct powerpc_macro
*macro_end
;
1235 bfd_boolean dup_insn
= FALSE
;
1237 if (ppc_hash
!= NULL
)
1238 hash_die (ppc_hash
);
1239 if (ppc_macro_hash
!= NULL
)
1240 hash_die (ppc_macro_hash
);
1242 /* Insert the opcodes into a hash table. */
1243 ppc_hash
= hash_new ();
1245 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1246 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1248 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1250 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1251 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1252 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1253 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1254 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1255 /* Certain instructions (eg: extsw) do not exist in the
1256 32-bit BookE instruction set, but they do exist in the
1257 64-bit BookE instruction set, and other PPC instruction
1258 sets. Check to see if the opcode has the BOOKE64 flag set.
1259 If it does make sure that the target CPU is not the BookE32. */
1260 && ((op
->flags
& PPC_OPCODE_BOOKE64
) == 0
1261 || (ppc_cpu
& PPC_OPCODE_BOOKE64
) == PPC_OPCODE_BOOKE64
1262 || (ppc_cpu
& PPC_OPCODE_BOOKE
) == 0)
1263 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1264 || ((op
->flags
& PPC_OPCODE_POWER4
)
1265 == (ppc_cpu
& PPC_OPCODE_POWER4
)))
1266 && ((op
->flags
& PPC_OPCODE_POWER5
) == 0
1267 || ((op
->flags
& PPC_OPCODE_POWER5
)
1268 == (ppc_cpu
& PPC_OPCODE_POWER5
))))
1272 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1275 /* Ignore Power duplicates for -m601. */
1276 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1277 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1280 as_bad (_("Internal assembler error for instruction %s"),
1287 if ((ppc_cpu
& PPC_OPCODE_ANY
) != 0)
1288 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1289 hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1291 /* Insert the macros into a hash table. */
1292 ppc_macro_hash
= hash_new ();
1294 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1295 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1297 if ((macro
->flags
& ppc_cpu
) != 0)
1301 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1302 if (retval
!= (const char *) NULL
)
1304 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1314 /* This function is called when the assembler starts up. It is called
1315 after the options have been parsed and the output file has been
1323 ppc_cie_data_alignment
= ppc_obj64
? -8 : -4;
1326 /* Set the ELF flags if desired. */
1327 if (ppc_flags
&& !msolaris
)
1328 bfd_set_private_flags (stdoutput
, ppc_flags
);
1331 ppc_setup_opcodes ();
1333 /* Tell the main code what the endianness is if it is not overridden
1335 if (!set_target_endian
)
1337 set_target_endian
= 1;
1338 target_big_endian
= PPC_BIG_ENDIAN
;
1342 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1344 /* Create dummy symbols to serve as initial csects. This forces the
1345 text csects to precede the data csects. These symbols will not
1347 ppc_text_csects
= symbol_make ("dummy\001");
1348 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1349 ppc_data_csects
= symbol_make ("dummy\001");
1350 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1355 ppc_current_section
= text_section
;
1356 ppc_previous_section
= 0;
1365 if (ppc_apuinfo_list
== NULL
)
1368 /* Ok, so write the section info out. We have this layout:
1372 0 8 length of "APUinfo\0"
1373 4 (n*4) number of APU's (4 bytes each)
1376 20 APU#1 first APU's info
1377 24 APU#2 second APU's info
1382 asection
*seg
= now_seg
;
1383 subsegT subseg
= now_subseg
;
1384 asection
*apuinfo_secp
= (asection
*) NULL
;
1387 /* Create the .PPC.EMB.apuinfo section. */
1388 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1389 bfd_set_section_flags (stdoutput
,
1391 SEC_HAS_CONTENTS
| SEC_READONLY
);
1394 md_number_to_chars (p
, (valueT
) 8, 4);
1397 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
* 4, 4);
1400 md_number_to_chars (p
, (valueT
) 2, 4);
1403 strcpy (p
, "APUinfo");
1405 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1408 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1411 frag_align (2, 0, 0);
1413 /* We probably can't restore the current segment, for there likely
1416 subseg_set (seg
, subseg
);
1421 /* Insert an operand value into an instruction. */
1423 static unsigned long
1424 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1426 const struct powerpc_operand
*operand
;
1431 if (operand
->bits
!= 32)
1436 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1438 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1439 max
= (1 << operand
->bits
) - 1;
1441 max
= (1 << (operand
->bits
- 1)) - 1;
1442 min
= - (1 << (operand
->bits
- 1));
1446 /* Some people write 32 bit hex constants with the sign
1447 extension done by hand. This shouldn't really be
1448 valid, but, to permit this code to assemble on a 64
1449 bit host, we sign extend the 32 bit value. */
1451 && (val
& (offsetT
) 0x80000000) != 0
1452 && (val
& (offsetT
) 0xffffffff) == val
)
1461 max
= (1 << operand
->bits
) - 1;
1465 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1470 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1471 as_bad_value_out_of_range (_("operand"), test
, (offsetT
) min
, (offsetT
) max
, file
, line
);
1474 if (operand
->insert
)
1479 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1480 if (errmsg
!= (const char *) NULL
)
1481 as_bad_where (file
, line
, errmsg
);
1484 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1492 /* Parse @got, etc. and return the desired relocation. */
1493 static bfd_reloc_code_real_type
1494 ppc_elf_suffix (str_p
, exp_p
)
1500 unsigned int length
: 8;
1501 unsigned int valid32
: 1;
1502 unsigned int valid64
: 1;
1511 const struct map_bfd
*ptr
;
1513 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1514 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1515 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1517 static const struct map_bfd mapping
[] = {
1518 MAP ("l", BFD_RELOC_LO16
),
1519 MAP ("h", BFD_RELOC_HI16
),
1520 MAP ("ha", BFD_RELOC_HI16_S
),
1521 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1522 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1523 MAP ("got", BFD_RELOC_16_GOTOFF
),
1524 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1525 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1526 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1527 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1528 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1529 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1530 MAP ("copy", BFD_RELOC_PPC_COPY
),
1531 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1532 MAP ("sectoff", BFD_RELOC_16_BASEREL
),
1533 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1534 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1535 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1536 MAP ("tls", BFD_RELOC_PPC_TLS
),
1537 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD
),
1538 MAP ("dtprel", BFD_RELOC_PPC_DTPREL
),
1539 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO
),
1540 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI
),
1541 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA
),
1542 MAP ("tprel", BFD_RELOC_PPC_TPREL
),
1543 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO
),
1544 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI
),
1545 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA
),
1546 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16
),
1547 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1548 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1549 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1550 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16
),
1551 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1552 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1553 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1554 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16
),
1555 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1556 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1557 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1558 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16
),
1559 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO
),
1560 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI
),
1561 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA
),
1562 MAP32 ("fixup", BFD_RELOC_CTOR
),
1563 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL
),
1564 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1565 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1566 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC
),
1567 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1568 MAP32 ("sdarel", BFD_RELOC_GPREL16
),
1569 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1570 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1571 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1572 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1573 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1574 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1575 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1576 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1577 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1578 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1579 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1580 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1581 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1582 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1583 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1584 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1585 MAP32 ("xgot", BFD_RELOC_PPC_TOC16
),
1586 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER
),
1587 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1588 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST
),
1589 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1590 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC
),
1591 MAP64 ("toc", BFD_RELOC_PPC_TOC16
),
1592 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1593 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1594 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1595 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1596 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1597 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1598 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1599 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER
),
1600 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1601 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1602 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1603 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED
}
1607 return BFD_RELOC_UNUSED
;
1609 for (ch
= *str
, str2
= ident
;
1610 (str2
< ident
+ sizeof (ident
) - 1
1611 && (ISALNUM (ch
) || ch
== '@'));
1614 *str2
++ = TOLOWER (ch
);
1621 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1622 if (ch
== ptr
->string
[0]
1623 && len
== ptr
->length
1624 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0
1625 && (ppc_obj64
? ptr
->valid64
: ptr
->valid32
))
1627 int reloc
= ptr
->reloc
;
1630 if (exp_p
->X_add_number
!= 0
1631 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1632 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1633 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1634 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1635 as_warn (_("identifier+constant@got means identifier@got+constant"));
1637 /* Now check for identifier@suffix+constant. */
1638 if (*str
== '-' || *str
== '+')
1640 char *orig_line
= input_line_pointer
;
1641 expressionS new_exp
;
1643 input_line_pointer
= str
;
1644 expression (&new_exp
);
1645 if (new_exp
.X_op
== O_constant
)
1647 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1648 str
= input_line_pointer
;
1651 if (&input_line_pointer
!= str_p
)
1652 input_line_pointer
= orig_line
;
1656 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1657 && exp_p
->X_op
== O_symbol
1658 && strcmp (S_GET_NAME (exp_p
->X_add_symbol
), ".TOC.") == 0)
1660 /* Change the symbol so that the dummy .TOC. symbol can be
1661 omitted from the object file. */
1662 exp_p
->X_add_symbol
= &abs_symbol
;
1665 return (bfd_reloc_code_real_type
) reloc
;
1668 return BFD_RELOC_UNUSED
;
1671 /* Like normal .long/.short/.word, except support @got, etc.
1672 Clobbers input_line_pointer, checks end-of-line. */
1674 ppc_elf_cons (nbytes
)
1675 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1678 bfd_reloc_code_real_type reloc
;
1680 if (is_it_end_of_statement ())
1682 demand_empty_rest_of_line ();
1689 if (exp
.X_op
== O_symbol
1690 && *input_line_pointer
== '@'
1691 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1692 &exp
)) != BFD_RELOC_UNUSED
)
1694 reloc_howto_type
*reloc_howto
;
1697 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1698 size
= bfd_get_reloc_size (reloc_howto
);
1702 as_bad (_("%s relocations do not fit in %d bytes\n"),
1703 reloc_howto
->name
, nbytes
);
1710 p
= frag_more (nbytes
);
1712 if (target_big_endian
)
1713 offset
= nbytes
- size
;
1714 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1719 emit_expr (&exp
, (unsigned int) nbytes
);
1721 while (*input_line_pointer
++ == ',');
1723 /* Put terminator back into stream. */
1724 input_line_pointer
--;
1725 demand_empty_rest_of_line ();
1728 /* Solaris pseduo op to change to the .rodata section. */
1733 char *save_line
= input_line_pointer
;
1734 static char section
[] = ".rodata\n";
1736 /* Just pretend this is .section .rodata */
1737 input_line_pointer
= section
;
1738 obj_elf_section (xxx
);
1740 input_line_pointer
= save_line
;
1743 /* Pseudo op to make file scope bss items. */
1746 int xxx ATTRIBUTE_UNUSED
;
1748 register char *name
;
1752 register symbolS
*symbolP
;
1759 name
= input_line_pointer
;
1760 c
= get_symbol_end ();
1762 /* just after name is now '\0'. */
1763 p
= input_line_pointer
;
1766 if (*input_line_pointer
!= ',')
1768 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1769 ignore_rest_of_line ();
1773 input_line_pointer
++; /* skip ',' */
1774 if ((size
= get_absolute_expression ()) < 0)
1776 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1777 ignore_rest_of_line ();
1781 /* The third argument to .lcomm is the alignment. */
1782 if (*input_line_pointer
!= ',')
1786 ++input_line_pointer
;
1787 align
= get_absolute_expression ();
1790 as_warn (_("ignoring bad alignment"));
1796 symbolP
= symbol_find_or_make (name
);
1799 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1801 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1802 S_GET_NAME (symbolP
));
1803 ignore_rest_of_line ();
1807 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1809 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1810 S_GET_NAME (symbolP
),
1811 (long) S_GET_VALUE (symbolP
),
1814 ignore_rest_of_line ();
1820 old_subsec
= now_subseg
;
1823 /* Convert to a power of 2 alignment. */
1824 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1827 as_bad (_("Common alignment not a power of 2"));
1828 ignore_rest_of_line ();
1835 record_alignment (bss_section
, align2
);
1836 subseg_set (bss_section
, 0);
1838 frag_align (align2
, 0, 0);
1839 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1840 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1841 symbol_set_frag (symbolP
, frag_now
);
1842 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1845 S_SET_SIZE (symbolP
, size
);
1846 S_SET_SEGMENT (symbolP
, bss_section
);
1847 subseg_set (old_sec
, old_subsec
);
1848 demand_empty_rest_of_line ();
1851 /* Validate any relocations emitted for -mrelocatable, possibly adding
1852 fixups for word relocations in writable segments, so we can adjust
1855 ppc_elf_validate_fix (fixp
, seg
)
1859 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1868 case SHLIB_MRELOCATABLE
:
1869 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1870 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1871 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1872 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1873 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1874 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1875 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1876 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1877 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1878 && (seg
->flags
& SEC_LOAD
) != 0
1879 && strcmp (segment_name (seg
), ".got2") != 0
1880 && strcmp (segment_name (seg
), ".dtors") != 0
1881 && strcmp (segment_name (seg
), ".ctors") != 0
1882 && strcmp (segment_name (seg
), ".fixup") != 0
1883 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1884 && strcmp (segment_name (seg
), ".eh_frame") != 0
1885 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1887 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1888 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1890 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1891 _("Relocation cannot be done when using -mrelocatable"));
1898 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1899 function descriptor sym if the corresponding code sym is used. */
1902 ppc_frob_file_before_adjust ()
1910 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1917 name
= S_GET_NAME (symp
);
1921 if (! S_IS_WEAK (symp
)
1922 || S_IS_DEFINED (symp
))
1925 len
= strlen (name
) + 1;
1926 dotname
= xmalloc (len
+ 1);
1928 memcpy (dotname
+ 1, name
, len
);
1929 dotsym
= symbol_find (dotname
);
1931 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1932 || symbol_used_in_reloc_p (dotsym
)))
1933 symbol_mark_used (symp
);
1937 toc
= bfd_get_section_by_name (stdoutput
, ".toc");
1939 && bfd_section_size (stdoutput
, toc
) > 0x10000)
1940 as_warn (_("TOC section size exceeds 64k"));
1942 /* Don't emit .TOC. symbol. */
1943 symp
= symbol_find (".TOC.");
1945 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1947 #endif /* OBJ_ELF */
1952 * Summary of parse_toc_entry.
1954 * in: Input_line_pointer points to the '[' in one of:
1956 * [toc] [tocv] [toc32] [toc64]
1958 * Anything else is an error of one kind or another.
1961 * return value: success or failure
1962 * toc_kind: kind of toc reference
1963 * input_line_pointer:
1964 * success: first char after the ']'
1965 * failure: unchanged
1969 * [toc] - rv == success, toc_kind = default_toc
1970 * [tocv] - rv == success, toc_kind = data_in_toc
1971 * [toc32] - rv == success, toc_kind = must_be_32
1972 * [toc64] - rv == success, toc_kind = must_be_64
1976 enum toc_size_qualifier
1978 default_toc
, /* The toc cell constructed should be the system default size */
1979 data_in_toc
, /* This is a direct reference to a toc cell */
1980 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1981 must_be_64
/* The toc cell constructed must be 64 bits wide */
1985 parse_toc_entry (toc_kind
)
1986 enum toc_size_qualifier
*toc_kind
;
1991 enum toc_size_qualifier t
;
1993 /* Save the input_line_pointer. */
1994 start
= input_line_pointer
;
1996 /* Skip over the '[' , and whitespace. */
1997 ++input_line_pointer
;
2000 /* Find the spelling of the operand. */
2001 toc_spec
= input_line_pointer
;
2002 c
= get_symbol_end ();
2004 if (strcmp (toc_spec
, "toc") == 0)
2008 else if (strcmp (toc_spec
, "tocv") == 0)
2012 else if (strcmp (toc_spec
, "toc32") == 0)
2016 else if (strcmp (toc_spec
, "toc64") == 0)
2022 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
2023 *input_line_pointer
= c
;
2024 input_line_pointer
= start
;
2028 /* Now find the ']'. */
2029 *input_line_pointer
= c
;
2031 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2032 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
2036 as_bad (_("syntax error: expected `]', found `%c'"), c
);
2037 input_line_pointer
= start
;
2048 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2050 ppc_apuinfo_section_add (apu
, version
)
2051 unsigned int apu
, version
;
2055 /* Check we don't already exist. */
2056 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2057 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2060 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2062 if (ppc_apuinfo_num_alloc
== 0)
2064 ppc_apuinfo_num_alloc
= 4;
2065 ppc_apuinfo_list
= (unsigned long *)
2066 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2070 ppc_apuinfo_num_alloc
+= 4;
2071 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2072 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2075 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2081 /* We need to keep a list of fixups. We can't simply generate them as
2082 we go, because that would require us to first create the frag, and
2083 that would screw up references to ``.''. */
2089 bfd_reloc_code_real_type reloc
;
2092 #define MAX_INSN_FIXUPS (5)
2094 /* This routine is called for each instruction to be assembled. */
2101 const struct powerpc_opcode
*opcode
;
2103 const unsigned char *opindex_ptr
;
2107 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2113 bfd_reloc_code_real_type reloc
;
2116 /* Get the opcode. */
2117 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2122 /* Look up the opcode in the hash table. */
2123 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2124 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2126 const struct powerpc_macro
*macro
;
2128 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2129 if (macro
== (const struct powerpc_macro
*) NULL
)
2130 as_bad (_("Unrecognized opcode: `%s'"), str
);
2132 ppc_macro (s
, macro
);
2137 insn
= opcode
->opcode
;
2140 while (ISSPACE (*str
))
2143 /* PowerPC operands are just expressions. The only real issue is
2144 that a few operand types are optional. All cases which might use
2145 an optional operand separate the operands only with commas (in some
2146 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2147 have optional operands). Most instructions with optional operands
2148 have only one. Those that have more than one optional operand can
2149 take either all their operands or none. So, before we start seriously
2150 parsing the operands, we check to see if we have optional operands,
2151 and if we do, we count the number of commas to see which operands
2152 have been omitted. */
2154 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2156 const struct powerpc_operand
*operand
;
2158 operand
= &powerpc_operands
[*opindex_ptr
];
2159 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2161 unsigned int opcount
;
2162 unsigned int num_operands_expected
;
2165 /* There is an optional operand. Count the number of
2166 commas in the input line. */
2173 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2180 /* Compute the number of expected operands.
2181 Do not count fake operands. */
2182 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2183 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2184 ++ num_operands_expected
;
2186 /* If there are fewer operands in the line then are called
2187 for by the instruction, we want to skip the optional
2189 if (opcount
< num_operands_expected
)
2196 /* Gather the operands. */
2200 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2202 const struct powerpc_operand
*operand
;
2208 if (next_opindex
== 0)
2209 operand
= &powerpc_operands
[*opindex_ptr
];
2212 operand
= &powerpc_operands
[next_opindex
];
2217 /* If this is a fake operand, then we do not expect anything
2219 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2221 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2222 if (errmsg
!= (const char *) NULL
)
2227 /* If this is an optional operand, and we are skipping it, just
2229 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2232 if (operand
->insert
)
2234 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2235 if (errmsg
!= (const char *) NULL
)
2238 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2239 next_opindex
= *opindex_ptr
+ 1;
2243 /* Gather the operand. */
2244 hold
= input_line_pointer
;
2245 input_line_pointer
= str
;
2248 if (*input_line_pointer
== '[')
2250 /* We are expecting something like the second argument here:
2252 * lwz r4,[toc].GS.0.static_int(rtoc)
2253 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2254 * The argument following the `]' must be a symbol name, and the
2255 * register must be the toc register: 'rtoc' or '2'
2257 * The effect is to 0 as the displacement field
2258 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2259 * the appropriate variation) reloc against it based on the symbol.
2260 * The linker will build the toc, and insert the resolved toc offset.
2263 * o The size of the toc entry is currently assumed to be
2264 * 32 bits. This should not be assumed to be a hard coded
2266 * o In an effort to cope with a change from 32 to 64 bits,
2267 * there are also toc entries that are specified to be
2268 * either 32 or 64 bits:
2269 * lwz r4,[toc32].GS.0.static_int(rtoc)
2270 * lwz r4,[toc64].GS.0.static_int(rtoc)
2271 * These demand toc entries of the specified size, and the
2272 * instruction probably requires it.
2276 enum toc_size_qualifier toc_kind
;
2277 bfd_reloc_code_real_type toc_reloc
;
2279 /* Go parse off the [tocXX] part. */
2280 valid_toc
= parse_toc_entry (&toc_kind
);
2284 /* Note: message has already been issued.
2285 FIXME: what sort of recovery should we do?
2286 demand_rest_of_line (); return; ? */
2289 /* Now get the symbol following the ']'. */
2295 /* In this case, we may not have seen the symbol yet,
2296 since it is allowed to appear on a .extern or .globl
2297 or just be a label in the .data section. */
2298 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2301 /* 1. The symbol must be defined and either in the toc
2302 section, or a global.
2303 2. The reloc generated must have the TOCDEFN flag set
2304 in upper bit mess of the reloc type.
2305 FIXME: It's a little confusing what the tocv
2306 qualifier can be used for. At the very least, I've
2307 seen three uses, only one of which I'm sure I can
2309 if (ex
.X_op
== O_symbol
)
2311 assert (ex
.X_add_symbol
!= NULL
);
2312 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2315 as_bad (_("[tocv] symbol is not a toc symbol"));
2319 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2322 /* FIXME: these next two specifically specify 32/64 bit
2323 toc entries. We don't support them today. Is this
2324 the right way to say that? */
2325 toc_reloc
= BFD_RELOC_UNUSED
;
2326 as_bad (_("Unimplemented toc32 expression modifier"));
2329 /* FIXME: see above. */
2330 toc_reloc
= BFD_RELOC_UNUSED
;
2331 as_bad (_("Unimplemented toc64 expression modifier"));
2335 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2341 /* We need to generate a fixup for this expression. */
2342 if (fc
>= MAX_INSN_FIXUPS
)
2343 as_fatal (_("too many fixups"));
2345 fixups
[fc
].reloc
= toc_reloc
;
2346 fixups
[fc
].exp
= ex
;
2347 fixups
[fc
].opindex
= *opindex_ptr
;
2350 /* Ok. We've set up the fixup for the instruction. Now make it
2351 look like the constant 0 was found here. */
2353 ex
.X_op
= O_constant
;
2354 ex
.X_add_number
= 0;
2355 ex
.X_add_symbol
= NULL
;
2356 ex
.X_op_symbol
= NULL
;
2362 if (! register_name (&ex
))
2364 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2371 str
= input_line_pointer
;
2372 input_line_pointer
= hold
;
2374 if (ex
.X_op
== O_illegal
)
2375 as_bad (_("illegal operand"));
2376 else if (ex
.X_op
== O_absent
)
2377 as_bad (_("missing operand"));
2378 else if (ex
.X_op
== O_register
)
2380 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2383 else if (ex
.X_op
== O_constant
)
2386 /* Allow @HA, @L, @H on constants. */
2387 char *orig_str
= str
;
2389 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2396 case BFD_RELOC_LO16
:
2397 /* X_unsigned is the default, so if the user has done
2398 something which cleared it, we always produce a
2400 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2401 ex
.X_add_number
&= 0xffff;
2403 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2406 case BFD_RELOC_HI16
:
2407 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2408 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2410 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2413 case BFD_RELOC_HI16_S
:
2414 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2415 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2417 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2420 case BFD_RELOC_PPC64_HIGHER
:
2421 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2422 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2424 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2427 case BFD_RELOC_PPC64_HIGHER_S
:
2428 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2429 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2431 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2434 case BFD_RELOC_PPC64_HIGHEST
:
2435 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2436 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2438 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2441 case BFD_RELOC_PPC64_HIGHEST_S
:
2442 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2443 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2445 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2448 #endif /* OBJ_ELF */
2449 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2453 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2455 /* Some TLS tweaks. */
2460 case BFD_RELOC_PPC_TLS
:
2461 insn
= ppc_insert_operand (insn
, operand
, ppc_obj64
? 13 : 2,
2464 /* We'll only use the 32 (or 64) bit form of these relocations
2465 in constants. Instructions get the 16 bit form. */
2466 case BFD_RELOC_PPC_DTPREL
:
2467 reloc
= BFD_RELOC_PPC_DTPREL16
;
2469 case BFD_RELOC_PPC_TPREL
:
2470 reloc
= BFD_RELOC_PPC_TPREL16
;
2474 /* For the absolute forms of branches, convert the PC
2475 relative form back into the absolute. */
2476 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2480 case BFD_RELOC_PPC_B26
:
2481 reloc
= BFD_RELOC_PPC_BA26
;
2483 case BFD_RELOC_PPC_B16
:
2484 reloc
= BFD_RELOC_PPC_BA16
;
2486 case BFD_RELOC_PPC_B16_BRTAKEN
:
2487 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2489 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2490 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2498 && (operand
->flags
& (PPC_OPERAND_DS
| PPC_OPERAND_DQ
)) != 0)
2503 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2505 case BFD_RELOC_LO16
:
2506 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2508 case BFD_RELOC_16_GOTOFF
:
2509 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2511 case BFD_RELOC_LO16_GOTOFF
:
2512 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2514 case BFD_RELOC_LO16_PLTOFF
:
2515 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2517 case BFD_RELOC_16_BASEREL
:
2518 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2520 case BFD_RELOC_LO16_BASEREL
:
2521 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2523 case BFD_RELOC_PPC_TOC16
:
2524 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2526 case BFD_RELOC_PPC64_TOC16_LO
:
2527 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2529 case BFD_RELOC_PPC64_PLTGOT16
:
2530 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2532 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2533 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2535 case BFD_RELOC_PPC_DTPREL16
:
2536 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2538 case BFD_RELOC_PPC_DTPREL16_LO
:
2539 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2541 case BFD_RELOC_PPC_TPREL16
:
2542 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2544 case BFD_RELOC_PPC_TPREL16_LO
:
2545 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2547 case BFD_RELOC_PPC_GOT_DTPREL16
:
2548 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2549 case BFD_RELOC_PPC_GOT_TPREL16
:
2550 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2553 as_bad (_("unsupported relocation for DS offset field"));
2558 /* We need to generate a fixup for this expression. */
2559 if (fc
>= MAX_INSN_FIXUPS
)
2560 as_fatal (_("too many fixups"));
2561 fixups
[fc
].exp
= ex
;
2562 fixups
[fc
].opindex
= 0;
2563 fixups
[fc
].reloc
= reloc
;
2566 #endif /* OBJ_ELF */
2570 /* We need to generate a fixup for this expression. */
2571 if (fc
>= MAX_INSN_FIXUPS
)
2572 as_fatal (_("too many fixups"));
2573 fixups
[fc
].exp
= ex
;
2574 fixups
[fc
].opindex
= *opindex_ptr
;
2575 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2584 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2592 /* The call to expression should have advanced str past any
2595 && (endc
!= ',' || *str
!= '\0'))
2597 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2605 while (ISSPACE (*str
))
2609 as_bad (_("junk at end of line: `%s'"), str
);
2612 /* Do we need/want a APUinfo section? */
2613 if (ppc_cpu
& (PPC_OPCODE_SPE
2614 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
2615 | PPC_OPCODE_BRLOCK
| PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
2616 | PPC_OPCODE_RFMCI
))
2618 /* These are all version "1". */
2619 if (opcode
->flags
& PPC_OPCODE_SPE
)
2620 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2621 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2622 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2623 if (opcode
->flags
& PPC_OPCODE_EFS
)
2624 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2625 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2626 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2627 if (opcode
->flags
& PPC_OPCODE_PMR
)
2628 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2629 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2630 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2631 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2632 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2636 /* Write out the instruction. */
2638 addr_mod
= frag_now_fix () & 3;
2639 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
2640 as_bad (_("instruction address is not a multiple of 4"));
2641 frag_now
->insn_addr
= addr_mod
;
2642 frag_now
->has_code
= 1;
2643 md_number_to_chars (f
, insn
, 4);
2646 dwarf2_emit_insn (4);
2649 /* Create any fixups. At this point we do not use a
2650 bfd_reloc_code_real_type, but instead just use the
2651 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2652 handle fixups for any operand type, although that is admittedly
2653 not a very exciting feature. We pick a BFD reloc type in
2655 for (i
= 0; i
< fc
; i
++)
2657 const struct powerpc_operand
*operand
;
2659 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2660 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2662 reloc_howto_type
*reloc_howto
;
2667 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2671 size
= bfd_get_reloc_size (reloc_howto
);
2672 offset
= target_big_endian
? (4 - size
) : 0;
2674 if (size
< 1 || size
> 4)
2677 fixP
= fix_new_exp (frag_now
,
2678 f
- frag_now
->fr_literal
+ offset
,
2681 reloc_howto
->pc_relative
,
2684 /* Turn off complaints that the addend is too large for things like
2686 switch (fixups
[i
].reloc
)
2688 case BFD_RELOC_16_GOTOFF
:
2689 case BFD_RELOC_PPC_TOC16
:
2690 case BFD_RELOC_LO16
:
2691 case BFD_RELOC_HI16
:
2692 case BFD_RELOC_HI16_S
:
2694 case BFD_RELOC_PPC64_HIGHER
:
2695 case BFD_RELOC_PPC64_HIGHER_S
:
2696 case BFD_RELOC_PPC64_HIGHEST
:
2697 case BFD_RELOC_PPC64_HIGHEST_S
:
2699 fixP
->fx_no_overflow
= 1;
2706 fix_new_exp (frag_now
,
2707 f
- frag_now
->fr_literal
,
2710 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2711 ((bfd_reloc_code_real_type
)
2712 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2716 /* Handle a macro. Gather all the operands, transform them as
2717 described by the macro, and call md_assemble recursively. All the
2718 operands are separated by commas; we don't accept parentheses
2719 around operands here. */
2722 ppc_macro (str
, macro
)
2724 const struct powerpc_macro
*macro
;
2735 /* Gather the users operands into the operands array. */
2740 if (count
>= sizeof operands
/ sizeof operands
[0])
2742 operands
[count
++] = s
;
2743 s
= strchr (s
, ',');
2744 if (s
== (char *) NULL
)
2749 if (count
!= macro
->operands
)
2751 as_bad (_("wrong number of operands"));
2755 /* Work out how large the string must be (the size is unbounded
2756 because it includes user input). */
2758 format
= macro
->format
;
2759 while (*format
!= '\0')
2768 arg
= strtol (format
+ 1, &send
, 10);
2769 know (send
!= format
&& arg
>= 0 && arg
< count
);
2770 len
+= strlen (operands
[arg
]);
2775 /* Put the string together. */
2776 complete
= s
= (char *) alloca (len
+ 1);
2777 format
= macro
->format
;
2778 while (*format
!= '\0')
2784 arg
= strtol (format
+ 1, &send
, 10);
2785 strcpy (s
, operands
[arg
]);
2792 /* Assemble the constructed instruction. */
2793 md_assemble (complete
);
2797 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2800 ppc_section_letter (letter
, ptr_msg
)
2807 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2812 ppc_section_word (str
, len
)
2816 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2823 ppc_section_type (str
, len
)
2827 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2834 ppc_section_flags (flags
, attr
, type
)
2839 if (type
== SHT_ORDERED
)
2840 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2842 if (attr
& SHF_EXCLUDE
)
2843 flags
|= SEC_EXCLUDE
;
2847 #endif /* OBJ_ELF */
2850 /* Pseudo-op handling. */
2852 /* The .byte pseudo-op. This is similar to the normal .byte
2853 pseudo-op, but it can also take a single ASCII string. */
2857 int ignore ATTRIBUTE_UNUSED
;
2859 if (*input_line_pointer
!= '\"')
2865 /* Gather characters. A real double quote is doubled. Unusual
2866 characters are not permitted. */
2867 ++input_line_pointer
;
2872 c
= *input_line_pointer
++;
2876 if (*input_line_pointer
!= '\"')
2878 ++input_line_pointer
;
2881 FRAG_APPEND_1_CHAR (c
);
2884 demand_empty_rest_of_line ();
2889 /* XCOFF specific pseudo-op handling. */
2891 /* This is set if we are creating a .stabx symbol, since we don't want
2892 to handle symbol suffixes for such symbols. */
2893 static bfd_boolean ppc_stab_symbol
;
2895 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2896 symbols in the .bss segment as though they were local common
2897 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
2898 aligns .comm and .lcomm to 4 bytes. */
2904 asection
*current_seg
= now_seg
;
2905 subsegT current_subseg
= now_subseg
;
2911 symbolS
*lcomm_sym
= NULL
;
2915 name
= input_line_pointer
;
2916 endc
= get_symbol_end ();
2917 end_name
= input_line_pointer
;
2920 if (*input_line_pointer
!= ',')
2922 as_bad (_("missing size"));
2923 ignore_rest_of_line ();
2926 ++input_line_pointer
;
2928 size
= get_absolute_expression ();
2931 as_bad (_("negative size"));
2932 ignore_rest_of_line ();
2938 /* The third argument to .comm is the alignment. */
2939 if (*input_line_pointer
!= ',')
2943 ++input_line_pointer
;
2944 align
= get_absolute_expression ();
2947 as_warn (_("ignoring bad alignment"));
2962 /* The third argument to .lcomm appears to be the real local
2963 common symbol to create. References to the symbol named in
2964 the first argument are turned into references to the third
2966 if (*input_line_pointer
!= ',')
2968 as_bad (_("missing real symbol name"));
2969 ignore_rest_of_line ();
2972 ++input_line_pointer
;
2974 lcomm_name
= input_line_pointer
;
2975 lcomm_endc
= get_symbol_end ();
2977 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2979 *input_line_pointer
= lcomm_endc
;
2983 sym
= symbol_find_or_make (name
);
2986 if (S_IS_DEFINED (sym
)
2987 || S_GET_VALUE (sym
) != 0)
2989 as_bad (_("attempt to redefine symbol"));
2990 ignore_rest_of_line ();
2994 record_alignment (bss_section
, align
);
2997 || ! S_IS_DEFINED (lcomm_sym
))
3006 S_SET_EXTERNAL (sym
);
3010 symbol_get_tc (lcomm_sym
)->output
= 1;
3011 def_sym
= lcomm_sym
;
3015 subseg_set (bss_section
, 1);
3016 frag_align (align
, 0, 0);
3018 symbol_set_frag (def_sym
, frag_now
);
3019 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
3020 def_size
, (char *) NULL
);
3022 S_SET_SEGMENT (def_sym
, bss_section
);
3023 symbol_get_tc (def_sym
)->align
= align
;
3027 /* Align the size of lcomm_sym. */
3028 symbol_get_frag (lcomm_sym
)->fr_offset
=
3029 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
3030 &~ ((1 << align
) - 1));
3031 if (align
> symbol_get_tc (lcomm_sym
)->align
)
3032 symbol_get_tc (lcomm_sym
)->align
= align
;
3037 /* Make sym an offset from lcomm_sym. */
3038 S_SET_SEGMENT (sym
, bss_section
);
3039 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
3040 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
3041 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
3044 subseg_set (current_seg
, current_subseg
);
3046 demand_empty_rest_of_line ();
3049 /* The .csect pseudo-op. This switches us into a different
3050 subsegment. The first argument is a symbol whose value is the
3051 start of the .csect. In COFF, csect symbols get special aux
3052 entries defined by the x_csect field of union internal_auxent. The
3053 optional second argument is the alignment (the default is 2). */
3057 int ignore ATTRIBUTE_UNUSED
;
3064 name
= input_line_pointer
;
3065 endc
= get_symbol_end ();
3067 sym
= symbol_find_or_make (name
);
3069 *input_line_pointer
= endc
;
3071 if (S_GET_NAME (sym
)[0] == '\0')
3073 /* An unnamed csect is assumed to be [PR]. */
3074 symbol_get_tc (sym
)->class = XMC_PR
;
3078 if (*input_line_pointer
== ',')
3080 ++input_line_pointer
;
3081 align
= get_absolute_expression ();
3084 ppc_change_csect (sym
, align
);
3086 demand_empty_rest_of_line ();
3089 /* Change to a different csect. */
3092 ppc_change_csect (sym
, align
)
3096 if (S_IS_DEFINED (sym
))
3097 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3107 /* This is a new csect. We need to look at the symbol class to
3108 figure out whether it should go in the text section or the
3112 switch (symbol_get_tc (sym
)->class)
3122 S_SET_SEGMENT (sym
, text_section
);
3123 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3124 ++ppc_text_subsegment
;
3125 list_ptr
= &ppc_text_csects
;
3135 if (ppc_toc_csect
!= NULL
3136 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3137 == ppc_data_subsegment
))
3139 S_SET_SEGMENT (sym
, data_section
);
3140 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3141 ++ppc_data_subsegment
;
3142 list_ptr
= &ppc_data_csects
;
3148 /* We set the obstack chunk size to a small value before
3149 changing subsegments, so that we don't use a lot of memory
3150 space for what may be a small section. */
3151 hold_chunksize
= chunksize
;
3154 sec
= subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3155 symbol_get_tc (sym
)->subseg
);
3157 chunksize
= hold_chunksize
;
3160 ppc_after_toc_frag
= frag_now
;
3162 record_alignment (sec
, align
);
3164 frag_align_code (align
, 0);
3166 frag_align (align
, 0, 0);
3168 symbol_set_frag (sym
, frag_now
);
3169 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3171 symbol_get_tc (sym
)->align
= align
;
3172 symbol_get_tc (sym
)->output
= 1;
3173 symbol_get_tc (sym
)->within
= sym
;
3175 for (list
= *list_ptr
;
3176 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3177 list
= symbol_get_tc (list
)->next
)
3179 symbol_get_tc (list
)->next
= sym
;
3181 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3182 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3186 ppc_current_csect
= sym
;
3189 /* This function handles the .text and .data pseudo-ops. These
3190 pseudo-ops aren't really used by XCOFF; we implement them for the
3191 convenience of people who aren't used to XCOFF. */
3202 else if (type
== 'd')
3207 sym
= symbol_find_or_make (name
);
3209 ppc_change_csect (sym
, 2);
3211 demand_empty_rest_of_line ();
3214 /* This function handles the .section pseudo-op. This is mostly to
3215 give an error, since XCOFF only supports .text, .data and .bss, but
3216 we do permit the user to name the text or data section. */
3219 ppc_named_section (ignore
)
3220 int ignore ATTRIBUTE_UNUSED
;
3223 const char *real_name
;
3227 user_name
= input_line_pointer
;
3228 c
= get_symbol_end ();
3230 if (strcmp (user_name
, ".text") == 0)
3231 real_name
= ".text[PR]";
3232 else if (strcmp (user_name
, ".data") == 0)
3233 real_name
= ".data[RW]";
3236 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3237 *input_line_pointer
= c
;
3238 ignore_rest_of_line ();
3242 *input_line_pointer
= c
;
3244 sym
= symbol_find_or_make (real_name
);
3246 ppc_change_csect (sym
, 2);
3248 demand_empty_rest_of_line ();
3251 /* The .extern pseudo-op. We create an undefined symbol. */
3255 int ignore ATTRIBUTE_UNUSED
;
3260 name
= input_line_pointer
;
3261 endc
= get_symbol_end ();
3263 (void) symbol_find_or_make (name
);
3265 *input_line_pointer
= endc
;
3267 demand_empty_rest_of_line ();
3270 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3274 int ignore ATTRIBUTE_UNUSED
;
3280 name
= input_line_pointer
;
3281 endc
= get_symbol_end ();
3283 sym
= symbol_find_or_make (name
);
3285 *input_line_pointer
= endc
;
3287 symbol_get_tc (sym
)->output
= 1;
3289 demand_empty_rest_of_line ();
3292 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3293 although I don't know why it bothers. */
3297 int ignore ATTRIBUTE_UNUSED
;
3304 name
= input_line_pointer
;
3305 endc
= get_symbol_end ();
3307 sym
= symbol_find_or_make (name
);
3309 *input_line_pointer
= endc
;
3311 if (*input_line_pointer
!= ',')
3313 as_bad (_("missing rename string"));
3314 ignore_rest_of_line ();
3317 ++input_line_pointer
;
3319 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3321 demand_empty_rest_of_line ();
3324 /* The .stabx pseudo-op. This is similar to a normal .stabs
3325 pseudo-op, but slightly different. A sample is
3326 .stabx "main:F-1",.main,142,0
3327 The first argument is the symbol name to create. The second is the
3328 value, and the third is the storage class. The fourth seems to be
3329 always zero, and I am assuming it is the type. */
3333 int ignore ATTRIBUTE_UNUSED
;
3340 name
= demand_copy_C_string (&len
);
3342 if (*input_line_pointer
!= ',')
3344 as_bad (_("missing value"));
3347 ++input_line_pointer
;
3349 ppc_stab_symbol
= TRUE
;
3350 sym
= symbol_make (name
);
3351 ppc_stab_symbol
= FALSE
;
3353 symbol_get_tc (sym
)->real_name
= name
;
3355 (void) expression (&exp
);
3362 as_bad (_("illegal .stabx expression; zero assumed"));
3363 exp
.X_add_number
= 0;
3366 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3367 symbol_set_frag (sym
, &zero_address_frag
);
3371 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3372 symbol_set_value_expression (sym
, &exp
);
3376 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3377 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3382 /* The value is some complex expression. This will probably
3383 fail at some later point, but this is probably the right
3384 thing to do here. */
3385 symbol_set_value_expression (sym
, &exp
);
3389 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3390 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3392 if (*input_line_pointer
!= ',')
3394 as_bad (_("missing class"));
3397 ++input_line_pointer
;
3399 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3401 if (*input_line_pointer
!= ',')
3403 as_bad (_("missing type"));
3406 ++input_line_pointer
;
3408 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3410 symbol_get_tc (sym
)->output
= 1;
3412 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3414 symbol_get_tc (sym
)->within
= ppc_current_block
;
3419 .stabx "z",arrays_,133,0
3422 .comm arrays_,13768,3
3424 resolve_symbol_value will copy the exp's "within" into sym's when the
3425 offset is 0. Since this seems to be corner case problem,
3426 only do the correction for storage class C_STSYM. A better solution
3427 would be to have the tc field updated in ppc_symbol_new_hook. */
3429 if (exp
.X_op
== O_symbol
)
3431 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3435 if (exp
.X_op
!= O_symbol
3436 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3437 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3438 ppc_frob_label (sym
);
3441 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3442 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3443 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3444 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3447 demand_empty_rest_of_line ();
3450 /* The .function pseudo-op. This takes several arguments. The first
3451 argument seems to be the external name of the symbol. The second
3452 argument seems to be the label for the start of the function. gcc
3453 uses the same name for both. I have no idea what the third and
3454 fourth arguments are meant to be. The optional fifth argument is
3455 an expression for the size of the function. In COFF this symbol
3456 gets an aux entry like that used for a csect. */
3459 ppc_function (ignore
)
3460 int ignore ATTRIBUTE_UNUSED
;
3468 name
= input_line_pointer
;
3469 endc
= get_symbol_end ();
3471 /* Ignore any [PR] suffix. */
3472 name
= ppc_canonicalize_symbol_name (name
);
3473 s
= strchr (name
, '[');
3474 if (s
!= (char *) NULL
3475 && strcmp (s
+ 1, "PR]") == 0)
3478 ext_sym
= symbol_find_or_make (name
);
3480 *input_line_pointer
= endc
;
3482 if (*input_line_pointer
!= ',')
3484 as_bad (_("missing symbol name"));
3485 ignore_rest_of_line ();
3488 ++input_line_pointer
;
3490 name
= input_line_pointer
;
3491 endc
= get_symbol_end ();
3493 lab_sym
= symbol_find_or_make (name
);
3495 *input_line_pointer
= endc
;
3497 if (ext_sym
!= lab_sym
)
3501 exp
.X_op
= O_symbol
;
3502 exp
.X_add_symbol
= lab_sym
;
3503 exp
.X_op_symbol
= NULL
;
3504 exp
.X_add_number
= 0;
3506 symbol_set_value_expression (ext_sym
, &exp
);
3509 if (symbol_get_tc (ext_sym
)->class == -1)
3510 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3511 symbol_get_tc (ext_sym
)->output
= 1;
3513 if (*input_line_pointer
== ',')
3517 /* Ignore the third argument. */
3518 ++input_line_pointer
;
3519 expression (&ignore
);
3520 if (*input_line_pointer
== ',')
3522 /* Ignore the fourth argument. */
3523 ++input_line_pointer
;
3524 expression (&ignore
);
3525 if (*input_line_pointer
== ',')
3527 /* The fifth argument is the function size. */
3528 ++input_line_pointer
;
3529 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3532 &zero_address_frag
);
3533 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3538 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3539 SF_SET_FUNCTION (ext_sym
);
3540 SF_SET_PROCESS (ext_sym
);
3541 coff_add_linesym (ext_sym
);
3543 demand_empty_rest_of_line ();
3546 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3547 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3548 with the correct line number */
3550 static symbolS
*saved_bi_sym
= 0;
3554 int ignore ATTRIBUTE_UNUSED
;
3558 sym
= symbol_make (".bf");
3559 S_SET_SEGMENT (sym
, text_section
);
3560 symbol_set_frag (sym
, frag_now
);
3561 S_SET_VALUE (sym
, frag_now_fix ());
3562 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3564 coff_line_base
= get_absolute_expression ();
3566 S_SET_NUMBER_AUXILIARY (sym
, 1);
3567 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3569 /* Line number for bi. */
3572 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3577 symbol_get_tc (sym
)->output
= 1;
3579 ppc_frob_label (sym
);
3581 demand_empty_rest_of_line ();
3584 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3585 ".ef", except that the line number is absolute, not relative to the
3586 most recent ".bf" symbol. */
3590 int ignore ATTRIBUTE_UNUSED
;
3594 sym
= symbol_make (".ef");
3595 S_SET_SEGMENT (sym
, text_section
);
3596 symbol_set_frag (sym
, frag_now
);
3597 S_SET_VALUE (sym
, frag_now_fix ());
3598 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3599 S_SET_NUMBER_AUXILIARY (sym
, 1);
3600 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3601 symbol_get_tc (sym
)->output
= 1;
3603 ppc_frob_label (sym
);
3605 demand_empty_rest_of_line ();
3608 /* The .bi and .ei pseudo-ops. These take a string argument and
3609 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3610 the symbol list. The value of .bi will be know when the next .bf
3617 static symbolS
*last_biei
;
3624 name
= demand_copy_C_string (&len
);
3626 /* The value of these symbols is actually file offset. Here we set
3627 the value to the index into the line number entries. In
3628 ppc_frob_symbols we set the fix_line field, which will cause BFD
3629 to do the right thing. */
3631 sym
= symbol_make (name
);
3632 /* obj-coff.c currently only handles line numbers correctly in the
3634 S_SET_SEGMENT (sym
, text_section
);
3635 S_SET_VALUE (sym
, coff_n_line_nos
);
3636 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3638 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3639 symbol_get_tc (sym
)->output
= 1;
3647 for (look
= last_biei
? last_biei
: symbol_rootP
;
3648 (look
!= (symbolS
*) NULL
3649 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3650 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3651 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3652 look
= symbol_next (look
))
3654 if (look
!= (symbolS
*) NULL
)
3656 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3657 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3661 demand_empty_rest_of_line ();
3664 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3665 There is one argument, which is a csect symbol. The value of the
3666 .bs symbol is the index of this csect symbol. */
3670 int ignore ATTRIBUTE_UNUSED
;
3677 if (ppc_current_block
!= NULL
)
3678 as_bad (_("nested .bs blocks"));
3680 name
= input_line_pointer
;
3681 endc
= get_symbol_end ();
3683 csect
= symbol_find_or_make (name
);
3685 *input_line_pointer
= endc
;
3687 sym
= symbol_make (".bs");
3688 S_SET_SEGMENT (sym
, now_seg
);
3689 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3690 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3691 symbol_get_tc (sym
)->output
= 1;
3693 symbol_get_tc (sym
)->within
= csect
;
3695 ppc_frob_label (sym
);
3697 ppc_current_block
= sym
;
3699 demand_empty_rest_of_line ();
3702 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3706 int ignore ATTRIBUTE_UNUSED
;
3710 if (ppc_current_block
== NULL
)
3711 as_bad (_(".es without preceding .bs"));
3713 sym
= symbol_make (".es");
3714 S_SET_SEGMENT (sym
, now_seg
);
3715 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3716 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3717 symbol_get_tc (sym
)->output
= 1;
3719 ppc_frob_label (sym
);
3721 ppc_current_block
= NULL
;
3723 demand_empty_rest_of_line ();
3726 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3731 int ignore ATTRIBUTE_UNUSED
;
3735 sym
= symbol_make (".bb");
3736 S_SET_SEGMENT (sym
, text_section
);
3737 symbol_set_frag (sym
, frag_now
);
3738 S_SET_VALUE (sym
, frag_now_fix ());
3739 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3741 S_SET_NUMBER_AUXILIARY (sym
, 1);
3742 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3744 symbol_get_tc (sym
)->output
= 1;
3746 SF_SET_PROCESS (sym
);
3748 ppc_frob_label (sym
);
3750 demand_empty_rest_of_line ();
3753 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3758 int ignore ATTRIBUTE_UNUSED
;
3762 sym
= symbol_make (".eb");
3763 S_SET_SEGMENT (sym
, text_section
);
3764 symbol_set_frag (sym
, frag_now
);
3765 S_SET_VALUE (sym
, frag_now_fix ());
3766 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3767 S_SET_NUMBER_AUXILIARY (sym
, 1);
3768 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3769 symbol_get_tc (sym
)->output
= 1;
3771 SF_SET_PROCESS (sym
);
3773 ppc_frob_label (sym
);
3775 demand_empty_rest_of_line ();
3778 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3783 int ignore ATTRIBUTE_UNUSED
;
3789 name
= demand_copy_C_string (&len
);
3790 sym
= symbol_make (name
);
3791 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3792 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3793 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3794 S_SET_VALUE (sym
, 0);
3795 symbol_get_tc (sym
)->output
= 1;
3797 ppc_frob_label (sym
);
3799 demand_empty_rest_of_line ();
3802 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3806 int ignore ATTRIBUTE_UNUSED
;
3810 sym
= symbol_make (".ec");
3811 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3812 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3813 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3814 S_SET_VALUE (sym
, 0);
3815 symbol_get_tc (sym
)->output
= 1;
3817 ppc_frob_label (sym
);
3819 demand_empty_rest_of_line ();
3822 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3826 int ignore ATTRIBUTE_UNUSED
;
3828 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3829 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3836 subseg
= ppc_data_subsegment
;
3837 ++ppc_data_subsegment
;
3839 subseg_new (segment_name (data_section
), subseg
);
3840 ppc_toc_frag
= frag_now
;
3842 sym
= symbol_find_or_make ("TOC[TC0]");
3843 symbol_set_frag (sym
, frag_now
);
3844 S_SET_SEGMENT (sym
, data_section
);
3845 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3846 symbol_get_tc (sym
)->subseg
= subseg
;
3847 symbol_get_tc (sym
)->output
= 1;
3848 symbol_get_tc (sym
)->within
= sym
;
3850 ppc_toc_csect
= sym
;
3852 for (list
= ppc_data_csects
;
3853 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3854 list
= symbol_get_tc (list
)->next
)
3856 symbol_get_tc (list
)->next
= sym
;
3858 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3859 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3863 ppc_current_csect
= ppc_toc_csect
;
3865 demand_empty_rest_of_line ();
3868 /* The AIX assembler automatically aligns the operands of a .long or
3869 .short pseudo-op, and we want to be compatible. */
3872 ppc_xcoff_cons (log_size
)
3875 frag_align (log_size
, 0, 0);
3876 record_alignment (now_seg
, log_size
);
3877 cons (1 << log_size
);
3882 int dummy ATTRIBUTE_UNUSED
;
3887 (void) expression (&exp
);
3889 if (exp
.X_op
!= O_constant
)
3891 as_bad (_("non-constant byte count"));
3895 byte_count
= exp
.X_add_number
;
3897 if (*input_line_pointer
!= ',')
3899 as_bad (_("missing value"));
3903 ++input_line_pointer
;
3907 #endif /* OBJ_XCOFF */
3908 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3910 /* The .tc pseudo-op. This is used when generating either XCOFF or
3911 ELF. This takes two or more arguments.
3913 When generating XCOFF output, the first argument is the name to
3914 give to this location in the toc; this will be a symbol with class
3915 TC. The rest of the arguments are N-byte values to actually put at
3916 this location in the TOC; often there is just one more argument, a
3917 relocatable symbol reference. The size of the value to store
3918 depends on target word size. A 32-bit target uses 4-byte values, a
3919 64-bit target uses 8-byte values.
3921 When not generating XCOFF output, the arguments are the same, but
3922 the first argument is simply ignored. */
3926 int ignore ATTRIBUTE_UNUSED
;
3930 /* Define the TOC symbol name. */
3936 if (ppc_toc_csect
== (symbolS
*) NULL
3937 || ppc_toc_csect
!= ppc_current_csect
)
3939 as_bad (_(".tc not in .toc section"));
3940 ignore_rest_of_line ();
3944 name
= input_line_pointer
;
3945 endc
= get_symbol_end ();
3947 sym
= symbol_find_or_make (name
);
3949 *input_line_pointer
= endc
;
3951 if (S_IS_DEFINED (sym
))
3955 label
= symbol_get_tc (ppc_current_csect
)->within
;
3956 if (symbol_get_tc (label
)->class != XMC_TC0
)
3958 as_bad (_(".tc with no label"));
3959 ignore_rest_of_line ();
3963 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3964 symbol_set_frag (label
, symbol_get_frag (sym
));
3965 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3967 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3968 ++input_line_pointer
;
3973 S_SET_SEGMENT (sym
, now_seg
);
3974 symbol_set_frag (sym
, frag_now
);
3975 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3976 symbol_get_tc (sym
)->class = XMC_TC
;
3977 symbol_get_tc (sym
)->output
= 1;
3979 ppc_frob_label (sym
);
3982 #endif /* OBJ_XCOFF */
3986 /* Skip the TOC symbol name. */
3987 while (is_part_of_name (*input_line_pointer
)
3988 || *input_line_pointer
== '['
3989 || *input_line_pointer
== ']'
3990 || *input_line_pointer
== '{'
3991 || *input_line_pointer
== '}')
3992 ++input_line_pointer
;
3994 /* Align to a four/eight byte boundary. */
3995 align
= ppc_obj64
? 3 : 2;
3996 frag_align (align
, 0, 0);
3997 record_alignment (now_seg
, align
);
3998 #endif /* OBJ_ELF */
4000 if (*input_line_pointer
!= ',')
4001 demand_empty_rest_of_line ();
4004 ++input_line_pointer
;
4005 cons (ppc_obj64
? 8 : 4);
4009 /* Pseudo-op .machine. */
4012 ppc_machine (ignore
)
4013 int ignore ATTRIBUTE_UNUSED
;
4016 #define MAX_HISTORY 100
4017 static unsigned long *cpu_history
;
4018 static int curr_hist
;
4022 if (*input_line_pointer
== '"')
4025 cpu_string
= demand_copy_C_string (&len
);
4030 cpu_string
= input_line_pointer
;
4031 c
= get_symbol_end ();
4032 cpu_string
= xstrdup (cpu_string
);
4033 *input_line_pointer
= c
;
4036 if (cpu_string
!= NULL
)
4038 unsigned long old_cpu
= ppc_cpu
;
4041 for (p
= cpu_string
; *p
!= 0; p
++)
4044 if (strcmp (cpu_string
, "push") == 0)
4046 if (cpu_history
== NULL
)
4047 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
4049 if (curr_hist
>= MAX_HISTORY
)
4050 as_bad (_(".machine stack overflow"));
4052 cpu_history
[curr_hist
++] = ppc_cpu
;
4054 else if (strcmp (cpu_string
, "pop") == 0)
4057 as_bad (_(".machine stack underflow"));
4059 ppc_cpu
= cpu_history
[--curr_hist
];
4061 else if (parse_cpu (cpu_string
))
4064 as_bad (_("invalid machine `%s'"), cpu_string
);
4066 if (ppc_cpu
!= old_cpu
)
4067 ppc_setup_opcodes ();
4070 demand_empty_rest_of_line ();
4073 /* See whether a symbol is in the TOC section. */
4076 ppc_is_toc_sym (sym
)
4080 return symbol_get_tc (sym
)->class == XMC_TC
;
4083 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
4085 return strcmp (sname
, ".toc") == 0;
4087 return strcmp (sname
, ".got") == 0;
4090 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4094 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4096 /* Set the current section. */
4098 ppc_set_current_section (new)
4101 ppc_previous_section
= ppc_current_section
;
4102 ppc_current_section
= new;
4105 /* pseudo-op: .previous
4106 behaviour: toggles the current section with the previous section.
4108 warnings: "No previous section" */
4111 ppc_previous (ignore
)
4112 int ignore ATTRIBUTE_UNUSED
;
4116 if (ppc_previous_section
== NULL
)
4118 as_warn (_("No previous section to return to. Directive ignored."));
4122 subseg_set (ppc_previous_section
, 0);
4124 ppc_set_current_section (ppc_previous_section
);
4127 /* pseudo-op: .pdata
4128 behaviour: predefined read only data section
4132 initial: .section .pdata "adr3"
4133 a - don't know -- maybe a misprint
4134 d - initialized data
4136 3 - double word aligned (that would be 4 byte boundary)
4139 Tag index tables (also known as the function table) for exception
4140 handling, debugging, etc. */
4144 int ignore ATTRIBUTE_UNUSED
;
4146 if (pdata_section
== 0)
4148 pdata_section
= subseg_new (".pdata", 0);
4150 bfd_set_section_flags (stdoutput
, pdata_section
,
4151 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4152 | SEC_READONLY
| SEC_DATA
));
4154 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4158 pdata_section
= subseg_new (".pdata", 0);
4160 ppc_set_current_section (pdata_section
);
4163 /* pseudo-op: .ydata
4164 behaviour: predefined read only data section
4168 initial: .section .ydata "drw3"
4169 a - don't know -- maybe a misprint
4170 d - initialized data
4172 3 - double word aligned (that would be 4 byte boundary)
4174 Tag tables (also known as the scope table) for exception handling,
4179 int ignore ATTRIBUTE_UNUSED
;
4181 if (ydata_section
== 0)
4183 ydata_section
= subseg_new (".ydata", 0);
4184 bfd_set_section_flags (stdoutput
, ydata_section
,
4185 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4186 | SEC_READONLY
| SEC_DATA
));
4188 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4192 ydata_section
= subseg_new (".ydata", 0);
4194 ppc_set_current_section (ydata_section
);
4197 /* pseudo-op: .reldata
4198 behaviour: predefined read write data section
4199 double word aligned (4-byte)
4200 FIXME: relocation is applied to it
4201 FIXME: what's the difference between this and .data?
4204 initial: .section .reldata "drw3"
4205 d - initialized data
4208 3 - double word aligned (that would be 8 byte boundary)
4211 Like .data, but intended to hold data subject to relocation, such as
4212 function descriptors, etc. */
4215 ppc_reldata (ignore
)
4216 int ignore ATTRIBUTE_UNUSED
;
4218 if (reldata_section
== 0)
4220 reldata_section
= subseg_new (".reldata", 0);
4222 bfd_set_section_flags (stdoutput
, reldata_section
,
4223 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4226 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4230 reldata_section
= subseg_new (".reldata", 0);
4232 ppc_set_current_section (reldata_section
);
4235 /* pseudo-op: .rdata
4236 behaviour: predefined read only data section
4240 initial: .section .rdata "dr3"
4241 d - initialized data
4243 3 - double word aligned (that would be 4 byte boundary) */
4247 int ignore ATTRIBUTE_UNUSED
;
4249 if (rdata_section
== 0)
4251 rdata_section
= subseg_new (".rdata", 0);
4252 bfd_set_section_flags (stdoutput
, rdata_section
,
4253 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4254 | SEC_READONLY
| SEC_DATA
));
4256 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4260 rdata_section
= subseg_new (".rdata", 0);
4262 ppc_set_current_section (rdata_section
);
4265 /* pseudo-op: .ualong
4266 behaviour: much like .int, with the exception that no alignment is
4268 FIXME: test the alignment statement
4274 int ignore ATTRIBUTE_UNUSED
;
4280 /* pseudo-op: .znop <symbol name>
4281 behaviour: Issue a nop instruction
4282 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4283 the supplied symbol name.
4285 warnings: Missing symbol name */
4289 int ignore ATTRIBUTE_UNUSED
;
4292 const struct powerpc_opcode
*opcode
;
4303 /* Strip out the symbol name. */
4304 symbol_name
= input_line_pointer
;
4305 c
= get_symbol_end ();
4307 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4308 strcpy (name
, symbol_name
);
4310 sym
= symbol_find_or_make (name
);
4312 *input_line_pointer
= c
;
4316 /* Look up the opcode in the hash table. */
4317 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4319 /* Stick in the nop. */
4320 insn
= opcode
->opcode
;
4322 /* Write out the instruction. */
4324 md_number_to_chars (f
, insn
, 4);
4326 f
- frag_now
->fr_literal
,
4331 BFD_RELOC_16_GOT_PCREL
);
4344 register char *name
;
4348 register symbolS
*symbolP
;
4351 name
= input_line_pointer
;
4352 c
= get_symbol_end ();
4354 /* just after name is now '\0'. */
4355 p
= input_line_pointer
;
4358 if (*input_line_pointer
!= ',')
4360 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4361 ignore_rest_of_line ();
4365 input_line_pointer
++; /* skip ',' */
4366 if ((temp
= get_absolute_expression ()) < 0)
4368 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4369 ignore_rest_of_line ();
4375 /* The third argument to .comm is the alignment. */
4376 if (*input_line_pointer
!= ',')
4380 ++input_line_pointer
;
4381 align
= get_absolute_expression ();
4384 as_warn (_("ignoring bad alignment"));
4391 symbolP
= symbol_find_or_make (name
);
4394 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4396 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4397 S_GET_NAME (symbolP
));
4398 ignore_rest_of_line ();
4402 if (S_GET_VALUE (symbolP
))
4404 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4405 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4406 S_GET_NAME (symbolP
),
4407 (long) S_GET_VALUE (symbolP
),
4412 S_SET_VALUE (symbolP
, (valueT
) temp
);
4413 S_SET_EXTERNAL (symbolP
);
4416 demand_empty_rest_of_line ();
4420 * implement the .section pseudo op:
4421 * .section name {, "flags"}
4423 * | +--- optional flags: 'b' for bss
4425 * +-- section name 'l' for lib
4429 * 'd' (apparently m88k for data)
4431 * But if the argument is not a quoted string, treat it as a
4432 * subsegment number.
4434 * FIXME: this is a copy of the section processing from obj-coff.c, with
4435 * additions/changes for the moto-pas assembler support. There are three
4438 * FIXME: I just noticed this. This doesn't work at all really. It it
4439 * setting bits that bfd probably neither understands or uses. The
4440 * correct approach (?) will have to incorporate extra fields attached
4441 * to the section to hold the system specific stuff. (krk)
4444 * 'a' - unknown - referred to in documentation, but no definition supplied
4445 * 'c' - section has code
4446 * 'd' - section has initialized data
4447 * 'u' - section has uninitialized data
4448 * 'i' - section contains directives (info)
4449 * 'n' - section can be discarded
4450 * 'R' - remove section at link time
4452 * Section Protection:
4453 * 'r' - section is readable
4454 * 'w' - section is writeable
4455 * 'x' - section is executable
4456 * 's' - section is sharable
4458 * Section Alignment:
4459 * '0' - align to byte boundary
4460 * '1' - align to halfword undary
4461 * '2' - align to word boundary
4462 * '3' - align to doubleword boundary
4463 * '4' - align to quadword boundary
4464 * '5' - align to 32 byte boundary
4465 * '6' - align to 64 byte boundary
4470 ppc_pe_section (ignore
)
4471 int ignore ATTRIBUTE_UNUSED
;
4473 /* Strip out the section name. */
4482 section_name
= input_line_pointer
;
4483 c
= get_symbol_end ();
4485 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4486 strcpy (name
, section_name
);
4488 *input_line_pointer
= c
;
4493 flags
= SEC_NO_FLAGS
;
4495 if (strcmp (name
, ".idata$2") == 0)
4499 else if (strcmp (name
, ".idata$3") == 0)
4503 else if (strcmp (name
, ".idata$4") == 0)
4507 else if (strcmp (name
, ".idata$5") == 0)
4511 else if (strcmp (name
, ".idata$6") == 0)
4516 /* Default alignment to 16 byte boundary. */
4519 if (*input_line_pointer
== ',')
4521 ++input_line_pointer
;
4523 if (*input_line_pointer
!= '"')
4524 exp
= get_absolute_expression ();
4527 ++input_line_pointer
;
4528 while (*input_line_pointer
!= '"'
4529 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4531 switch (*input_line_pointer
)
4533 /* Section Contents */
4534 case 'a': /* unknown */
4535 as_bad (_("Unsupported section attribute -- 'a'"));
4537 case 'c': /* code section */
4540 case 'd': /* section has initialized data */
4543 case 'u': /* section has uninitialized data */
4544 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4548 case 'i': /* section contains directives (info) */
4549 /* FIXME: This is IMAGE_SCN_LNK_INFO
4551 flags
|= SEC_HAS_CONTENTS
;
4553 case 'n': /* section can be discarded */
4556 case 'R': /* Remove section at link time */
4557 flags
|= SEC_NEVER_LOAD
;
4560 /* Section Protection */
4561 case 'r': /* section is readable */
4562 flags
|= IMAGE_SCN_MEM_READ
;
4564 case 'w': /* section is writeable */
4565 flags
|= IMAGE_SCN_MEM_WRITE
;
4567 case 'x': /* section is executable */
4568 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4570 case 's': /* section is sharable */
4571 flags
|= IMAGE_SCN_MEM_SHARED
;
4574 /* Section Alignment */
4575 case '0': /* align to byte boundary */
4576 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4579 case '1': /* align to halfword boundary */
4580 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4583 case '2': /* align to word boundary */
4584 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4587 case '3': /* align to doubleword boundary */
4588 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4591 case '4': /* align to quadword boundary */
4592 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4595 case '5': /* align to 32 byte boundary */
4596 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4599 case '6': /* align to 64 byte boundary */
4600 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4605 as_bad (_("unknown section attribute '%c'"),
4606 *input_line_pointer
);
4609 ++input_line_pointer
;
4611 if (*input_line_pointer
== '"')
4612 ++input_line_pointer
;
4616 sec
= subseg_new (name
, (subsegT
) exp
);
4618 ppc_set_current_section (sec
);
4620 if (flags
!= SEC_NO_FLAGS
)
4622 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4623 as_bad (_("error setting flags for \"%s\": %s"),
4624 bfd_section_name (stdoutput
, sec
),
4625 bfd_errmsg (bfd_get_error ()));
4628 bfd_set_section_alignment (stdoutput
, sec
, align
);
4633 ppc_pe_function (ignore
)
4634 int ignore ATTRIBUTE_UNUSED
;
4640 name
= input_line_pointer
;
4641 endc
= get_symbol_end ();
4643 ext_sym
= symbol_find_or_make (name
);
4645 *input_line_pointer
= endc
;
4647 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4648 SF_SET_FUNCTION (ext_sym
);
4649 SF_SET_PROCESS (ext_sym
);
4650 coff_add_linesym (ext_sym
);
4652 demand_empty_rest_of_line ();
4656 ppc_pe_tocd (ignore
)
4657 int ignore ATTRIBUTE_UNUSED
;
4659 if (tocdata_section
== 0)
4661 tocdata_section
= subseg_new (".tocd", 0);
4662 /* FIXME: section flags won't work. */
4663 bfd_set_section_flags (stdoutput
, tocdata_section
,
4664 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4665 | SEC_READONLY
| SEC_DATA
));
4667 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4671 rdata_section
= subseg_new (".tocd", 0);
4674 ppc_set_current_section (tocdata_section
);
4676 demand_empty_rest_of_line ();
4679 /* Don't adjust TOC relocs to use the section symbol. */
4682 ppc_pe_fix_adjustable (fix
)
4685 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4692 /* XCOFF specific symbol and file handling. */
4694 /* Canonicalize the symbol name. We use the to force the suffix, if
4695 any, to use square brackets, and to be in upper case. */
4698 ppc_canonicalize_symbol_name (name
)
4703 if (ppc_stab_symbol
)
4706 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4720 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4723 if (*s
== '\0' || s
[1] != '\0')
4724 as_bad (_("bad symbol suffix"));
4732 /* Set the class of a symbol based on the suffix, if any. This is
4733 called whenever a new symbol is created. */
4736 ppc_symbol_new_hook (sym
)
4739 struct ppc_tc_sy
*tc
;
4742 tc
= symbol_get_tc (sym
);
4746 tc
->real_name
= NULL
;
4752 if (ppc_stab_symbol
)
4755 s
= strchr (S_GET_NAME (sym
), '[');
4756 if (s
== (const char *) NULL
)
4758 /* There is no suffix. */
4767 if (strcmp (s
, "BS]") == 0)
4771 if (strcmp (s
, "DB]") == 0)
4773 else if (strcmp (s
, "DS]") == 0)
4777 if (strcmp (s
, "GL]") == 0)
4781 if (strcmp (s
, "PR]") == 0)
4785 if (strcmp (s
, "RO]") == 0)
4787 else if (strcmp (s
, "RW]") == 0)
4791 if (strcmp (s
, "SV]") == 0)
4795 if (strcmp (s
, "TC]") == 0)
4797 else if (strcmp (s
, "TI]") == 0)
4799 else if (strcmp (s
, "TB]") == 0)
4801 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4802 tc
->class = XMC_TC0
;
4805 if (strcmp (s
, "UA]") == 0)
4807 else if (strcmp (s
, "UC]") == 0)
4811 if (strcmp (s
, "XO]") == 0)
4816 if (tc
->class == -1)
4817 as_bad (_("Unrecognized symbol suffix"));
4820 /* Set the class of a label based on where it is defined. This
4821 handles symbols without suffixes. Also, move the symbol so that it
4822 follows the csect symbol. */
4825 ppc_frob_label (sym
)
4828 if (ppc_current_csect
!= (symbolS
*) NULL
)
4830 if (symbol_get_tc (sym
)->class == -1)
4831 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4833 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4834 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4835 &symbol_rootP
, &symbol_lastP
);
4836 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4840 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4841 seen. It tells ppc_adjust_symtab whether it needs to look through
4844 static bfd_boolean ppc_saw_abs
;
4846 /* Change the name of a symbol just before writing it out. Set the
4847 real name if the .rename pseudo-op was used. Otherwise, remove any
4848 class suffix. Return 1 if the symbol should not be included in the
4852 ppc_frob_symbol (sym
)
4855 static symbolS
*ppc_last_function
;
4856 static symbolS
*set_end
;
4858 /* Discard symbols that should not be included in the output symbol
4860 if (! symbol_used_in_reloc_p (sym
)
4861 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4862 || (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
4863 && ! symbol_get_tc (sym
)->output
4864 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4867 /* This one will disappear anyway. Don't make a csect sym for it. */
4868 if (sym
== abs_section_sym
)
4871 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4872 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4878 name
= S_GET_NAME (sym
);
4879 s
= strchr (name
, '[');
4880 if (s
!= (char *) NULL
)
4886 snew
= xmalloc (len
+ 1);
4887 memcpy (snew
, name
, len
);
4890 S_SET_NAME (sym
, snew
);
4894 if (set_end
!= (symbolS
*) NULL
)
4896 SA_SET_SYM_ENDNDX (set_end
, sym
);
4900 if (SF_GET_FUNCTION (sym
))
4902 if (ppc_last_function
!= (symbolS
*) NULL
)
4903 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4904 ppc_last_function
= sym
;
4905 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4907 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4908 SA_SET_SYM_FSIZE (sym
,
4909 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4912 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4913 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4915 if (ppc_last_function
== (symbolS
*) NULL
)
4916 as_bad (_(".ef with no preceding .function"));
4919 set_end
= ppc_last_function
;
4920 ppc_last_function
= NULL
;
4922 /* We don't have a C_EFCN symbol, but we need to force the
4923 COFF backend to believe that it has seen one. */
4924 coff_last_function
= NULL
;
4928 if (! (S_IS_EXTERNAL (sym
) || S_IS_WEAK (sym
))
4929 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4930 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4931 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4932 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4933 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4934 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4935 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4936 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4937 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4938 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4940 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4941 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4944 union internal_auxent
*a
;
4946 /* Create a csect aux. */
4947 i
= S_GET_NUMBER_AUXILIARY (sym
);
4948 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4949 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4950 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4952 /* This is the TOC table. */
4953 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4954 a
->x_csect
.x_scnlen
.l
= 0;
4955 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4957 else if (symbol_get_tc (sym
)->subseg
!= 0)
4959 /* This is a csect symbol. x_scnlen is the size of the
4961 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4962 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4963 S_GET_SEGMENT (sym
))
4964 - S_GET_VALUE (sym
));
4967 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4968 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4969 - S_GET_VALUE (sym
));
4971 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4973 else if (S_GET_SEGMENT (sym
) == bss_section
)
4975 /* This is a common symbol. */
4976 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4977 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4978 if (S_IS_EXTERNAL (sym
))
4979 symbol_get_tc (sym
)->class = XMC_RW
;
4981 symbol_get_tc (sym
)->class = XMC_BS
;
4983 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4985 /* This is an absolute symbol. The csect will be created by
4986 ppc_adjust_symtab. */
4988 a
->x_csect
.x_smtyp
= XTY_LD
;
4989 if (symbol_get_tc (sym
)->class == -1)
4990 symbol_get_tc (sym
)->class = XMC_XO
;
4992 else if (! S_IS_DEFINED (sym
))
4994 /* This is an external symbol. */
4995 a
->x_csect
.x_scnlen
.l
= 0;
4996 a
->x_csect
.x_smtyp
= XTY_ER
;
4998 else if (symbol_get_tc (sym
)->class == XMC_TC
)
5002 /* This is a TOC definition. x_scnlen is the size of the
5004 next
= symbol_next (sym
);
5005 while (symbol_get_tc (next
)->class == XMC_TC0
)
5006 next
= symbol_next (next
);
5007 if (next
== (symbolS
*) NULL
5008 || symbol_get_tc (next
)->class != XMC_TC
)
5010 if (ppc_after_toc_frag
== (fragS
*) NULL
)
5011 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
5013 - S_GET_VALUE (sym
));
5015 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
5016 - S_GET_VALUE (sym
));
5020 resolve_symbol_value (next
);
5021 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
5022 - S_GET_VALUE (sym
));
5024 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
5030 /* This is a normal symbol definition. x_scnlen is the
5031 symbol index of the containing csect. */
5032 if (S_GET_SEGMENT (sym
) == text_section
)
5033 csect
= ppc_text_csects
;
5034 else if (S_GET_SEGMENT (sym
) == data_section
)
5035 csect
= ppc_data_csects
;
5039 /* Skip the initial dummy symbol. */
5040 csect
= symbol_get_tc (csect
)->next
;
5042 if (csect
== (symbolS
*) NULL
)
5044 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
5045 a
->x_csect
.x_scnlen
.l
= 0;
5049 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
5051 resolve_symbol_value (symbol_get_tc (csect
)->next
);
5052 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
5053 > S_GET_VALUE (sym
))
5055 csect
= symbol_get_tc (csect
)->next
;
5058 a
->x_csect
.x_scnlen
.p
=
5059 coffsymbol (symbol_get_bfdsym (csect
))->native
;
5060 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
5063 a
->x_csect
.x_smtyp
= XTY_LD
;
5066 a
->x_csect
.x_parmhash
= 0;
5067 a
->x_csect
.x_snhash
= 0;
5068 if (symbol_get_tc (sym
)->class == -1)
5069 a
->x_csect
.x_smclas
= XMC_PR
;
5071 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
5072 a
->x_csect
.x_stab
= 0;
5073 a
->x_csect
.x_snstab
= 0;
5075 /* Don't let the COFF backend resort these symbols. */
5076 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
5078 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
5080 /* We want the value to be the symbol index of the referenced
5081 csect symbol. BFD will do that for us if we set the right
5083 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
5084 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
5086 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
5087 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
5089 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
5094 /* The value is the offset from the enclosing csect. */
5095 block
= symbol_get_tc (sym
)->within
;
5096 csect
= symbol_get_tc (block
)->within
;
5097 resolve_symbol_value (csect
);
5098 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
5100 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
5101 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
5103 /* We want the value to be a file offset into the line numbers.
5104 BFD will do that for us if we set the right flags. We have
5105 already set the value correctly. */
5106 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
5112 /* Adjust the symbol table. This creates csect symbols for all
5113 absolute symbols. */
5116 ppc_adjust_symtab ()
5123 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5127 union internal_auxent
*a
;
5129 if (S_GET_SEGMENT (sym
) != absolute_section
)
5132 csect
= symbol_create (".abs[XO]", absolute_section
,
5133 S_GET_VALUE (sym
), &zero_address_frag
);
5134 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5135 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5136 i
= S_GET_NUMBER_AUXILIARY (csect
);
5137 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5138 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5139 a
->x_csect
.x_scnlen
.l
= 0;
5140 a
->x_csect
.x_smtyp
= XTY_SD
;
5141 a
->x_csect
.x_parmhash
= 0;
5142 a
->x_csect
.x_snhash
= 0;
5143 a
->x_csect
.x_smclas
= XMC_XO
;
5144 a
->x_csect
.x_stab
= 0;
5145 a
->x_csect
.x_snstab
= 0;
5147 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5149 i
= S_GET_NUMBER_AUXILIARY (sym
);
5150 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5151 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5152 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5155 ppc_saw_abs
= FALSE
;
5158 /* Set the VMA for a section. This is called on all the sections in
5162 ppc_frob_section (sec
)
5165 static bfd_vma vma
= 0;
5167 vma
= md_section_align (sec
, vma
);
5168 bfd_set_section_vma (stdoutput
, sec
, vma
);
5169 vma
+= bfd_section_size (stdoutput
, sec
);
5172 #endif /* OBJ_XCOFF */
5174 /* Turn a string in input_line_pointer into a floating point constant
5175 of type TYPE, and store the appropriate bytes in *LITP. The number
5176 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5177 returned, or NULL on OK. */
5180 md_atof (type
, litp
, sizep
)
5186 LITTLENUM_TYPE words
[4];
5202 return _("bad call to md_atof");
5205 t
= atof_ieee (input_line_pointer
, type
, words
);
5207 input_line_pointer
= t
;
5211 if (target_big_endian
)
5213 for (i
= 0; i
< prec
; i
++)
5215 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5221 for (i
= prec
- 1; i
>= 0; i
--)
5223 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5231 /* Write a value out to the object file, using the appropriate
5235 md_number_to_chars (buf
, val
, n
)
5240 if (target_big_endian
)
5241 number_to_chars_bigendian (buf
, val
, n
);
5243 number_to_chars_littleendian (buf
, val
, n
);
5246 /* Align a section (I don't know why this is machine dependent). */
5249 md_section_align (seg
, addr
)
5253 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5255 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5258 /* We don't have any form of relaxing. */
5261 md_estimate_size_before_relax (fragp
, seg
)
5262 fragS
*fragp ATTRIBUTE_UNUSED
;
5263 asection
*seg ATTRIBUTE_UNUSED
;
5269 /* Convert a machine dependent frag. We never generate these. */
5272 md_convert_frag (abfd
, sec
, fragp
)
5273 bfd
*abfd ATTRIBUTE_UNUSED
;
5274 asection
*sec ATTRIBUTE_UNUSED
;
5275 fragS
*fragp ATTRIBUTE_UNUSED
;
5280 /* We have no need to default values of symbols. */
5283 md_undefined_symbol (name
)
5284 char *name ATTRIBUTE_UNUSED
;
5289 /* Functions concerning relocs. */
5291 /* The location from which a PC relative jump should be calculated,
5292 given a PC relative reloc. */
5295 md_pcrel_from_section (fixp
, sec
)
5297 segT sec ATTRIBUTE_UNUSED
;
5299 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5304 /* This is called to see whether a fixup should be adjusted to use a
5305 section symbol. We take the opportunity to change a fixup against
5306 a symbol in the TOC subsegment into a reloc against the
5307 corresponding .tc symbol. */
5310 ppc_fix_adjustable (fix
)
5313 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5314 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5315 TC_SYMFIELD_TYPE
*tc
;
5317 if (symseg
== absolute_section
)
5320 if (ppc_toc_csect
!= (symbolS
*) NULL
5321 && fix
->fx_addsy
!= ppc_toc_csect
5322 && symseg
== data_section
5323 && val
>= ppc_toc_frag
->fr_address
5324 && (ppc_after_toc_frag
== (fragS
*) NULL
5325 || val
< ppc_after_toc_frag
->fr_address
))
5329 for (sy
= symbol_next (ppc_toc_csect
);
5330 sy
!= (symbolS
*) NULL
;
5331 sy
= symbol_next (sy
))
5333 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5335 if (sy_tc
->class == XMC_TC0
)
5337 if (sy_tc
->class != XMC_TC
)
5339 if (val
== resolve_symbol_value (sy
))
5342 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5347 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5348 _("symbol in .toc does not match any .tc"));
5351 /* Possibly adjust the reloc to be against the csect. */
5352 tc
= symbol_get_tc (fix
->fx_addsy
);
5354 && tc
->class != XMC_TC0
5355 && tc
->class != XMC_TC
5356 && symseg
!= bss_section
5357 /* Don't adjust if this is a reloc in the toc section. */
5358 && (symseg
!= data_section
5359 || ppc_toc_csect
== NULL
5360 || val
< ppc_toc_frag
->fr_address
5361 || (ppc_after_toc_frag
!= NULL
5362 && val
>= ppc_after_toc_frag
->fr_address
)))
5365 symbolS
*next_csect
;
5367 if (symseg
== text_section
)
5368 csect
= ppc_text_csects
;
5369 else if (symseg
== data_section
)
5370 csect
= ppc_data_csects
;
5374 /* Skip the initial dummy symbol. */
5375 csect
= symbol_get_tc (csect
)->next
;
5377 if (csect
!= (symbolS
*) NULL
)
5379 while ((next_csect
= symbol_get_tc (csect
)->next
) != (symbolS
*) NULL
5380 && (symbol_get_frag (next_csect
)->fr_address
<= val
))
5382 /* If the csect address equals the symbol value, then we
5383 have to look through the full symbol table to see
5384 whether this is the csect we want. Note that we will
5385 only get here if the csect has zero length. */
5386 if (symbol_get_frag (csect
)->fr_address
== val
5387 && S_GET_VALUE (csect
) == val
)
5391 for (scan
= symbol_next (csect
);
5393 scan
= symbol_next (scan
))
5395 if (symbol_get_tc (scan
)->subseg
!= 0)
5397 if (scan
== fix
->fx_addsy
)
5401 /* If we found the symbol before the next csect
5402 symbol, then this is the csect we want. */
5403 if (scan
== fix
->fx_addsy
)
5410 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5411 fix
->fx_addsy
= csect
;
5416 /* Adjust a reloc against a .lcomm symbol to be against the base
5418 if (symseg
== bss_section
5419 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5421 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5423 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5430 /* A reloc from one csect to another must be kept. The assembler
5431 will, of course, keep relocs between sections, and it will keep
5432 absolute relocs, but we need to force it to keep PC relative relocs
5433 between two csects in the same section. */
5436 ppc_force_relocation (fix
)
5439 /* At this point fix->fx_addsy should already have been converted to
5440 a csect symbol. If the csect does not include the fragment, then
5441 we need to force the relocation. */
5443 && fix
->fx_addsy
!= NULL
5444 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5445 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5446 > fix
->fx_frag
->fr_address
)
5447 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5448 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5449 <= fix
->fx_frag
->fr_address
))))
5452 return generic_force_reloc (fix
);
5455 #endif /* OBJ_XCOFF */
5458 /* If this function returns non-zero, it guarantees that a relocation
5459 will be emitted for a fixup. */
5462 ppc_force_relocation (fix
)
5465 /* Branch prediction relocations must force a relocation, as must
5466 the vtable description relocs. */
5467 switch (fix
->fx_r_type
)
5469 case BFD_RELOC_PPC_B16_BRTAKEN
:
5470 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5471 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5472 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5473 case BFD_RELOC_24_PLT_PCREL
:
5474 case BFD_RELOC_PPC64_TOC
:
5480 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5481 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5484 return generic_force_reloc (fix
);
5488 ppc_fix_adjustable (fix
)
5491 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5492 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5493 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5494 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5495 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5496 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5497 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5498 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5499 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
));
5503 /* Apply a fixup to the object code. This is called for all the
5504 fixups we generated by the call to fix_new_exp, above. In the call
5505 above we used a reloc code which was the largest legal reloc code
5506 plus the operand index. Here we undo that to recover the operand
5507 index. At this point all symbol values should be fully resolved,
5508 and we attempt to completely resolve the reloc. If we can not do
5509 that, we determine the correct reloc code and put it back in the
5513 md_apply_fix (fixP
, valP
, seg
)
5516 segT seg ATTRIBUTE_UNUSED
;
5518 valueT value
= * valP
;
5521 if (fixP
->fx_addsy
!= NULL
)
5523 /* Hack around bfd_install_relocation brain damage. */
5525 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5530 /* FIXME FIXME FIXME: The value we are passed in *valP includes
5531 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5532 doing this relocation the code in write.c is going to call
5533 bfd_install_relocation, which is also going to use the symbol
5534 value. That means that if the reloc is fully resolved we want to
5535 use *valP since bfd_install_relocation is not being used.
5536 However, if the reloc is not fully resolved we do not want to use
5537 *valP, and must use fx_offset instead. However, if the reloc
5538 is PC relative, we do want to use *valP since it includes the
5539 result of md_pcrel_from. This is confusing. */
5540 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5543 else if (fixP
->fx_pcrel
)
5547 value
= fixP
->fx_offset
;
5550 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5552 /* We can't actually support subtracting a symbol. */
5553 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
5556 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5559 const struct powerpc_operand
*operand
;
5563 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5565 operand
= &powerpc_operands
[opindex
];
5568 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5569 does not generate a reloc. It uses the offset of `sym' within its
5570 csect. Other usages, such as `.long sym', generate relocs. This
5571 is the documented behaviour of non-TOC symbols. */
5572 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5573 && operand
->bits
== 16
5574 && operand
->shift
== 0
5575 && (operand
->insert
== NULL
|| ppc_obj64
)
5576 && fixP
->fx_addsy
!= NULL
5577 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5578 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5579 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5580 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5582 value
= fixP
->fx_offset
;
5587 /* Fetch the instruction, insert the fully resolved operand
5588 value, and stuff the instruction back again. */
5589 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5590 if (target_big_endian
)
5591 insn
= bfd_getb32 ((unsigned char *) where
);
5593 insn
= bfd_getl32 ((unsigned char *) where
);
5594 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5595 fixP
->fx_file
, fixP
->fx_line
);
5596 if (target_big_endian
)
5597 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5599 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5602 /* Nothing else to do here. */
5605 assert (fixP
->fx_addsy
!= NULL
);
5607 /* Determine a BFD reloc value based on the operand information.
5608 We are only prepared to turn a few of the operands into
5610 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5611 && operand
->bits
== 26
5612 && operand
->shift
== 0)
5613 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5614 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5615 && operand
->bits
== 16
5616 && operand
->shift
== 0)
5618 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5621 if (target_big_endian
)
5622 fixP
->fx_where
+= 2;
5625 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5626 && operand
->bits
== 26
5627 && operand
->shift
== 0)
5628 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5629 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5630 && operand
->bits
== 16
5631 && operand
->shift
== 0)
5633 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5636 if (target_big_endian
)
5637 fixP
->fx_where
+= 2;
5640 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5641 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5642 && operand
->bits
== 16
5643 && operand
->shift
== 0)
5645 if (ppc_is_toc_sym (fixP
->fx_addsy
))
5647 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5650 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5651 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5656 fixP
->fx_r_type
= BFD_RELOC_16
;
5659 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5660 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
5664 if (target_big_endian
)
5665 fixP
->fx_where
+= 2;
5667 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5673 /* Use expr_symbol_where to see if this is an expression
5675 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5676 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5677 _("unresolved expression that must be resolved"));
5679 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5680 _("unsupported relocation against %s"),
5681 S_GET_NAME (fixP
->fx_addsy
));
5689 ppc_elf_validate_fix (fixP
, seg
);
5691 switch (fixP
->fx_r_type
)
5693 case BFD_RELOC_CTOR
:
5700 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5704 case BFD_RELOC_32_PCREL
:
5705 case BFD_RELOC_PPC_EMB_NADDR32
:
5706 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5713 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5716 case BFD_RELOC_64_PCREL
:
5717 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5721 case BFD_RELOC_GPREL16
:
5722 case BFD_RELOC_16_GOT_PCREL
:
5723 case BFD_RELOC_16_GOTOFF
:
5724 case BFD_RELOC_LO16_GOTOFF
:
5725 case BFD_RELOC_HI16_GOTOFF
:
5726 case BFD_RELOC_HI16_S_GOTOFF
:
5727 case BFD_RELOC_16_BASEREL
:
5728 case BFD_RELOC_LO16_BASEREL
:
5729 case BFD_RELOC_HI16_BASEREL
:
5730 case BFD_RELOC_HI16_S_BASEREL
:
5731 case BFD_RELOC_PPC_EMB_NADDR16
:
5732 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5733 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5734 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5735 case BFD_RELOC_PPC_EMB_SDAI16
:
5736 case BFD_RELOC_PPC_EMB_SDA2REL
:
5737 case BFD_RELOC_PPC_EMB_SDA2I16
:
5738 case BFD_RELOC_PPC_EMB_RELSEC16
:
5739 case BFD_RELOC_PPC_EMB_RELST_LO
:
5740 case BFD_RELOC_PPC_EMB_RELST_HI
:
5741 case BFD_RELOC_PPC_EMB_RELST_HA
:
5742 case BFD_RELOC_PPC_EMB_RELSDA
:
5743 case BFD_RELOC_PPC_TOC16
:
5745 case BFD_RELOC_PPC64_TOC16_LO
:
5746 case BFD_RELOC_PPC64_TOC16_HI
:
5747 case BFD_RELOC_PPC64_TOC16_HA
:
5751 if (fixP
->fx_addsy
!= NULL
)
5752 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5753 _("cannot emit PC relative %s relocation against %s"),
5754 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5755 S_GET_NAME (fixP
->fx_addsy
));
5757 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5758 _("cannot emit PC relative %s relocation"),
5759 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5762 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5768 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5771 case BFD_RELOC_16_PCREL
:
5772 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5776 case BFD_RELOC_LO16
:
5778 fixP
->fx_r_type
= BFD_RELOC_LO16_PCREL
;
5781 case BFD_RELOC_LO16_PCREL
:
5782 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5786 /* This case happens when you write, for example,
5788 where L1 and L2 are defined later. */
5789 case BFD_RELOC_HI16
:
5791 fixP
->fx_r_type
= BFD_RELOC_HI16_PCREL
;
5794 case BFD_RELOC_HI16_PCREL
:
5795 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5799 case BFD_RELOC_HI16_S
:
5801 fixP
->fx_r_type
= BFD_RELOC_HI16_S_PCREL
;
5804 case BFD_RELOC_HI16_S_PCREL
:
5805 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5810 case BFD_RELOC_PPC64_HIGHER
:
5813 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5814 PPC_HIGHER (value
), 2);
5817 case BFD_RELOC_PPC64_HIGHER_S
:
5820 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5821 PPC_HIGHERA (value
), 2);
5824 case BFD_RELOC_PPC64_HIGHEST
:
5827 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5828 PPC_HIGHEST (value
), 2);
5831 case BFD_RELOC_PPC64_HIGHEST_S
:
5834 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5835 PPC_HIGHESTA (value
), 2);
5838 case BFD_RELOC_PPC64_ADDR16_DS
:
5839 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5840 case BFD_RELOC_PPC64_GOT16_DS
:
5841 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5842 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5843 case BFD_RELOC_PPC64_SECTOFF_DS
:
5844 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5845 case BFD_RELOC_PPC64_TOC16_DS
:
5846 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5847 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5848 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5852 char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5853 unsigned long val
, mask
;
5855 if (target_big_endian
)
5856 val
= bfd_getb32 (where
- 2);
5858 val
= bfd_getl32 (where
);
5860 /* lq insns reserve the four lsbs. */
5861 if ((ppc_cpu
& PPC_OPCODE_POWER4
) != 0
5862 && (val
& (0x3f << 26)) == (56u << 26))
5864 val
|= value
& mask
;
5865 if (target_big_endian
)
5866 bfd_putb16 ((bfd_vma
) val
, where
);
5868 bfd_putl16 ((bfd_vma
) val
, where
);
5872 case BFD_RELOC_PPC_B16_BRTAKEN
:
5873 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5874 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5875 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5878 case BFD_RELOC_PPC_TLS
:
5881 case BFD_RELOC_PPC_DTPMOD
:
5882 case BFD_RELOC_PPC_TPREL16
:
5883 case BFD_RELOC_PPC_TPREL16_LO
:
5884 case BFD_RELOC_PPC_TPREL16_HI
:
5885 case BFD_RELOC_PPC_TPREL16_HA
:
5886 case BFD_RELOC_PPC_TPREL
:
5887 case BFD_RELOC_PPC_DTPREL16
:
5888 case BFD_RELOC_PPC_DTPREL16_LO
:
5889 case BFD_RELOC_PPC_DTPREL16_HI
:
5890 case BFD_RELOC_PPC_DTPREL16_HA
:
5891 case BFD_RELOC_PPC_DTPREL
:
5892 case BFD_RELOC_PPC_GOT_TLSGD16
:
5893 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
5894 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
5895 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
5896 case BFD_RELOC_PPC_GOT_TLSLD16
:
5897 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
5898 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
5899 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
5900 case BFD_RELOC_PPC_GOT_TPREL16
:
5901 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
5902 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
5903 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
5904 case BFD_RELOC_PPC_GOT_DTPREL16
:
5905 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
5906 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
5907 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
5908 case BFD_RELOC_PPC64_TPREL16_DS
:
5909 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
5910 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
5911 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
5912 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
5913 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
5914 case BFD_RELOC_PPC64_DTPREL16_DS
:
5915 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
5916 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
5917 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
5918 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
5919 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
5920 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
5923 /* Because SDA21 modifies the register field, the size is set to 4
5924 bytes, rather than 2, so offset it here appropriately. */
5925 case BFD_RELOC_PPC_EMB_SDA21
:
5929 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5930 + ((target_big_endian
) ? 2 : 0),
5937 /* This can occur if there is a bug in the input assembler, eg:
5938 ".byte <undefined_symbol> - ." */
5940 as_bad (_("Unable to handle reference to symbol %s"),
5941 S_GET_NAME (fixP
->fx_addsy
));
5943 as_bad (_("Unable to resolve expression"));
5947 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5951 case BFD_RELOC_24_PLT_PCREL
:
5952 case BFD_RELOC_PPC_LOCAL24PC
:
5953 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5961 /* Fetch the instruction, insert the fully resolved operand
5962 value, and stuff the instruction back again. */
5963 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5964 if (target_big_endian
)
5965 insn
= bfd_getb32 ((unsigned char *) where
);
5967 insn
= bfd_getl32 ((unsigned char *) where
);
5968 if ((value
& 3) != 0)
5969 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5970 _("must branch to an address a multiple of 4"));
5971 if ((offsetT
) value
< -0x40000000
5972 || (offsetT
) value
>= 0x40000000)
5973 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5974 _("@local or @plt branch destination is too far away, %ld bytes"),
5976 insn
= insn
| (value
& 0x03fffffc);
5977 if (target_big_endian
)
5978 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5980 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5984 case BFD_RELOC_VTABLE_INHERIT
:
5987 && !S_IS_DEFINED (fixP
->fx_addsy
)
5988 && !S_IS_WEAK (fixP
->fx_addsy
))
5989 S_SET_WEAK (fixP
->fx_addsy
);
5992 case BFD_RELOC_VTABLE_ENTRY
:
5997 /* Generated by reference to `sym@tocbase'. The sym is
5998 ignored by the linker. */
5999 case BFD_RELOC_PPC64_TOC
:
6005 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
6012 fixP
->fx_addnumber
= value
;
6014 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
6015 fixP
->fx_addnumber
= 0;
6019 fixP
->fx_addnumber
= 0;
6021 /* We want to use the offset within the data segment of the
6022 symbol, not the actual VMA of the symbol. */
6023 fixP
->fx_addnumber
=
6024 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
6030 /* Generate a reloc for a fixup. */
6033 tc_gen_reloc (seg
, fixp
)
6034 asection
*seg ATTRIBUTE_UNUSED
;
6039 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
6041 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6042 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6043 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6044 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6045 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
6047 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6048 _("reloc %d not supported by object file format"),
6049 (int) fixp
->fx_r_type
);
6052 reloc
->addend
= fixp
->fx_addnumber
;
6058 ppc_cfi_frame_initial_instructions ()
6060 cfi_add_CFA_def_cfa (1, 0);
6064 tc_ppc_regname_to_dw2regnum (const char *regname
)
6066 unsigned int regnum
= -1;
6070 static struct { char *name
; int dw2regnum
; } regnames
[] =
6072 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6073 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6074 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6075 { "spe_acc", 111 }, { "spefscr", 112 }
6078 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
6079 if (strcmp (regnames
[i
].name
, regname
) == 0)
6080 return regnames
[i
].dw2regnum
;
6082 if (regname
[0] == 'r' || regname
[0] == 'f' || regname
[0] == 'v')
6084 p
= regname
+ 1 + (regname
[1] == '.');
6085 regnum
= strtoul (p
, &q
, 10);
6086 if (p
== q
|| *q
|| regnum
>= 32)
6088 if (regname
[0] == 'f')
6090 else if (regname
[0] == 'v')
6093 else if (regname
[0] == 'c' && regname
[1] == 'r')
6095 p
= regname
+ 2 + (regname
[2] == '.');
6096 if (p
[0] < '0' || p
[0] > '7' || p
[1])
6098 regnum
= p
[0] - '0' + 68;