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 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, 59 Temple Place - Suite 330, Boston, MA
25 #include "safe-ctype.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
*));
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 target specific pseudo-ops which we support. */
192 const pseudo_typeS md_pseudo_table
[] =
194 /* Pseudo-ops which must be overridden. */
195 { "byte", ppc_byte
, 0 },
198 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
199 legitimately belong in the obj-*.c file. However, XCOFF is based
200 on COFF, and is only implemented for the RS/6000. We just use
201 obj-coff.c, and add what we need here. */
202 { "comm", ppc_comm
, 0 },
203 { "lcomm", ppc_comm
, 1 },
207 { "bi", ppc_biei
, 0 },
209 { "csect", ppc_csect
, 0 },
210 { "data", ppc_section
, 'd' },
214 { "ei", ppc_biei
, 1 },
216 { "extern", ppc_extern
, 0 },
217 { "function", ppc_function
, 0 },
218 { "lglobl", ppc_lglobl
, 0 },
219 { "rename", ppc_rename
, 0 },
220 { "section", ppc_named_section
, 0 },
221 { "stabx", ppc_stabx
, 0 },
222 { "text", ppc_section
, 't' },
223 { "toc", ppc_toc
, 0 },
224 { "long", ppc_xcoff_cons
, 2 },
225 { "llong", ppc_xcoff_cons
, 3 },
226 { "word", ppc_xcoff_cons
, 1 },
227 { "short", ppc_xcoff_cons
, 1 },
228 { "vbyte", ppc_vbyte
, 0 },
232 { "llong", ppc_elf_cons
, 8 },
233 { "quad", ppc_elf_cons
, 8 },
234 { "long", ppc_elf_cons
, 4 },
235 { "word", ppc_elf_cons
, 2 },
236 { "short", ppc_elf_cons
, 2 },
237 { "rdata", ppc_elf_rdata
, 0 },
238 { "rodata", ppc_elf_rdata
, 0 },
239 { "lcomm", ppc_elf_lcomm
, 0 },
240 { "file", (void (*) PARAMS ((int))) dwarf2_directive_file
, 0 },
241 { "loc", dwarf2_directive_loc
, 0 },
245 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
246 { "previous", ppc_previous
, 0 },
247 { "pdata", ppc_pdata
, 0 },
248 { "ydata", ppc_ydata
, 0 },
249 { "reldata", ppc_reldata
, 0 },
250 { "rdata", ppc_rdata
, 0 },
251 { "ualong", ppc_ualong
, 0 },
252 { "znop", ppc_znop
, 0 },
253 { "comm", ppc_pe_comm
, 0 },
254 { "lcomm", ppc_pe_comm
, 1 },
255 { "section", ppc_pe_section
, 0 },
256 { "function", ppc_pe_function
,0 },
257 { "tocd", ppc_pe_tocd
, 0 },
260 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
262 { "machine", ppc_machine
, 0 },
269 /* Predefined register names if -mregnames (or default for Windows NT).
270 In general, there are lots of them, in an attempt to be compatible
271 with a number of other Windows NT assemblers. */
273 /* Structure to hold information about predefined registers. */
280 /* List of registers that are pre-defined:
282 Each general register has predefined names of the form:
283 1. r<reg_num> which has the value <reg_num>.
284 2. r.<reg_num> which has the value <reg_num>.
286 Each floating point register has predefined names of the form:
287 1. f<reg_num> which has the value <reg_num>.
288 2. f.<reg_num> which has the value <reg_num>.
290 Each vector unit register has predefined names of the form:
291 1. v<reg_num> which has the value <reg_num>.
292 2. v.<reg_num> which has the value <reg_num>.
294 Each condition register has predefined names of the form:
295 1. cr<reg_num> which has the value <reg_num>.
296 2. cr.<reg_num> which has the value <reg_num>.
298 There are individual registers as well:
299 sp or r.sp has the value 1
300 rtoc or r.toc has the value 2
301 fpscr has the value 0
307 dsisr has the value 18
309 sdr1 has the value 25
310 srr0 has the value 26
311 srr1 has the value 27
313 The table is sorted. Suitable for searching by a binary search. */
315 static const struct pd_reg pre_defined_registers
[] =
317 { "cr.0", 0 }, /* Condition Registers */
337 { "dar", 19 }, /* Data Access Register */
338 { "dec", 22 }, /* Decrementer */
339 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
341 { "f.0", 0 }, /* Floating point registers */
409 { "lr", 8 }, /* Link Register */
413 { "r.0", 0 }, /* General Purpose Registers */
446 { "r.sp", 1 }, /* Stack Pointer */
448 { "r.toc", 2 }, /* Pointer to the table of contents */
450 { "r0", 0 }, /* More general purpose registers */
483 { "rtoc", 2 }, /* Table of contents */
485 { "sdr1", 25 }, /* Storage Description Register 1 */
489 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
490 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
492 { "v.0", 0 }, /* Vector registers */
562 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
564 /* Given NAME, find the register number associated with that name, return
565 the integer value associated with the given name or -1 on failure. */
567 static int reg_name_search
568 PARAMS ((const struct pd_reg
*, int, const char * name
));
571 reg_name_search (regs
, regcount
, name
)
572 const struct pd_reg
*regs
;
576 int middle
, low
, high
;
584 middle
= (low
+ high
) / 2;
585 cmp
= strcasecmp (name
, regs
[middle
].name
);
591 return regs
[middle
].value
;
599 * Summary of register_name.
601 * in: Input_line_pointer points to 1st char of operand.
603 * out: A expressionS.
604 * The operand may have been a register: in this case, X_op == O_register,
605 * X_add_number is set to the register number, and truth is returned.
606 * Input_line_pointer->(next non-blank) char after operand, or is in its
611 register_name (expressionP
)
612 expressionS
*expressionP
;
619 /* Find the spelling of the operand. */
620 start
= name
= input_line_pointer
;
621 if (name
[0] == '%' && ISALPHA (name
[1]))
622 name
= ++input_line_pointer
;
624 else if (!reg_names_p
|| !ISALPHA (name
[0]))
627 c
= get_symbol_end ();
628 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
630 /* Put back the delimiting char. */
631 *input_line_pointer
= c
;
633 /* Look to see if it's in the register table. */
636 expressionP
->X_op
= O_register
;
637 expressionP
->X_add_number
= reg_number
;
639 /* Make the rest nice. */
640 expressionP
->X_add_symbol
= NULL
;
641 expressionP
->X_op_symbol
= NULL
;
645 /* Reset the line as if we had not done anything. */
646 input_line_pointer
= start
;
650 /* This function is called for each symbol seen in an expression. It
651 handles the special parsing which PowerPC assemblers are supposed
652 to use for condition codes. */
654 /* Whether to do the special parsing. */
655 static bfd_boolean cr_operand
;
657 /* Names to recognize in a condition code. This table is sorted. */
658 static const struct pd_reg cr_names
[] =
675 /* Parsing function. This returns non-zero if it recognized an
679 ppc_parse_name (name
, expr
)
688 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
693 expr
->X_op
= O_constant
;
694 expr
->X_add_number
= val
;
699 /* Local variables. */
701 /* The type of processor we are assembling for. This is one or more
702 of the PPC_OPCODE flags defined in opcode/ppc.h. */
703 static unsigned long ppc_cpu
= 0;
705 /* Whether to target xcoff64/elf64. */
706 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
708 /* Opcode hash table. */
709 static struct hash_control
*ppc_hash
;
711 /* Macro hash table. */
712 static struct hash_control
*ppc_macro_hash
;
715 /* What type of shared library support to use. */
716 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
718 /* Flags to set in the elf header. */
719 static flagword ppc_flags
= 0;
721 /* Whether this is Solaris or not. */
722 #ifdef TARGET_SOLARIS_COMMENT
723 #define SOLARIS_P TRUE
725 #define SOLARIS_P FALSE
728 static bfd_boolean msolaris
= SOLARIS_P
;
733 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
734 using a bunch of different sections. These assembler sections,
735 however, are all encompassed within the .text or .data sections of
736 the final output file. We handle this by using different
737 subsegments within these main segments. */
739 /* Next subsegment to allocate within the .text segment. */
740 static subsegT ppc_text_subsegment
= 2;
742 /* Linked list of csects in the text section. */
743 static symbolS
*ppc_text_csects
;
745 /* Next subsegment to allocate within the .data segment. */
746 static subsegT ppc_data_subsegment
= 2;
748 /* Linked list of csects in the data section. */
749 static symbolS
*ppc_data_csects
;
751 /* The current csect. */
752 static symbolS
*ppc_current_csect
;
754 /* The RS/6000 assembler uses a TOC which holds addresses of functions
755 and variables. Symbols are put in the TOC with the .tc pseudo-op.
756 A special relocation is used when accessing TOC entries. We handle
757 the TOC as a subsegment within the .data segment. We set it up if
758 we see a .toc pseudo-op, and save the csect symbol here. */
759 static symbolS
*ppc_toc_csect
;
761 /* The first frag in the TOC subsegment. */
762 static fragS
*ppc_toc_frag
;
764 /* The first frag in the first subsegment after the TOC in the .data
765 segment. NULL if there are no subsegments after the TOC. */
766 static fragS
*ppc_after_toc_frag
;
768 /* The current static block. */
769 static symbolS
*ppc_current_block
;
771 /* The COFF debugging section; set by md_begin. This is not the
772 .debug section, but is instead the secret BFD section which will
773 cause BFD to set the section number of a symbol to N_DEBUG. */
774 static asection
*ppc_coff_debug_section
;
776 #endif /* OBJ_XCOFF */
780 /* Various sections that we need for PE coff support. */
781 static segT ydata_section
;
782 static segT pdata_section
;
783 static segT reldata_section
;
784 static segT rdata_section
;
785 static segT tocdata_section
;
787 /* The current section and the previous section. See ppc_previous. */
788 static segT ppc_previous_section
;
789 static segT ppc_current_section
;
794 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
795 #define PPC_APUINFO_ISEL 0x40
796 #define PPC_APUINFO_PMR 0x41
797 #define PPC_APUINFO_RFMCI 0x42
798 #define PPC_APUINFO_CACHELCK 0x43
799 #define PPC_APUINFO_SPE 0x100
800 #define PPC_APUINFO_EFS 0x101
801 #define PPC_APUINFO_BRLOCK 0x102
804 * We keep a list of APUinfo
806 unsigned long *ppc_apuinfo_list
;
807 unsigned int ppc_apuinfo_num
;
808 unsigned int ppc_apuinfo_num_alloc
;
812 const char *const md_shortopts
= "b:l:usm:K:VQ:";
814 const char *const md_shortopts
= "um:";
816 const struct option md_longopts
[] = {
817 {NULL
, no_argument
, NULL
, 0}
819 const size_t md_longopts_size
= sizeof (md_longopts
);
822 md_parse_option (c
, arg
)
829 /* -u means that any undefined symbols should be treated as
830 external, which is the default for gas anyhow. */
835 /* Solaris as takes -le (presumably for little endian). For completeness
836 sake, recognize -be also. */
837 if (strcmp (arg
, "e") == 0)
839 target_big_endian
= 0;
840 set_target_endian
= 1;
848 if (strcmp (arg
, "e") == 0)
850 target_big_endian
= 1;
851 set_target_endian
= 1;
859 /* Recognize -K PIC. */
860 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
863 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
871 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
873 if (strcmp (arg
, "64") == 0)
878 as_fatal (_("%s unsupported"), "-a64");
881 else if (strcmp (arg
, "32") == 0)
888 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
890 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
891 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
| PPC_OPCODE_32
;
892 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
893 else if (strcmp (arg
, "pwr") == 0)
894 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
895 /* -m601 means to assemble for the PowerPC 601, which includes
896 instructions that are holdovers from the Power. */
897 else if (strcmp (arg
, "601") == 0)
898 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
899 | PPC_OPCODE_601
| PPC_OPCODE_32
);
900 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
902 else if (strcmp (arg
, "ppc") == 0
903 || strcmp (arg
, "ppc32") == 0
904 || strcmp (arg
, "603") == 0
905 || strcmp (arg
, "604") == 0)
906 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
907 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
908 else if (strcmp (arg
, "403") == 0
909 || strcmp (arg
, "405") == 0)
910 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
911 | PPC_OPCODE_403
| PPC_OPCODE_32
);
912 else if (strcmp (arg
, "7400") == 0
913 || strcmp (arg
, "7410") == 0
914 || strcmp (arg
, "7450") == 0
915 || strcmp (arg
, "7455") == 0)
916 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
917 | PPC_OPCODE_ALTIVEC
| PPC_OPCODE_32
);
918 else if (strcmp (arg
, "altivec") == 0)
921 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_ALTIVEC
;
923 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
925 else if (strcmp (arg
, "e500") == 0 || strcmp (arg
, "e500x2") == 0)
927 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_SPE
928 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
| PPC_OPCODE_BRLOCK
929 | PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
932 else if (strcmp (arg
, "spe") == 0)
935 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_SPE
| PPC_OPCODE_EFS
;
937 ppc_cpu
|= PPC_OPCODE_SPE
;
939 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
941 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
943 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
945 else if (strcmp (arg
, "ppc64bridge") == 0)
947 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
948 | PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
);
950 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
951 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
953 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
;
955 /* -mbooke64 means enable 64-bit BookE support. */
956 else if (strcmp (arg
, "booke64") == 0)
958 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
959 | PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
);
961 else if (strcmp (arg
, "power4") == 0)
963 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
964 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
);
966 /* -mcom means assemble for the common intersection between Power
967 and PowerPC. At present, we just allow the union, rather
968 than the intersection. */
969 else if (strcmp (arg
, "com") == 0)
970 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
971 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
972 else if (strcmp (arg
, "any") == 0)
973 ppc_cpu
= PPC_OPCODE_ANY
| PPC_OPCODE_32
;
975 else if (strcmp (arg
, "regnames") == 0)
978 else if (strcmp (arg
, "no-regnames") == 0)
982 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
983 that require relocation. */
984 else if (strcmp (arg
, "relocatable") == 0)
986 shlib
= SHLIB_MRELOCATABLE
;
987 ppc_flags
|= EF_PPC_RELOCATABLE
;
990 else if (strcmp (arg
, "relocatable-lib") == 0)
992 shlib
= SHLIB_MRELOCATABLE
;
993 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
996 /* -memb, set embedded bit. */
997 else if (strcmp (arg
, "emb") == 0)
998 ppc_flags
|= EF_PPC_EMB
;
1000 /* -mlittle/-mbig set the endianess. */
1001 else if (strcmp (arg
, "little") == 0
1002 || strcmp (arg
, "little-endian") == 0)
1004 target_big_endian
= 0;
1005 set_target_endian
= 1;
1008 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1010 target_big_endian
= 1;
1011 set_target_endian
= 1;
1014 else if (strcmp (arg
, "solaris") == 0)
1017 ppc_comment_chars
= ppc_solaris_comment_chars
;
1020 else if (strcmp (arg
, "no-solaris") == 0)
1023 ppc_comment_chars
= ppc_eabi_comment_chars
;
1028 as_bad (_("invalid switch -m%s"), arg
);
1034 /* -V: SVR4 argument to print version ID. */
1036 print_version_id ();
1039 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1040 should be emitted or not. FIXME: Not implemented. */
1044 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1045 rather than .stabs.excl, which is ignored by the linker.
1046 FIXME: Not implemented. */
1062 md_show_usage (stream
)
1065 fprintf (stream
, _("\
1067 -a32 generate ELF32/XCOFF32\n\
1068 -a64 generate ELF64/XCOFF64\n\
1070 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1071 -mpwr generate code for POWER (RIOS1)\n\
1072 -m601 generate code for PowerPC 601\n\
1073 -mppc, -mppc32, -m603, -m604\n\
1074 generate code for PowerPC 603/604\n\
1075 -m403, -m405 generate code for PowerPC 403/405\n\
1076 -m7400, -m7410, -m7450, -m7455\n\
1077 generate code For PowerPC 7400/7410/7450/7455\n"));
1078 fprintf (stream
, _("\
1079 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1080 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1081 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1082 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1083 -mpower4 generate code for Power4 architecture\n\
1084 -mcom generate code Power/PowerPC common instructions\n\
1085 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1086 fprintf (stream
, _("\
1087 -maltivec generate code for AltiVec\n\
1088 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1089 -mspe generate code for Motorola SPE instructions\n\
1090 -mregnames Allow symbolic names for registers\n\
1091 -mno-regnames Do not allow symbolic names for registers\n"));
1093 fprintf (stream
, _("\
1094 -mrelocatable support for GCC's -mrelocatble option\n\
1095 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1096 -memb set PPC_EMB bit in ELF flags\n\
1097 -mlittle, -mlittle-endian, -l, -le\n\
1098 generate code for a little endian machine\n\
1099 -mbig, -mbig-endian, -b, -be\n\
1100 generate code for a big endian machine\n\
1101 -msolaris generate code for Solaris\n\
1102 -mno-solaris do not generate code for Solaris\n\
1103 -V print assembler version number\n\
1104 -Qy, -Qn ignored\n"));
1108 /* Set ppc_cpu if it is not already set. */
1113 const char *default_os
= TARGET_OS
;
1114 const char *default_cpu
= TARGET_CPU
;
1119 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1120 else if (strncmp (default_os
, "aix", 3) == 0
1121 && default_os
[3] >= '4' && default_os
[3] <= '9')
1122 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1123 else if (strncmp (default_os
, "aix3", 4) == 0)
1124 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1125 else if (strcmp (default_cpu
, "rs6000") == 0)
1126 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1127 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1129 if (default_cpu
[7] == '6' && default_cpu
[8] == '4')
1130 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1132 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
1135 as_fatal (_("Unknown default cpu = %s, os = %s"),
1136 default_cpu
, default_os
);
1140 /* Figure out the BFD architecture to use. */
1142 enum bfd_architecture
1145 const char *default_cpu
= TARGET_CPU
;
1148 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1149 return bfd_arch_powerpc
;
1150 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1151 return bfd_arch_rs6000
;
1152 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1154 if (strcmp (default_cpu
, "rs6000") == 0)
1155 return bfd_arch_rs6000
;
1156 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1157 return bfd_arch_powerpc
;
1160 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1161 return bfd_arch_unknown
;
1168 return bfd_mach_ppc64
;
1169 else if (ppc_arch () == bfd_arch_rs6000
)
1170 return bfd_mach_rs6k
;
1172 return bfd_mach_ppc
;
1176 ppc_target_format ()
1180 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1182 return "xcoff-powermac";
1185 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1187 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1192 return (target_big_endian
1193 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1194 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1198 /* This function is called when the assembler starts up. It is called
1199 after the options have been parsed and the output file has been
1205 register const struct powerpc_opcode
*op
;
1206 const struct powerpc_opcode
*op_end
;
1207 const struct powerpc_macro
*macro
;
1208 const struct powerpc_macro
*macro_end
;
1209 bfd_boolean dup_insn
= FALSE
;
1214 /* Set the ELF flags if desired. */
1215 if (ppc_flags
&& !msolaris
)
1216 bfd_set_private_flags (stdoutput
, ppc_flags
);
1219 /* Insert the opcodes into a hash table. */
1220 ppc_hash
= hash_new ();
1222 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1223 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1225 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1227 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1228 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1229 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1230 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1231 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1232 /* Certain instructions (eg: extsw) do not exist in the
1233 32-bit BookE instruction set, but they do exist in the
1234 64-bit BookE instruction set, and other PPC instruction
1235 sets. Check to see if the opcode has the BOOKE64 flag set.
1236 If it does make sure that the target CPU is not the BookE32. */
1237 && ((op
->flags
& PPC_OPCODE_BOOKE64
) == 0
1238 || (ppc_cpu
& PPC_OPCODE_BOOKE64
) == PPC_OPCODE_BOOKE64
1239 || (ppc_cpu
& PPC_OPCODE_BOOKE
) == 0)
1240 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1241 || ((op
->flags
& PPC_OPCODE_POWER4
)
1242 == (ppc_cpu
& PPC_OPCODE_POWER4
))))
1246 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1247 if (retval
!= (const char *) NULL
)
1249 /* Ignore Power duplicates for -m601. */
1250 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1251 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1254 as_bad (_("Internal assembler error for instruction %s"),
1261 /* Insert the macros into a hash table. */
1262 ppc_macro_hash
= hash_new ();
1264 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1265 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1267 if ((macro
->flags
& ppc_cpu
) != 0)
1271 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1272 if (retval
!= (const char *) NULL
)
1274 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1283 /* Tell the main code what the endianness is if it is not overidden
1285 if (!set_target_endian
)
1287 set_target_endian
= 1;
1288 target_big_endian
= PPC_BIG_ENDIAN
;
1292 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1294 /* Create dummy symbols to serve as initial csects. This forces the
1295 text csects to precede the data csects. These symbols will not
1297 ppc_text_csects
= symbol_make ("dummy\001");
1298 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1299 ppc_data_csects
= symbol_make ("dummy\001");
1300 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1305 ppc_current_section
= text_section
;
1306 ppc_previous_section
= 0;
1315 if (ppc_apuinfo_list
== NULL
)
1318 /* Ok, so write the section info out. We have this layout:
1322 0 8 length of "APUinfo\0"
1323 4 (n*4) number of APU's (4 bytes each)
1326 20 APU#1 first APU's info
1327 24 APU#2 second APU's info
1332 asection
*seg
= now_seg
;
1333 subsegT subseg
= now_subseg
;
1334 asection
*apuinfo_secp
= (asection
*) NULL
;
1337 /* Create the .PPC.EMB.apuinfo section. */
1338 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1339 bfd_set_section_flags (stdoutput
,
1341 SEC_HAS_CONTENTS
| SEC_READONLY
);
1344 md_number_to_chars (p
, (valueT
) 8, 4);
1347 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
, 4);
1350 md_number_to_chars (p
, (valueT
) 2, 4);
1353 strcpy (p
, "APUinfo");
1355 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1358 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1361 frag_align (2, 0, 0);
1363 /* We probably can't restore the current segment, for there likely
1366 subseg_set (seg
, subseg
);
1371 /* Insert an operand value into an instruction. */
1373 static unsigned long
1374 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1376 const struct powerpc_operand
*operand
;
1381 if (operand
->bits
!= 32)
1386 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1388 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1389 max
= (1 << operand
->bits
) - 1;
1391 max
= (1 << (operand
->bits
- 1)) - 1;
1392 min
= - (1 << (operand
->bits
- 1));
1396 /* Some people write 32 bit hex constants with the sign
1397 extension done by hand. This shouldn't really be
1398 valid, but, to permit this code to assemble on a 64
1399 bit host, we sign extend the 32 bit value. */
1401 && (val
& (offsetT
) 0x80000000) != 0
1402 && (val
& (offsetT
) 0xffffffff) == val
)
1411 max
= (1 << operand
->bits
) - 1;
1415 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1420 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1423 _("operand out of range (%s not between %ld and %ld)");
1426 sprint_value (buf
, test
);
1427 as_bad_where (file
, line
, err
, buf
, min
, max
);
1431 if (operand
->insert
)
1436 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1437 if (errmsg
!= (const char *) NULL
)
1438 as_bad_where (file
, line
, errmsg
);
1441 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1449 /* Parse @got, etc. and return the desired relocation. */
1450 static bfd_reloc_code_real_type
1451 ppc_elf_suffix (str_p
, exp_p
)
1466 const struct map_bfd
*ptr
;
1468 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1470 static const struct map_bfd mapping
[] = {
1471 MAP ("l", (int) BFD_RELOC_LO16
),
1472 MAP ("h", (int) BFD_RELOC_HI16
),
1473 MAP ("ha", (int) BFD_RELOC_HI16_S
),
1474 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN
),
1475 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN
),
1476 MAP ("got", (int) BFD_RELOC_16_GOTOFF
),
1477 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF
),
1478 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF
),
1479 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF
),
1480 MAP ("fixup", (int) BFD_RELOC_CTOR
),
1481 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL
),
1482 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL
),
1483 MAP ("copy", (int) BFD_RELOC_PPC_COPY
),
1484 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT
),
1485 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC
),
1486 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC
),
1487 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL
),
1488 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF
),
1489 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF
),
1490 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF
),
1491 MAP ("sdarel", (int) BFD_RELOC_GPREL16
),
1492 MAP ("sectoff", (int) BFD_RELOC_16_BASEREL
),
1493 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL
),
1494 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL
),
1495 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL
),
1496 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32
),
1497 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16
),
1498 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO
),
1499 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI
),
1500 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA
),
1501 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16
),
1502 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL
),
1503 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16
),
1504 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21
),
1505 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF
),
1506 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16
),
1507 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO
),
1508 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI
),
1509 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA
),
1510 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD
),
1511 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA
),
1512 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16
),
1513 MAP ("tls", (int) BFD_RELOC_PPC_TLS
),
1514 MAP ("dtpmod", (int) BFD_RELOC_PPC_DTPMOD
),
1515 MAP ("dtprel", (int) BFD_RELOC_PPC_DTPREL
),
1516 MAP ("dtprel@l", (int) BFD_RELOC_PPC_DTPREL16_LO
),
1517 MAP ("dtprel@h", (int) BFD_RELOC_PPC_DTPREL16_HI
),
1518 MAP ("dtprel@ha", (int) BFD_RELOC_PPC_DTPREL16_HA
),
1519 MAP ("tprel", (int) BFD_RELOC_PPC_TPREL
),
1520 MAP ("tprel@l", (int) BFD_RELOC_PPC_TPREL16_LO
),
1521 MAP ("tprel@h", (int) BFD_RELOC_PPC_TPREL16_HI
),
1522 MAP ("tprel@ha", (int) BFD_RELOC_PPC_TPREL16_HA
),
1523 MAP ("got@tlsgd", (int) BFD_RELOC_PPC_GOT_TLSGD16
),
1524 MAP ("got@tlsgd@l", (int) BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1525 MAP ("got@tlsgd@h", (int) BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1526 MAP ("got@tlsgd@ha", (int) BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1527 MAP ("got@tlsld", (int) BFD_RELOC_PPC_GOT_TLSLD16
),
1528 MAP ("got@tlsld@l", (int) BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1529 MAP ("got@tlsld@h", (int) BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1530 MAP ("got@tlsld@ha", (int) BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1531 MAP ("got@dtprel", (int) BFD_RELOC_PPC_GOT_DTPREL16
),
1532 MAP ("got@dtprel@l", (int) BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1533 MAP ("got@dtprel@h", (int) BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1534 MAP ("got@dtprel@ha", (int) BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1535 MAP ("got@tprel", (int) BFD_RELOC_PPC_GOT_TPREL16
),
1536 MAP ("got@tprel@l", (int) BFD_RELOC_PPC_GOT_TPREL16_LO
),
1537 MAP ("got@tprel@h", (int) BFD_RELOC_PPC_GOT_TPREL16_HI
),
1538 MAP ("got@tprel@ha", (int) BFD_RELOC_PPC_GOT_TPREL16_HA
),
1539 /* The following are only valid for ppc64. Negative values are
1540 used instead of a flag. */
1541 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER
),
1542 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S
),
1543 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST
),
1544 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S
),
1545 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC
),
1546 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16
),
1547 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO
),
1548 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI
),
1549 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA
),
1550 MAP ("dtprel@higher", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1551 MAP ("dtprel@highera", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1552 MAP ("dtprel@highest", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1553 MAP ("dtprel@highesta", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1554 MAP ("tprel@higher", - (int) BFD_RELOC_PPC64_TPREL16_HIGHER
),
1555 MAP ("tprel@highera", - (int) BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1556 MAP ("tprel@highest", - (int) BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1557 MAP ("tprel@highesta", - (int) BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1558 { (char *) 0, 0, (int) BFD_RELOC_UNUSED
}
1562 return BFD_RELOC_UNUSED
;
1564 for (ch
= *str
, str2
= ident
;
1565 (str2
< ident
+ sizeof (ident
) - 1
1566 && (ISALNUM (ch
) || ch
== '@'));
1569 *str2
++ = TOLOWER (ch
);
1576 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1577 if (ch
== ptr
->string
[0]
1578 && len
== ptr
->length
1579 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1581 int reloc
= ptr
->reloc
;
1586 return BFD_RELOC_UNUSED
;
1591 if (exp_p
->X_add_number
!= 0
1592 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1593 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1594 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1595 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1596 as_warn (_("identifier+constant@got means identifier@got+constant"));
1598 /* Now check for identifier@suffix+constant. */
1599 if (*str
== '-' || *str
== '+')
1601 char *orig_line
= input_line_pointer
;
1602 expressionS new_exp
;
1604 input_line_pointer
= str
;
1605 expression (&new_exp
);
1606 if (new_exp
.X_op
== O_constant
)
1608 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1609 str
= input_line_pointer
;
1612 if (&input_line_pointer
!= str_p
)
1613 input_line_pointer
= orig_line
;
1617 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1618 && exp_p
->X_op
== O_symbol
)
1620 /* This reloc type ignores the symbol. Change the symbol
1621 so that the dummy .TOC. symbol can be omitted from the
1623 exp_p
->X_add_symbol
= &abs_symbol
;
1626 return (bfd_reloc_code_real_type
) reloc
;
1629 return BFD_RELOC_UNUSED
;
1632 /* Like normal .long/.short/.word, except support @got, etc.
1633 Clobbers input_line_pointer, checks end-of-line. */
1635 ppc_elf_cons (nbytes
)
1636 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1639 bfd_reloc_code_real_type reloc
;
1641 if (is_it_end_of_statement ())
1643 demand_empty_rest_of_line ();
1650 if (exp
.X_op
== O_symbol
1651 && *input_line_pointer
== '@'
1652 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1653 &exp
)) != BFD_RELOC_UNUSED
)
1655 reloc_howto_type
*reloc_howto
;
1658 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1659 size
= bfd_get_reloc_size (reloc_howto
);
1663 as_bad (_("%s relocations do not fit in %d bytes\n"),
1664 reloc_howto
->name
, nbytes
);
1671 p
= frag_more (nbytes
);
1673 if (target_big_endian
)
1674 offset
= nbytes
- size
;
1675 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1680 emit_expr (&exp
, (unsigned int) nbytes
);
1682 while (*input_line_pointer
++ == ',');
1684 /* Put terminator back into stream. */
1685 input_line_pointer
--;
1686 demand_empty_rest_of_line ();
1689 /* Solaris pseduo op to change to the .rodata section. */
1694 char *save_line
= input_line_pointer
;
1695 static char section
[] = ".rodata\n";
1697 /* Just pretend this is .section .rodata */
1698 input_line_pointer
= section
;
1699 obj_elf_section (xxx
);
1701 input_line_pointer
= save_line
;
1704 /* Pseudo op to make file scope bss items. */
1707 int xxx ATTRIBUTE_UNUSED
;
1709 register char *name
;
1713 register symbolS
*symbolP
;
1720 name
= input_line_pointer
;
1721 c
= get_symbol_end ();
1723 /* just after name is now '\0'. */
1724 p
= input_line_pointer
;
1727 if (*input_line_pointer
!= ',')
1729 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1730 ignore_rest_of_line ();
1734 input_line_pointer
++; /* skip ',' */
1735 if ((size
= get_absolute_expression ()) < 0)
1737 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1738 ignore_rest_of_line ();
1742 /* The third argument to .lcomm is the alignment. */
1743 if (*input_line_pointer
!= ',')
1747 ++input_line_pointer
;
1748 align
= get_absolute_expression ();
1751 as_warn (_("ignoring bad alignment"));
1757 symbolP
= symbol_find_or_make (name
);
1760 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1762 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1763 S_GET_NAME (symbolP
));
1764 ignore_rest_of_line ();
1768 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1770 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1771 S_GET_NAME (symbolP
),
1772 (long) S_GET_VALUE (symbolP
),
1775 ignore_rest_of_line ();
1781 old_subsec
= now_subseg
;
1784 /* Convert to a power of 2 alignment. */
1785 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1788 as_bad (_("Common alignment not a power of 2"));
1789 ignore_rest_of_line ();
1796 record_alignment (bss_section
, align2
);
1797 subseg_set (bss_section
, 0);
1799 frag_align (align2
, 0, 0);
1800 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1801 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1802 symbol_set_frag (symbolP
, frag_now
);
1803 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1806 S_SET_SIZE (symbolP
, size
);
1807 S_SET_SEGMENT (symbolP
, bss_section
);
1808 subseg_set (old_sec
, old_subsec
);
1809 demand_empty_rest_of_line ();
1812 /* Validate any relocations emitted for -mrelocatable, possibly adding
1813 fixups for word relocations in writable segments, so we can adjust
1816 ppc_elf_validate_fix (fixp
, seg
)
1820 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1829 case SHLIB_MRELOCATABLE
:
1830 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1831 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1832 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1833 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1834 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1835 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1836 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1837 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1838 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1839 && (seg
->flags
& SEC_LOAD
) != 0
1840 && strcmp (segment_name (seg
), ".got2") != 0
1841 && strcmp (segment_name (seg
), ".dtors") != 0
1842 && strcmp (segment_name (seg
), ".ctors") != 0
1843 && strcmp (segment_name (seg
), ".fixup") != 0
1844 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1845 && strcmp (segment_name (seg
), ".eh_frame") != 0
1846 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1848 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1849 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1851 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1852 _("Relocation cannot be done when using -mrelocatable"));
1859 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1860 function descriptor sym if the corresponding code sym is used. */
1863 ppc_frob_file_before_adjust ()
1870 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1877 name
= S_GET_NAME (symp
);
1881 if (! S_IS_WEAK (symp
)
1882 || S_IS_DEFINED (symp
))
1885 len
= strlen (name
) + 1;
1886 dotname
= xmalloc (len
+ 1);
1888 memcpy (dotname
+ 1, name
, len
);
1889 dotsym
= symbol_find (dotname
);
1891 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1892 || symbol_used_in_reloc_p (dotsym
)))
1894 symbol_mark_used (symp
);
1898 /* Don't emit .TOC. symbol. */
1899 symp
= symbol_find (".TOC.");
1901 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1903 #endif /* OBJ_ELF */
1908 * Summary of parse_toc_entry.
1910 * in: Input_line_pointer points to the '[' in one of:
1912 * [toc] [tocv] [toc32] [toc64]
1914 * Anything else is an error of one kind or another.
1917 * return value: success or failure
1918 * toc_kind: kind of toc reference
1919 * input_line_pointer:
1920 * success: first char after the ']'
1921 * failure: unchanged
1925 * [toc] - rv == success, toc_kind = default_toc
1926 * [tocv] - rv == success, toc_kind = data_in_toc
1927 * [toc32] - rv == success, toc_kind = must_be_32
1928 * [toc64] - rv == success, toc_kind = must_be_64
1932 enum toc_size_qualifier
1934 default_toc
, /* The toc cell constructed should be the system default size */
1935 data_in_toc
, /* This is a direct reference to a toc cell */
1936 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1937 must_be_64
/* The toc cell constructed must be 64 bits wide */
1941 parse_toc_entry (toc_kind
)
1942 enum toc_size_qualifier
*toc_kind
;
1947 enum toc_size_qualifier t
;
1949 /* Save the input_line_pointer. */
1950 start
= input_line_pointer
;
1952 /* Skip over the '[' , and whitespace. */
1953 ++input_line_pointer
;
1956 /* Find the spelling of the operand. */
1957 toc_spec
= input_line_pointer
;
1958 c
= get_symbol_end ();
1960 if (strcmp (toc_spec
, "toc") == 0)
1964 else if (strcmp (toc_spec
, "tocv") == 0)
1968 else if (strcmp (toc_spec
, "toc32") == 0)
1972 else if (strcmp (toc_spec
, "toc64") == 0)
1978 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1979 *input_line_pointer
= c
;
1980 input_line_pointer
= start
;
1984 /* Now find the ']'. */
1985 *input_line_pointer
= c
;
1987 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1988 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1992 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1993 input_line_pointer
= start
;
2004 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2006 ppc_apuinfo_section_add (apu
, version
)
2007 unsigned int apu
, version
;
2011 /* Check we don't already exist. */
2012 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2013 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2016 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2018 if (ppc_apuinfo_num_alloc
== 0)
2020 ppc_apuinfo_num_alloc
= 4;
2021 ppc_apuinfo_list
= (unsigned long *)
2022 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2026 ppc_apuinfo_num_alloc
+= 4;
2027 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2028 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2031 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2037 /* We need to keep a list of fixups. We can't simply generate them as
2038 we go, because that would require us to first create the frag, and
2039 that would screw up references to ``.''. */
2045 bfd_reloc_code_real_type reloc
;
2048 #define MAX_INSN_FIXUPS (5)
2050 /* This routine is called for each instruction to be assembled. */
2057 const struct powerpc_opcode
*opcode
;
2059 const unsigned char *opindex_ptr
;
2063 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2068 bfd_reloc_code_real_type reloc
;
2071 /* Get the opcode. */
2072 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2077 /* Look up the opcode in the hash table. */
2078 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2079 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2081 const struct powerpc_macro
*macro
;
2083 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2084 if (macro
== (const struct powerpc_macro
*) NULL
)
2085 as_bad (_("Unrecognized opcode: `%s'"), str
);
2087 ppc_macro (s
, macro
);
2092 insn
= opcode
->opcode
;
2095 while (ISSPACE (*str
))
2098 /* PowerPC operands are just expressions. The only real issue is
2099 that a few operand types are optional. All cases which might use
2100 an optional operand separate the operands only with commas (in
2101 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
2102 cases never have optional operands). There is never more than
2103 one optional operand for an instruction. So, before we start
2104 seriously parsing the operands, we check to see if we have an
2105 optional operand, and, if we do, we count the number of commas to
2106 see whether the operand should be omitted. */
2108 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2110 const struct powerpc_operand
*operand
;
2112 operand
= &powerpc_operands
[*opindex_ptr
];
2113 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2115 unsigned int opcount
;
2116 unsigned int num_operands_expected
;
2119 /* There is an optional operand. Count the number of
2120 commas in the input line. */
2127 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2134 /* Compute the number of expected operands.
2135 Do not count fake operands. */
2136 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2137 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2138 ++ num_operands_expected
;
2140 /* If there are fewer operands in the line then are called
2141 for by the instruction, we want to skip the optional
2143 if (opcount
< num_operands_expected
)
2150 /* Gather the operands. */
2154 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2156 const struct powerpc_operand
*operand
;
2162 if (next_opindex
== 0)
2163 operand
= &powerpc_operands
[*opindex_ptr
];
2166 operand
= &powerpc_operands
[next_opindex
];
2171 /* If this is a fake operand, then we do not expect anything
2173 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2175 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2176 if (errmsg
!= (const char *) NULL
)
2181 /* If this is an optional operand, and we are skipping it, just
2183 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2186 if (operand
->insert
)
2188 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2189 if (errmsg
!= (const char *) NULL
)
2192 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2193 next_opindex
= *opindex_ptr
+ 1;
2197 /* Gather the operand. */
2198 hold
= input_line_pointer
;
2199 input_line_pointer
= str
;
2202 if (*input_line_pointer
== '[')
2204 /* We are expecting something like the second argument here:
2206 * lwz r4,[toc].GS.0.static_int(rtoc)
2207 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2208 * The argument following the `]' must be a symbol name, and the
2209 * register must be the toc register: 'rtoc' or '2'
2211 * The effect is to 0 as the displacement field
2212 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2213 * the appropriate variation) reloc against it based on the symbol.
2214 * The linker will build the toc, and insert the resolved toc offset.
2217 * o The size of the toc entry is currently assumed to be
2218 * 32 bits. This should not be assumed to be a hard coded
2220 * o In an effort to cope with a change from 32 to 64 bits,
2221 * there are also toc entries that are specified to be
2222 * either 32 or 64 bits:
2223 * lwz r4,[toc32].GS.0.static_int(rtoc)
2224 * lwz r4,[toc64].GS.0.static_int(rtoc)
2225 * These demand toc entries of the specified size, and the
2226 * instruction probably requires it.
2230 enum toc_size_qualifier toc_kind
;
2231 bfd_reloc_code_real_type toc_reloc
;
2233 /* Go parse off the [tocXX] part. */
2234 valid_toc
= parse_toc_entry (&toc_kind
);
2238 /* Note: message has already been issued.
2239 FIXME: what sort of recovery should we do?
2240 demand_rest_of_line (); return; ? */
2243 /* Now get the symbol following the ']'. */
2249 /* In this case, we may not have seen the symbol yet,
2250 since it is allowed to appear on a .extern or .globl
2251 or just be a label in the .data section. */
2252 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2255 /* 1. The symbol must be defined and either in the toc
2256 section, or a global.
2257 2. The reloc generated must have the TOCDEFN flag set
2258 in upper bit mess of the reloc type.
2259 FIXME: It's a little confusing what the tocv
2260 qualifier can be used for. At the very least, I've
2261 seen three uses, only one of which I'm sure I can
2263 if (ex
.X_op
== O_symbol
)
2265 assert (ex
.X_add_symbol
!= NULL
);
2266 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2269 as_bad (_("[tocv] symbol is not a toc symbol"));
2273 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2276 /* FIXME: these next two specifically specify 32/64 bit
2277 toc entries. We don't support them today. Is this
2278 the right way to say that? */
2279 toc_reloc
= BFD_RELOC_UNUSED
;
2280 as_bad (_("Unimplemented toc32 expression modifier"));
2283 /* FIXME: see above. */
2284 toc_reloc
= BFD_RELOC_UNUSED
;
2285 as_bad (_("Unimplemented toc64 expression modifier"));
2289 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2295 /* We need to generate a fixup for this expression. */
2296 if (fc
>= MAX_INSN_FIXUPS
)
2297 as_fatal (_("too many fixups"));
2299 fixups
[fc
].reloc
= toc_reloc
;
2300 fixups
[fc
].exp
= ex
;
2301 fixups
[fc
].opindex
= *opindex_ptr
;
2304 /* Ok. We've set up the fixup for the instruction. Now make it
2305 look like the constant 0 was found here. */
2307 ex
.X_op
= O_constant
;
2308 ex
.X_add_number
= 0;
2309 ex
.X_add_symbol
= NULL
;
2310 ex
.X_op_symbol
= NULL
;
2316 if (! register_name (&ex
))
2318 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2325 str
= input_line_pointer
;
2326 input_line_pointer
= hold
;
2328 if (ex
.X_op
== O_illegal
)
2329 as_bad (_("illegal operand"));
2330 else if (ex
.X_op
== O_absent
)
2331 as_bad (_("missing operand"));
2332 else if (ex
.X_op
== O_register
)
2334 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2337 else if (ex
.X_op
== O_constant
)
2340 /* Allow @HA, @L, @H on constants. */
2341 char *orig_str
= str
;
2343 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2350 case BFD_RELOC_LO16
:
2351 /* X_unsigned is the default, so if the user has done
2352 something which cleared it, we always produce a
2354 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2355 ex
.X_add_number
&= 0xffff;
2357 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2360 case BFD_RELOC_HI16
:
2361 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2362 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2364 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2367 case BFD_RELOC_HI16_S
:
2368 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2369 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2371 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2374 case BFD_RELOC_PPC64_HIGHER
:
2375 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2376 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2378 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2381 case BFD_RELOC_PPC64_HIGHER_S
:
2382 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2383 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2385 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2388 case BFD_RELOC_PPC64_HIGHEST
:
2389 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2390 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2392 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2395 case BFD_RELOC_PPC64_HIGHEST_S
:
2396 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2397 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2399 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2402 #endif /* OBJ_ELF */
2403 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2407 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2409 /* Some TLS tweaks. */
2414 case BFD_RELOC_PPC_TLS
:
2415 insn
= ppc_insert_operand (insn
, operand
, ppc_obj64
? 13 : 2,
2418 /* We'll only use the 32 (or 64) bit form of these relocations
2419 in constants. Instructions get the 16 bit form. */
2420 case BFD_RELOC_PPC_DTPREL
:
2421 reloc
= BFD_RELOC_PPC_DTPREL16
;
2423 case BFD_RELOC_PPC_TPREL
:
2424 reloc
= BFD_RELOC_PPC_TPREL16
;
2428 /* For the absolute forms of branches, convert the PC
2429 relative form back into the absolute. */
2430 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2434 case BFD_RELOC_PPC_B26
:
2435 reloc
= BFD_RELOC_PPC_BA26
;
2437 case BFD_RELOC_PPC_B16
:
2438 reloc
= BFD_RELOC_PPC_BA16
;
2440 case BFD_RELOC_PPC_B16_BRTAKEN
:
2441 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2443 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2444 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2452 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2457 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2459 case BFD_RELOC_LO16
:
2460 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2462 case BFD_RELOC_16_GOTOFF
:
2463 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2465 case BFD_RELOC_LO16_GOTOFF
:
2466 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2468 case BFD_RELOC_LO16_PLTOFF
:
2469 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2471 case BFD_RELOC_16_BASEREL
:
2472 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2474 case BFD_RELOC_LO16_BASEREL
:
2475 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2477 case BFD_RELOC_PPC_TOC16
:
2478 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2480 case BFD_RELOC_PPC64_TOC16_LO
:
2481 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2483 case BFD_RELOC_PPC64_PLTGOT16
:
2484 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2486 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2487 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2489 case BFD_RELOC_PPC_DTPREL16
:
2490 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2492 case BFD_RELOC_PPC_DTPREL16_LO
:
2493 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2495 case BFD_RELOC_PPC_TPREL16
:
2496 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2498 case BFD_RELOC_PPC_TPREL16_LO
:
2499 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2501 case BFD_RELOC_PPC_GOT_DTPREL16
:
2502 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2503 case BFD_RELOC_PPC_GOT_TPREL16
:
2504 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2507 as_bad (_("unsupported relocation for DS offset field"));
2512 /* We need to generate a fixup for this expression. */
2513 if (fc
>= MAX_INSN_FIXUPS
)
2514 as_fatal (_("too many fixups"));
2515 fixups
[fc
].exp
= ex
;
2516 fixups
[fc
].opindex
= 0;
2517 fixups
[fc
].reloc
= reloc
;
2520 #endif /* OBJ_ELF */
2524 /* We need to generate a fixup for this expression. */
2525 if (fc
>= MAX_INSN_FIXUPS
)
2526 as_fatal (_("too many fixups"));
2527 fixups
[fc
].exp
= ex
;
2528 fixups
[fc
].opindex
= *opindex_ptr
;
2529 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2538 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2546 /* The call to expression should have advanced str past any
2549 && (endc
!= ',' || *str
!= '\0'))
2551 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2559 while (ISSPACE (*str
))
2563 as_bad (_("junk at end of line: `%s'"), str
);
2566 /* Do we need/want a APUinfo section? */
2567 if (ppc_cpu
& (PPC_OPCODE_SPE
2568 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
2569 | PPC_OPCODE_BRLOCK
| PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
2570 | PPC_OPCODE_RFMCI
))
2572 /* These are all version "1". */
2573 if (opcode
->flags
& PPC_OPCODE_SPE
)
2574 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2575 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2576 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2577 if (opcode
->flags
& PPC_OPCODE_EFS
)
2578 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2579 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2580 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2581 if (opcode
->flags
& PPC_OPCODE_PMR
)
2582 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2583 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2584 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2585 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2586 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2590 /* Write out the instruction. */
2592 md_number_to_chars (f
, insn
, 4);
2595 dwarf2_emit_insn (4);
2598 /* Create any fixups. At this point we do not use a
2599 bfd_reloc_code_real_type, but instead just use the
2600 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2601 handle fixups for any operand type, although that is admittedly
2602 not a very exciting feature. We pick a BFD reloc type in
2604 for (i
= 0; i
< fc
; i
++)
2606 const struct powerpc_operand
*operand
;
2608 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2609 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2611 reloc_howto_type
*reloc_howto
;
2616 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2620 size
= bfd_get_reloc_size (reloc_howto
);
2621 offset
= target_big_endian
? (4 - size
) : 0;
2623 if (size
< 1 || size
> 4)
2626 fixP
= fix_new_exp (frag_now
,
2627 f
- frag_now
->fr_literal
+ offset
,
2630 reloc_howto
->pc_relative
,
2633 /* Turn off complaints that the addend is too large for things like
2635 switch (fixups
[i
].reloc
)
2637 case BFD_RELOC_16_GOTOFF
:
2638 case BFD_RELOC_PPC_TOC16
:
2639 case BFD_RELOC_LO16
:
2640 case BFD_RELOC_HI16
:
2641 case BFD_RELOC_HI16_S
:
2643 case BFD_RELOC_PPC64_HIGHER
:
2644 case BFD_RELOC_PPC64_HIGHER_S
:
2645 case BFD_RELOC_PPC64_HIGHEST
:
2646 case BFD_RELOC_PPC64_HIGHEST_S
:
2648 fixP
->fx_no_overflow
= 1;
2655 fix_new_exp (frag_now
,
2656 f
- frag_now
->fr_literal
,
2659 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2660 ((bfd_reloc_code_real_type
)
2661 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2665 /* Handle a macro. Gather all the operands, transform them as
2666 described by the macro, and call md_assemble recursively. All the
2667 operands are separated by commas; we don't accept parentheses
2668 around operands here. */
2671 ppc_macro (str
, macro
)
2673 const struct powerpc_macro
*macro
;
2684 /* Gather the users operands into the operands array. */
2689 if (count
>= sizeof operands
/ sizeof operands
[0])
2691 operands
[count
++] = s
;
2692 s
= strchr (s
, ',');
2693 if (s
== (char *) NULL
)
2698 if (count
!= macro
->operands
)
2700 as_bad (_("wrong number of operands"));
2704 /* Work out how large the string must be (the size is unbounded
2705 because it includes user input). */
2707 format
= macro
->format
;
2708 while (*format
!= '\0')
2717 arg
= strtol (format
+ 1, &send
, 10);
2718 know (send
!= format
&& arg
>= 0 && arg
< count
);
2719 len
+= strlen (operands
[arg
]);
2724 /* Put the string together. */
2725 complete
= s
= (char *) alloca (len
+ 1);
2726 format
= macro
->format
;
2727 while (*format
!= '\0')
2733 arg
= strtol (format
+ 1, &send
, 10);
2734 strcpy (s
, operands
[arg
]);
2741 /* Assemble the constructed instruction. */
2742 md_assemble (complete
);
2746 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2749 ppc_section_letter (letter
, ptr_msg
)
2756 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2761 ppc_section_word (str
, len
)
2765 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2772 ppc_section_type (str
, len
)
2776 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2783 ppc_section_flags (flags
, attr
, type
)
2788 if (type
== SHT_ORDERED
)
2789 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2791 if (attr
& SHF_EXCLUDE
)
2792 flags
|= SEC_EXCLUDE
;
2796 #endif /* OBJ_ELF */
2799 /* Pseudo-op handling. */
2801 /* The .byte pseudo-op. This is similar to the normal .byte
2802 pseudo-op, but it can also take a single ASCII string. */
2806 int ignore ATTRIBUTE_UNUSED
;
2808 if (*input_line_pointer
!= '\"')
2814 /* Gather characters. A real double quote is doubled. Unusual
2815 characters are not permitted. */
2816 ++input_line_pointer
;
2821 c
= *input_line_pointer
++;
2825 if (*input_line_pointer
!= '\"')
2827 ++input_line_pointer
;
2830 FRAG_APPEND_1_CHAR (c
);
2833 demand_empty_rest_of_line ();
2838 /* XCOFF specific pseudo-op handling. */
2840 /* This is set if we are creating a .stabx symbol, since we don't want
2841 to handle symbol suffixes for such symbols. */
2842 static bfd_boolean ppc_stab_symbol
;
2844 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2845 symbols in the .bss segment as though they were local common
2846 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2847 aligns .comm and .lcomm to 4 bytes. */
2853 asection
*current_seg
= now_seg
;
2854 subsegT current_subseg
= now_subseg
;
2860 symbolS
*lcomm_sym
= NULL
;
2864 name
= input_line_pointer
;
2865 endc
= get_symbol_end ();
2866 end_name
= input_line_pointer
;
2869 if (*input_line_pointer
!= ',')
2871 as_bad (_("missing size"));
2872 ignore_rest_of_line ();
2875 ++input_line_pointer
;
2877 size
= get_absolute_expression ();
2880 as_bad (_("negative size"));
2881 ignore_rest_of_line ();
2887 /* The third argument to .comm is the alignment. */
2888 if (*input_line_pointer
!= ',')
2892 ++input_line_pointer
;
2893 align
= get_absolute_expression ();
2896 as_warn (_("ignoring bad alignment"));
2911 /* The third argument to .lcomm appears to be the real local
2912 common symbol to create. References to the symbol named in
2913 the first argument are turned into references to the third
2915 if (*input_line_pointer
!= ',')
2917 as_bad (_("missing real symbol name"));
2918 ignore_rest_of_line ();
2921 ++input_line_pointer
;
2923 lcomm_name
= input_line_pointer
;
2924 lcomm_endc
= get_symbol_end ();
2926 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2928 *input_line_pointer
= lcomm_endc
;
2932 sym
= symbol_find_or_make (name
);
2935 if (S_IS_DEFINED (sym
)
2936 || S_GET_VALUE (sym
) != 0)
2938 as_bad (_("attempt to redefine symbol"));
2939 ignore_rest_of_line ();
2943 record_alignment (bss_section
, align
);
2946 || ! S_IS_DEFINED (lcomm_sym
))
2955 S_SET_EXTERNAL (sym
);
2959 symbol_get_tc (lcomm_sym
)->output
= 1;
2960 def_sym
= lcomm_sym
;
2964 subseg_set (bss_section
, 1);
2965 frag_align (align
, 0, 0);
2967 symbol_set_frag (def_sym
, frag_now
);
2968 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2969 def_size
, (char *) NULL
);
2971 S_SET_SEGMENT (def_sym
, bss_section
);
2972 symbol_get_tc (def_sym
)->align
= align
;
2976 /* Align the size of lcomm_sym. */
2977 symbol_get_frag (lcomm_sym
)->fr_offset
=
2978 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2979 &~ ((1 << align
) - 1));
2980 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2981 symbol_get_tc (lcomm_sym
)->align
= align
;
2986 /* Make sym an offset from lcomm_sym. */
2987 S_SET_SEGMENT (sym
, bss_section
);
2988 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2989 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2990 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2993 subseg_set (current_seg
, current_subseg
);
2995 demand_empty_rest_of_line ();
2998 /* The .csect pseudo-op. This switches us into a different
2999 subsegment. The first argument is a symbol whose value is the
3000 start of the .csect. In COFF, csect symbols get special aux
3001 entries defined by the x_csect field of union internal_auxent. The
3002 optional second argument is the alignment (the default is 2). */
3006 int ignore ATTRIBUTE_UNUSED
;
3012 name
= input_line_pointer
;
3013 endc
= get_symbol_end ();
3015 sym
= symbol_find_or_make (name
);
3017 *input_line_pointer
= endc
;
3019 if (S_GET_NAME (sym
)[0] == '\0')
3021 /* An unnamed csect is assumed to be [PR]. */
3022 symbol_get_tc (sym
)->class = XMC_PR
;
3025 ppc_change_csect (sym
);
3027 if (*input_line_pointer
== ',')
3029 ++input_line_pointer
;
3030 symbol_get_tc (sym
)->align
= get_absolute_expression ();
3033 demand_empty_rest_of_line ();
3036 /* Change to a different csect. */
3039 ppc_change_csect (sym
)
3042 if (S_IS_DEFINED (sym
))
3043 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3051 /* This is a new csect. We need to look at the symbol class to
3052 figure out whether it should go in the text section or the
3055 switch (symbol_get_tc (sym
)->class)
3065 S_SET_SEGMENT (sym
, text_section
);
3066 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3067 ++ppc_text_subsegment
;
3068 list_ptr
= &ppc_text_csects
;
3077 if (ppc_toc_csect
!= NULL
3078 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3079 == ppc_data_subsegment
))
3081 S_SET_SEGMENT (sym
, data_section
);
3082 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3083 ++ppc_data_subsegment
;
3084 list_ptr
= &ppc_data_csects
;
3090 /* We set the obstack chunk size to a small value before
3091 changing subsegments, so that we don't use a lot of memory
3092 space for what may be a small section. */
3093 hold_chunksize
= chunksize
;
3096 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3097 symbol_get_tc (sym
)->subseg
);
3099 chunksize
= hold_chunksize
;
3102 ppc_after_toc_frag
= frag_now
;
3104 symbol_set_frag (sym
, frag_now
);
3105 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3107 symbol_get_tc (sym
)->align
= 2;
3108 symbol_get_tc (sym
)->output
= 1;
3109 symbol_get_tc (sym
)->within
= sym
;
3111 for (list
= *list_ptr
;
3112 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3113 list
= symbol_get_tc (list
)->next
)
3115 symbol_get_tc (list
)->next
= sym
;
3117 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3118 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3122 ppc_current_csect
= sym
;
3125 /* This function handles the .text and .data pseudo-ops. These
3126 pseudo-ops aren't really used by XCOFF; we implement them for the
3127 convenience of people who aren't used to XCOFF. */
3138 else if (type
== 'd')
3143 sym
= symbol_find_or_make (name
);
3145 ppc_change_csect (sym
);
3147 demand_empty_rest_of_line ();
3150 /* This function handles the .section pseudo-op. This is mostly to
3151 give an error, since XCOFF only supports .text, .data and .bss, but
3152 we do permit the user to name the text or data section. */
3155 ppc_named_section (ignore
)
3156 int ignore ATTRIBUTE_UNUSED
;
3159 const char *real_name
;
3163 user_name
= input_line_pointer
;
3164 c
= get_symbol_end ();
3166 if (strcmp (user_name
, ".text") == 0)
3167 real_name
= ".text[PR]";
3168 else if (strcmp (user_name
, ".data") == 0)
3169 real_name
= ".data[RW]";
3172 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3173 *input_line_pointer
= c
;
3174 ignore_rest_of_line ();
3178 *input_line_pointer
= c
;
3180 sym
= symbol_find_or_make (real_name
);
3182 ppc_change_csect (sym
);
3184 demand_empty_rest_of_line ();
3187 /* The .extern pseudo-op. We create an undefined symbol. */
3191 int ignore ATTRIBUTE_UNUSED
;
3196 name
= input_line_pointer
;
3197 endc
= get_symbol_end ();
3199 (void) symbol_find_or_make (name
);
3201 *input_line_pointer
= endc
;
3203 demand_empty_rest_of_line ();
3206 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3210 int ignore ATTRIBUTE_UNUSED
;
3216 name
= input_line_pointer
;
3217 endc
= get_symbol_end ();
3219 sym
= symbol_find_or_make (name
);
3221 *input_line_pointer
= endc
;
3223 symbol_get_tc (sym
)->output
= 1;
3225 demand_empty_rest_of_line ();
3228 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3229 although I don't know why it bothers. */
3233 int ignore ATTRIBUTE_UNUSED
;
3240 name
= input_line_pointer
;
3241 endc
= get_symbol_end ();
3243 sym
= symbol_find_or_make (name
);
3245 *input_line_pointer
= endc
;
3247 if (*input_line_pointer
!= ',')
3249 as_bad (_("missing rename string"));
3250 ignore_rest_of_line ();
3253 ++input_line_pointer
;
3255 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3257 demand_empty_rest_of_line ();
3260 /* The .stabx pseudo-op. This is similar to a normal .stabs
3261 pseudo-op, but slightly different. A sample is
3262 .stabx "main:F-1",.main,142,0
3263 The first argument is the symbol name to create. The second is the
3264 value, and the third is the storage class. The fourth seems to be
3265 always zero, and I am assuming it is the type. */
3269 int ignore ATTRIBUTE_UNUSED
;
3276 name
= demand_copy_C_string (&len
);
3278 if (*input_line_pointer
!= ',')
3280 as_bad (_("missing value"));
3283 ++input_line_pointer
;
3285 ppc_stab_symbol
= TRUE
;
3286 sym
= symbol_make (name
);
3287 ppc_stab_symbol
= FALSE
;
3289 symbol_get_tc (sym
)->real_name
= name
;
3291 (void) expression (&exp
);
3298 as_bad (_("illegal .stabx expression; zero assumed"));
3299 exp
.X_add_number
= 0;
3302 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3303 symbol_set_frag (sym
, &zero_address_frag
);
3307 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3308 symbol_set_value_expression (sym
, &exp
);
3312 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3313 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3318 /* The value is some complex expression. This will probably
3319 fail at some later point, but this is probably the right
3320 thing to do here. */
3321 symbol_set_value_expression (sym
, &exp
);
3325 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3326 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3328 if (*input_line_pointer
!= ',')
3330 as_bad (_("missing class"));
3333 ++input_line_pointer
;
3335 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3337 if (*input_line_pointer
!= ',')
3339 as_bad (_("missing type"));
3342 ++input_line_pointer
;
3344 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3346 symbol_get_tc (sym
)->output
= 1;
3348 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3350 symbol_get_tc (sym
)->within
= ppc_current_block
;
3355 .stabx "z",arrays_,133,0
3358 .comm arrays_,13768,3
3360 resolve_symbol_value will copy the exp's "within" into sym's when the
3361 offset is 0. Since this seems to be corner case problem,
3362 only do the correction for storage class C_STSYM. A better solution
3363 would be to have the tc field updated in ppc_symbol_new_hook. */
3365 if (exp
.X_op
== O_symbol
)
3367 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3371 if (exp
.X_op
!= O_symbol
3372 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3373 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3374 ppc_frob_label (sym
);
3377 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3378 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3379 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3380 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3383 demand_empty_rest_of_line ();
3386 /* The .function pseudo-op. This takes several arguments. The first
3387 argument seems to be the external name of the symbol. The second
3388 argment seems to be the label for the start of the function. gcc
3389 uses the same name for both. I have no idea what the third and
3390 fourth arguments are meant to be. The optional fifth argument is
3391 an expression for the size of the function. In COFF this symbol
3392 gets an aux entry like that used for a csect. */
3395 ppc_function (ignore
)
3396 int ignore ATTRIBUTE_UNUSED
;
3404 name
= input_line_pointer
;
3405 endc
= get_symbol_end ();
3407 /* Ignore any [PR] suffix. */
3408 name
= ppc_canonicalize_symbol_name (name
);
3409 s
= strchr (name
, '[');
3410 if (s
!= (char *) NULL
3411 && strcmp (s
+ 1, "PR]") == 0)
3414 ext_sym
= symbol_find_or_make (name
);
3416 *input_line_pointer
= endc
;
3418 if (*input_line_pointer
!= ',')
3420 as_bad (_("missing symbol name"));
3421 ignore_rest_of_line ();
3424 ++input_line_pointer
;
3426 name
= input_line_pointer
;
3427 endc
= get_symbol_end ();
3429 lab_sym
= symbol_find_or_make (name
);
3431 *input_line_pointer
= endc
;
3433 if (ext_sym
!= lab_sym
)
3437 exp
.X_op
= O_symbol
;
3438 exp
.X_add_symbol
= lab_sym
;
3439 exp
.X_op_symbol
= NULL
;
3440 exp
.X_add_number
= 0;
3442 symbol_set_value_expression (ext_sym
, &exp
);
3445 if (symbol_get_tc (ext_sym
)->class == -1)
3446 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3447 symbol_get_tc (ext_sym
)->output
= 1;
3449 if (*input_line_pointer
== ',')
3453 /* Ignore the third argument. */
3454 ++input_line_pointer
;
3455 expression (&ignore
);
3456 if (*input_line_pointer
== ',')
3458 /* Ignore the fourth argument. */
3459 ++input_line_pointer
;
3460 expression (&ignore
);
3461 if (*input_line_pointer
== ',')
3463 /* The fifth argument is the function size. */
3464 ++input_line_pointer
;
3465 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3468 &zero_address_frag
);
3469 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3474 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3475 SF_SET_FUNCTION (ext_sym
);
3476 SF_SET_PROCESS (ext_sym
);
3477 coff_add_linesym (ext_sym
);
3479 demand_empty_rest_of_line ();
3482 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3483 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3484 with the correct line number */
3486 static symbolS
*saved_bi_sym
= 0;
3490 int ignore ATTRIBUTE_UNUSED
;
3494 sym
= symbol_make (".bf");
3495 S_SET_SEGMENT (sym
, text_section
);
3496 symbol_set_frag (sym
, frag_now
);
3497 S_SET_VALUE (sym
, frag_now_fix ());
3498 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3500 coff_line_base
= get_absolute_expression ();
3502 S_SET_NUMBER_AUXILIARY (sym
, 1);
3503 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3505 /* Line number for bi. */
3508 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3513 symbol_get_tc (sym
)->output
= 1;
3515 ppc_frob_label (sym
);
3517 demand_empty_rest_of_line ();
3520 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3521 ".ef", except that the line number is absolute, not relative to the
3522 most recent ".bf" symbol. */
3526 int ignore ATTRIBUTE_UNUSED
;
3530 sym
= symbol_make (".ef");
3531 S_SET_SEGMENT (sym
, text_section
);
3532 symbol_set_frag (sym
, frag_now
);
3533 S_SET_VALUE (sym
, frag_now_fix ());
3534 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3535 S_SET_NUMBER_AUXILIARY (sym
, 1);
3536 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3537 symbol_get_tc (sym
)->output
= 1;
3539 ppc_frob_label (sym
);
3541 demand_empty_rest_of_line ();
3544 /* The .bi and .ei pseudo-ops. These take a string argument and
3545 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3546 the symbol list. The value of .bi will be know when the next .bf
3553 static symbolS
*last_biei
;
3560 name
= demand_copy_C_string (&len
);
3562 /* The value of these symbols is actually file offset. Here we set
3563 the value to the index into the line number entries. In
3564 ppc_frob_symbols we set the fix_line field, which will cause BFD
3565 to do the right thing. */
3567 sym
= symbol_make (name
);
3568 /* obj-coff.c currently only handles line numbers correctly in the
3570 S_SET_SEGMENT (sym
, text_section
);
3571 S_SET_VALUE (sym
, coff_n_line_nos
);
3572 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3574 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3575 symbol_get_tc (sym
)->output
= 1;
3583 for (look
= last_biei
? last_biei
: symbol_rootP
;
3584 (look
!= (symbolS
*) NULL
3585 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3586 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3587 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3588 look
= symbol_next (look
))
3590 if (look
!= (symbolS
*) NULL
)
3592 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3593 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3597 demand_empty_rest_of_line ();
3600 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3601 There is one argument, which is a csect symbol. The value of the
3602 .bs symbol is the index of this csect symbol. */
3606 int ignore ATTRIBUTE_UNUSED
;
3613 if (ppc_current_block
!= NULL
)
3614 as_bad (_("nested .bs blocks"));
3616 name
= input_line_pointer
;
3617 endc
= get_symbol_end ();
3619 csect
= symbol_find_or_make (name
);
3621 *input_line_pointer
= endc
;
3623 sym
= symbol_make (".bs");
3624 S_SET_SEGMENT (sym
, now_seg
);
3625 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3626 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3627 symbol_get_tc (sym
)->output
= 1;
3629 symbol_get_tc (sym
)->within
= csect
;
3631 ppc_frob_label (sym
);
3633 ppc_current_block
= sym
;
3635 demand_empty_rest_of_line ();
3638 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3642 int ignore ATTRIBUTE_UNUSED
;
3646 if (ppc_current_block
== NULL
)
3647 as_bad (_(".es without preceding .bs"));
3649 sym
= symbol_make (".es");
3650 S_SET_SEGMENT (sym
, now_seg
);
3651 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3652 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3653 symbol_get_tc (sym
)->output
= 1;
3655 ppc_frob_label (sym
);
3657 ppc_current_block
= NULL
;
3659 demand_empty_rest_of_line ();
3662 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3667 int ignore ATTRIBUTE_UNUSED
;
3671 sym
= symbol_make (".bb");
3672 S_SET_SEGMENT (sym
, text_section
);
3673 symbol_set_frag (sym
, frag_now
);
3674 S_SET_VALUE (sym
, frag_now_fix ());
3675 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3677 S_SET_NUMBER_AUXILIARY (sym
, 1);
3678 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3680 symbol_get_tc (sym
)->output
= 1;
3682 SF_SET_PROCESS (sym
);
3684 ppc_frob_label (sym
);
3686 demand_empty_rest_of_line ();
3689 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3694 int ignore ATTRIBUTE_UNUSED
;
3698 sym
= symbol_make (".eb");
3699 S_SET_SEGMENT (sym
, text_section
);
3700 symbol_set_frag (sym
, frag_now
);
3701 S_SET_VALUE (sym
, frag_now_fix ());
3702 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3703 S_SET_NUMBER_AUXILIARY (sym
, 1);
3704 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3705 symbol_get_tc (sym
)->output
= 1;
3707 SF_SET_PROCESS (sym
);
3709 ppc_frob_label (sym
);
3711 demand_empty_rest_of_line ();
3714 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3719 int ignore ATTRIBUTE_UNUSED
;
3725 name
= demand_copy_C_string (&len
);
3726 sym
= symbol_make (name
);
3727 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3728 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3729 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3730 S_SET_VALUE (sym
, 0);
3731 symbol_get_tc (sym
)->output
= 1;
3733 ppc_frob_label (sym
);
3735 demand_empty_rest_of_line ();
3738 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3742 int ignore ATTRIBUTE_UNUSED
;
3746 sym
= symbol_make (".ec");
3747 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3748 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3749 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3750 S_SET_VALUE (sym
, 0);
3751 symbol_get_tc (sym
)->output
= 1;
3753 ppc_frob_label (sym
);
3755 demand_empty_rest_of_line ();
3758 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3762 int ignore ATTRIBUTE_UNUSED
;
3764 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3765 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3772 subseg
= ppc_data_subsegment
;
3773 ++ppc_data_subsegment
;
3775 subseg_new (segment_name (data_section
), subseg
);
3776 ppc_toc_frag
= frag_now
;
3778 sym
= symbol_find_or_make ("TOC[TC0]");
3779 symbol_set_frag (sym
, frag_now
);
3780 S_SET_SEGMENT (sym
, data_section
);
3781 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3782 symbol_get_tc (sym
)->subseg
= subseg
;
3783 symbol_get_tc (sym
)->output
= 1;
3784 symbol_get_tc (sym
)->within
= sym
;
3786 ppc_toc_csect
= sym
;
3788 for (list
= ppc_data_csects
;
3789 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3790 list
= symbol_get_tc (list
)->next
)
3792 symbol_get_tc (list
)->next
= sym
;
3794 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3795 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3799 ppc_current_csect
= ppc_toc_csect
;
3801 demand_empty_rest_of_line ();
3804 /* The AIX assembler automatically aligns the operands of a .long or
3805 .short pseudo-op, and we want to be compatible. */
3808 ppc_xcoff_cons (log_size
)
3811 frag_align (log_size
, 0, 0);
3812 record_alignment (now_seg
, log_size
);
3813 cons (1 << log_size
);
3818 int dummy ATTRIBUTE_UNUSED
;
3823 (void) expression (&exp
);
3825 if (exp
.X_op
!= O_constant
)
3827 as_bad (_("non-constant byte count"));
3831 byte_count
= exp
.X_add_number
;
3833 if (*input_line_pointer
!= ',')
3835 as_bad (_("missing value"));
3839 ++input_line_pointer
;
3843 #endif /* OBJ_XCOFF */
3844 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3846 /* The .tc pseudo-op. This is used when generating either XCOFF or
3847 ELF. This takes two or more arguments.
3849 When generating XCOFF output, the first argument is the name to
3850 give to this location in the toc; this will be a symbol with class
3851 TC. The rest of the arguments are N-byte values to actually put at
3852 this location in the TOC; often there is just one more argument, a
3853 relocateable symbol reference. The size of the value to store
3854 depends on target word size. A 32-bit target uses 4-byte values, a
3855 64-bit target uses 8-byte values.
3857 When not generating XCOFF output, the arguments are the same, but
3858 the first argument is simply ignored. */
3862 int ignore ATTRIBUTE_UNUSED
;
3866 /* Define the TOC symbol name. */
3872 if (ppc_toc_csect
== (symbolS
*) NULL
3873 || ppc_toc_csect
!= ppc_current_csect
)
3875 as_bad (_(".tc not in .toc section"));
3876 ignore_rest_of_line ();
3880 name
= input_line_pointer
;
3881 endc
= get_symbol_end ();
3883 sym
= symbol_find_or_make (name
);
3885 *input_line_pointer
= endc
;
3887 if (S_IS_DEFINED (sym
))
3891 label
= symbol_get_tc (ppc_current_csect
)->within
;
3892 if (symbol_get_tc (label
)->class != XMC_TC0
)
3894 as_bad (_(".tc with no label"));
3895 ignore_rest_of_line ();
3899 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3900 symbol_set_frag (label
, symbol_get_frag (sym
));
3901 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3903 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3904 ++input_line_pointer
;
3909 S_SET_SEGMENT (sym
, now_seg
);
3910 symbol_set_frag (sym
, frag_now
);
3911 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3912 symbol_get_tc (sym
)->class = XMC_TC
;
3913 symbol_get_tc (sym
)->output
= 1;
3915 ppc_frob_label (sym
);
3918 #endif /* OBJ_XCOFF */
3922 /* Skip the TOC symbol name. */
3923 while (is_part_of_name (*input_line_pointer
)
3924 || *input_line_pointer
== '['
3925 || *input_line_pointer
== ']'
3926 || *input_line_pointer
== '{'
3927 || *input_line_pointer
== '}')
3928 ++input_line_pointer
;
3930 /* Align to a four/eight byte boundary. */
3931 align
= ppc_obj64
? 3 : 2;
3932 frag_align (align
, 0, 0);
3933 record_alignment (now_seg
, align
);
3934 #endif /* OBJ_ELF */
3936 if (*input_line_pointer
!= ',')
3937 demand_empty_rest_of_line ();
3940 ++input_line_pointer
;
3941 cons (ppc_obj64
? 8 : 4);
3945 /* Pseudo-op .machine. */
3946 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3947 accept this directive on the first line of input and set ppc_obj64
3948 and the target format accordingly. Unfortunately, the target
3949 format is selected in output-file.c:output_file_create before we
3950 even get to md_begin, so it's not possible without changing
3954 ppc_machine (ignore
)
3955 int ignore ATTRIBUTE_UNUSED
;
3957 discard_rest_of_line ();
3960 /* See whether a symbol is in the TOC section. */
3963 ppc_is_toc_sym (sym
)
3967 return symbol_get_tc (sym
)->class == XMC_TC
;
3970 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3972 return strcmp (sname
, ".toc") == 0;
3974 return strcmp (sname
, ".got") == 0;
3977 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3981 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3983 /* Set the current section. */
3985 ppc_set_current_section (new)
3988 ppc_previous_section
= ppc_current_section
;
3989 ppc_current_section
= new;
3992 /* pseudo-op: .previous
3993 behaviour: toggles the current section with the previous section.
3995 warnings: "No previous section" */
3998 ppc_previous (ignore
)
3999 int ignore ATTRIBUTE_UNUSED
;
4003 if (ppc_previous_section
== NULL
)
4005 as_warn (_("No previous section to return to. Directive ignored."));
4009 subseg_set (ppc_previous_section
, 0);
4011 ppc_set_current_section (ppc_previous_section
);
4014 /* pseudo-op: .pdata
4015 behaviour: predefined read only data section
4019 initial: .section .pdata "adr3"
4020 a - don't know -- maybe a misprint
4021 d - initialized data
4023 3 - double word aligned (that would be 4 byte boundary)
4026 Tag index tables (also known as the function table) for exception
4027 handling, debugging, etc. */
4031 int ignore ATTRIBUTE_UNUSED
;
4033 if (pdata_section
== 0)
4035 pdata_section
= subseg_new (".pdata", 0);
4037 bfd_set_section_flags (stdoutput
, pdata_section
,
4038 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4039 | SEC_READONLY
| SEC_DATA
));
4041 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4045 pdata_section
= subseg_new (".pdata", 0);
4047 ppc_set_current_section (pdata_section
);
4050 /* pseudo-op: .ydata
4051 behaviour: predefined read only data section
4055 initial: .section .ydata "drw3"
4056 a - don't know -- maybe a misprint
4057 d - initialized data
4059 3 - double word aligned (that would be 4 byte boundary)
4061 Tag tables (also known as the scope table) for exception handling,
4066 int ignore ATTRIBUTE_UNUSED
;
4068 if (ydata_section
== 0)
4070 ydata_section
= subseg_new (".ydata", 0);
4071 bfd_set_section_flags (stdoutput
, ydata_section
,
4072 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4073 | SEC_READONLY
| SEC_DATA
));
4075 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4079 ydata_section
= subseg_new (".ydata", 0);
4081 ppc_set_current_section (ydata_section
);
4084 /* pseudo-op: .reldata
4085 behaviour: predefined read write data section
4086 double word aligned (4-byte)
4087 FIXME: relocation is applied to it
4088 FIXME: what's the difference between this and .data?
4091 initial: .section .reldata "drw3"
4092 d - initialized data
4095 3 - double word aligned (that would be 8 byte boundary)
4098 Like .data, but intended to hold data subject to relocation, such as
4099 function descriptors, etc. */
4102 ppc_reldata (ignore
)
4103 int ignore ATTRIBUTE_UNUSED
;
4105 if (reldata_section
== 0)
4107 reldata_section
= subseg_new (".reldata", 0);
4109 bfd_set_section_flags (stdoutput
, reldata_section
,
4110 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4113 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4117 reldata_section
= subseg_new (".reldata", 0);
4119 ppc_set_current_section (reldata_section
);
4122 /* pseudo-op: .rdata
4123 behaviour: predefined read only data section
4127 initial: .section .rdata "dr3"
4128 d - initialized data
4130 3 - double word aligned (that would be 4 byte boundary) */
4134 int ignore ATTRIBUTE_UNUSED
;
4136 if (rdata_section
== 0)
4138 rdata_section
= subseg_new (".rdata", 0);
4139 bfd_set_section_flags (stdoutput
, rdata_section
,
4140 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4141 | SEC_READONLY
| SEC_DATA
));
4143 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4147 rdata_section
= subseg_new (".rdata", 0);
4149 ppc_set_current_section (rdata_section
);
4152 /* pseudo-op: .ualong
4153 behaviour: much like .int, with the exception that no alignment is
4155 FIXME: test the alignment statement
4161 int ignore ATTRIBUTE_UNUSED
;
4167 /* pseudo-op: .znop <symbol name>
4168 behaviour: Issue a nop instruction
4169 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4170 the supplied symbol name.
4172 warnings: Missing symbol name */
4176 int ignore ATTRIBUTE_UNUSED
;
4179 const struct powerpc_opcode
*opcode
;
4190 /* Strip out the symbol name. */
4191 symbol_name
= input_line_pointer
;
4192 c
= get_symbol_end ();
4194 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4195 strcpy (name
, symbol_name
);
4197 sym
= symbol_find_or_make (name
);
4199 *input_line_pointer
= c
;
4203 /* Look up the opcode in the hash table. */
4204 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4206 /* Stick in the nop. */
4207 insn
= opcode
->opcode
;
4209 /* Write out the instruction. */
4211 md_number_to_chars (f
, insn
, 4);
4213 f
- frag_now
->fr_literal
,
4218 BFD_RELOC_16_GOT_PCREL
);
4231 register char *name
;
4235 register symbolS
*symbolP
;
4238 name
= input_line_pointer
;
4239 c
= get_symbol_end ();
4241 /* just after name is now '\0'. */
4242 p
= input_line_pointer
;
4245 if (*input_line_pointer
!= ',')
4247 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4248 ignore_rest_of_line ();
4252 input_line_pointer
++; /* skip ',' */
4253 if ((temp
= get_absolute_expression ()) < 0)
4255 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4256 ignore_rest_of_line ();
4262 /* The third argument to .comm is the alignment. */
4263 if (*input_line_pointer
!= ',')
4267 ++input_line_pointer
;
4268 align
= get_absolute_expression ();
4271 as_warn (_("ignoring bad alignment"));
4278 symbolP
= symbol_find_or_make (name
);
4281 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4283 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4284 S_GET_NAME (symbolP
));
4285 ignore_rest_of_line ();
4289 if (S_GET_VALUE (symbolP
))
4291 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4292 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4293 S_GET_NAME (symbolP
),
4294 (long) S_GET_VALUE (symbolP
),
4299 S_SET_VALUE (symbolP
, (valueT
) temp
);
4300 S_SET_EXTERNAL (symbolP
);
4303 demand_empty_rest_of_line ();
4307 * implement the .section pseudo op:
4308 * .section name {, "flags"}
4310 * | +--- optional flags: 'b' for bss
4312 * +-- section name 'l' for lib
4316 * 'd' (apparently m88k for data)
4318 * But if the argument is not a quoted string, treat it as a
4319 * subsegment number.
4321 * FIXME: this is a copy of the section processing from obj-coff.c, with
4322 * additions/changes for the moto-pas assembler support. There are three
4325 * FIXME: I just noticed this. This doesn't work at all really. It it
4326 * setting bits that bfd probably neither understands or uses. The
4327 * correct approach (?) will have to incorporate extra fields attached
4328 * to the section to hold the system specific stuff. (krk)
4331 * 'a' - unknown - referred to in documentation, but no definition supplied
4332 * 'c' - section has code
4333 * 'd' - section has initialized data
4334 * 'u' - section has uninitialized data
4335 * 'i' - section contains directives (info)
4336 * 'n' - section can be discarded
4337 * 'R' - remove section at link time
4339 * Section Protection:
4340 * 'r' - section is readable
4341 * 'w' - section is writeable
4342 * 'x' - section is executable
4343 * 's' - section is sharable
4345 * Section Alignment:
4346 * '0' - align to byte boundary
4347 * '1' - align to halfword undary
4348 * '2' - align to word boundary
4349 * '3' - align to doubleword boundary
4350 * '4' - align to quadword boundary
4351 * '5' - align to 32 byte boundary
4352 * '6' - align to 64 byte boundary
4357 ppc_pe_section (ignore
)
4358 int ignore ATTRIBUTE_UNUSED
;
4360 /* Strip out the section name. */
4369 section_name
= input_line_pointer
;
4370 c
= get_symbol_end ();
4372 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4373 strcpy (name
, section_name
);
4375 *input_line_pointer
= c
;
4380 flags
= SEC_NO_FLAGS
;
4382 if (strcmp (name
, ".idata$2") == 0)
4386 else if (strcmp (name
, ".idata$3") == 0)
4390 else if (strcmp (name
, ".idata$4") == 0)
4394 else if (strcmp (name
, ".idata$5") == 0)
4398 else if (strcmp (name
, ".idata$6") == 0)
4403 /* Default alignment to 16 byte boundary. */
4406 if (*input_line_pointer
== ',')
4408 ++input_line_pointer
;
4410 if (*input_line_pointer
!= '"')
4411 exp
= get_absolute_expression ();
4414 ++input_line_pointer
;
4415 while (*input_line_pointer
!= '"'
4416 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4418 switch (*input_line_pointer
)
4420 /* Section Contents */
4421 case 'a': /* unknown */
4422 as_bad (_("Unsupported section attribute -- 'a'"));
4424 case 'c': /* code section */
4427 case 'd': /* section has initialized data */
4430 case 'u': /* section has uninitialized data */
4431 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4435 case 'i': /* section contains directives (info) */
4436 /* FIXME: This is IMAGE_SCN_LNK_INFO
4438 flags
|= SEC_HAS_CONTENTS
;
4440 case 'n': /* section can be discarded */
4443 case 'R': /* Remove section at link time */
4444 flags
|= SEC_NEVER_LOAD
;
4447 /* Section Protection */
4448 case 'r': /* section is readable */
4449 flags
|= IMAGE_SCN_MEM_READ
;
4451 case 'w': /* section is writeable */
4452 flags
|= IMAGE_SCN_MEM_WRITE
;
4454 case 'x': /* section is executable */
4455 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4457 case 's': /* section is sharable */
4458 flags
|= IMAGE_SCN_MEM_SHARED
;
4461 /* Section Alignment */
4462 case '0': /* align to byte boundary */
4463 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4466 case '1': /* align to halfword boundary */
4467 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4470 case '2': /* align to word boundary */
4471 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4474 case '3': /* align to doubleword boundary */
4475 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4478 case '4': /* align to quadword boundary */
4479 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4482 case '5': /* align to 32 byte boundary */
4483 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4486 case '6': /* align to 64 byte boundary */
4487 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4492 as_bad (_("unknown section attribute '%c'"),
4493 *input_line_pointer
);
4496 ++input_line_pointer
;
4498 if (*input_line_pointer
== '"')
4499 ++input_line_pointer
;
4503 sec
= subseg_new (name
, (subsegT
) exp
);
4505 ppc_set_current_section (sec
);
4507 if (flags
!= SEC_NO_FLAGS
)
4509 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4510 as_bad (_("error setting flags for \"%s\": %s"),
4511 bfd_section_name (stdoutput
, sec
),
4512 bfd_errmsg (bfd_get_error ()));
4515 bfd_set_section_alignment (stdoutput
, sec
, align
);
4520 ppc_pe_function (ignore
)
4521 int ignore ATTRIBUTE_UNUSED
;
4527 name
= input_line_pointer
;
4528 endc
= get_symbol_end ();
4530 ext_sym
= symbol_find_or_make (name
);
4532 *input_line_pointer
= endc
;
4534 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4535 SF_SET_FUNCTION (ext_sym
);
4536 SF_SET_PROCESS (ext_sym
);
4537 coff_add_linesym (ext_sym
);
4539 demand_empty_rest_of_line ();
4543 ppc_pe_tocd (ignore
)
4544 int ignore ATTRIBUTE_UNUSED
;
4546 if (tocdata_section
== 0)
4548 tocdata_section
= subseg_new (".tocd", 0);
4549 /* FIXME: section flags won't work. */
4550 bfd_set_section_flags (stdoutput
, tocdata_section
,
4551 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4552 | SEC_READONLY
| SEC_DATA
));
4554 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4558 rdata_section
= subseg_new (".tocd", 0);
4561 ppc_set_current_section (tocdata_section
);
4563 demand_empty_rest_of_line ();
4566 /* Don't adjust TOC relocs to use the section symbol. */
4569 ppc_pe_fix_adjustable (fix
)
4572 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4579 /* XCOFF specific symbol and file handling. */
4581 /* Canonicalize the symbol name. We use the to force the suffix, if
4582 any, to use square brackets, and to be in upper case. */
4585 ppc_canonicalize_symbol_name (name
)
4590 if (ppc_stab_symbol
)
4593 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4607 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4610 if (*s
== '\0' || s
[1] != '\0')
4611 as_bad (_("bad symbol suffix"));
4619 /* Set the class of a symbol based on the suffix, if any. This is
4620 called whenever a new symbol is created. */
4623 ppc_symbol_new_hook (sym
)
4626 struct ppc_tc_sy
*tc
;
4629 tc
= symbol_get_tc (sym
);
4633 tc
->real_name
= NULL
;
4639 if (ppc_stab_symbol
)
4642 s
= strchr (S_GET_NAME (sym
), '[');
4643 if (s
== (const char *) NULL
)
4645 /* There is no suffix. */
4654 if (strcmp (s
, "BS]") == 0)
4658 if (strcmp (s
, "DB]") == 0)
4660 else if (strcmp (s
, "DS]") == 0)
4664 if (strcmp (s
, "GL]") == 0)
4668 if (strcmp (s
, "PR]") == 0)
4672 if (strcmp (s
, "RO]") == 0)
4674 else if (strcmp (s
, "RW]") == 0)
4678 if (strcmp (s
, "SV]") == 0)
4682 if (strcmp (s
, "TC]") == 0)
4684 else if (strcmp (s
, "TI]") == 0)
4686 else if (strcmp (s
, "TB]") == 0)
4688 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4689 tc
->class = XMC_TC0
;
4692 if (strcmp (s
, "UA]") == 0)
4694 else if (strcmp (s
, "UC]") == 0)
4698 if (strcmp (s
, "XO]") == 0)
4703 if (tc
->class == -1)
4704 as_bad (_("Unrecognized symbol suffix"));
4707 /* Set the class of a label based on where it is defined. This
4708 handles symbols without suffixes. Also, move the symbol so that it
4709 follows the csect symbol. */
4712 ppc_frob_label (sym
)
4715 if (ppc_current_csect
!= (symbolS
*) NULL
)
4717 if (symbol_get_tc (sym
)->class == -1)
4718 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4720 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4721 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4722 &symbol_rootP
, &symbol_lastP
);
4723 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4727 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4728 seen. It tells ppc_adjust_symtab whether it needs to look through
4731 static bfd_boolean ppc_saw_abs
;
4733 /* Change the name of a symbol just before writing it out. Set the
4734 real name if the .rename pseudo-op was used. Otherwise, remove any
4735 class suffix. Return 1 if the symbol should not be included in the
4739 ppc_frob_symbol (sym
)
4742 static symbolS
*ppc_last_function
;
4743 static symbolS
*set_end
;
4745 /* Discard symbols that should not be included in the output symbol
4747 if (! symbol_used_in_reloc_p (sym
)
4748 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4749 || (! S_IS_EXTERNAL (sym
)
4750 && ! symbol_get_tc (sym
)->output
4751 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4754 /* This one will disappear anyway. Don't make a csect sym for it. */
4755 if (sym
== abs_section_sym
)
4758 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4759 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4765 name
= S_GET_NAME (sym
);
4766 s
= strchr (name
, '[');
4767 if (s
!= (char *) NULL
)
4773 snew
= xmalloc (len
+ 1);
4774 memcpy (snew
, name
, len
);
4777 S_SET_NAME (sym
, snew
);
4781 if (set_end
!= (symbolS
*) NULL
)
4783 SA_SET_SYM_ENDNDX (set_end
, sym
);
4787 if (SF_GET_FUNCTION (sym
))
4789 if (ppc_last_function
!= (symbolS
*) NULL
)
4790 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4791 ppc_last_function
= sym
;
4792 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4794 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4795 SA_SET_SYM_FSIZE (sym
,
4796 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4799 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4800 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4802 if (ppc_last_function
== (symbolS
*) NULL
)
4803 as_bad (_(".ef with no preceding .function"));
4806 set_end
= ppc_last_function
;
4807 ppc_last_function
= NULL
;
4809 /* We don't have a C_EFCN symbol, but we need to force the
4810 COFF backend to believe that it has seen one. */
4811 coff_last_function
= NULL
;
4815 if (! S_IS_EXTERNAL (sym
)
4816 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4817 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4818 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4819 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4820 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4821 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4822 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4823 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4824 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4825 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4827 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4828 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4831 union internal_auxent
*a
;
4833 /* Create a csect aux. */
4834 i
= S_GET_NUMBER_AUXILIARY (sym
);
4835 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4836 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4837 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4839 /* This is the TOC table. */
4840 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4841 a
->x_csect
.x_scnlen
.l
= 0;
4842 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4844 else if (symbol_get_tc (sym
)->subseg
!= 0)
4846 /* This is a csect symbol. x_scnlen is the size of the
4848 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4849 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4850 S_GET_SEGMENT (sym
))
4851 - S_GET_VALUE (sym
));
4854 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4855 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4856 - S_GET_VALUE (sym
));
4858 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4860 else if (S_GET_SEGMENT (sym
) == bss_section
)
4862 /* This is a common symbol. */
4863 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4864 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4865 if (S_IS_EXTERNAL (sym
))
4866 symbol_get_tc (sym
)->class = XMC_RW
;
4868 symbol_get_tc (sym
)->class = XMC_BS
;
4870 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4872 /* This is an absolute symbol. The csect will be created by
4873 ppc_adjust_symtab. */
4875 a
->x_csect
.x_smtyp
= XTY_LD
;
4876 if (symbol_get_tc (sym
)->class == -1)
4877 symbol_get_tc (sym
)->class = XMC_XO
;
4879 else if (! S_IS_DEFINED (sym
))
4881 /* This is an external symbol. */
4882 a
->x_csect
.x_scnlen
.l
= 0;
4883 a
->x_csect
.x_smtyp
= XTY_ER
;
4885 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4889 /* This is a TOC definition. x_scnlen is the size of the
4891 next
= symbol_next (sym
);
4892 while (symbol_get_tc (next
)->class == XMC_TC0
)
4893 next
= symbol_next (next
);
4894 if (next
== (symbolS
*) NULL
4895 || symbol_get_tc (next
)->class != XMC_TC
)
4897 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4898 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4900 - S_GET_VALUE (sym
));
4902 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4903 - S_GET_VALUE (sym
));
4907 resolve_symbol_value (next
);
4908 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4909 - S_GET_VALUE (sym
));
4911 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4917 /* This is a normal symbol definition. x_scnlen is the
4918 symbol index of the containing csect. */
4919 if (S_GET_SEGMENT (sym
) == text_section
)
4920 csect
= ppc_text_csects
;
4921 else if (S_GET_SEGMENT (sym
) == data_section
)
4922 csect
= ppc_data_csects
;
4926 /* Skip the initial dummy symbol. */
4927 csect
= symbol_get_tc (csect
)->next
;
4929 if (csect
== (symbolS
*) NULL
)
4931 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4932 a
->x_csect
.x_scnlen
.l
= 0;
4936 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4938 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4939 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4940 > S_GET_VALUE (sym
))
4942 csect
= symbol_get_tc (csect
)->next
;
4945 a
->x_csect
.x_scnlen
.p
=
4946 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4947 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4950 a
->x_csect
.x_smtyp
= XTY_LD
;
4953 a
->x_csect
.x_parmhash
= 0;
4954 a
->x_csect
.x_snhash
= 0;
4955 if (symbol_get_tc (sym
)->class == -1)
4956 a
->x_csect
.x_smclas
= XMC_PR
;
4958 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4959 a
->x_csect
.x_stab
= 0;
4960 a
->x_csect
.x_snstab
= 0;
4962 /* Don't let the COFF backend resort these symbols. */
4963 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4965 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4967 /* We want the value to be the symbol index of the referenced
4968 csect symbol. BFD will do that for us if we set the right
4970 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
4971 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
4973 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
4974 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4976 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4981 /* The value is the offset from the enclosing csect. */
4982 block
= symbol_get_tc (sym
)->within
;
4983 csect
= symbol_get_tc (block
)->within
;
4984 resolve_symbol_value (csect
);
4985 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4987 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4988 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4990 /* We want the value to be a file offset into the line numbers.
4991 BFD will do that for us if we set the right flags. We have
4992 already set the value correctly. */
4993 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4999 /* Adjust the symbol table. This creates csect symbols for all
5000 absolute symbols. */
5003 ppc_adjust_symtab ()
5010 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5014 union internal_auxent
*a
;
5016 if (S_GET_SEGMENT (sym
) != absolute_section
)
5019 csect
= symbol_create (".abs[XO]", absolute_section
,
5020 S_GET_VALUE (sym
), &zero_address_frag
);
5021 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5022 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5023 i
= S_GET_NUMBER_AUXILIARY (csect
);
5024 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5025 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5026 a
->x_csect
.x_scnlen
.l
= 0;
5027 a
->x_csect
.x_smtyp
= XTY_SD
;
5028 a
->x_csect
.x_parmhash
= 0;
5029 a
->x_csect
.x_snhash
= 0;
5030 a
->x_csect
.x_smclas
= XMC_XO
;
5031 a
->x_csect
.x_stab
= 0;
5032 a
->x_csect
.x_snstab
= 0;
5034 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5036 i
= S_GET_NUMBER_AUXILIARY (sym
);
5037 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5038 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5039 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5042 ppc_saw_abs
= FALSE
;
5045 /* Set the VMA for a section. This is called on all the sections in
5049 ppc_frob_section (sec
)
5052 static bfd_size_type vma
= 0;
5054 bfd_set_section_vma (stdoutput
, sec
, vma
);
5055 vma
+= bfd_section_size (stdoutput
, sec
);
5058 #endif /* OBJ_XCOFF */
5060 /* Turn a string in input_line_pointer into a floating point constant
5061 of type TYPE, and store the appropriate bytes in *LITP. The number
5062 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5063 returned, or NULL on OK. */
5066 md_atof (type
, litp
, sizep
)
5072 LITTLENUM_TYPE words
[4];
5088 return _("bad call to md_atof");
5091 t
= atof_ieee (input_line_pointer
, type
, words
);
5093 input_line_pointer
= t
;
5097 if (target_big_endian
)
5099 for (i
= 0; i
< prec
; i
++)
5101 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5107 for (i
= prec
- 1; i
>= 0; i
--)
5109 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5117 /* Write a value out to the object file, using the appropriate
5121 md_number_to_chars (buf
, val
, n
)
5126 if (target_big_endian
)
5127 number_to_chars_bigendian (buf
, val
, n
);
5129 number_to_chars_littleendian (buf
, val
, n
);
5132 /* Align a section (I don't know why this is machine dependent). */
5135 md_section_align (seg
, addr
)
5139 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5141 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5144 /* We don't have any form of relaxing. */
5147 md_estimate_size_before_relax (fragp
, seg
)
5148 fragS
*fragp ATTRIBUTE_UNUSED
;
5149 asection
*seg ATTRIBUTE_UNUSED
;
5155 /* Convert a machine dependent frag. We never generate these. */
5158 md_convert_frag (abfd
, sec
, fragp
)
5159 bfd
*abfd ATTRIBUTE_UNUSED
;
5160 asection
*sec ATTRIBUTE_UNUSED
;
5161 fragS
*fragp ATTRIBUTE_UNUSED
;
5166 /* We have no need to default values of symbols. */
5169 md_undefined_symbol (name
)
5170 char *name ATTRIBUTE_UNUSED
;
5175 /* Functions concerning relocs. */
5177 /* The location from which a PC relative jump should be calculated,
5178 given a PC relative reloc. */
5181 md_pcrel_from_section (fixp
, sec
)
5183 segT sec ATTRIBUTE_UNUSED
;
5185 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5190 /* This is called to see whether a fixup should be adjusted to use a
5191 section symbol. We take the opportunity to change a fixup against
5192 a symbol in the TOC subsegment into a reloc against the
5193 corresponding .tc symbol. */
5196 ppc_fix_adjustable (fix
)
5199 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5200 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5201 TC_SYMFIELD_TYPE
*tc
;
5203 if (symseg
== absolute_section
)
5206 if (ppc_toc_csect
!= (symbolS
*) NULL
5207 && fix
->fx_addsy
!= ppc_toc_csect
5208 && symseg
== data_section
5209 && val
>= ppc_toc_frag
->fr_address
5210 && (ppc_after_toc_frag
== (fragS
*) NULL
5211 || val
< ppc_after_toc_frag
->fr_address
))
5215 for (sy
= symbol_next (ppc_toc_csect
);
5216 sy
!= (symbolS
*) NULL
;
5217 sy
= symbol_next (sy
))
5219 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5221 if (sy_tc
->class == XMC_TC0
)
5223 if (sy_tc
->class != XMC_TC
)
5225 if (val
== resolve_symbol_value (sy
))
5228 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5233 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5234 _("symbol in .toc does not match any .tc"));
5237 /* Possibly adjust the reloc to be against the csect. */
5238 tc
= symbol_get_tc (fix
->fx_addsy
);
5240 && tc
->class != XMC_TC0
5241 && tc
->class != XMC_TC
5242 && symseg
!= bss_section
5243 /* Don't adjust if this is a reloc in the toc section. */
5244 && (symseg
!= data_section
5245 || ppc_toc_csect
== NULL
5246 || val
< ppc_toc_frag
->fr_address
5247 || (ppc_after_toc_frag
!= NULL
5248 && val
>= ppc_after_toc_frag
->fr_address
)))
5251 symbolS
*next_csect
;
5253 if (symseg
== text_section
)
5254 csect
= ppc_text_csects
;
5255 else if (symseg
== data_section
)
5256 csect
= ppc_data_csects
;
5260 /* Skip the initial dummy symbol. */
5261 csect
= symbol_get_tc (csect
)->next
;
5263 if (csect
!= (symbolS
*) NULL
)
5265 while ((next_csect
= symbol_get_tc (csect
)->next
) != (symbolS
*) NULL
5266 && (symbol_get_frag (next_csect
)->fr_address
<= val
))
5268 /* If the csect address equals the symbol value, then we
5269 have to look through the full symbol table to see
5270 whether this is the csect we want. Note that we will
5271 only get here if the csect has zero length. */
5272 if (symbol_get_frag (csect
)->fr_address
== val
5273 && S_GET_VALUE (csect
) == val
)
5277 for (scan
= symbol_next (csect
);
5279 scan
= symbol_next (scan
))
5281 if (symbol_get_tc (scan
)->subseg
!= 0)
5283 if (scan
== fix
->fx_addsy
)
5287 /* If we found the symbol before the next csect
5288 symbol, then this is the csect we want. */
5289 if (scan
== fix
->fx_addsy
)
5296 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5297 fix
->fx_addsy
= csect
;
5302 /* Adjust a reloc against a .lcomm symbol to be against the base
5304 if (symseg
== bss_section
5305 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5307 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5309 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5316 /* A reloc from one csect to another must be kept. The assembler
5317 will, of course, keep relocs between sections, and it will keep
5318 absolute relocs, but we need to force it to keep PC relative relocs
5319 between two csects in the same section. */
5322 ppc_force_relocation (fix
)
5325 /* At this point fix->fx_addsy should already have been converted to
5326 a csect symbol. If the csect does not include the fragment, then
5327 we need to force the relocation. */
5329 && fix
->fx_addsy
!= NULL
5330 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5331 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5332 > fix
->fx_frag
->fr_address
)
5333 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5334 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5335 <= fix
->fx_frag
->fr_address
))))
5338 return generic_force_reloc (fix
);
5341 #endif /* OBJ_XCOFF */
5344 /* If this function returns non-zero, it guarantees that a relocation
5345 will be emitted for a fixup. */
5348 ppc_force_relocation (fix
)
5351 /* Branch prediction relocations must force a relocation, as must
5352 the vtable description relocs. */
5353 switch (fix
->fx_r_type
)
5355 case BFD_RELOC_PPC_B16_BRTAKEN
:
5356 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5357 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5358 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5359 case BFD_RELOC_PPC64_TOC
:
5365 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5366 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5369 return generic_force_reloc (fix
);
5373 ppc_fix_adjustable (fix
)
5376 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5377 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5378 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5379 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5380 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5381 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5382 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5383 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5384 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5386 || (fix
->fx_subsy
!= NULL
5387 && (S_GET_SEGMENT (fix
->fx_subsy
)
5388 == S_GET_SEGMENT (fix
->fx_addsy
)))
5389 || S_IS_LOCAL (fix
->fx_addsy
)));
5393 /* Apply a fixup to the object code. This is called for all the
5394 fixups we generated by the call to fix_new_exp, above. In the call
5395 above we used a reloc code which was the largest legal reloc code
5396 plus the operand index. Here we undo that to recover the operand
5397 index. At this point all symbol values should be fully resolved,
5398 and we attempt to completely resolve the reloc. If we can not do
5399 that, we determine the correct reloc code and put it back in the
5403 md_apply_fix3 (fixP
, valP
, seg
)
5406 segT seg ATTRIBUTE_UNUSED
;
5408 valueT value
= * valP
;
5411 if (fixP
->fx_addsy
!= NULL
)
5413 /* Hack around bfd_install_relocation brain damage. */
5415 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5420 /* FIXME FIXME FIXME: The value we are passed in *valP includes
5421 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5422 doing this relocation the code in write.c is going to call
5423 bfd_install_relocation, which is also going to use the symbol
5424 value. That means that if the reloc is fully resolved we want to
5425 use *valP since bfd_install_relocation is not being used.
5426 However, if the reloc is not fully resolved we do not want to use
5427 *valP, and must use fx_offset instead. However, if the reloc
5428 is PC relative, we do want to use *valP since it includes the
5429 result of md_pcrel_from. This is confusing. */
5430 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5433 else if (fixP
->fx_pcrel
)
5437 value
= fixP
->fx_offset
;
5440 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5442 /* We can't actually support subtracting a symbol. */
5443 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
5446 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5449 const struct powerpc_operand
*operand
;
5453 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5455 operand
= &powerpc_operands
[opindex
];
5458 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5459 does not generate a reloc. It uses the offset of `sym' within its
5460 csect. Other usages, such as `.long sym', generate relocs. This
5461 is the documented behaviour of non-TOC symbols. */
5462 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5463 && operand
->bits
== 16
5464 && operand
->shift
== 0
5465 && (operand
->insert
== NULL
|| ppc_obj64
)
5466 && fixP
->fx_addsy
!= NULL
5467 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5468 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5469 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5470 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5472 value
= fixP
->fx_offset
;
5477 /* Fetch the instruction, insert the fully resolved operand
5478 value, and stuff the instruction back again. */
5479 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5480 if (target_big_endian
)
5481 insn
= bfd_getb32 ((unsigned char *) where
);
5483 insn
= bfd_getl32 ((unsigned char *) where
);
5484 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5485 fixP
->fx_file
, fixP
->fx_line
);
5486 if (target_big_endian
)
5487 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5489 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5492 /* Nothing else to do here. */
5495 assert (fixP
->fx_addsy
!= NULL
);
5497 /* Determine a BFD reloc value based on the operand information.
5498 We are only prepared to turn a few of the operands into
5500 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5501 && operand
->bits
== 26
5502 && operand
->shift
== 0)
5503 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5504 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5505 && operand
->bits
== 16
5506 && operand
->shift
== 0)
5508 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5511 if (target_big_endian
)
5512 fixP
->fx_where
+= 2;
5515 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5516 && operand
->bits
== 26
5517 && operand
->shift
== 0)
5518 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5519 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5520 && operand
->bits
== 16
5521 && operand
->shift
== 0)
5523 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5526 if (target_big_endian
)
5527 fixP
->fx_where
+= 2;
5530 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5531 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5532 && operand
->bits
== 16
5533 && operand
->shift
== 0)
5535 if (ppc_is_toc_sym (fixP
->fx_addsy
))
5537 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5540 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5541 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5546 fixP
->fx_r_type
= BFD_RELOC_16
;
5549 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5550 fixP
->fx_r_type
= BFD_RELOC_PPC64_ADDR16_DS
;
5554 if (target_big_endian
)
5555 fixP
->fx_where
+= 2;
5557 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5563 /* Use expr_symbol_where to see if this is an expression
5565 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5566 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5567 _("unresolved expression that must be resolved"));
5569 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5570 _("unsupported relocation against %s"),
5571 S_GET_NAME (fixP
->fx_addsy
));
5579 ppc_elf_validate_fix (fixP
, seg
);
5581 switch (fixP
->fx_r_type
)
5583 case BFD_RELOC_CTOR
:
5590 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5594 case BFD_RELOC_32_PCREL
:
5595 case BFD_RELOC_PPC_EMB_NADDR32
:
5596 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5603 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5606 case BFD_RELOC_64_PCREL
:
5607 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5611 case BFD_RELOC_LO16
:
5613 case BFD_RELOC_GPREL16
:
5614 case BFD_RELOC_16_GOT_PCREL
:
5615 case BFD_RELOC_16_GOTOFF
:
5616 case BFD_RELOC_LO16_GOTOFF
:
5617 case BFD_RELOC_HI16_GOTOFF
:
5618 case BFD_RELOC_HI16_S_GOTOFF
:
5619 case BFD_RELOC_16_BASEREL
:
5620 case BFD_RELOC_LO16_BASEREL
:
5621 case BFD_RELOC_HI16_BASEREL
:
5622 case BFD_RELOC_HI16_S_BASEREL
:
5623 case BFD_RELOC_PPC_EMB_NADDR16
:
5624 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5625 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5626 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5627 case BFD_RELOC_PPC_EMB_SDAI16
:
5628 case BFD_RELOC_PPC_EMB_SDA2REL
:
5629 case BFD_RELOC_PPC_EMB_SDA2I16
:
5630 case BFD_RELOC_PPC_EMB_RELSEC16
:
5631 case BFD_RELOC_PPC_EMB_RELST_LO
:
5632 case BFD_RELOC_PPC_EMB_RELST_HI
:
5633 case BFD_RELOC_PPC_EMB_RELST_HA
:
5634 case BFD_RELOC_PPC_EMB_RELSDA
:
5635 case BFD_RELOC_PPC_TOC16
:
5637 case BFD_RELOC_PPC64_TOC16_LO
:
5638 case BFD_RELOC_PPC64_TOC16_HI
:
5639 case BFD_RELOC_PPC64_TOC16_HA
:
5643 if (fixP
->fx_addsy
!= NULL
)
5644 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5645 _("cannot emit PC relative %s relocation against %s"),
5646 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5647 S_GET_NAME (fixP
->fx_addsy
));
5649 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5650 _("cannot emit PC relative %s relocation"),
5651 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5654 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5658 /* This case happens when you write, for example,
5660 where L1 and L2 are defined later. */
5661 case BFD_RELOC_HI16
:
5664 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5668 case BFD_RELOC_HI16_S
:
5671 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5676 case BFD_RELOC_PPC64_HIGHER
:
5679 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5680 PPC_HIGHER (value
), 2);
5683 case BFD_RELOC_PPC64_HIGHER_S
:
5686 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5687 PPC_HIGHERA (value
), 2);
5690 case BFD_RELOC_PPC64_HIGHEST
:
5693 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5694 PPC_HIGHEST (value
), 2);
5697 case BFD_RELOC_PPC64_HIGHEST_S
:
5700 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5701 PPC_HIGHESTA (value
), 2);
5704 case BFD_RELOC_PPC64_ADDR16_DS
:
5705 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5706 case BFD_RELOC_PPC64_GOT16_DS
:
5707 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5708 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5709 case BFD_RELOC_PPC64_SECTOFF_DS
:
5710 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5711 case BFD_RELOC_PPC64_TOC16_DS
:
5712 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5713 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5714 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5718 unsigned char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5721 if (target_big_endian
)
5722 val
= bfd_getb16 (where
);
5724 val
= bfd_getl16 (where
);
5725 val
|= (value
& 0xfffc);
5726 if (target_big_endian
)
5727 bfd_putb16 ((bfd_vma
) val
, where
);
5729 bfd_putl16 ((bfd_vma
) val
, where
);
5733 case BFD_RELOC_PPC_TLS
:
5734 case BFD_RELOC_PPC_DTPMOD
:
5735 case BFD_RELOC_PPC_TPREL16
:
5736 case BFD_RELOC_PPC_TPREL16_LO
:
5737 case BFD_RELOC_PPC_TPREL16_HI
:
5738 case BFD_RELOC_PPC_TPREL16_HA
:
5739 case BFD_RELOC_PPC_TPREL
:
5740 case BFD_RELOC_PPC_DTPREL16
:
5741 case BFD_RELOC_PPC_DTPREL16_LO
:
5742 case BFD_RELOC_PPC_DTPREL16_HI
:
5743 case BFD_RELOC_PPC_DTPREL16_HA
:
5744 case BFD_RELOC_PPC_DTPREL
:
5745 case BFD_RELOC_PPC_GOT_TLSGD16
:
5746 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
5747 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
5748 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
5749 case BFD_RELOC_PPC_GOT_TLSLD16
:
5750 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
5751 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
5752 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
5753 case BFD_RELOC_PPC_GOT_TPREL16
:
5754 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
5755 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
5756 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
5757 case BFD_RELOC_PPC_GOT_DTPREL16
:
5758 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
5759 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
5760 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
5761 case BFD_RELOC_PPC64_TPREL16_DS
:
5762 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
5763 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
5764 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
5765 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
5766 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
5767 case BFD_RELOC_PPC64_DTPREL16_DS
:
5768 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
5769 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
5770 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
5771 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
5772 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
5775 /* Because SDA21 modifies the register field, the size is set to 4
5776 bytes, rather than 2, so offset it here appropriately. */
5777 case BFD_RELOC_PPC_EMB_SDA21
:
5781 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5782 + ((target_big_endian
) ? 2 : 0),
5790 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5794 case BFD_RELOC_24_PLT_PCREL
:
5795 case BFD_RELOC_PPC_LOCAL24PC
:
5796 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5804 /* Fetch the instruction, insert the fully resolved operand
5805 value, and stuff the instruction back again. */
5806 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5807 if (target_big_endian
)
5808 insn
= bfd_getb32 ((unsigned char *) where
);
5810 insn
= bfd_getl32 ((unsigned char *) where
);
5811 if ((value
& 3) != 0)
5812 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5813 _("must branch to an address a multiple of 4"));
5814 if ((offsetT
) value
< -0x40000000
5815 || (offsetT
) value
>= 0x40000000)
5816 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5817 _("@local or @plt branch destination is too far away, %ld bytes"),
5819 insn
= insn
| (value
& 0x03fffffc);
5820 if (target_big_endian
)
5821 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5823 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5827 case BFD_RELOC_VTABLE_INHERIT
:
5830 && !S_IS_DEFINED (fixP
->fx_addsy
)
5831 && !S_IS_WEAK (fixP
->fx_addsy
))
5832 S_SET_WEAK (fixP
->fx_addsy
);
5835 case BFD_RELOC_VTABLE_ENTRY
:
5840 /* Generated by reference to `sym@tocbase'. The sym is
5841 ignored by the linker. */
5842 case BFD_RELOC_PPC64_TOC
:
5848 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
5855 fixP
->fx_addnumber
= value
;
5857 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5858 fixP
->fx_addnumber
= 0;
5862 fixP
->fx_addnumber
= 0;
5864 /* We want to use the offset within the data segment of the
5865 symbol, not the actual VMA of the symbol. */
5866 fixP
->fx_addnumber
=
5867 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
5873 /* Generate a reloc for a fixup. */
5876 tc_gen_reloc (seg
, fixp
)
5877 asection
*seg ATTRIBUTE_UNUSED
;
5882 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5884 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5885 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5886 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5887 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5888 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5890 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5891 _("reloc %d not supported by object file format"),
5892 (int) fixp
->fx_r_type
);
5895 reloc
->addend
= fixp
->fx_addnumber
;