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 /* The target specific pseudo-ops which we support. */
188 const pseudo_typeS md_pseudo_table
[] =
190 /* Pseudo-ops which must be overridden. */
191 { "byte", ppc_byte
, 0 },
194 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
195 legitimately belong in the obj-*.c file. However, XCOFF is based
196 on COFF, and is only implemented for the RS/6000. We just use
197 obj-coff.c, and add what we need here. */
198 { "comm", ppc_comm
, 0 },
199 { "lcomm", ppc_comm
, 1 },
203 { "bi", ppc_biei
, 0 },
205 { "csect", ppc_csect
, 0 },
206 { "data", ppc_section
, 'd' },
210 { "ei", ppc_biei
, 1 },
212 { "extern", ppc_extern
, 0 },
213 { "function", ppc_function
, 0 },
214 { "lglobl", ppc_lglobl
, 0 },
215 { "rename", ppc_rename
, 0 },
216 { "section", ppc_named_section
, 0 },
217 { "stabx", ppc_stabx
, 0 },
218 { "text", ppc_section
, 't' },
219 { "toc", ppc_toc
, 0 },
220 { "long", ppc_xcoff_cons
, 2 },
221 { "llong", ppc_xcoff_cons
, 3 },
222 { "word", ppc_xcoff_cons
, 1 },
223 { "short", ppc_xcoff_cons
, 1 },
224 { "vbyte", ppc_vbyte
, 0 },
228 { "llong", ppc_elf_cons
, 8 },
229 { "quad", ppc_elf_cons
, 8 },
230 { "long", ppc_elf_cons
, 4 },
231 { "word", ppc_elf_cons
, 2 },
232 { "short", ppc_elf_cons
, 2 },
233 { "rdata", ppc_elf_rdata
, 0 },
234 { "rodata", ppc_elf_rdata
, 0 },
235 { "lcomm", ppc_elf_lcomm
, 0 },
236 { "file", (void (*) PARAMS ((int))) dwarf2_directive_file
, 0 },
237 { "loc", dwarf2_directive_loc
, 0 },
241 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
242 { "previous", ppc_previous
, 0 },
243 { "pdata", ppc_pdata
, 0 },
244 { "ydata", ppc_ydata
, 0 },
245 { "reldata", ppc_reldata
, 0 },
246 { "rdata", ppc_rdata
, 0 },
247 { "ualong", ppc_ualong
, 0 },
248 { "znop", ppc_znop
, 0 },
249 { "comm", ppc_pe_comm
, 0 },
250 { "lcomm", ppc_pe_comm
, 1 },
251 { "section", ppc_pe_section
, 0 },
252 { "function", ppc_pe_function
,0 },
253 { "tocd", ppc_pe_tocd
, 0 },
256 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
258 { "machine", ppc_machine
, 0 },
265 /* Predefined register names if -mregnames (or default for Windows NT).
266 In general, there are lots of them, in an attempt to be compatible
267 with a number of other Windows NT assemblers. */
269 /* Structure to hold information about predefined registers. */
276 /* List of registers that are pre-defined:
278 Each general register has predefined names of the form:
279 1. r<reg_num> which has the value <reg_num>.
280 2. r.<reg_num> which has the value <reg_num>.
282 Each floating point register has predefined names of the form:
283 1. f<reg_num> which has the value <reg_num>.
284 2. f.<reg_num> which has the value <reg_num>.
286 Each vector unit register has predefined names of the form:
287 1. v<reg_num> which has the value <reg_num>.
288 2. v.<reg_num> which has the value <reg_num>.
290 Each condition register has predefined names of the form:
291 1. cr<reg_num> which has the value <reg_num>.
292 2. cr.<reg_num> which has the value <reg_num>.
294 There are individual registers as well:
295 sp or r.sp has the value 1
296 rtoc or r.toc has the value 2
297 fpscr has the value 0
303 dsisr has the value 18
305 sdr1 has the value 25
306 srr0 has the value 26
307 srr1 has the value 27
309 The table is sorted. Suitable for searching by a binary search. */
311 static const struct pd_reg pre_defined_registers
[] =
313 { "cr.0", 0 }, /* Condition Registers */
333 { "dar", 19 }, /* Data Access Register */
334 { "dec", 22 }, /* Decrementer */
335 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
337 { "f.0", 0 }, /* Floating point registers */
405 { "lr", 8 }, /* Link Register */
409 { "r.0", 0 }, /* General Purpose Registers */
442 { "r.sp", 1 }, /* Stack Pointer */
444 { "r.toc", 2 }, /* Pointer to the table of contents */
446 { "r0", 0 }, /* More general purpose registers */
479 { "rtoc", 2 }, /* Table of contents */
481 { "sdr1", 25 }, /* Storage Description Register 1 */
485 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
486 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
488 { "v.0", 0 }, /* Vector registers */
558 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
560 /* Given NAME, find the register number associated with that name, return
561 the integer value associated with the given name or -1 on failure. */
563 static int reg_name_search
564 PARAMS ((const struct pd_reg
*, int, const char * name
));
567 reg_name_search (regs
, regcount
, name
)
568 const struct pd_reg
*regs
;
572 int middle
, low
, high
;
580 middle
= (low
+ high
) / 2;
581 cmp
= strcasecmp (name
, regs
[middle
].name
);
587 return regs
[middle
].value
;
595 * Summary of register_name.
597 * in: Input_line_pointer points to 1st char of operand.
599 * out: A expressionS.
600 * The operand may have been a register: in this case, X_op == O_register,
601 * X_add_number is set to the register number, and truth is returned.
602 * Input_line_pointer->(next non-blank) char after operand, or is in its
607 register_name (expressionP
)
608 expressionS
*expressionP
;
615 /* Find the spelling of the operand. */
616 start
= name
= input_line_pointer
;
617 if (name
[0] == '%' && ISALPHA (name
[1]))
618 name
= ++input_line_pointer
;
620 else if (!reg_names_p
|| !ISALPHA (name
[0]))
623 c
= get_symbol_end ();
624 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
626 /* Put back the delimiting char. */
627 *input_line_pointer
= c
;
629 /* Look to see if it's in the register table. */
632 expressionP
->X_op
= O_register
;
633 expressionP
->X_add_number
= reg_number
;
635 /* Make the rest nice. */
636 expressionP
->X_add_symbol
= NULL
;
637 expressionP
->X_op_symbol
= NULL
;
641 /* Reset the line as if we had not done anything. */
642 input_line_pointer
= start
;
646 /* This function is called for each symbol seen in an expression. It
647 handles the special parsing which PowerPC assemblers are supposed
648 to use for condition codes. */
650 /* Whether to do the special parsing. */
651 static bfd_boolean cr_operand
;
653 /* Names to recognize in a condition code. This table is sorted. */
654 static const struct pd_reg cr_names
[] =
671 /* Parsing function. This returns non-zero if it recognized an
675 ppc_parse_name (name
, expr
)
684 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
689 expr
->X_op
= O_constant
;
690 expr
->X_add_number
= val
;
695 /* Local variables. */
697 /* The type of processor we are assembling for. This is one or more
698 of the PPC_OPCODE flags defined in opcode/ppc.h. */
699 static unsigned long ppc_cpu
= 0;
701 /* Whether to target xcoff64/elf64. */
702 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
704 /* Opcode hash table. */
705 static struct hash_control
*ppc_hash
;
707 /* Macro hash table. */
708 static struct hash_control
*ppc_macro_hash
;
711 /* What type of shared library support to use. */
712 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
714 /* Flags to set in the elf header. */
715 static flagword ppc_flags
= 0;
717 /* Whether this is Solaris or not. */
718 #ifdef TARGET_SOLARIS_COMMENT
719 #define SOLARIS_P TRUE
721 #define SOLARIS_P FALSE
724 static bfd_boolean msolaris
= SOLARIS_P
;
729 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
730 using a bunch of different sections. These assembler sections,
731 however, are all encompassed within the .text or .data sections of
732 the final output file. We handle this by using different
733 subsegments within these main segments. */
735 /* Next subsegment to allocate within the .text segment. */
736 static subsegT ppc_text_subsegment
= 2;
738 /* Linked list of csects in the text section. */
739 static symbolS
*ppc_text_csects
;
741 /* Next subsegment to allocate within the .data segment. */
742 static subsegT ppc_data_subsegment
= 2;
744 /* Linked list of csects in the data section. */
745 static symbolS
*ppc_data_csects
;
747 /* The current csect. */
748 static symbolS
*ppc_current_csect
;
750 /* The RS/6000 assembler uses a TOC which holds addresses of functions
751 and variables. Symbols are put in the TOC with the .tc pseudo-op.
752 A special relocation is used when accessing TOC entries. We handle
753 the TOC as a subsegment within the .data segment. We set it up if
754 we see a .toc pseudo-op, and save the csect symbol here. */
755 static symbolS
*ppc_toc_csect
;
757 /* The first frag in the TOC subsegment. */
758 static fragS
*ppc_toc_frag
;
760 /* The first frag in the first subsegment after the TOC in the .data
761 segment. NULL if there are no subsegments after the TOC. */
762 static fragS
*ppc_after_toc_frag
;
764 /* The current static block. */
765 static symbolS
*ppc_current_block
;
767 /* The COFF debugging section; set by md_begin. This is not the
768 .debug section, but is instead the secret BFD section which will
769 cause BFD to set the section number of a symbol to N_DEBUG. */
770 static asection
*ppc_coff_debug_section
;
772 #endif /* OBJ_XCOFF */
776 /* Various sections that we need for PE coff support. */
777 static segT ydata_section
;
778 static segT pdata_section
;
779 static segT reldata_section
;
780 static segT rdata_section
;
781 static segT tocdata_section
;
783 /* The current section and the previous section. See ppc_previous. */
784 static segT ppc_previous_section
;
785 static segT ppc_current_section
;
790 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
791 #define PPC_APUINFO_ISEL 0x40
792 #define PPC_APUINFO_PMR 0x41
793 #define PPC_APUINFO_RFMCI 0x42
794 #define PPC_APUINFO_CACHELCK 0x43
795 #define PPC_APUINFO_SPE 0x100
796 #define PPC_APUINFO_EFS 0x101
797 #define PPC_APUINFO_BRLOCK 0x102
800 * We keep a list of APUinfo
802 unsigned long *ppc_apuinfo_list
;
803 unsigned int ppc_apuinfo_num
;
804 unsigned int ppc_apuinfo_num_alloc
;
808 const char *const md_shortopts
= "b:l:usm:K:VQ:";
810 const char *const md_shortopts
= "um:";
812 const struct option md_longopts
[] = {
813 {NULL
, no_argument
, NULL
, 0}
815 const size_t md_longopts_size
= sizeof (md_longopts
);
818 md_parse_option (c
, arg
)
825 /* -u means that any undefined symbols should be treated as
826 external, which is the default for gas anyhow. */
831 /* Solaris as takes -le (presumably for little endian). For completeness
832 sake, recognize -be also. */
833 if (strcmp (arg
, "e") == 0)
835 target_big_endian
= 0;
836 set_target_endian
= 1;
844 if (strcmp (arg
, "e") == 0)
846 target_big_endian
= 1;
847 set_target_endian
= 1;
855 /* Recognize -K PIC. */
856 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
859 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
867 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
869 if (strcmp (arg
, "64") == 0)
874 as_fatal (_("%s unsupported"), "-a64");
877 else if (strcmp (arg
, "32") == 0)
884 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
886 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
887 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
| PPC_OPCODE_32
;
888 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
889 else if (strcmp (arg
, "pwr") == 0)
890 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
891 /* -m601 means to assemble for the PowerPC 601, which includes
892 instructions that are holdovers from the Power. */
893 else if (strcmp (arg
, "601") == 0)
894 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
895 | PPC_OPCODE_601
| PPC_OPCODE_32
);
896 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
898 else if (strcmp (arg
, "ppc") == 0
899 || strcmp (arg
, "ppc32") == 0
900 || strcmp (arg
, "603") == 0
901 || strcmp (arg
, "604") == 0)
902 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
903 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
904 else if (strcmp (arg
, "403") == 0
905 || strcmp (arg
, "405") == 0)
906 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
907 | PPC_OPCODE_403
| PPC_OPCODE_32
);
908 else if (strcmp (arg
, "7400") == 0
909 || strcmp (arg
, "7410") == 0
910 || strcmp (arg
, "7450") == 0
911 || strcmp (arg
, "7455") == 0)
912 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
913 | PPC_OPCODE_ALTIVEC
| PPC_OPCODE_32
);
914 else if (strcmp (arg
, "altivec") == 0)
917 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_ALTIVEC
;
919 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
921 else if (strcmp (arg
, "e500") == 0 || strcmp (arg
, "e500x2") == 0)
923 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_SPE
924 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
| PPC_OPCODE_BRLOCK
925 | PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
928 else if (strcmp (arg
, "spe") == 0)
931 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_SPE
| PPC_OPCODE_EFS
;
933 ppc_cpu
|= PPC_OPCODE_SPE
;
935 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
937 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
939 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
941 else if (strcmp (arg
, "ppc64bridge") == 0)
943 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
944 | PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
);
946 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
947 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
949 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
;
951 /* -mbooke64 means enable 64-bit BookE support. */
952 else if (strcmp (arg
, "booke64") == 0)
954 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
955 | PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
);
957 else if (strcmp (arg
, "power4") == 0)
959 ppc_cpu
= (PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
960 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
);
962 /* -mcom means assemble for the common intersection between Power
963 and PowerPC. At present, we just allow the union, rather
964 than the intersection. */
965 else if (strcmp (arg
, "com") == 0)
966 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
967 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
968 else if (strcmp (arg
, "any") == 0)
969 ppc_cpu
= PPC_OPCODE_ANY
| PPC_OPCODE_32
;
971 else if (strcmp (arg
, "regnames") == 0)
974 else if (strcmp (arg
, "no-regnames") == 0)
978 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
979 that require relocation. */
980 else if (strcmp (arg
, "relocatable") == 0)
982 shlib
= SHLIB_MRELOCATABLE
;
983 ppc_flags
|= EF_PPC_RELOCATABLE
;
986 else if (strcmp (arg
, "relocatable-lib") == 0)
988 shlib
= SHLIB_MRELOCATABLE
;
989 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
992 /* -memb, set embedded bit. */
993 else if (strcmp (arg
, "emb") == 0)
994 ppc_flags
|= EF_PPC_EMB
;
996 /* -mlittle/-mbig set the endianess. */
997 else if (strcmp (arg
, "little") == 0
998 || strcmp (arg
, "little-endian") == 0)
1000 target_big_endian
= 0;
1001 set_target_endian
= 1;
1004 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
1006 target_big_endian
= 1;
1007 set_target_endian
= 1;
1010 else if (strcmp (arg
, "solaris") == 0)
1013 ppc_comment_chars
= ppc_solaris_comment_chars
;
1016 else if (strcmp (arg
, "no-solaris") == 0)
1019 ppc_comment_chars
= ppc_eabi_comment_chars
;
1024 as_bad (_("invalid switch -m%s"), arg
);
1030 /* -V: SVR4 argument to print version ID. */
1032 print_version_id ();
1035 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1036 should be emitted or not. FIXME: Not implemented. */
1040 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1041 rather than .stabs.excl, which is ignored by the linker.
1042 FIXME: Not implemented. */
1058 md_show_usage (stream
)
1061 fprintf (stream
, _("\
1064 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1065 -mpwr generate code for POWER (RIOS1)\n\
1066 -m601 generate code for PowerPC 601\n\
1067 -mppc, -mppc32, -m603, -m604\n\
1068 generate code for PowerPC 603/604\n\
1069 -m403, -m405 generate code for PowerPC 403/405\n\
1070 -m7400, -m7410, -m7450, -m7455\n\
1071 generate code For PowerPC 7400/7410/7450/7455\n\
1072 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1073 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1074 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1075 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1076 -mpower4 generate code for Power4 architecture\n\
1077 -maltivec generate code for AltiVec\n\
1078 -mcom generate code Power/PowerPC common instructions\n\
1079 -many generate code for any architecture (PWR/PWRX/PPC)\n\
1080 -mregnames Allow symbolic names for registers\n\
1081 -mno-regnames Do not allow symbolic names for registers\n"));
1082 fprintf (stream
, _("\
1083 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1084 -mspe generate code for Motorola SPE instructions\n"));
1086 fprintf (stream
, _("\
1087 -mrelocatable support for GCC's -mrelocatble option\n\
1088 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1089 -memb set PPC_EMB bit in ELF flags\n\
1090 -mlittle, -mlittle-endian\n\
1091 generate code for a little endian machine\n\
1092 -mbig, -mbig-endian generate code for a big endian machine\n\
1093 -msolaris generate code for Solaris\n\
1094 -mno-solaris do not generate code for Solaris\n\
1095 -V print assembler version number\n\
1096 -Qy, -Qn ignored\n"));
1100 /* Set ppc_cpu if it is not already set. */
1105 const char *default_os
= TARGET_OS
;
1106 const char *default_cpu
= TARGET_CPU
;
1111 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1112 else if (strncmp (default_os
, "aix", 3) == 0
1113 && default_os
[3] >= '4' && default_os
[3] <= '9')
1114 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1115 else if (strncmp (default_os
, "aix3", 4) == 0)
1116 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1117 else if (strcmp (default_cpu
, "rs6000") == 0)
1118 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1119 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1121 if (default_cpu
[7] == '6' && default_cpu
[8] == '4')
1122 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1124 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
1127 as_fatal (_("Unknown default cpu = %s, os = %s"),
1128 default_cpu
, default_os
);
1132 /* Figure out the BFD architecture to use. */
1134 enum bfd_architecture
1137 const char *default_cpu
= TARGET_CPU
;
1140 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1141 return bfd_arch_powerpc
;
1142 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1143 return bfd_arch_rs6000
;
1144 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1146 if (strcmp (default_cpu
, "rs6000") == 0)
1147 return bfd_arch_rs6000
;
1148 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1149 return bfd_arch_powerpc
;
1152 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1153 return bfd_arch_unknown
;
1160 return bfd_mach_ppc64
;
1161 else if (ppc_arch () == bfd_arch_rs6000
)
1162 return bfd_mach_rs6k
;
1164 return bfd_mach_ppc
;
1168 ppc_target_format ()
1172 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1174 return "xcoff-powermac";
1177 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1179 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1184 return (target_big_endian
1185 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1186 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1190 /* This function is called when the assembler starts up. It is called
1191 after the options have been parsed and the output file has been
1197 register const struct powerpc_opcode
*op
;
1198 const struct powerpc_opcode
*op_end
;
1199 const struct powerpc_macro
*macro
;
1200 const struct powerpc_macro
*macro_end
;
1201 bfd_boolean dup_insn
= FALSE
;
1206 /* Set the ELF flags if desired. */
1207 if (ppc_flags
&& !msolaris
)
1208 bfd_set_private_flags (stdoutput
, ppc_flags
);
1211 /* Insert the opcodes into a hash table. */
1212 ppc_hash
= hash_new ();
1214 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1215 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1217 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1219 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1220 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1221 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1222 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1223 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1224 /* Certain instructions (eg: extsw) do not exist in the
1225 32-bit BookE instruction set, but they do exist in the
1226 64-bit BookE instruction set, and other PPC instruction
1227 sets. Check to see if the opcode has the BOOKE64 flag set.
1228 If it does make sure that the target CPU is not the BookE32. */
1229 && ((op
->flags
& PPC_OPCODE_BOOKE64
) == 0
1230 || (ppc_cpu
& PPC_OPCODE_BOOKE64
) == PPC_OPCODE_BOOKE64
1231 || (ppc_cpu
& PPC_OPCODE_BOOKE
) == 0)
1232 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1233 || ((op
->flags
& PPC_OPCODE_POWER4
)
1234 == (ppc_cpu
& PPC_OPCODE_POWER4
))))
1238 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1239 if (retval
!= (const char *) NULL
)
1241 /* Ignore Power duplicates for -m601. */
1242 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1243 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1246 as_bad (_("Internal assembler error for instruction %s"),
1253 /* Insert the macros into a hash table. */
1254 ppc_macro_hash
= hash_new ();
1256 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1257 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1259 if ((macro
->flags
& ppc_cpu
) != 0)
1263 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1264 if (retval
!= (const char *) NULL
)
1266 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1275 /* Tell the main code what the endianness is if it is not overidden
1277 if (!set_target_endian
)
1279 set_target_endian
= 1;
1280 target_big_endian
= PPC_BIG_ENDIAN
;
1284 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1286 /* Create dummy symbols to serve as initial csects. This forces the
1287 text csects to precede the data csects. These symbols will not
1289 ppc_text_csects
= symbol_make ("dummy\001");
1290 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1291 ppc_data_csects
= symbol_make ("dummy\001");
1292 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1297 ppc_current_section
= text_section
;
1298 ppc_previous_section
= 0;
1307 if (ppc_apuinfo_list
== NULL
)
1310 /* Ok, so write the section info out. We have this layout:
1314 0 8 length of "APUinfo\0"
1315 4 (n*4) number of APU's (4 bytes each)
1318 20 APU#1 first APU's info
1319 24 APU#2 second APU's info
1324 asection
*seg
= now_seg
;
1325 subsegT subseg
= now_subseg
;
1326 asection
*apuinfo_secp
= (asection
*) NULL
;
1329 /* Create the .PPC.EMB.apuinfo section. */
1330 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1331 bfd_set_section_flags (stdoutput
,
1333 SEC_HAS_CONTENTS
| SEC_READONLY
);
1336 md_number_to_chars (p
, (valueT
) 8, 4);
1339 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
, 4);
1342 md_number_to_chars (p
, (valueT
) 2, 4);
1345 strcpy (p
, "APUinfo");
1347 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1350 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1353 frag_align (2, 0, 0);
1355 /* We probably can't restore the current segment, for there likely
1358 subseg_set (seg
, subseg
);
1363 /* Insert an operand value into an instruction. */
1365 static unsigned long
1366 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1368 const struct powerpc_operand
*operand
;
1373 if (operand
->bits
!= 32)
1378 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1380 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1381 max
= (1 << operand
->bits
) - 1;
1383 max
= (1 << (operand
->bits
- 1)) - 1;
1384 min
= - (1 << (operand
->bits
- 1));
1388 /* Some people write 32 bit hex constants with the sign
1389 extension done by hand. This shouldn't really be
1390 valid, but, to permit this code to assemble on a 64
1391 bit host, we sign extend the 32 bit value. */
1393 && (val
& (offsetT
) 0x80000000) != 0
1394 && (val
& (offsetT
) 0xffffffff) == val
)
1403 max
= (1 << operand
->bits
) - 1;
1407 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1412 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1415 _("operand out of range (%s not between %ld and %ld)");
1418 sprint_value (buf
, test
);
1419 as_bad_where (file
, line
, err
, buf
, min
, max
);
1423 if (operand
->insert
)
1428 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1429 if (errmsg
!= (const char *) NULL
)
1430 as_bad_where (file
, line
, errmsg
);
1433 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1441 /* Parse @got, etc. and return the desired relocation. */
1442 static bfd_reloc_code_real_type
1443 ppc_elf_suffix (str_p
, exp_p
)
1458 const struct map_bfd
*ptr
;
1460 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1462 static const struct map_bfd mapping
[] = {
1463 MAP ("l", (int) BFD_RELOC_LO16
),
1464 MAP ("h", (int) BFD_RELOC_HI16
),
1465 MAP ("ha", (int) BFD_RELOC_HI16_S
),
1466 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN
),
1467 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN
),
1468 MAP ("got", (int) BFD_RELOC_16_GOTOFF
),
1469 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF
),
1470 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF
),
1471 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF
),
1472 MAP ("fixup", (int) BFD_RELOC_CTOR
),
1473 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL
),
1474 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL
),
1475 MAP ("copy", (int) BFD_RELOC_PPC_COPY
),
1476 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT
),
1477 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC
),
1478 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC
),
1479 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL
),
1480 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF
),
1481 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF
),
1482 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF
),
1483 MAP ("sdarel", (int) BFD_RELOC_GPREL16
),
1484 MAP ("sectoff", (int) BFD_RELOC_16_BASEREL
),
1485 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL
),
1486 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL
),
1487 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL
),
1488 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32
),
1489 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16
),
1490 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO
),
1491 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI
),
1492 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA
),
1493 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16
),
1494 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL
),
1495 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16
),
1496 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21
),
1497 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF
),
1498 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16
),
1499 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO
),
1500 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI
),
1501 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA
),
1502 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD
),
1503 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA
),
1504 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16
),
1505 MAP ("tls", (int) BFD_RELOC_PPC_TLS
),
1506 MAP ("dtpmod", (int) BFD_RELOC_PPC_DTPMOD
),
1507 MAP ("dtprel", (int) BFD_RELOC_PPC_DTPREL
),
1508 MAP ("dtprel@l", (int) BFD_RELOC_PPC_DTPREL16_LO
),
1509 MAP ("dtprel@h", (int) BFD_RELOC_PPC_DTPREL16_HI
),
1510 MAP ("dtprel@ha", (int) BFD_RELOC_PPC_DTPREL16_HA
),
1511 MAP ("tprel", (int) BFD_RELOC_PPC_TPREL
),
1512 MAP ("tprel@l", (int) BFD_RELOC_PPC_TPREL16_LO
),
1513 MAP ("tprel@h", (int) BFD_RELOC_PPC_TPREL16_HI
),
1514 MAP ("tprel@ha", (int) BFD_RELOC_PPC_TPREL16_HA
),
1515 MAP ("got@tlsgd", (int) BFD_RELOC_PPC_GOT_TLSGD16
),
1516 MAP ("got@tlsgd@l", (int) BFD_RELOC_PPC_GOT_TLSGD16_LO
),
1517 MAP ("got@tlsgd@h", (int) BFD_RELOC_PPC_GOT_TLSGD16_HI
),
1518 MAP ("got@tlsgd@ha", (int) BFD_RELOC_PPC_GOT_TLSGD16_HA
),
1519 MAP ("got@tlsld", (int) BFD_RELOC_PPC_GOT_TLSLD16
),
1520 MAP ("got@tlsld@l", (int) BFD_RELOC_PPC_GOT_TLSLD16_LO
),
1521 MAP ("got@tlsld@h", (int) BFD_RELOC_PPC_GOT_TLSLD16_HI
),
1522 MAP ("got@tlsld@ha", (int) BFD_RELOC_PPC_GOT_TLSLD16_HA
),
1523 MAP ("got@dtprel", (int) BFD_RELOC_PPC_GOT_DTPREL16
),
1524 MAP ("got@dtprel@l", (int) BFD_RELOC_PPC_GOT_DTPREL16_LO
),
1525 MAP ("got@dtprel@h", (int) BFD_RELOC_PPC_GOT_DTPREL16_HI
),
1526 MAP ("got@dtprel@ha", (int) BFD_RELOC_PPC_GOT_DTPREL16_HA
),
1527 MAP ("got@tprel", (int) BFD_RELOC_PPC_GOT_TPREL16
),
1528 MAP ("got@tprel@l", (int) BFD_RELOC_PPC_GOT_TPREL16_LO
),
1529 MAP ("got@tprel@h", (int) BFD_RELOC_PPC_GOT_TPREL16_HI
),
1530 MAP ("got@tprel@ha", (int) BFD_RELOC_PPC_GOT_TPREL16_HA
),
1531 /* The following are only valid for ppc64. Negative values are
1532 used instead of a flag. */
1533 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER
),
1534 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S
),
1535 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST
),
1536 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S
),
1537 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC
),
1538 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16
),
1539 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO
),
1540 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI
),
1541 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA
),
1542 MAP ("dtprel@higher", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHER
),
1543 MAP ("dtprel@highera", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHERA
),
1544 MAP ("dtprel@highest", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHEST
),
1545 MAP ("dtprel@highesta", - (int) BFD_RELOC_PPC64_DTPREL16_HIGHESTA
),
1546 MAP ("tprel@higher", - (int) BFD_RELOC_PPC64_TPREL16_HIGHER
),
1547 MAP ("tprel@highera", - (int) BFD_RELOC_PPC64_TPREL16_HIGHERA
),
1548 MAP ("tprel@highest", - (int) BFD_RELOC_PPC64_TPREL16_HIGHEST
),
1549 MAP ("tprel@highesta", - (int) BFD_RELOC_PPC64_TPREL16_HIGHESTA
),
1550 { (char *) 0, 0, (int) BFD_RELOC_UNUSED
}
1554 return BFD_RELOC_UNUSED
;
1556 for (ch
= *str
, str2
= ident
;
1557 (str2
< ident
+ sizeof (ident
) - 1
1558 && (ISALNUM (ch
) || ch
== '@'));
1561 *str2
++ = TOLOWER (ch
);
1568 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1569 if (ch
== ptr
->string
[0]
1570 && len
== ptr
->length
1571 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1573 int reloc
= ptr
->reloc
;
1578 return BFD_RELOC_UNUSED
;
1583 if (exp_p
->X_add_number
!= 0
1584 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1585 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1586 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1587 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1588 as_warn (_("identifier+constant@got means identifier@got+constant"));
1590 /* Now check for identifier@suffix+constant. */
1591 if (*str
== '-' || *str
== '+')
1593 char *orig_line
= input_line_pointer
;
1594 expressionS new_exp
;
1596 input_line_pointer
= str
;
1597 expression (&new_exp
);
1598 if (new_exp
.X_op
== O_constant
)
1600 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1601 str
= input_line_pointer
;
1604 if (&input_line_pointer
!= str_p
)
1605 input_line_pointer
= orig_line
;
1609 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1610 && exp_p
->X_op
== O_symbol
)
1612 /* This reloc type ignores the symbol. Change the symbol
1613 so that the dummy .TOC. symbol can be omitted from the
1615 exp_p
->X_add_symbol
= &abs_symbol
;
1618 return (bfd_reloc_code_real_type
) reloc
;
1621 return BFD_RELOC_UNUSED
;
1624 /* Like normal .long/.short/.word, except support @got, etc.
1625 Clobbers input_line_pointer, checks end-of-line. */
1627 ppc_elf_cons (nbytes
)
1628 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1631 bfd_reloc_code_real_type reloc
;
1633 if (is_it_end_of_statement ())
1635 demand_empty_rest_of_line ();
1642 if (exp
.X_op
== O_symbol
1643 && *input_line_pointer
== '@'
1644 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1645 &exp
)) != BFD_RELOC_UNUSED
)
1647 reloc_howto_type
*reloc_howto
;
1650 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1651 size
= bfd_get_reloc_size (reloc_howto
);
1655 as_bad (_("%s relocations do not fit in %d bytes\n"),
1656 reloc_howto
->name
, nbytes
);
1663 p
= frag_more (nbytes
);
1665 if (target_big_endian
)
1666 offset
= nbytes
- size
;
1667 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1672 emit_expr (&exp
, (unsigned int) nbytes
);
1674 while (*input_line_pointer
++ == ',');
1676 /* Put terminator back into stream. */
1677 input_line_pointer
--;
1678 demand_empty_rest_of_line ();
1681 /* Solaris pseduo op to change to the .rodata section. */
1686 char *save_line
= input_line_pointer
;
1687 static char section
[] = ".rodata\n";
1689 /* Just pretend this is .section .rodata */
1690 input_line_pointer
= section
;
1691 obj_elf_section (xxx
);
1693 input_line_pointer
= save_line
;
1696 /* Pseudo op to make file scope bss items. */
1699 int xxx ATTRIBUTE_UNUSED
;
1701 register char *name
;
1705 register symbolS
*symbolP
;
1712 name
= input_line_pointer
;
1713 c
= get_symbol_end ();
1715 /* just after name is now '\0'. */
1716 p
= input_line_pointer
;
1719 if (*input_line_pointer
!= ',')
1721 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1722 ignore_rest_of_line ();
1726 input_line_pointer
++; /* skip ',' */
1727 if ((size
= get_absolute_expression ()) < 0)
1729 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1730 ignore_rest_of_line ();
1734 /* The third argument to .lcomm is the alignment. */
1735 if (*input_line_pointer
!= ',')
1739 ++input_line_pointer
;
1740 align
= get_absolute_expression ();
1743 as_warn (_("ignoring bad alignment"));
1749 symbolP
= symbol_find_or_make (name
);
1752 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1754 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1755 S_GET_NAME (symbolP
));
1756 ignore_rest_of_line ();
1760 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1762 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1763 S_GET_NAME (symbolP
),
1764 (long) S_GET_VALUE (symbolP
),
1767 ignore_rest_of_line ();
1773 old_subsec
= now_subseg
;
1776 /* Convert to a power of 2 alignment. */
1777 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1780 as_bad (_("Common alignment not a power of 2"));
1781 ignore_rest_of_line ();
1788 record_alignment (bss_section
, align2
);
1789 subseg_set (bss_section
, 0);
1791 frag_align (align2
, 0, 0);
1792 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1793 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1794 symbol_set_frag (symbolP
, frag_now
);
1795 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1798 S_SET_SIZE (symbolP
, size
);
1799 S_SET_SEGMENT (symbolP
, bss_section
);
1800 subseg_set (old_sec
, old_subsec
);
1801 demand_empty_rest_of_line ();
1804 /* Validate any relocations emitted for -mrelocatable, possibly adding
1805 fixups for word relocations in writable segments, so we can adjust
1808 ppc_elf_validate_fix (fixp
, seg
)
1812 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1821 case SHLIB_MRELOCATABLE
:
1822 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1823 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1824 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1825 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1826 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1827 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1828 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1829 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1830 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1831 && (seg
->flags
& SEC_LOAD
) != 0
1832 && strcmp (segment_name (seg
), ".got2") != 0
1833 && strcmp (segment_name (seg
), ".dtors") != 0
1834 && strcmp (segment_name (seg
), ".ctors") != 0
1835 && strcmp (segment_name (seg
), ".fixup") != 0
1836 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1837 && strcmp (segment_name (seg
), ".eh_frame") != 0
1838 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1840 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1841 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1843 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1844 _("Relocation cannot be done when using -mrelocatable"));
1851 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1852 function descriptor sym if the corresponding code sym is used. */
1855 ppc_frob_file_before_adjust ()
1862 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1869 name
= S_GET_NAME (symp
);
1873 if (! S_IS_WEAK (symp
)
1874 || S_IS_DEFINED (symp
))
1877 len
= strlen (name
) + 1;
1878 dotname
= xmalloc (len
+ 1);
1880 memcpy (dotname
+ 1, name
, len
);
1881 dotsym
= symbol_find (dotname
);
1883 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1884 || symbol_used_in_reloc_p (dotsym
)))
1886 symbol_mark_used (symp
);
1890 /* Don't emit .TOC. symbol. */
1891 symp
= symbol_find (".TOC.");
1893 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1895 #endif /* OBJ_ELF */
1900 * Summary of parse_toc_entry.
1902 * in: Input_line_pointer points to the '[' in one of:
1904 * [toc] [tocv] [toc32] [toc64]
1906 * Anything else is an error of one kind or another.
1909 * return value: success or failure
1910 * toc_kind: kind of toc reference
1911 * input_line_pointer:
1912 * success: first char after the ']'
1913 * failure: unchanged
1917 * [toc] - rv == success, toc_kind = default_toc
1918 * [tocv] - rv == success, toc_kind = data_in_toc
1919 * [toc32] - rv == success, toc_kind = must_be_32
1920 * [toc64] - rv == success, toc_kind = must_be_64
1924 enum toc_size_qualifier
1926 default_toc
, /* The toc cell constructed should be the system default size */
1927 data_in_toc
, /* This is a direct reference to a toc cell */
1928 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1929 must_be_64
/* The toc cell constructed must be 64 bits wide */
1933 parse_toc_entry (toc_kind
)
1934 enum toc_size_qualifier
*toc_kind
;
1939 enum toc_size_qualifier t
;
1941 /* Save the input_line_pointer. */
1942 start
= input_line_pointer
;
1944 /* Skip over the '[' , and whitespace. */
1945 ++input_line_pointer
;
1948 /* Find the spelling of the operand. */
1949 toc_spec
= input_line_pointer
;
1950 c
= get_symbol_end ();
1952 if (strcmp (toc_spec
, "toc") == 0)
1956 else if (strcmp (toc_spec
, "tocv") == 0)
1960 else if (strcmp (toc_spec
, "toc32") == 0)
1964 else if (strcmp (toc_spec
, "toc64") == 0)
1970 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1971 *input_line_pointer
= c
;
1972 input_line_pointer
= start
;
1976 /* Now find the ']'. */
1977 *input_line_pointer
= c
;
1979 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1980 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1984 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1985 input_line_pointer
= start
;
1996 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
1998 ppc_apuinfo_section_add (apu
, version
)
1999 unsigned int apu
, version
;
2003 /* Check we don't already exist. */
2004 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
2005 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
2008 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
2010 if (ppc_apuinfo_num_alloc
== 0)
2012 ppc_apuinfo_num_alloc
= 4;
2013 ppc_apuinfo_list
= (unsigned long *)
2014 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2018 ppc_apuinfo_num_alloc
+= 4;
2019 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
2020 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
2023 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
2029 /* We need to keep a list of fixups. We can't simply generate them as
2030 we go, because that would require us to first create the frag, and
2031 that would screw up references to ``.''. */
2037 bfd_reloc_code_real_type reloc
;
2040 #define MAX_INSN_FIXUPS (5)
2042 /* This routine is called for each instruction to be assembled. */
2049 const struct powerpc_opcode
*opcode
;
2051 const unsigned char *opindex_ptr
;
2055 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2060 bfd_reloc_code_real_type reloc
;
2063 /* Get the opcode. */
2064 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2069 /* Look up the opcode in the hash table. */
2070 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2071 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2073 const struct powerpc_macro
*macro
;
2075 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2076 if (macro
== (const struct powerpc_macro
*) NULL
)
2077 as_bad (_("Unrecognized opcode: `%s'"), str
);
2079 ppc_macro (s
, macro
);
2084 insn
= opcode
->opcode
;
2087 while (ISSPACE (*str
))
2090 /* PowerPC operands are just expressions. The only real issue is
2091 that a few operand types are optional. All cases which might use
2092 an optional operand separate the operands only with commas (in
2093 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
2094 cases never have optional operands). There is never more than
2095 one optional operand for an instruction. So, before we start
2096 seriously parsing the operands, we check to see if we have an
2097 optional operand, and, if we do, we count the number of commas to
2098 see whether the operand should be omitted. */
2100 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2102 const struct powerpc_operand
*operand
;
2104 operand
= &powerpc_operands
[*opindex_ptr
];
2105 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2107 unsigned int opcount
;
2108 unsigned int num_operands_expected
;
2111 /* There is an optional operand. Count the number of
2112 commas in the input line. */
2119 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2126 /* Compute the number of expected operands.
2127 Do not count fake operands. */
2128 for (num_operands_expected
= 0, i
= 0; opcode
->operands
[i
]; i
++)
2129 if ((powerpc_operands
[opcode
->operands
[i
]].flags
& PPC_OPERAND_FAKE
) == 0)
2130 ++ num_operands_expected
;
2132 /* If there are fewer operands in the line then are called
2133 for by the instruction, we want to skip the optional
2135 if (opcount
< num_operands_expected
)
2142 /* Gather the operands. */
2146 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2148 const struct powerpc_operand
*operand
;
2154 if (next_opindex
== 0)
2155 operand
= &powerpc_operands
[*opindex_ptr
];
2158 operand
= &powerpc_operands
[next_opindex
];
2163 /* If this is a fake operand, then we do not expect anything
2165 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2167 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2168 if (errmsg
!= (const char *) NULL
)
2173 /* If this is an optional operand, and we are skipping it, just
2175 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2178 if (operand
->insert
)
2180 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2181 if (errmsg
!= (const char *) NULL
)
2184 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2185 next_opindex
= *opindex_ptr
+ 1;
2189 /* Gather the operand. */
2190 hold
= input_line_pointer
;
2191 input_line_pointer
= str
;
2194 if (*input_line_pointer
== '[')
2196 /* We are expecting something like the second argument here:
2198 * lwz r4,[toc].GS.0.static_int(rtoc)
2199 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2200 * The argument following the `]' must be a symbol name, and the
2201 * register must be the toc register: 'rtoc' or '2'
2203 * The effect is to 0 as the displacement field
2204 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2205 * the appropriate variation) reloc against it based on the symbol.
2206 * The linker will build the toc, and insert the resolved toc offset.
2209 * o The size of the toc entry is currently assumed to be
2210 * 32 bits. This should not be assumed to be a hard coded
2212 * o In an effort to cope with a change from 32 to 64 bits,
2213 * there are also toc entries that are specified to be
2214 * either 32 or 64 bits:
2215 * lwz r4,[toc32].GS.0.static_int(rtoc)
2216 * lwz r4,[toc64].GS.0.static_int(rtoc)
2217 * These demand toc entries of the specified size, and the
2218 * instruction probably requires it.
2222 enum toc_size_qualifier toc_kind
;
2223 bfd_reloc_code_real_type toc_reloc
;
2225 /* Go parse off the [tocXX] part. */
2226 valid_toc
= parse_toc_entry (&toc_kind
);
2230 /* Note: message has already been issued.
2231 FIXME: what sort of recovery should we do?
2232 demand_rest_of_line (); return; ? */
2235 /* Now get the symbol following the ']'. */
2241 /* In this case, we may not have seen the symbol yet,
2242 since it is allowed to appear on a .extern or .globl
2243 or just be a label in the .data section. */
2244 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2247 /* 1. The symbol must be defined and either in the toc
2248 section, or a global.
2249 2. The reloc generated must have the TOCDEFN flag set
2250 in upper bit mess of the reloc type.
2251 FIXME: It's a little confusing what the tocv
2252 qualifier can be used for. At the very least, I've
2253 seen three uses, only one of which I'm sure I can
2255 if (ex
.X_op
== O_symbol
)
2257 assert (ex
.X_add_symbol
!= NULL
);
2258 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2261 as_bad (_("[tocv] symbol is not a toc symbol"));
2265 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2268 /* FIXME: these next two specifically specify 32/64 bit
2269 toc entries. We don't support them today. Is this
2270 the right way to say that? */
2271 toc_reloc
= BFD_RELOC_UNUSED
;
2272 as_bad (_("Unimplemented toc32 expression modifier"));
2275 /* FIXME: see above. */
2276 toc_reloc
= BFD_RELOC_UNUSED
;
2277 as_bad (_("Unimplemented toc64 expression modifier"));
2281 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2287 /* We need to generate a fixup for this expression. */
2288 if (fc
>= MAX_INSN_FIXUPS
)
2289 as_fatal (_("too many fixups"));
2291 fixups
[fc
].reloc
= toc_reloc
;
2292 fixups
[fc
].exp
= ex
;
2293 fixups
[fc
].opindex
= *opindex_ptr
;
2296 /* Ok. We've set up the fixup for the instruction. Now make it
2297 look like the constant 0 was found here. */
2299 ex
.X_op
= O_constant
;
2300 ex
.X_add_number
= 0;
2301 ex
.X_add_symbol
= NULL
;
2302 ex
.X_op_symbol
= NULL
;
2308 if (! register_name (&ex
))
2310 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2317 str
= input_line_pointer
;
2318 input_line_pointer
= hold
;
2320 if (ex
.X_op
== O_illegal
)
2321 as_bad (_("illegal operand"));
2322 else if (ex
.X_op
== O_absent
)
2323 as_bad (_("missing operand"));
2324 else if (ex
.X_op
== O_register
)
2326 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2329 else if (ex
.X_op
== O_constant
)
2332 /* Allow @HA, @L, @H on constants. */
2333 char *orig_str
= str
;
2335 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2342 case BFD_RELOC_LO16
:
2343 /* X_unsigned is the default, so if the user has done
2344 something which cleared it, we always produce a
2346 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2347 ex
.X_add_number
&= 0xffff;
2349 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2352 case BFD_RELOC_HI16
:
2353 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2354 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2356 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2359 case BFD_RELOC_HI16_S
:
2360 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2361 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2363 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2366 case BFD_RELOC_PPC64_HIGHER
:
2367 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2368 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2370 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2373 case BFD_RELOC_PPC64_HIGHER_S
:
2374 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2375 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2377 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2380 case BFD_RELOC_PPC64_HIGHEST
:
2381 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2382 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2384 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2387 case BFD_RELOC_PPC64_HIGHEST_S
:
2388 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2389 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2391 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2394 #endif /* OBJ_ELF */
2395 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2399 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2401 /* Some TLS tweaks. */
2406 case BFD_RELOC_PPC_TLS
:
2407 insn
= ppc_insert_operand (insn
, operand
, ppc_obj64
? 13 : 2,
2410 /* We'll only use the 32 (or 64) bit form of these relocations
2411 in constants. Instructions get the 16 bit form. */
2412 case BFD_RELOC_PPC_DTPREL
:
2413 reloc
= BFD_RELOC_PPC_DTPREL16
;
2415 case BFD_RELOC_PPC_TPREL
:
2416 reloc
= BFD_RELOC_PPC_TPREL16
;
2420 /* For the absolute forms of branches, convert the PC
2421 relative form back into the absolute. */
2422 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2426 case BFD_RELOC_PPC_B26
:
2427 reloc
= BFD_RELOC_PPC_BA26
;
2429 case BFD_RELOC_PPC_B16
:
2430 reloc
= BFD_RELOC_PPC_BA16
;
2432 case BFD_RELOC_PPC_B16_BRTAKEN
:
2433 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2435 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2436 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2444 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2449 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2451 case BFD_RELOC_LO16
:
2452 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2454 case BFD_RELOC_16_GOTOFF
:
2455 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2457 case BFD_RELOC_LO16_GOTOFF
:
2458 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2460 case BFD_RELOC_LO16_PLTOFF
:
2461 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2463 case BFD_RELOC_16_BASEREL
:
2464 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2466 case BFD_RELOC_LO16_BASEREL
:
2467 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2469 case BFD_RELOC_PPC_TOC16
:
2470 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2472 case BFD_RELOC_PPC64_TOC16_LO
:
2473 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2475 case BFD_RELOC_PPC64_PLTGOT16
:
2476 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2478 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2479 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2481 case BFD_RELOC_PPC_DTPREL16
:
2482 reloc
= BFD_RELOC_PPC64_DTPREL16_DS
;
2484 case BFD_RELOC_PPC_DTPREL16_LO
:
2485 reloc
= BFD_RELOC_PPC64_DTPREL16_LO_DS
;
2487 case BFD_RELOC_PPC_TPREL16
:
2488 reloc
= BFD_RELOC_PPC64_TPREL16_DS
;
2490 case BFD_RELOC_PPC_TPREL16_LO
:
2491 reloc
= BFD_RELOC_PPC64_TPREL16_LO_DS
;
2493 case BFD_RELOC_PPC_GOT_DTPREL16
:
2494 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
2495 case BFD_RELOC_PPC_GOT_TPREL16
:
2496 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
2499 as_bad (_("unsupported relocation for DS offset field"));
2504 /* We need to generate a fixup for this expression. */
2505 if (fc
>= MAX_INSN_FIXUPS
)
2506 as_fatal (_("too many fixups"));
2507 fixups
[fc
].exp
= ex
;
2508 fixups
[fc
].opindex
= 0;
2509 fixups
[fc
].reloc
= reloc
;
2512 #endif /* OBJ_ELF */
2516 /* We need to generate a fixup for this expression. */
2517 if (fc
>= MAX_INSN_FIXUPS
)
2518 as_fatal (_("too many fixups"));
2519 fixups
[fc
].exp
= ex
;
2520 fixups
[fc
].opindex
= *opindex_ptr
;
2521 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2530 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2538 /* The call to expression should have advanced str past any
2541 && (endc
!= ',' || *str
!= '\0'))
2543 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2551 while (ISSPACE (*str
))
2555 as_bad (_("junk at end of line: `%s'"), str
);
2558 /* Do we need/want a APUinfo section? */
2559 if (ppc_cpu
& (PPC_OPCODE_SPE
2560 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
2561 | PPC_OPCODE_BRLOCK
| PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
2562 | PPC_OPCODE_RFMCI
))
2564 /* These are all version "1". */
2565 if (opcode
->flags
& PPC_OPCODE_SPE
)
2566 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2567 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2568 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2569 if (opcode
->flags
& PPC_OPCODE_EFS
)
2570 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2571 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2572 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2573 if (opcode
->flags
& PPC_OPCODE_PMR
)
2574 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2575 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2576 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2577 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2578 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2582 /* Write out the instruction. */
2584 md_number_to_chars (f
, insn
, 4);
2587 dwarf2_emit_insn (4);
2590 /* Create any fixups. At this point we do not use a
2591 bfd_reloc_code_real_type, but instead just use the
2592 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2593 handle fixups for any operand type, although that is admittedly
2594 not a very exciting feature. We pick a BFD reloc type in
2596 for (i
= 0; i
< fc
; i
++)
2598 const struct powerpc_operand
*operand
;
2600 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2601 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2603 reloc_howto_type
*reloc_howto
;
2608 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2612 size
= bfd_get_reloc_size (reloc_howto
);
2613 offset
= target_big_endian
? (4 - size
) : 0;
2615 if (size
< 1 || size
> 4)
2618 fixP
= fix_new_exp (frag_now
,
2619 f
- frag_now
->fr_literal
+ offset
,
2622 reloc_howto
->pc_relative
,
2625 /* Turn off complaints that the addend is too large for things like
2627 switch (fixups
[i
].reloc
)
2629 case BFD_RELOC_16_GOTOFF
:
2630 case BFD_RELOC_PPC_TOC16
:
2631 case BFD_RELOC_LO16
:
2632 case BFD_RELOC_HI16
:
2633 case BFD_RELOC_HI16_S
:
2635 case BFD_RELOC_PPC64_HIGHER
:
2636 case BFD_RELOC_PPC64_HIGHER_S
:
2637 case BFD_RELOC_PPC64_HIGHEST
:
2638 case BFD_RELOC_PPC64_HIGHEST_S
:
2640 fixP
->fx_no_overflow
= 1;
2647 fix_new_exp (frag_now
,
2648 f
- frag_now
->fr_literal
,
2651 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2652 ((bfd_reloc_code_real_type
)
2653 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2657 /* Handle a macro. Gather all the operands, transform them as
2658 described by the macro, and call md_assemble recursively. All the
2659 operands are separated by commas; we don't accept parentheses
2660 around operands here. */
2663 ppc_macro (str
, macro
)
2665 const struct powerpc_macro
*macro
;
2676 /* Gather the users operands into the operands array. */
2681 if (count
>= sizeof operands
/ sizeof operands
[0])
2683 operands
[count
++] = s
;
2684 s
= strchr (s
, ',');
2685 if (s
== (char *) NULL
)
2690 if (count
!= macro
->operands
)
2692 as_bad (_("wrong number of operands"));
2696 /* Work out how large the string must be (the size is unbounded
2697 because it includes user input). */
2699 format
= macro
->format
;
2700 while (*format
!= '\0')
2709 arg
= strtol (format
+ 1, &send
, 10);
2710 know (send
!= format
&& arg
>= 0 && arg
< count
);
2711 len
+= strlen (operands
[arg
]);
2716 /* Put the string together. */
2717 complete
= s
= (char *) alloca (len
+ 1);
2718 format
= macro
->format
;
2719 while (*format
!= '\0')
2725 arg
= strtol (format
+ 1, &send
, 10);
2726 strcpy (s
, operands
[arg
]);
2733 /* Assemble the constructed instruction. */
2734 md_assemble (complete
);
2738 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2741 ppc_section_letter (letter
, ptr_msg
)
2748 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2753 ppc_section_word (str
, len
)
2757 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2764 ppc_section_type (str
, len
)
2768 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2775 ppc_section_flags (flags
, attr
, type
)
2780 if (type
== SHT_ORDERED
)
2781 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2783 if (attr
& SHF_EXCLUDE
)
2784 flags
|= SEC_EXCLUDE
;
2788 #endif /* OBJ_ELF */
2791 /* Pseudo-op handling. */
2793 /* The .byte pseudo-op. This is similar to the normal .byte
2794 pseudo-op, but it can also take a single ASCII string. */
2798 int ignore ATTRIBUTE_UNUSED
;
2800 if (*input_line_pointer
!= '\"')
2806 /* Gather characters. A real double quote is doubled. Unusual
2807 characters are not permitted. */
2808 ++input_line_pointer
;
2813 c
= *input_line_pointer
++;
2817 if (*input_line_pointer
!= '\"')
2819 ++input_line_pointer
;
2822 FRAG_APPEND_1_CHAR (c
);
2825 demand_empty_rest_of_line ();
2830 /* XCOFF specific pseudo-op handling. */
2832 /* This is set if we are creating a .stabx symbol, since we don't want
2833 to handle symbol suffixes for such symbols. */
2834 static bfd_boolean ppc_stab_symbol
;
2836 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2837 symbols in the .bss segment as though they were local common
2838 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2839 aligns .comm and .lcomm to 4 bytes. */
2845 asection
*current_seg
= now_seg
;
2846 subsegT current_subseg
= now_subseg
;
2852 symbolS
*lcomm_sym
= NULL
;
2856 name
= input_line_pointer
;
2857 endc
= get_symbol_end ();
2858 end_name
= input_line_pointer
;
2861 if (*input_line_pointer
!= ',')
2863 as_bad (_("missing size"));
2864 ignore_rest_of_line ();
2867 ++input_line_pointer
;
2869 size
= get_absolute_expression ();
2872 as_bad (_("negative size"));
2873 ignore_rest_of_line ();
2879 /* The third argument to .comm is the alignment. */
2880 if (*input_line_pointer
!= ',')
2884 ++input_line_pointer
;
2885 align
= get_absolute_expression ();
2888 as_warn (_("ignoring bad alignment"));
2903 /* The third argument to .lcomm appears to be the real local
2904 common symbol to create. References to the symbol named in
2905 the first argument are turned into references to the third
2907 if (*input_line_pointer
!= ',')
2909 as_bad (_("missing real symbol name"));
2910 ignore_rest_of_line ();
2913 ++input_line_pointer
;
2915 lcomm_name
= input_line_pointer
;
2916 lcomm_endc
= get_symbol_end ();
2918 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2920 *input_line_pointer
= lcomm_endc
;
2924 sym
= symbol_find_or_make (name
);
2927 if (S_IS_DEFINED (sym
)
2928 || S_GET_VALUE (sym
) != 0)
2930 as_bad (_("attempt to redefine symbol"));
2931 ignore_rest_of_line ();
2935 record_alignment (bss_section
, align
);
2938 || ! S_IS_DEFINED (lcomm_sym
))
2947 S_SET_EXTERNAL (sym
);
2951 symbol_get_tc (lcomm_sym
)->output
= 1;
2952 def_sym
= lcomm_sym
;
2956 subseg_set (bss_section
, 1);
2957 frag_align (align
, 0, 0);
2959 symbol_set_frag (def_sym
, frag_now
);
2960 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2961 def_size
, (char *) NULL
);
2963 S_SET_SEGMENT (def_sym
, bss_section
);
2964 symbol_get_tc (def_sym
)->align
= align
;
2968 /* Align the size of lcomm_sym. */
2969 symbol_get_frag (lcomm_sym
)->fr_offset
=
2970 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2971 &~ ((1 << align
) - 1));
2972 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2973 symbol_get_tc (lcomm_sym
)->align
= align
;
2978 /* Make sym an offset from lcomm_sym. */
2979 S_SET_SEGMENT (sym
, bss_section
);
2980 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2981 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2982 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2985 subseg_set (current_seg
, current_subseg
);
2987 demand_empty_rest_of_line ();
2990 /* The .csect pseudo-op. This switches us into a different
2991 subsegment. The first argument is a symbol whose value is the
2992 start of the .csect. In COFF, csect symbols get special aux
2993 entries defined by the x_csect field of union internal_auxent. The
2994 optional second argument is the alignment (the default is 2). */
2998 int ignore ATTRIBUTE_UNUSED
;
3004 name
= input_line_pointer
;
3005 endc
= get_symbol_end ();
3007 sym
= symbol_find_or_make (name
);
3009 *input_line_pointer
= endc
;
3011 if (S_GET_NAME (sym
)[0] == '\0')
3013 /* An unnamed csect is assumed to be [PR]. */
3014 symbol_get_tc (sym
)->class = XMC_PR
;
3017 ppc_change_csect (sym
);
3019 if (*input_line_pointer
== ',')
3021 ++input_line_pointer
;
3022 symbol_get_tc (sym
)->align
= get_absolute_expression ();
3025 demand_empty_rest_of_line ();
3028 /* Change to a different csect. */
3031 ppc_change_csect (sym
)
3034 if (S_IS_DEFINED (sym
))
3035 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
3043 /* This is a new csect. We need to look at the symbol class to
3044 figure out whether it should go in the text section or the
3047 switch (symbol_get_tc (sym
)->class)
3057 S_SET_SEGMENT (sym
, text_section
);
3058 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
3059 ++ppc_text_subsegment
;
3060 list_ptr
= &ppc_text_csects
;
3069 if (ppc_toc_csect
!= NULL
3070 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
3071 == ppc_data_subsegment
))
3073 S_SET_SEGMENT (sym
, data_section
);
3074 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
3075 ++ppc_data_subsegment
;
3076 list_ptr
= &ppc_data_csects
;
3082 /* We set the obstack chunk size to a small value before
3083 changing subsegments, so that we don't use a lot of memory
3084 space for what may be a small section. */
3085 hold_chunksize
= chunksize
;
3088 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
3089 symbol_get_tc (sym
)->subseg
);
3091 chunksize
= hold_chunksize
;
3094 ppc_after_toc_frag
= frag_now
;
3096 symbol_set_frag (sym
, frag_now
);
3097 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3099 symbol_get_tc (sym
)->align
= 2;
3100 symbol_get_tc (sym
)->output
= 1;
3101 symbol_get_tc (sym
)->within
= sym
;
3103 for (list
= *list_ptr
;
3104 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3105 list
= symbol_get_tc (list
)->next
)
3107 symbol_get_tc (list
)->next
= sym
;
3109 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3110 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3114 ppc_current_csect
= sym
;
3117 /* This function handles the .text and .data pseudo-ops. These
3118 pseudo-ops aren't really used by XCOFF; we implement them for the
3119 convenience of people who aren't used to XCOFF. */
3130 else if (type
== 'd')
3135 sym
= symbol_find_or_make (name
);
3137 ppc_change_csect (sym
);
3139 demand_empty_rest_of_line ();
3142 /* This function handles the .section pseudo-op. This is mostly to
3143 give an error, since XCOFF only supports .text, .data and .bss, but
3144 we do permit the user to name the text or data section. */
3147 ppc_named_section (ignore
)
3148 int ignore ATTRIBUTE_UNUSED
;
3151 const char *real_name
;
3155 user_name
= input_line_pointer
;
3156 c
= get_symbol_end ();
3158 if (strcmp (user_name
, ".text") == 0)
3159 real_name
= ".text[PR]";
3160 else if (strcmp (user_name
, ".data") == 0)
3161 real_name
= ".data[RW]";
3164 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3165 *input_line_pointer
= c
;
3166 ignore_rest_of_line ();
3170 *input_line_pointer
= c
;
3172 sym
= symbol_find_or_make (real_name
);
3174 ppc_change_csect (sym
);
3176 demand_empty_rest_of_line ();
3179 /* The .extern pseudo-op. We create an undefined symbol. */
3183 int ignore ATTRIBUTE_UNUSED
;
3188 name
= input_line_pointer
;
3189 endc
= get_symbol_end ();
3191 (void) symbol_find_or_make (name
);
3193 *input_line_pointer
= endc
;
3195 demand_empty_rest_of_line ();
3198 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3202 int ignore ATTRIBUTE_UNUSED
;
3208 name
= input_line_pointer
;
3209 endc
= get_symbol_end ();
3211 sym
= symbol_find_or_make (name
);
3213 *input_line_pointer
= endc
;
3215 symbol_get_tc (sym
)->output
= 1;
3217 demand_empty_rest_of_line ();
3220 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3221 although I don't know why it bothers. */
3225 int ignore ATTRIBUTE_UNUSED
;
3232 name
= input_line_pointer
;
3233 endc
= get_symbol_end ();
3235 sym
= symbol_find_or_make (name
);
3237 *input_line_pointer
= endc
;
3239 if (*input_line_pointer
!= ',')
3241 as_bad (_("missing rename string"));
3242 ignore_rest_of_line ();
3245 ++input_line_pointer
;
3247 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3249 demand_empty_rest_of_line ();
3252 /* The .stabx pseudo-op. This is similar to a normal .stabs
3253 pseudo-op, but slightly different. A sample is
3254 .stabx "main:F-1",.main,142,0
3255 The first argument is the symbol name to create. The second is the
3256 value, and the third is the storage class. The fourth seems to be
3257 always zero, and I am assuming it is the type. */
3261 int ignore ATTRIBUTE_UNUSED
;
3268 name
= demand_copy_C_string (&len
);
3270 if (*input_line_pointer
!= ',')
3272 as_bad (_("missing value"));
3275 ++input_line_pointer
;
3277 ppc_stab_symbol
= TRUE
;
3278 sym
= symbol_make (name
);
3279 ppc_stab_symbol
= FALSE
;
3281 symbol_get_tc (sym
)->real_name
= name
;
3283 (void) expression (&exp
);
3290 as_bad (_("illegal .stabx expression; zero assumed"));
3291 exp
.X_add_number
= 0;
3294 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3295 symbol_set_frag (sym
, &zero_address_frag
);
3299 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3300 symbol_set_value_expression (sym
, &exp
);
3304 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3305 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3310 /* The value is some complex expression. This will probably
3311 fail at some later point, but this is probably the right
3312 thing to do here. */
3313 symbol_set_value_expression (sym
, &exp
);
3317 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3318 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3320 if (*input_line_pointer
!= ',')
3322 as_bad (_("missing class"));
3325 ++input_line_pointer
;
3327 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3329 if (*input_line_pointer
!= ',')
3331 as_bad (_("missing type"));
3334 ++input_line_pointer
;
3336 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3338 symbol_get_tc (sym
)->output
= 1;
3340 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3342 symbol_get_tc (sym
)->within
= ppc_current_block
;
3347 .stabx "z",arrays_,133,0
3350 .comm arrays_,13768,3
3352 resolve_symbol_value will copy the exp's "within" into sym's when the
3353 offset is 0. Since this seems to be corner case problem,
3354 only do the correction for storage class C_STSYM. A better solution
3355 would be to have the tc field updated in ppc_symbol_new_hook. */
3357 if (exp
.X_op
== O_symbol
)
3359 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3363 if (exp
.X_op
!= O_symbol
3364 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3365 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3366 ppc_frob_label (sym
);
3369 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3370 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3371 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3372 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3375 demand_empty_rest_of_line ();
3378 /* The .function pseudo-op. This takes several arguments. The first
3379 argument seems to be the external name of the symbol. The second
3380 argment seems to be the label for the start of the function. gcc
3381 uses the same name for both. I have no idea what the third and
3382 fourth arguments are meant to be. The optional fifth argument is
3383 an expression for the size of the function. In COFF this symbol
3384 gets an aux entry like that used for a csect. */
3387 ppc_function (ignore
)
3388 int ignore ATTRIBUTE_UNUSED
;
3396 name
= input_line_pointer
;
3397 endc
= get_symbol_end ();
3399 /* Ignore any [PR] suffix. */
3400 name
= ppc_canonicalize_symbol_name (name
);
3401 s
= strchr (name
, '[');
3402 if (s
!= (char *) NULL
3403 && strcmp (s
+ 1, "PR]") == 0)
3406 ext_sym
= symbol_find_or_make (name
);
3408 *input_line_pointer
= endc
;
3410 if (*input_line_pointer
!= ',')
3412 as_bad (_("missing symbol name"));
3413 ignore_rest_of_line ();
3416 ++input_line_pointer
;
3418 name
= input_line_pointer
;
3419 endc
= get_symbol_end ();
3421 lab_sym
= symbol_find_or_make (name
);
3423 *input_line_pointer
= endc
;
3425 if (ext_sym
!= lab_sym
)
3429 exp
.X_op
= O_symbol
;
3430 exp
.X_add_symbol
= lab_sym
;
3431 exp
.X_op_symbol
= NULL
;
3432 exp
.X_add_number
= 0;
3434 symbol_set_value_expression (ext_sym
, &exp
);
3437 if (symbol_get_tc (ext_sym
)->class == -1)
3438 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3439 symbol_get_tc (ext_sym
)->output
= 1;
3441 if (*input_line_pointer
== ',')
3445 /* Ignore the third argument. */
3446 ++input_line_pointer
;
3447 expression (&ignore
);
3448 if (*input_line_pointer
== ',')
3450 /* Ignore the fourth argument. */
3451 ++input_line_pointer
;
3452 expression (&ignore
);
3453 if (*input_line_pointer
== ',')
3455 /* The fifth argument is the function size. */
3456 ++input_line_pointer
;
3457 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3460 &zero_address_frag
);
3461 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3466 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3467 SF_SET_FUNCTION (ext_sym
);
3468 SF_SET_PROCESS (ext_sym
);
3469 coff_add_linesym (ext_sym
);
3471 demand_empty_rest_of_line ();
3474 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3475 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3476 with the correct line number */
3478 static symbolS
*saved_bi_sym
= 0;
3482 int ignore ATTRIBUTE_UNUSED
;
3486 sym
= symbol_make (".bf");
3487 S_SET_SEGMENT (sym
, text_section
);
3488 symbol_set_frag (sym
, frag_now
);
3489 S_SET_VALUE (sym
, frag_now_fix ());
3490 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3492 coff_line_base
= get_absolute_expression ();
3494 S_SET_NUMBER_AUXILIARY (sym
, 1);
3495 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3497 /* Line number for bi. */
3500 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3505 symbol_get_tc (sym
)->output
= 1;
3507 ppc_frob_label (sym
);
3509 demand_empty_rest_of_line ();
3512 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3513 ".ef", except that the line number is absolute, not relative to the
3514 most recent ".bf" symbol. */
3518 int ignore ATTRIBUTE_UNUSED
;
3522 sym
= symbol_make (".ef");
3523 S_SET_SEGMENT (sym
, text_section
);
3524 symbol_set_frag (sym
, frag_now
);
3525 S_SET_VALUE (sym
, frag_now_fix ());
3526 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3527 S_SET_NUMBER_AUXILIARY (sym
, 1);
3528 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3529 symbol_get_tc (sym
)->output
= 1;
3531 ppc_frob_label (sym
);
3533 demand_empty_rest_of_line ();
3536 /* The .bi and .ei pseudo-ops. These take a string argument and
3537 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3538 the symbol list. The value of .bi will be know when the next .bf
3545 static symbolS
*last_biei
;
3552 name
= demand_copy_C_string (&len
);
3554 /* The value of these symbols is actually file offset. Here we set
3555 the value to the index into the line number entries. In
3556 ppc_frob_symbols we set the fix_line field, which will cause BFD
3557 to do the right thing. */
3559 sym
= symbol_make (name
);
3560 /* obj-coff.c currently only handles line numbers correctly in the
3562 S_SET_SEGMENT (sym
, text_section
);
3563 S_SET_VALUE (sym
, coff_n_line_nos
);
3564 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3566 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3567 symbol_get_tc (sym
)->output
= 1;
3575 for (look
= last_biei
? last_biei
: symbol_rootP
;
3576 (look
!= (symbolS
*) NULL
3577 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3578 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3579 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3580 look
= symbol_next (look
))
3582 if (look
!= (symbolS
*) NULL
)
3584 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3585 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3589 demand_empty_rest_of_line ();
3592 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3593 There is one argument, which is a csect symbol. The value of the
3594 .bs symbol is the index of this csect symbol. */
3598 int ignore ATTRIBUTE_UNUSED
;
3605 if (ppc_current_block
!= NULL
)
3606 as_bad (_("nested .bs blocks"));
3608 name
= input_line_pointer
;
3609 endc
= get_symbol_end ();
3611 csect
= symbol_find_or_make (name
);
3613 *input_line_pointer
= endc
;
3615 sym
= symbol_make (".bs");
3616 S_SET_SEGMENT (sym
, now_seg
);
3617 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3618 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3619 symbol_get_tc (sym
)->output
= 1;
3621 symbol_get_tc (sym
)->within
= csect
;
3623 ppc_frob_label (sym
);
3625 ppc_current_block
= sym
;
3627 demand_empty_rest_of_line ();
3630 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3634 int ignore ATTRIBUTE_UNUSED
;
3638 if (ppc_current_block
== NULL
)
3639 as_bad (_(".es without preceding .bs"));
3641 sym
= symbol_make (".es");
3642 S_SET_SEGMENT (sym
, now_seg
);
3643 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3644 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3645 symbol_get_tc (sym
)->output
= 1;
3647 ppc_frob_label (sym
);
3649 ppc_current_block
= NULL
;
3651 demand_empty_rest_of_line ();
3654 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3659 int ignore ATTRIBUTE_UNUSED
;
3663 sym
= symbol_make (".bb");
3664 S_SET_SEGMENT (sym
, text_section
);
3665 symbol_set_frag (sym
, frag_now
);
3666 S_SET_VALUE (sym
, frag_now_fix ());
3667 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3669 S_SET_NUMBER_AUXILIARY (sym
, 1);
3670 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3672 symbol_get_tc (sym
)->output
= 1;
3674 SF_SET_PROCESS (sym
);
3676 ppc_frob_label (sym
);
3678 demand_empty_rest_of_line ();
3681 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3686 int ignore ATTRIBUTE_UNUSED
;
3690 sym
= symbol_make (".eb");
3691 S_SET_SEGMENT (sym
, text_section
);
3692 symbol_set_frag (sym
, frag_now
);
3693 S_SET_VALUE (sym
, frag_now_fix ());
3694 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3695 S_SET_NUMBER_AUXILIARY (sym
, 1);
3696 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3697 symbol_get_tc (sym
)->output
= 1;
3699 SF_SET_PROCESS (sym
);
3701 ppc_frob_label (sym
);
3703 demand_empty_rest_of_line ();
3706 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3711 int ignore ATTRIBUTE_UNUSED
;
3717 name
= demand_copy_C_string (&len
);
3718 sym
= symbol_make (name
);
3719 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3720 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3721 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3722 S_SET_VALUE (sym
, 0);
3723 symbol_get_tc (sym
)->output
= 1;
3725 ppc_frob_label (sym
);
3727 demand_empty_rest_of_line ();
3730 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3734 int ignore ATTRIBUTE_UNUSED
;
3738 sym
= symbol_make (".ec");
3739 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3740 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3741 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3742 S_SET_VALUE (sym
, 0);
3743 symbol_get_tc (sym
)->output
= 1;
3745 ppc_frob_label (sym
);
3747 demand_empty_rest_of_line ();
3750 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3754 int ignore ATTRIBUTE_UNUSED
;
3756 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3757 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3764 subseg
= ppc_data_subsegment
;
3765 ++ppc_data_subsegment
;
3767 subseg_new (segment_name (data_section
), subseg
);
3768 ppc_toc_frag
= frag_now
;
3770 sym
= symbol_find_or_make ("TOC[TC0]");
3771 symbol_set_frag (sym
, frag_now
);
3772 S_SET_SEGMENT (sym
, data_section
);
3773 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3774 symbol_get_tc (sym
)->subseg
= subseg
;
3775 symbol_get_tc (sym
)->output
= 1;
3776 symbol_get_tc (sym
)->within
= sym
;
3778 ppc_toc_csect
= sym
;
3780 for (list
= ppc_data_csects
;
3781 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3782 list
= symbol_get_tc (list
)->next
)
3784 symbol_get_tc (list
)->next
= sym
;
3786 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3787 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3791 ppc_current_csect
= ppc_toc_csect
;
3793 demand_empty_rest_of_line ();
3796 /* The AIX assembler automatically aligns the operands of a .long or
3797 .short pseudo-op, and we want to be compatible. */
3800 ppc_xcoff_cons (log_size
)
3803 frag_align (log_size
, 0, 0);
3804 record_alignment (now_seg
, log_size
);
3805 cons (1 << log_size
);
3810 int dummy ATTRIBUTE_UNUSED
;
3815 (void) expression (&exp
);
3817 if (exp
.X_op
!= O_constant
)
3819 as_bad (_("non-constant byte count"));
3823 byte_count
= exp
.X_add_number
;
3825 if (*input_line_pointer
!= ',')
3827 as_bad (_("missing value"));
3831 ++input_line_pointer
;
3835 #endif /* OBJ_XCOFF */
3836 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3838 /* The .tc pseudo-op. This is used when generating either XCOFF or
3839 ELF. This takes two or more arguments.
3841 When generating XCOFF output, the first argument is the name to
3842 give to this location in the toc; this will be a symbol with class
3843 TC. The rest of the arguments are N-byte values to actually put at
3844 this location in the TOC; often there is just one more argument, a
3845 relocateable symbol reference. The size of the value to store
3846 depends on target word size. A 32-bit target uses 4-byte values, a
3847 64-bit target uses 8-byte values.
3849 When not generating XCOFF output, the arguments are the same, but
3850 the first argument is simply ignored. */
3854 int ignore ATTRIBUTE_UNUSED
;
3858 /* Define the TOC symbol name. */
3864 if (ppc_toc_csect
== (symbolS
*) NULL
3865 || ppc_toc_csect
!= ppc_current_csect
)
3867 as_bad (_(".tc not in .toc section"));
3868 ignore_rest_of_line ();
3872 name
= input_line_pointer
;
3873 endc
= get_symbol_end ();
3875 sym
= symbol_find_or_make (name
);
3877 *input_line_pointer
= endc
;
3879 if (S_IS_DEFINED (sym
))
3883 label
= symbol_get_tc (ppc_current_csect
)->within
;
3884 if (symbol_get_tc (label
)->class != XMC_TC0
)
3886 as_bad (_(".tc with no label"));
3887 ignore_rest_of_line ();
3891 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3892 symbol_set_frag (label
, symbol_get_frag (sym
));
3893 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3895 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3896 ++input_line_pointer
;
3901 S_SET_SEGMENT (sym
, now_seg
);
3902 symbol_set_frag (sym
, frag_now
);
3903 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3904 symbol_get_tc (sym
)->class = XMC_TC
;
3905 symbol_get_tc (sym
)->output
= 1;
3907 ppc_frob_label (sym
);
3910 #endif /* OBJ_XCOFF */
3914 /* Skip the TOC symbol name. */
3915 while (is_part_of_name (*input_line_pointer
)
3916 || *input_line_pointer
== '['
3917 || *input_line_pointer
== ']'
3918 || *input_line_pointer
== '{'
3919 || *input_line_pointer
== '}')
3920 ++input_line_pointer
;
3922 /* Align to a four/eight byte boundary. */
3923 align
= ppc_obj64
? 3 : 2;
3924 frag_align (align
, 0, 0);
3925 record_alignment (now_seg
, align
);
3926 #endif /* OBJ_ELF */
3928 if (*input_line_pointer
!= ',')
3929 demand_empty_rest_of_line ();
3932 ++input_line_pointer
;
3933 cons (ppc_obj64
? 8 : 4);
3937 /* Pseudo-op .machine. */
3938 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3939 accept this directive on the first line of input and set ppc_obj64
3940 and the target format accordingly. Unfortunately, the target
3941 format is selected in output-file.c:output_file_create before we
3942 even get to md_begin, so it's not possible without changing
3946 ppc_machine (ignore
)
3947 int ignore ATTRIBUTE_UNUSED
;
3949 discard_rest_of_line ();
3952 /* See whether a symbol is in the TOC section. */
3955 ppc_is_toc_sym (sym
)
3959 return symbol_get_tc (sym
)->class == XMC_TC
;
3962 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3964 return strcmp (sname
, ".toc") == 0;
3966 return strcmp (sname
, ".got") == 0;
3969 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3973 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3975 /* Set the current section. */
3977 ppc_set_current_section (new)
3980 ppc_previous_section
= ppc_current_section
;
3981 ppc_current_section
= new;
3984 /* pseudo-op: .previous
3985 behaviour: toggles the current section with the previous section.
3987 warnings: "No previous section" */
3990 ppc_previous (ignore
)
3991 int ignore ATTRIBUTE_UNUSED
;
3995 if (ppc_previous_section
== NULL
)
3997 as_warn (_("No previous section to return to. Directive ignored."));
4001 subseg_set (ppc_previous_section
, 0);
4003 ppc_set_current_section (ppc_previous_section
);
4006 /* pseudo-op: .pdata
4007 behaviour: predefined read only data section
4011 initial: .section .pdata "adr3"
4012 a - don't know -- maybe a misprint
4013 d - initialized data
4015 3 - double word aligned (that would be 4 byte boundary)
4018 Tag index tables (also known as the function table) for exception
4019 handling, debugging, etc. */
4023 int ignore ATTRIBUTE_UNUSED
;
4025 if (pdata_section
== 0)
4027 pdata_section
= subseg_new (".pdata", 0);
4029 bfd_set_section_flags (stdoutput
, pdata_section
,
4030 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4031 | SEC_READONLY
| SEC_DATA
));
4033 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
4037 pdata_section
= subseg_new (".pdata", 0);
4039 ppc_set_current_section (pdata_section
);
4042 /* pseudo-op: .ydata
4043 behaviour: predefined read only data section
4047 initial: .section .ydata "drw3"
4048 a - don't know -- maybe a misprint
4049 d - initialized data
4051 3 - double word aligned (that would be 4 byte boundary)
4053 Tag tables (also known as the scope table) for exception handling,
4058 int ignore ATTRIBUTE_UNUSED
;
4060 if (ydata_section
== 0)
4062 ydata_section
= subseg_new (".ydata", 0);
4063 bfd_set_section_flags (stdoutput
, ydata_section
,
4064 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4065 | SEC_READONLY
| SEC_DATA
));
4067 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
4071 ydata_section
= subseg_new (".ydata", 0);
4073 ppc_set_current_section (ydata_section
);
4076 /* pseudo-op: .reldata
4077 behaviour: predefined read write data section
4078 double word aligned (4-byte)
4079 FIXME: relocation is applied to it
4080 FIXME: what's the difference between this and .data?
4083 initial: .section .reldata "drw3"
4084 d - initialized data
4087 3 - double word aligned (that would be 8 byte boundary)
4090 Like .data, but intended to hold data subject to relocation, such as
4091 function descriptors, etc. */
4094 ppc_reldata (ignore
)
4095 int ignore ATTRIBUTE_UNUSED
;
4097 if (reldata_section
== 0)
4099 reldata_section
= subseg_new (".reldata", 0);
4101 bfd_set_section_flags (stdoutput
, reldata_section
,
4102 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4105 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4109 reldata_section
= subseg_new (".reldata", 0);
4111 ppc_set_current_section (reldata_section
);
4114 /* pseudo-op: .rdata
4115 behaviour: predefined read only data section
4119 initial: .section .rdata "dr3"
4120 d - initialized data
4122 3 - double word aligned (that would be 4 byte boundary) */
4126 int ignore ATTRIBUTE_UNUSED
;
4128 if (rdata_section
== 0)
4130 rdata_section
= subseg_new (".rdata", 0);
4131 bfd_set_section_flags (stdoutput
, rdata_section
,
4132 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4133 | SEC_READONLY
| SEC_DATA
));
4135 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4139 rdata_section
= subseg_new (".rdata", 0);
4141 ppc_set_current_section (rdata_section
);
4144 /* pseudo-op: .ualong
4145 behaviour: much like .int, with the exception that no alignment is
4147 FIXME: test the alignment statement
4153 int ignore ATTRIBUTE_UNUSED
;
4159 /* pseudo-op: .znop <symbol name>
4160 behaviour: Issue a nop instruction
4161 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4162 the supplied symbol name.
4164 warnings: Missing symbol name */
4168 int ignore ATTRIBUTE_UNUSED
;
4171 const struct powerpc_opcode
*opcode
;
4182 /* Strip out the symbol name. */
4183 symbol_name
= input_line_pointer
;
4184 c
= get_symbol_end ();
4186 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4187 strcpy (name
, symbol_name
);
4189 sym
= symbol_find_or_make (name
);
4191 *input_line_pointer
= c
;
4195 /* Look up the opcode in the hash table. */
4196 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4198 /* Stick in the nop. */
4199 insn
= opcode
->opcode
;
4201 /* Write out the instruction. */
4203 md_number_to_chars (f
, insn
, 4);
4205 f
- frag_now
->fr_literal
,
4210 BFD_RELOC_16_GOT_PCREL
);
4223 register char *name
;
4227 register symbolS
*symbolP
;
4230 name
= input_line_pointer
;
4231 c
= get_symbol_end ();
4233 /* just after name is now '\0'. */
4234 p
= input_line_pointer
;
4237 if (*input_line_pointer
!= ',')
4239 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4240 ignore_rest_of_line ();
4244 input_line_pointer
++; /* skip ',' */
4245 if ((temp
= get_absolute_expression ()) < 0)
4247 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4248 ignore_rest_of_line ();
4254 /* The third argument to .comm is the alignment. */
4255 if (*input_line_pointer
!= ',')
4259 ++input_line_pointer
;
4260 align
= get_absolute_expression ();
4263 as_warn (_("ignoring bad alignment"));
4270 symbolP
= symbol_find_or_make (name
);
4273 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4275 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4276 S_GET_NAME (symbolP
));
4277 ignore_rest_of_line ();
4281 if (S_GET_VALUE (symbolP
))
4283 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4284 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4285 S_GET_NAME (symbolP
),
4286 (long) S_GET_VALUE (symbolP
),
4291 S_SET_VALUE (symbolP
, (valueT
) temp
);
4292 S_SET_EXTERNAL (symbolP
);
4295 demand_empty_rest_of_line ();
4299 * implement the .section pseudo op:
4300 * .section name {, "flags"}
4302 * | +--- optional flags: 'b' for bss
4304 * +-- section name 'l' for lib
4308 * 'd' (apparently m88k for data)
4310 * But if the argument is not a quoted string, treat it as a
4311 * subsegment number.
4313 * FIXME: this is a copy of the section processing from obj-coff.c, with
4314 * additions/changes for the moto-pas assembler support. There are three
4317 * FIXME: I just noticed this. This doesn't work at all really. It it
4318 * setting bits that bfd probably neither understands or uses. The
4319 * correct approach (?) will have to incorporate extra fields attached
4320 * to the section to hold the system specific stuff. (krk)
4323 * 'a' - unknown - referred to in documentation, but no definition supplied
4324 * 'c' - section has code
4325 * 'd' - section has initialized data
4326 * 'u' - section has uninitialized data
4327 * 'i' - section contains directives (info)
4328 * 'n' - section can be discarded
4329 * 'R' - remove section at link time
4331 * Section Protection:
4332 * 'r' - section is readable
4333 * 'w' - section is writeable
4334 * 'x' - section is executable
4335 * 's' - section is sharable
4337 * Section Alignment:
4338 * '0' - align to byte boundary
4339 * '1' - align to halfword undary
4340 * '2' - align to word boundary
4341 * '3' - align to doubleword boundary
4342 * '4' - align to quadword boundary
4343 * '5' - align to 32 byte boundary
4344 * '6' - align to 64 byte boundary
4349 ppc_pe_section (ignore
)
4350 int ignore ATTRIBUTE_UNUSED
;
4352 /* Strip out the section name. */
4361 section_name
= input_line_pointer
;
4362 c
= get_symbol_end ();
4364 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4365 strcpy (name
, section_name
);
4367 *input_line_pointer
= c
;
4372 flags
= SEC_NO_FLAGS
;
4374 if (strcmp (name
, ".idata$2") == 0)
4378 else if (strcmp (name
, ".idata$3") == 0)
4382 else if (strcmp (name
, ".idata$4") == 0)
4386 else if (strcmp (name
, ".idata$5") == 0)
4390 else if (strcmp (name
, ".idata$6") == 0)
4395 /* Default alignment to 16 byte boundary. */
4398 if (*input_line_pointer
== ',')
4400 ++input_line_pointer
;
4402 if (*input_line_pointer
!= '"')
4403 exp
= get_absolute_expression ();
4406 ++input_line_pointer
;
4407 while (*input_line_pointer
!= '"'
4408 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4410 switch (*input_line_pointer
)
4412 /* Section Contents */
4413 case 'a': /* unknown */
4414 as_bad (_("Unsupported section attribute -- 'a'"));
4416 case 'c': /* code section */
4419 case 'd': /* section has initialized data */
4422 case 'u': /* section has uninitialized data */
4423 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4427 case 'i': /* section contains directives (info) */
4428 /* FIXME: This is IMAGE_SCN_LNK_INFO
4430 flags
|= SEC_HAS_CONTENTS
;
4432 case 'n': /* section can be discarded */
4435 case 'R': /* Remove section at link time */
4436 flags
|= SEC_NEVER_LOAD
;
4439 /* Section Protection */
4440 case 'r': /* section is readable */
4441 flags
|= IMAGE_SCN_MEM_READ
;
4443 case 'w': /* section is writeable */
4444 flags
|= IMAGE_SCN_MEM_WRITE
;
4446 case 'x': /* section is executable */
4447 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4449 case 's': /* section is sharable */
4450 flags
|= IMAGE_SCN_MEM_SHARED
;
4453 /* Section Alignment */
4454 case '0': /* align to byte boundary */
4455 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4458 case '1': /* align to halfword boundary */
4459 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4462 case '2': /* align to word boundary */
4463 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4466 case '3': /* align to doubleword boundary */
4467 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4470 case '4': /* align to quadword boundary */
4471 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4474 case '5': /* align to 32 byte boundary */
4475 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4478 case '6': /* align to 64 byte boundary */
4479 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4484 as_bad (_("unknown section attribute '%c'"),
4485 *input_line_pointer
);
4488 ++input_line_pointer
;
4490 if (*input_line_pointer
== '"')
4491 ++input_line_pointer
;
4495 sec
= subseg_new (name
, (subsegT
) exp
);
4497 ppc_set_current_section (sec
);
4499 if (flags
!= SEC_NO_FLAGS
)
4501 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4502 as_bad (_("error setting flags for \"%s\": %s"),
4503 bfd_section_name (stdoutput
, sec
),
4504 bfd_errmsg (bfd_get_error ()));
4507 bfd_set_section_alignment (stdoutput
, sec
, align
);
4512 ppc_pe_function (ignore
)
4513 int ignore ATTRIBUTE_UNUSED
;
4519 name
= input_line_pointer
;
4520 endc
= get_symbol_end ();
4522 ext_sym
= symbol_find_or_make (name
);
4524 *input_line_pointer
= endc
;
4526 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4527 SF_SET_FUNCTION (ext_sym
);
4528 SF_SET_PROCESS (ext_sym
);
4529 coff_add_linesym (ext_sym
);
4531 demand_empty_rest_of_line ();
4535 ppc_pe_tocd (ignore
)
4536 int ignore ATTRIBUTE_UNUSED
;
4538 if (tocdata_section
== 0)
4540 tocdata_section
= subseg_new (".tocd", 0);
4541 /* FIXME: section flags won't work. */
4542 bfd_set_section_flags (stdoutput
, tocdata_section
,
4543 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4544 | SEC_READONLY
| SEC_DATA
));
4546 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4550 rdata_section
= subseg_new (".tocd", 0);
4553 ppc_set_current_section (tocdata_section
);
4555 demand_empty_rest_of_line ();
4558 /* Don't adjust TOC relocs to use the section symbol. */
4561 ppc_pe_fix_adjustable (fix
)
4564 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4571 /* XCOFF specific symbol and file handling. */
4573 /* Canonicalize the symbol name. We use the to force the suffix, if
4574 any, to use square brackets, and to be in upper case. */
4577 ppc_canonicalize_symbol_name (name
)
4582 if (ppc_stab_symbol
)
4585 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4599 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4602 if (*s
== '\0' || s
[1] != '\0')
4603 as_bad (_("bad symbol suffix"));
4611 /* Set the class of a symbol based on the suffix, if any. This is
4612 called whenever a new symbol is created. */
4615 ppc_symbol_new_hook (sym
)
4618 struct ppc_tc_sy
*tc
;
4621 tc
= symbol_get_tc (sym
);
4625 tc
->real_name
= NULL
;
4631 if (ppc_stab_symbol
)
4634 s
= strchr (S_GET_NAME (sym
), '[');
4635 if (s
== (const char *) NULL
)
4637 /* There is no suffix. */
4646 if (strcmp (s
, "BS]") == 0)
4650 if (strcmp (s
, "DB]") == 0)
4652 else if (strcmp (s
, "DS]") == 0)
4656 if (strcmp (s
, "GL]") == 0)
4660 if (strcmp (s
, "PR]") == 0)
4664 if (strcmp (s
, "RO]") == 0)
4666 else if (strcmp (s
, "RW]") == 0)
4670 if (strcmp (s
, "SV]") == 0)
4674 if (strcmp (s
, "TC]") == 0)
4676 else if (strcmp (s
, "TI]") == 0)
4678 else if (strcmp (s
, "TB]") == 0)
4680 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4681 tc
->class = XMC_TC0
;
4684 if (strcmp (s
, "UA]") == 0)
4686 else if (strcmp (s
, "UC]") == 0)
4690 if (strcmp (s
, "XO]") == 0)
4695 if (tc
->class == -1)
4696 as_bad (_("Unrecognized symbol suffix"));
4699 /* Set the class of a label based on where it is defined. This
4700 handles symbols without suffixes. Also, move the symbol so that it
4701 follows the csect symbol. */
4704 ppc_frob_label (sym
)
4707 if (ppc_current_csect
!= (symbolS
*) NULL
)
4709 if (symbol_get_tc (sym
)->class == -1)
4710 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4712 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4713 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4714 &symbol_rootP
, &symbol_lastP
);
4715 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4719 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4720 seen. It tells ppc_adjust_symtab whether it needs to look through
4723 static bfd_boolean ppc_saw_abs
;
4725 /* Change the name of a symbol just before writing it out. Set the
4726 real name if the .rename pseudo-op was used. Otherwise, remove any
4727 class suffix. Return 1 if the symbol should not be included in the
4731 ppc_frob_symbol (sym
)
4734 static symbolS
*ppc_last_function
;
4735 static symbolS
*set_end
;
4737 /* Discard symbols that should not be included in the output symbol
4739 if (! symbol_used_in_reloc_p (sym
)
4740 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4741 || (! S_IS_EXTERNAL (sym
)
4742 && ! symbol_get_tc (sym
)->output
4743 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4746 /* This one will disappear anyway. Don't make a csect sym for it. */
4747 if (sym
== abs_section_sym
)
4750 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4751 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4757 name
= S_GET_NAME (sym
);
4758 s
= strchr (name
, '[');
4759 if (s
!= (char *) NULL
)
4765 snew
= xmalloc (len
+ 1);
4766 memcpy (snew
, name
, len
);
4769 S_SET_NAME (sym
, snew
);
4773 if (set_end
!= (symbolS
*) NULL
)
4775 SA_SET_SYM_ENDNDX (set_end
, sym
);
4779 if (SF_GET_FUNCTION (sym
))
4781 if (ppc_last_function
!= (symbolS
*) NULL
)
4782 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4783 ppc_last_function
= sym
;
4784 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4786 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4787 SA_SET_SYM_FSIZE (sym
,
4788 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4791 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4792 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4794 if (ppc_last_function
== (symbolS
*) NULL
)
4795 as_bad (_(".ef with no preceding .function"));
4798 set_end
= ppc_last_function
;
4799 ppc_last_function
= NULL
;
4801 /* We don't have a C_EFCN symbol, but we need to force the
4802 COFF backend to believe that it has seen one. */
4803 coff_last_function
= NULL
;
4807 if (! S_IS_EXTERNAL (sym
)
4808 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4809 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4810 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4811 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4812 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4813 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4814 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4815 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4816 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4817 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4819 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4820 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4823 union internal_auxent
*a
;
4825 /* Create a csect aux. */
4826 i
= S_GET_NUMBER_AUXILIARY (sym
);
4827 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4828 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4829 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4831 /* This is the TOC table. */
4832 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4833 a
->x_csect
.x_scnlen
.l
= 0;
4834 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4836 else if (symbol_get_tc (sym
)->subseg
!= 0)
4838 /* This is a csect symbol. x_scnlen is the size of the
4840 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4841 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4842 S_GET_SEGMENT (sym
))
4843 - S_GET_VALUE (sym
));
4846 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4847 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4848 - S_GET_VALUE (sym
));
4850 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4852 else if (S_GET_SEGMENT (sym
) == bss_section
)
4854 /* This is a common symbol. */
4855 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4856 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4857 if (S_IS_EXTERNAL (sym
))
4858 symbol_get_tc (sym
)->class = XMC_RW
;
4860 symbol_get_tc (sym
)->class = XMC_BS
;
4862 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4864 /* This is an absolute symbol. The csect will be created by
4865 ppc_adjust_symtab. */
4867 a
->x_csect
.x_smtyp
= XTY_LD
;
4868 if (symbol_get_tc (sym
)->class == -1)
4869 symbol_get_tc (sym
)->class = XMC_XO
;
4871 else if (! S_IS_DEFINED (sym
))
4873 /* This is an external symbol. */
4874 a
->x_csect
.x_scnlen
.l
= 0;
4875 a
->x_csect
.x_smtyp
= XTY_ER
;
4877 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4881 /* This is a TOC definition. x_scnlen is the size of the
4883 next
= symbol_next (sym
);
4884 while (symbol_get_tc (next
)->class == XMC_TC0
)
4885 next
= symbol_next (next
);
4886 if (next
== (symbolS
*) NULL
4887 || symbol_get_tc (next
)->class != XMC_TC
)
4889 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4890 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4892 - S_GET_VALUE (sym
));
4894 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4895 - S_GET_VALUE (sym
));
4899 resolve_symbol_value (next
);
4900 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4901 - S_GET_VALUE (sym
));
4903 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4909 /* This is a normal symbol definition. x_scnlen is the
4910 symbol index of the containing csect. */
4911 if (S_GET_SEGMENT (sym
) == text_section
)
4912 csect
= ppc_text_csects
;
4913 else if (S_GET_SEGMENT (sym
) == data_section
)
4914 csect
= ppc_data_csects
;
4918 /* Skip the initial dummy symbol. */
4919 csect
= symbol_get_tc (csect
)->next
;
4921 if (csect
== (symbolS
*) NULL
)
4923 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4924 a
->x_csect
.x_scnlen
.l
= 0;
4928 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4930 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4931 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4932 > S_GET_VALUE (sym
))
4934 csect
= symbol_get_tc (csect
)->next
;
4937 a
->x_csect
.x_scnlen
.p
=
4938 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4939 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4942 a
->x_csect
.x_smtyp
= XTY_LD
;
4945 a
->x_csect
.x_parmhash
= 0;
4946 a
->x_csect
.x_snhash
= 0;
4947 if (symbol_get_tc (sym
)->class == -1)
4948 a
->x_csect
.x_smclas
= XMC_PR
;
4950 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4951 a
->x_csect
.x_stab
= 0;
4952 a
->x_csect
.x_snstab
= 0;
4954 /* Don't let the COFF backend resort these symbols. */
4955 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4957 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4959 /* We want the value to be the symbol index of the referenced
4960 csect symbol. BFD will do that for us if we set the right
4962 asymbol
*bsym
= symbol_get_bfdsym (symbol_get_tc (sym
)->within
);
4963 combined_entry_type
*c
= coffsymbol (bsym
)->native
;
4965 S_SET_VALUE (sym
, (valueT
) (size_t) c
);
4966 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4968 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4973 /* The value is the offset from the enclosing csect. */
4974 block
= symbol_get_tc (sym
)->within
;
4975 csect
= symbol_get_tc (block
)->within
;
4976 resolve_symbol_value (csect
);
4977 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4979 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4980 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4982 /* We want the value to be a file offset into the line numbers.
4983 BFD will do that for us if we set the right flags. We have
4984 already set the value correctly. */
4985 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4991 /* Adjust the symbol table. This creates csect symbols for all
4992 absolute symbols. */
4995 ppc_adjust_symtab ()
5002 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
5006 union internal_auxent
*a
;
5008 if (S_GET_SEGMENT (sym
) != absolute_section
)
5011 csect
= symbol_create (".abs[XO]", absolute_section
,
5012 S_GET_VALUE (sym
), &zero_address_frag
);
5013 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
5014 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
5015 i
= S_GET_NUMBER_AUXILIARY (csect
);
5016 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
5017 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
5018 a
->x_csect
.x_scnlen
.l
= 0;
5019 a
->x_csect
.x_smtyp
= XTY_SD
;
5020 a
->x_csect
.x_parmhash
= 0;
5021 a
->x_csect
.x_snhash
= 0;
5022 a
->x_csect
.x_smclas
= XMC_XO
;
5023 a
->x_csect
.x_stab
= 0;
5024 a
->x_csect
.x_snstab
= 0;
5026 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
5028 i
= S_GET_NUMBER_AUXILIARY (sym
);
5029 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
5030 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
5031 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
5034 ppc_saw_abs
= FALSE
;
5037 /* Set the VMA for a section. This is called on all the sections in
5041 ppc_frob_section (sec
)
5044 static bfd_size_type vma
= 0;
5046 bfd_set_section_vma (stdoutput
, sec
, vma
);
5047 vma
+= bfd_section_size (stdoutput
, sec
);
5050 #endif /* OBJ_XCOFF */
5052 /* Turn a string in input_line_pointer into a floating point constant
5053 of type TYPE, and store the appropriate bytes in *LITP. The number
5054 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5055 returned, or NULL on OK. */
5058 md_atof (type
, litp
, sizep
)
5064 LITTLENUM_TYPE words
[4];
5080 return _("bad call to md_atof");
5083 t
= atof_ieee (input_line_pointer
, type
, words
);
5085 input_line_pointer
= t
;
5089 if (target_big_endian
)
5091 for (i
= 0; i
< prec
; i
++)
5093 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5099 for (i
= prec
- 1; i
>= 0; i
--)
5101 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5109 /* Write a value out to the object file, using the appropriate
5113 md_number_to_chars (buf
, val
, n
)
5118 if (target_big_endian
)
5119 number_to_chars_bigendian (buf
, val
, n
);
5121 number_to_chars_littleendian (buf
, val
, n
);
5124 /* Align a section (I don't know why this is machine dependent). */
5127 md_section_align (seg
, addr
)
5131 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5133 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5136 /* We don't have any form of relaxing. */
5139 md_estimate_size_before_relax (fragp
, seg
)
5140 fragS
*fragp ATTRIBUTE_UNUSED
;
5141 asection
*seg ATTRIBUTE_UNUSED
;
5147 /* Convert a machine dependent frag. We never generate these. */
5150 md_convert_frag (abfd
, sec
, fragp
)
5151 bfd
*abfd ATTRIBUTE_UNUSED
;
5152 asection
*sec ATTRIBUTE_UNUSED
;
5153 fragS
*fragp ATTRIBUTE_UNUSED
;
5158 /* We have no need to default values of symbols. */
5161 md_undefined_symbol (name
)
5162 char *name ATTRIBUTE_UNUSED
;
5167 /* Functions concerning relocs. */
5169 /* The location from which a PC relative jump should be calculated,
5170 given a PC relative reloc. */
5173 md_pcrel_from_section (fixp
, sec
)
5175 segT sec ATTRIBUTE_UNUSED
;
5177 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5182 /* This is called to see whether a fixup should be adjusted to use a
5183 section symbol. We take the opportunity to change a fixup against
5184 a symbol in the TOC subsegment into a reloc against the
5185 corresponding .tc symbol. */
5188 ppc_fix_adjustable (fix
)
5191 valueT val
= resolve_symbol_value (fix
->fx_addsy
);
5192 segT symseg
= S_GET_SEGMENT (fix
->fx_addsy
);
5193 TC_SYMFIELD_TYPE
*tc
;
5195 if (symseg
== absolute_section
)
5198 if (ppc_toc_csect
!= (symbolS
*) NULL
5199 && fix
->fx_addsy
!= ppc_toc_csect
5200 && symseg
== data_section
5201 && val
>= ppc_toc_frag
->fr_address
5202 && (ppc_after_toc_frag
== (fragS
*) NULL
5203 || val
< ppc_after_toc_frag
->fr_address
))
5207 for (sy
= symbol_next (ppc_toc_csect
);
5208 sy
!= (symbolS
*) NULL
;
5209 sy
= symbol_next (sy
))
5211 TC_SYMFIELD_TYPE
*sy_tc
= symbol_get_tc (sy
);
5213 if (sy_tc
->class == XMC_TC0
)
5215 if (sy_tc
->class != XMC_TC
)
5217 if (val
== resolve_symbol_value (sy
))
5220 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5225 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5226 _("symbol in .toc does not match any .tc"));
5229 /* Possibly adjust the reloc to be against the csect. */
5230 tc
= symbol_get_tc (fix
->fx_addsy
);
5232 && tc
->class != XMC_TC0
5233 && tc
->class != XMC_TC
5234 && symseg
!= bss_section
5235 /* Don't adjust if this is a reloc in the toc section. */
5236 && (symseg
!= data_section
5237 || ppc_toc_csect
== NULL
5238 || val
< ppc_toc_frag
->fr_address
5239 || (ppc_after_toc_frag
!= NULL
5240 && val
>= ppc_after_toc_frag
->fr_address
)))
5243 symbolS
*next_csect
;
5245 if (symseg
== text_section
)
5246 csect
= ppc_text_csects
;
5247 else if (symseg
== data_section
)
5248 csect
= ppc_data_csects
;
5252 /* Skip the initial dummy symbol. */
5253 csect
= symbol_get_tc (csect
)->next
;
5255 if (csect
!= (symbolS
*) NULL
)
5257 while ((next_csect
= symbol_get_tc (csect
)->next
) != (symbolS
*) NULL
5258 && (symbol_get_frag (next_csect
)->fr_address
<= val
))
5260 /* If the csect address equals the symbol value, then we
5261 have to look through the full symbol table to see
5262 whether this is the csect we want. Note that we will
5263 only get here if the csect has zero length. */
5264 if (symbol_get_frag (csect
)->fr_address
== val
5265 && S_GET_VALUE (csect
) == val
)
5269 for (scan
= symbol_next (csect
);
5271 scan
= symbol_next (scan
))
5273 if (symbol_get_tc (scan
)->subseg
!= 0)
5275 if (scan
== fix
->fx_addsy
)
5279 /* If we found the symbol before the next csect
5280 symbol, then this is the csect we want. */
5281 if (scan
== fix
->fx_addsy
)
5288 fix
->fx_offset
+= val
- symbol_get_frag (csect
)->fr_address
;
5289 fix
->fx_addsy
= csect
;
5294 /* Adjust a reloc against a .lcomm symbol to be against the base
5296 if (symseg
== bss_section
5297 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5299 symbolS
*sy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5301 fix
->fx_offset
+= val
- resolve_symbol_value (sy
);
5308 /* A reloc from one csect to another must be kept. The assembler
5309 will, of course, keep relocs between sections, and it will keep
5310 absolute relocs, but we need to force it to keep PC relative relocs
5311 between two csects in the same section. */
5314 ppc_force_relocation (fix
)
5317 /* At this point fix->fx_addsy should already have been converted to
5318 a csect symbol. If the csect does not include the fragment, then
5319 we need to force the relocation. */
5321 && fix
->fx_addsy
!= NULL
5322 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5323 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5324 > fix
->fx_frag
->fr_address
)
5325 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5326 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5327 <= fix
->fx_frag
->fr_address
))))
5330 return generic_force_reloc (fix
);
5333 #endif /* OBJ_XCOFF */
5336 /* If this function returns non-zero, it guarantees that a relocation
5337 will be emitted for a fixup. */
5340 ppc_force_relocation (fix
)
5343 /* Branch prediction relocations must force a relocation, as must
5344 the vtable description relocs. */
5345 switch (fix
->fx_r_type
)
5347 case BFD_RELOC_PPC_B16_BRTAKEN
:
5348 case BFD_RELOC_PPC_B16_BRNTAKEN
:
5349 case BFD_RELOC_PPC_BA16_BRTAKEN
:
5350 case BFD_RELOC_PPC_BA16_BRNTAKEN
:
5351 case BFD_RELOC_PPC64_TOC
:
5357 if (fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5358 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5361 return generic_force_reloc (fix
);
5365 ppc_fix_adjustable (fix
)
5368 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5369 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5370 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5371 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5372 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5373 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5374 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5375 && !(fix
->fx_r_type
>= BFD_RELOC_PPC_TLS
5376 && fix
->fx_r_type
<= BFD_RELOC_PPC64_DTPREL16_HIGHESTA
)
5378 || (fix
->fx_subsy
!= NULL
5379 && (S_GET_SEGMENT (fix
->fx_subsy
)
5380 == S_GET_SEGMENT (fix
->fx_addsy
)))
5381 || S_IS_LOCAL (fix
->fx_addsy
)));
5385 /* Apply a fixup to the object code. This is called for all the
5386 fixups we generated by the call to fix_new_exp, above. In the call
5387 above we used a reloc code which was the largest legal reloc code
5388 plus the operand index. Here we undo that to recover the operand
5389 index. At this point all symbol values should be fully resolved,
5390 and we attempt to completely resolve the reloc. If we can not do
5391 that, we determine the correct reloc code and put it back in the
5395 md_apply_fix3 (fixP
, valP
, seg
)
5398 segT seg ATTRIBUTE_UNUSED
;
5400 valueT value
= * valP
;
5403 if (fixP
->fx_addsy
!= NULL
)
5405 /* Hack around bfd_install_relocation brain damage. */
5407 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5412 /* FIXME FIXME FIXME: The value we are passed in *valP includes
5413 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5414 doing this relocation the code in write.c is going to call
5415 bfd_install_relocation, which is also going to use the symbol
5416 value. That means that if the reloc is fully resolved we want to
5417 use *valP since bfd_install_relocation is not being used.
5418 However, if the reloc is not fully resolved we do not want to use
5419 *valP, and must use fx_offset instead. However, if the reloc
5420 is PC relative, we do want to use *valP since it includes the
5421 result of md_pcrel_from. This is confusing. */
5422 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5425 else if (fixP
->fx_pcrel
)
5429 value
= fixP
->fx_offset
;
5432 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5434 /* We can't actually support subtracting a symbol. */
5435 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
5438 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5441 const struct powerpc_operand
*operand
;
5445 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5447 operand
= &powerpc_operands
[opindex
];
5450 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5451 does not generate a reloc. It uses the offset of `sym' within its
5452 csect. Other usages, such as `.long sym', generate relocs. This
5453 is the documented behaviour of non-TOC symbols. */
5454 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5455 && operand
->bits
== 16
5456 && operand
->shift
== 0
5457 && (operand
->insert
== NULL
|| ppc_obj64
)
5458 && fixP
->fx_addsy
!= NULL
5459 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5460 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5461 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5462 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5464 value
= fixP
->fx_offset
;
5469 /* Fetch the instruction, insert the fully resolved operand
5470 value, and stuff the instruction back again. */
5471 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5472 if (target_big_endian
)
5473 insn
= bfd_getb32 ((unsigned char *) where
);
5475 insn
= bfd_getl32 ((unsigned char *) where
);
5476 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5477 fixP
->fx_file
, fixP
->fx_line
);
5478 if (target_big_endian
)
5479 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5481 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5484 /* Nothing else to do here. */
5487 assert (fixP
->fx_addsy
!= NULL
);
5489 /* Determine a BFD reloc value based on the operand information.
5490 We are only prepared to turn a few of the operands into
5492 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5493 && operand
->bits
== 26
5494 && operand
->shift
== 0)
5495 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5496 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5497 && operand
->bits
== 16
5498 && operand
->shift
== 0)
5500 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5503 if (target_big_endian
)
5504 fixP
->fx_where
+= 2;
5507 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5508 && operand
->bits
== 26
5509 && operand
->shift
== 0)
5510 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5511 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5512 && operand
->bits
== 16
5513 && operand
->shift
== 0)
5515 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5518 if (target_big_endian
)
5519 fixP
->fx_where
+= 2;
5522 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5523 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5524 && operand
->bits
== 16
5525 && operand
->shift
== 0
5526 && ppc_is_toc_sym (fixP
->fx_addsy
))
5528 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5531 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5532 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5535 if (target_big_endian
)
5536 fixP
->fx_where
+= 2;
5538 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5544 /* Use expr_symbol_where to see if this is an expression
5546 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5547 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5548 _("unresolved expression that must be resolved"));
5550 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5551 _("unsupported relocation against %s"),
5552 S_GET_NAME (fixP
->fx_addsy
));
5560 ppc_elf_validate_fix (fixP
, seg
);
5562 switch (fixP
->fx_r_type
)
5564 case BFD_RELOC_CTOR
:
5571 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5575 case BFD_RELOC_32_PCREL
:
5576 case BFD_RELOC_PPC_EMB_NADDR32
:
5577 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5584 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5587 case BFD_RELOC_64_PCREL
:
5588 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5592 case BFD_RELOC_LO16
:
5594 case BFD_RELOC_GPREL16
:
5595 case BFD_RELOC_16_GOT_PCREL
:
5596 case BFD_RELOC_16_GOTOFF
:
5597 case BFD_RELOC_LO16_GOTOFF
:
5598 case BFD_RELOC_HI16_GOTOFF
:
5599 case BFD_RELOC_HI16_S_GOTOFF
:
5600 case BFD_RELOC_16_BASEREL
:
5601 case BFD_RELOC_LO16_BASEREL
:
5602 case BFD_RELOC_HI16_BASEREL
:
5603 case BFD_RELOC_HI16_S_BASEREL
:
5604 case BFD_RELOC_PPC_EMB_NADDR16
:
5605 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5606 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5607 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5608 case BFD_RELOC_PPC_EMB_SDAI16
:
5609 case BFD_RELOC_PPC_EMB_SDA2REL
:
5610 case BFD_RELOC_PPC_EMB_SDA2I16
:
5611 case BFD_RELOC_PPC_EMB_RELSEC16
:
5612 case BFD_RELOC_PPC_EMB_RELST_LO
:
5613 case BFD_RELOC_PPC_EMB_RELST_HI
:
5614 case BFD_RELOC_PPC_EMB_RELST_HA
:
5615 case BFD_RELOC_PPC_EMB_RELSDA
:
5616 case BFD_RELOC_PPC_TOC16
:
5618 case BFD_RELOC_PPC64_TOC16_LO
:
5619 case BFD_RELOC_PPC64_TOC16_HI
:
5620 case BFD_RELOC_PPC64_TOC16_HA
:
5624 if (fixP
->fx_addsy
!= NULL
)
5625 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5626 _("cannot emit PC relative %s relocation against %s"),
5627 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5628 S_GET_NAME (fixP
->fx_addsy
));
5630 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5631 _("cannot emit PC relative %s relocation"),
5632 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5635 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5639 /* This case happens when you write, for example,
5641 where L1 and L2 are defined later. */
5642 case BFD_RELOC_HI16
:
5645 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5649 case BFD_RELOC_HI16_S
:
5652 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5657 case BFD_RELOC_PPC64_HIGHER
:
5660 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5661 PPC_HIGHER (value
), 2);
5664 case BFD_RELOC_PPC64_HIGHER_S
:
5667 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5668 PPC_HIGHERA (value
), 2);
5671 case BFD_RELOC_PPC64_HIGHEST
:
5674 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5675 PPC_HIGHEST (value
), 2);
5678 case BFD_RELOC_PPC64_HIGHEST_S
:
5681 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5682 PPC_HIGHESTA (value
), 2);
5685 case BFD_RELOC_PPC64_ADDR16_DS
:
5686 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5687 case BFD_RELOC_PPC64_GOT16_DS
:
5688 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5689 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5690 case BFD_RELOC_PPC64_SECTOFF_DS
:
5691 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5692 case BFD_RELOC_PPC64_TOC16_DS
:
5693 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5694 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5695 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5699 unsigned char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5702 if (target_big_endian
)
5703 val
= bfd_getb16 (where
);
5705 val
= bfd_getl16 (where
);
5706 val
|= (value
& 0xfffc);
5707 if (target_big_endian
)
5708 bfd_putb16 ((bfd_vma
) val
, where
);
5710 bfd_putl16 ((bfd_vma
) val
, where
);
5714 case BFD_RELOC_PPC_TLS
:
5715 case BFD_RELOC_PPC_DTPMOD
:
5716 case BFD_RELOC_PPC_TPREL16
:
5717 case BFD_RELOC_PPC_TPREL16_LO
:
5718 case BFD_RELOC_PPC_TPREL16_HI
:
5719 case BFD_RELOC_PPC_TPREL16_HA
:
5720 case BFD_RELOC_PPC_TPREL
:
5721 case BFD_RELOC_PPC_DTPREL16
:
5722 case BFD_RELOC_PPC_DTPREL16_LO
:
5723 case BFD_RELOC_PPC_DTPREL16_HI
:
5724 case BFD_RELOC_PPC_DTPREL16_HA
:
5725 case BFD_RELOC_PPC_DTPREL
:
5726 case BFD_RELOC_PPC_GOT_TLSGD16
:
5727 case BFD_RELOC_PPC_GOT_TLSGD16_LO
:
5728 case BFD_RELOC_PPC_GOT_TLSGD16_HI
:
5729 case BFD_RELOC_PPC_GOT_TLSGD16_HA
:
5730 case BFD_RELOC_PPC_GOT_TLSLD16
:
5731 case BFD_RELOC_PPC_GOT_TLSLD16_LO
:
5732 case BFD_RELOC_PPC_GOT_TLSLD16_HI
:
5733 case BFD_RELOC_PPC_GOT_TLSLD16_HA
:
5734 case BFD_RELOC_PPC_GOT_TPREL16
:
5735 case BFD_RELOC_PPC_GOT_TPREL16_LO
:
5736 case BFD_RELOC_PPC_GOT_TPREL16_HI
:
5737 case BFD_RELOC_PPC_GOT_TPREL16_HA
:
5738 case BFD_RELOC_PPC_GOT_DTPREL16
:
5739 case BFD_RELOC_PPC_GOT_DTPREL16_LO
:
5740 case BFD_RELOC_PPC_GOT_DTPREL16_HI
:
5741 case BFD_RELOC_PPC_GOT_DTPREL16_HA
:
5742 case BFD_RELOC_PPC64_TPREL16_DS
:
5743 case BFD_RELOC_PPC64_TPREL16_LO_DS
:
5744 case BFD_RELOC_PPC64_TPREL16_HIGHER
:
5745 case BFD_RELOC_PPC64_TPREL16_HIGHERA
:
5746 case BFD_RELOC_PPC64_TPREL16_HIGHEST
:
5747 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
:
5748 case BFD_RELOC_PPC64_DTPREL16_DS
:
5749 case BFD_RELOC_PPC64_DTPREL16_LO_DS
:
5750 case BFD_RELOC_PPC64_DTPREL16_HIGHER
:
5751 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
:
5752 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
:
5753 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
:
5756 /* Because SDA21 modifies the register field, the size is set to 4
5757 bytes, rather than 2, so offset it here appropriately. */
5758 case BFD_RELOC_PPC_EMB_SDA21
:
5762 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5763 + ((target_big_endian
) ? 2 : 0),
5771 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5775 case BFD_RELOC_24_PLT_PCREL
:
5776 case BFD_RELOC_PPC_LOCAL24PC
:
5777 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5785 /* Fetch the instruction, insert the fully resolved operand
5786 value, and stuff the instruction back again. */
5787 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5788 if (target_big_endian
)
5789 insn
= bfd_getb32 ((unsigned char *) where
);
5791 insn
= bfd_getl32 ((unsigned char *) where
);
5792 if ((value
& 3) != 0)
5793 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5794 _("must branch to an address a multiple of 4"));
5795 if ((offsetT
) value
< -0x40000000
5796 || (offsetT
) value
>= 0x40000000)
5797 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5798 _("@local or @plt branch destination is too far away, %ld bytes"),
5800 insn
= insn
| (value
& 0x03fffffc);
5801 if (target_big_endian
)
5802 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5804 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5808 case BFD_RELOC_VTABLE_INHERIT
:
5811 && !S_IS_DEFINED (fixP
->fx_addsy
)
5812 && !S_IS_WEAK (fixP
->fx_addsy
))
5813 S_SET_WEAK (fixP
->fx_addsy
);
5816 case BFD_RELOC_VTABLE_ENTRY
:
5821 /* Generated by reference to `sym@tocbase'. The sym is
5822 ignored by the linker. */
5823 case BFD_RELOC_PPC64_TOC
:
5829 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
5836 fixP
->fx_addnumber
= value
;
5838 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5839 fixP
->fx_addnumber
= 0;
5843 fixP
->fx_addnumber
= 0;
5845 /* We want to use the offset within the data segment of the
5846 symbol, not the actual VMA of the symbol. */
5847 fixP
->fx_addnumber
=
5848 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
5854 /* Generate a reloc for a fixup. */
5857 tc_gen_reloc (seg
, fixp
)
5858 asection
*seg ATTRIBUTE_UNUSED
;
5863 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5865 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5866 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5867 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5868 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5869 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5871 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5872 _("reloc %d not supported by object file format"),
5873 (int) fixp
->fx_r_type
);
5876 reloc
->addend
= fixp
->fx_addnumber
;