1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
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) >> 32) & 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) >> 48) & 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 boolean reg_names_p
= TARGET_REG_NAMES_P
;
88 static 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 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 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)
871 else if (strcmp (arg
, "32") == 0)
878 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
880 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
881 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
| PPC_OPCODE_32
;
882 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
883 else if (strcmp (arg
, "pwr") == 0)
884 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
885 /* -m601 means to assemble for the PowerPC 601, which includes
886 instructions that are holdovers from the Power. */
887 else if (strcmp (arg
, "601") == 0)
888 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
889 | PPC_OPCODE_601
| PPC_OPCODE_32
;
890 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
892 else if (strcmp (arg
, "ppc") == 0
893 || strcmp (arg
, "ppc32") == 0
894 || strcmp (arg
, "603") == 0
895 || strcmp (arg
, "604") == 0)
896 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
897 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
898 else if (strcmp (arg
, "403") == 0
899 || strcmp (arg
, "405") == 0)
900 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
901 | PPC_OPCODE_403
| PPC_OPCODE_32
;
902 else if (strcmp (arg
, "7400") == 0
903 || strcmp (arg
, "7410") == 0
904 || strcmp (arg
, "7450") == 0
905 || strcmp (arg
, "7455") == 0)
906 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
907 | PPC_OPCODE_ALTIVEC
| PPC_OPCODE_32
;
908 else if (strcmp (arg
, "altivec") == 0)
911 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_ALTIVEC
;
913 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
915 else if (strcmp (arg
, "e500") == 0 || strcmp (arg
, "e500x2") == 0)
917 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_SPE
918 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
| PPC_OPCODE_BRLOCK
919 | PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
| PPC_OPCODE_RFMCI
;
921 else if (strcmp (arg
, "spe") == 0)
924 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_SPE
| PPC_OPCODE_EFS
;
926 ppc_cpu
|= PPC_OPCODE_SPE
;
928 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
930 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
932 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
934 else if (strcmp (arg
, "ppc64bridge") == 0)
936 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
937 | PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
;
939 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
940 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
942 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
;
944 /* -mbooke64 means enable 64-bit BookE support. */
945 else if (strcmp (arg
, "booke64") == 0)
947 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
|
948 PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
;
950 else if (strcmp (arg
, "power4") == 0)
952 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
953 | PPC_OPCODE_64
| PPC_OPCODE_POWER4
;
955 /* -mcom means assemble for the common intersection between Power
956 and PowerPC. At present, we just allow the union, rather
957 than the intersection. */
958 else if (strcmp (arg
, "com") == 0)
959 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
960 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
961 else if (strcmp (arg
, "any") == 0)
962 ppc_cpu
= PPC_OPCODE_ANY
| PPC_OPCODE_32
;
964 else if (strcmp (arg
, "regnames") == 0)
967 else if (strcmp (arg
, "no-regnames") == 0)
971 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
972 that require relocation. */
973 else if (strcmp (arg
, "relocatable") == 0)
975 shlib
= SHLIB_MRELOCATABLE
;
976 ppc_flags
|= EF_PPC_RELOCATABLE
;
979 else if (strcmp (arg
, "relocatable-lib") == 0)
981 shlib
= SHLIB_MRELOCATABLE
;
982 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
985 /* -memb, set embedded bit. */
986 else if (strcmp (arg
, "emb") == 0)
987 ppc_flags
|= EF_PPC_EMB
;
989 /* -mlittle/-mbig set the endianess. */
990 else if (strcmp (arg
, "little") == 0
991 || strcmp (arg
, "little-endian") == 0)
993 target_big_endian
= 0;
994 set_target_endian
= 1;
997 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
999 target_big_endian
= 1;
1000 set_target_endian
= 1;
1003 else if (strcmp (arg
, "solaris") == 0)
1006 ppc_comment_chars
= ppc_solaris_comment_chars
;
1009 else if (strcmp (arg
, "no-solaris") == 0)
1012 ppc_comment_chars
= ppc_eabi_comment_chars
;
1017 as_bad (_("invalid switch -m%s"), arg
);
1023 /* -V: SVR4 argument to print version ID. */
1025 print_version_id ();
1028 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1029 should be emitted or not. FIXME: Not implemented. */
1033 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1034 rather than .stabs.excl, which is ignored by the linker.
1035 FIXME: Not implemented. */
1051 md_show_usage (stream
)
1054 fprintf (stream
, _("\
1057 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1058 -mpwr generate code for POWER (RIOS1)\n\
1059 -m601 generate code for PowerPC 601\n\
1060 -mppc, -mppc32, -m603, -m604\n\
1061 generate code for PowerPC 603/604\n\
1062 -m403, -m405 generate code for PowerPC 403/405\n\
1063 -m7400, -m7410, -m7450, -m7455\n\
1064 generate code For PowerPC 7400/7410/7450/7455\n\
1065 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1066 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1067 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1068 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1069 -mpower4 generate code for Power4 architecture\n\
1070 -maltivec generate code for AltiVec\n\
1071 -mcom generate code Power/PowerPC common instructions\n\
1072 -many generate code for any architecture (PWR/PWRX/PPC)\n\
1073 -mregnames Allow symbolic names for registers\n\
1074 -mno-regnames Do not allow symbolic names for registers\n"));
1075 fprintf (stream
, _("\
1076 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1077 -mspe generate code for Motorola SPE instructions\n"));
1079 fprintf (stream
, _("\
1080 -mrelocatable support for GCC's -mrelocatble option\n\
1081 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1082 -memb set PPC_EMB bit in ELF flags\n\
1083 -mlittle, -mlittle-endian\n\
1084 generate code for a little endian machine\n\
1085 -mbig, -mbig-endian generate code for a big endian machine\n\
1086 -msolaris generate code for Solaris\n\
1087 -mno-solaris do not generate code for Solaris\n\
1088 -V print assembler version number\n\
1089 -Qy, -Qn ignored\n"));
1093 /* Set ppc_cpu if it is not already set. */
1098 const char *default_os
= TARGET_OS
;
1099 const char *default_cpu
= TARGET_CPU
;
1103 if (strncmp (default_os
, "aix", 3) == 0
1104 && default_os
[3] >= '4' && default_os
[3] <= '9')
1105 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1106 else if (strncmp (default_os
, "aix3", 4) == 0)
1107 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1108 else if (strcmp (default_cpu
, "rs6000") == 0)
1109 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1110 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1112 if (default_cpu
[7] == '6' && default_cpu
[8] == '4')
1113 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_64
;
1115 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_CLASSIC
| PPC_OPCODE_32
;
1118 as_fatal (_("Unknown default cpu = %s, os = %s"),
1119 default_cpu
, default_os
);
1123 /* Figure out the BFD architecture to use. */
1125 enum bfd_architecture
1128 const char *default_cpu
= TARGET_CPU
;
1131 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1132 return bfd_arch_powerpc
;
1133 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1134 return bfd_arch_rs6000
;
1135 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1137 if (strcmp (default_cpu
, "rs6000") == 0)
1138 return bfd_arch_rs6000
;
1139 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1140 return bfd_arch_powerpc
;
1143 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1144 return bfd_arch_unknown
;
1150 return ppc_obj64
? bfd_mach_ppc64
: bfd_mach_ppc
;
1154 ppc_target_format ()
1158 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1160 return "xcoff-powermac";
1163 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1165 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1170 return (target_big_endian
1171 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1172 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1176 /* This function is called when the assembler starts up. It is called
1177 after the options have been parsed and the output file has been
1183 register const struct powerpc_opcode
*op
;
1184 const struct powerpc_opcode
*op_end
;
1185 const struct powerpc_macro
*macro
;
1186 const struct powerpc_macro
*macro_end
;
1187 boolean dup_insn
= false;
1192 /* Set the ELF flags if desired. */
1193 if (ppc_flags
&& !msolaris
)
1194 bfd_set_private_flags (stdoutput
, ppc_flags
);
1197 /* Insert the opcodes into a hash table. */
1198 ppc_hash
= hash_new ();
1200 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1201 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1203 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1205 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1206 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1207 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1208 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1209 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1210 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1211 || ((op
->flags
& PPC_OPCODE_POWER4
)
1212 == (ppc_cpu
& PPC_OPCODE_POWER4
))))
1216 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1217 if (retval
!= (const char *) NULL
)
1219 /* Ignore Power duplicates for -m601. */
1220 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1221 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1224 as_bad (_("Internal assembler error for instruction %s"),
1231 /* Insert the macros into a hash table. */
1232 ppc_macro_hash
= hash_new ();
1234 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1235 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1237 if ((macro
->flags
& ppc_cpu
) != 0)
1241 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1242 if (retval
!= (const char *) NULL
)
1244 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1253 /* Tell the main code what the endianness is if it is not overidden
1255 if (!set_target_endian
)
1257 set_target_endian
= 1;
1258 target_big_endian
= PPC_BIG_ENDIAN
;
1262 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1264 /* Create dummy symbols to serve as initial csects. This forces the
1265 text csects to precede the data csects. These symbols will not
1267 ppc_text_csects
= symbol_make ("dummy\001");
1268 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1269 ppc_data_csects
= symbol_make ("dummy\001");
1270 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1275 ppc_current_section
= text_section
;
1276 ppc_previous_section
= 0;
1285 if (ppc_apuinfo_list
== NULL
)
1288 /* Ok, so write the section info out. We have this layout:
1292 0 8 length of "APUinfo\0"
1293 4 (n*4) number of APU's (4 bytes each)
1296 20 APU#1 first APU's info
1297 24 APU#2 second APU's info
1302 asection
*seg
= now_seg
;
1303 subsegT subseg
= now_subseg
;
1304 asection
*apuinfo_secp
= (asection
*) NULL
;
1307 /* Create the .PPC.EMB.apuinfo section. */
1308 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1309 bfd_set_section_flags (stdoutput
,
1311 SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_MERGE
);
1314 md_number_to_chars (p
, (valueT
) 8, 4);
1317 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
, 4);
1320 md_number_to_chars (p
, (valueT
) 2, 4);
1323 strcpy (p
, "APUinfo");
1325 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1328 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1331 frag_align (2, 0, 0);
1333 /* We probably can't restore the current segment, for there likely
1336 subseg_set (seg
, subseg
);
1341 /* Insert an operand value into an instruction. */
1343 static unsigned long
1344 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1346 const struct powerpc_operand
*operand
;
1351 if (operand
->bits
!= 32)
1356 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1358 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1359 max
= (1 << operand
->bits
) - 1;
1361 max
= (1 << (operand
->bits
- 1)) - 1;
1362 min
= - (1 << (operand
->bits
- 1));
1366 /* Some people write 32 bit hex constants with the sign
1367 extension done by hand. This shouldn't really be
1368 valid, but, to permit this code to assemble on a 64
1369 bit host, we sign extend the 32 bit value. */
1371 && (val
& (offsetT
) 0x80000000) != 0
1372 && (val
& (offsetT
) 0xffffffff) == val
)
1381 max
= (1 << operand
->bits
) - 1;
1385 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1390 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1393 _("operand out of range (%s not between %ld and %ld)");
1396 sprint_value (buf
, test
);
1397 as_bad_where (file
, line
, err
, buf
, min
, max
);
1401 if (operand
->insert
)
1406 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1407 if (errmsg
!= (const char *) NULL
)
1408 as_bad_where (file
, line
, errmsg
);
1411 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1419 /* Parse @got, etc. and return the desired relocation. */
1420 static bfd_reloc_code_real_type
1421 ppc_elf_suffix (str_p
, exp_p
)
1436 const struct map_bfd
*ptr
;
1438 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1440 static const struct map_bfd mapping
[] = {
1441 MAP ("l", (int) BFD_RELOC_LO16
),
1442 MAP ("h", (int) BFD_RELOC_HI16
),
1443 MAP ("ha", (int) BFD_RELOC_HI16_S
),
1444 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN
),
1445 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN
),
1446 MAP ("got", (int) BFD_RELOC_16_GOTOFF
),
1447 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF
),
1448 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF
),
1449 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF
),
1450 MAP ("fixup", (int) BFD_RELOC_CTOR
), /* warning with -mrelocatable */
1451 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL
),
1452 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL
),
1453 MAP ("copy", (int) BFD_RELOC_PPC_COPY
),
1454 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT
),
1455 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC
),
1456 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC
),
1457 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL
),
1458 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF
),
1459 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF
),
1460 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF
),
1461 MAP ("sdarel", (int) BFD_RELOC_GPREL16
),
1462 MAP ("sectoff", (int) BFD_RELOC_16_BASEREL
),
1463 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL
),
1464 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL
),
1465 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL
),
1466 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32
),
1467 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16
),
1468 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO
),
1469 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI
),
1470 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA
),
1471 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16
),
1472 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL
),
1473 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16
),
1474 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21
),
1475 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF
),
1476 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16
),
1477 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO
),
1478 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI
),
1479 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA
),
1480 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD
),
1481 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA
),
1482 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16
),
1483 /* The following are only valid for ppc64. Negative values are
1484 used instead of a flag. */
1485 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER
),
1486 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S
),
1487 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST
),
1488 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S
),
1489 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC
),
1490 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16
),
1491 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO
),
1492 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI
),
1493 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA
),
1494 { (char *) 0, 0, (int) BFD_RELOC_UNUSED
}
1498 return BFD_RELOC_UNUSED
;
1500 for (ch
= *str
, str2
= ident
;
1501 (str2
< ident
+ sizeof (ident
) - 1
1502 && (ISALNUM (ch
) || ch
== '@'));
1505 *str2
++ = TOLOWER (ch
);
1512 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1513 if (ch
== ptr
->string
[0]
1514 && len
== ptr
->length
1515 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1517 int reloc
= ptr
->reloc
;
1522 return BFD_RELOC_UNUSED
;
1526 if (exp_p
->X_add_number
!= 0
1527 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1528 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1529 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1530 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1531 as_warn (_("identifier+constant@got means identifier@got+constant"));
1533 /* Now check for identifier@suffix+constant. */
1534 if (*str
== '-' || *str
== '+')
1536 char *orig_line
= input_line_pointer
;
1537 expressionS new_exp
;
1539 input_line_pointer
= str
;
1540 expression (&new_exp
);
1541 if (new_exp
.X_op
== O_constant
)
1543 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1544 str
= input_line_pointer
;
1547 if (&input_line_pointer
!= str_p
)
1548 input_line_pointer
= orig_line
;
1552 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1553 && exp_p
->X_op
== O_symbol
)
1555 /* This reloc type ignores the symbol. Change the symbol
1556 so that the dummy .TOC. symbol can be omitted from the
1558 exp_p
->X_add_symbol
= &abs_symbol
;
1561 return (bfd_reloc_code_real_type
) reloc
;
1564 return BFD_RELOC_UNUSED
;
1567 /* Like normal .long/.short/.word, except support @got, etc.
1568 Clobbers input_line_pointer, checks end-of-line. */
1570 ppc_elf_cons (nbytes
)
1571 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1574 bfd_reloc_code_real_type reloc
;
1576 if (is_it_end_of_statement ())
1578 demand_empty_rest_of_line ();
1585 if (exp
.X_op
== O_symbol
1586 && *input_line_pointer
== '@'
1587 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1588 &exp
)) != BFD_RELOC_UNUSED
)
1590 reloc_howto_type
*reloc_howto
;
1593 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1594 size
= bfd_get_reloc_size (reloc_howto
);
1598 as_bad (_("%s relocations do not fit in %d bytes\n"),
1599 reloc_howto
->name
, nbytes
);
1606 p
= frag_more (nbytes
);
1608 if (target_big_endian
)
1609 offset
= nbytes
- size
;
1610 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1615 emit_expr (&exp
, (unsigned int) nbytes
);
1617 while (*input_line_pointer
++ == ',');
1619 /* Put terminator back into stream. */
1620 input_line_pointer
--;
1621 demand_empty_rest_of_line ();
1624 /* Solaris pseduo op to change to the .rodata section. */
1629 char *save_line
= input_line_pointer
;
1630 static char section
[] = ".rodata\n";
1632 /* Just pretend this is .section .rodata */
1633 input_line_pointer
= section
;
1634 obj_elf_section (xxx
);
1636 input_line_pointer
= save_line
;
1639 /* Pseudo op to make file scope bss items. */
1642 int xxx ATTRIBUTE_UNUSED
;
1644 register char *name
;
1648 register symbolS
*symbolP
;
1655 name
= input_line_pointer
;
1656 c
= get_symbol_end ();
1658 /* just after name is now '\0'. */
1659 p
= input_line_pointer
;
1662 if (*input_line_pointer
!= ',')
1664 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1665 ignore_rest_of_line ();
1669 input_line_pointer
++; /* skip ',' */
1670 if ((size
= get_absolute_expression ()) < 0)
1672 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1673 ignore_rest_of_line ();
1677 /* The third argument to .lcomm is the alignment. */
1678 if (*input_line_pointer
!= ',')
1682 ++input_line_pointer
;
1683 align
= get_absolute_expression ();
1686 as_warn (_("ignoring bad alignment"));
1692 symbolP
= symbol_find_or_make (name
);
1695 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1697 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1698 S_GET_NAME (symbolP
));
1699 ignore_rest_of_line ();
1703 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1705 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1706 S_GET_NAME (symbolP
),
1707 (long) S_GET_VALUE (symbolP
),
1710 ignore_rest_of_line ();
1716 old_subsec
= now_subseg
;
1719 /* Convert to a power of 2 alignment. */
1720 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1723 as_bad (_("Common alignment not a power of 2"));
1724 ignore_rest_of_line ();
1731 record_alignment (bss_section
, align2
);
1732 subseg_set (bss_section
, 0);
1734 frag_align (align2
, 0, 0);
1735 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1736 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1737 symbol_set_frag (symbolP
, frag_now
);
1738 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1741 S_SET_SIZE (symbolP
, size
);
1742 S_SET_SEGMENT (symbolP
, bss_section
);
1743 subseg_set (old_sec
, old_subsec
);
1744 demand_empty_rest_of_line ();
1747 /* Validate any relocations emitted for -mrelocatable, possibly adding
1748 fixups for word relocations in writable segments, so we can adjust
1751 ppc_elf_validate_fix (fixp
, seg
)
1755 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1764 case SHLIB_MRELOCATABLE
:
1765 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1766 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1767 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1768 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1769 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1770 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1771 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1772 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1773 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1774 && (seg
->flags
& SEC_LOAD
) != 0
1775 && strcmp (segment_name (seg
), ".got2") != 0
1776 && strcmp (segment_name (seg
), ".dtors") != 0
1777 && strcmp (segment_name (seg
), ".ctors") != 0
1778 && strcmp (segment_name (seg
), ".fixup") != 0
1779 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1780 && strcmp (segment_name (seg
), ".eh_frame") != 0
1781 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1783 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1784 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1786 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1787 _("Relocation cannot be done when using -mrelocatable"));
1794 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1795 function descriptor sym if the corresponding code sym is used. */
1798 ppc_frob_file_before_adjust ()
1805 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1812 name
= S_GET_NAME (symp
);
1816 if (! S_IS_WEAK (symp
)
1817 || S_IS_DEFINED (symp
))
1820 len
= strlen (name
) + 1;
1821 dotname
= xmalloc (len
+ 1);
1823 memcpy (dotname
+ 1, name
, len
);
1824 dotsym
= symbol_find (dotname
);
1826 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1827 || symbol_used_in_reloc_p (dotsym
)))
1829 symbol_mark_used (symp
);
1833 /* Don't emit .TOC. symbol. */
1834 symp
= symbol_find (".TOC.");
1836 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1838 #endif /* OBJ_ELF */
1843 * Summary of parse_toc_entry.
1845 * in: Input_line_pointer points to the '[' in one of:
1847 * [toc] [tocv] [toc32] [toc64]
1849 * Anything else is an error of one kind or another.
1852 * return value: success or failure
1853 * toc_kind: kind of toc reference
1854 * input_line_pointer:
1855 * success: first char after the ']'
1856 * failure: unchanged
1860 * [toc] - rv == success, toc_kind = default_toc
1861 * [tocv] - rv == success, toc_kind = data_in_toc
1862 * [toc32] - rv == success, toc_kind = must_be_32
1863 * [toc64] - rv == success, toc_kind = must_be_64
1867 enum toc_size_qualifier
1869 default_toc
, /* The toc cell constructed should be the system default size */
1870 data_in_toc
, /* This is a direct reference to a toc cell */
1871 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1872 must_be_64
/* The toc cell constructed must be 64 bits wide */
1876 parse_toc_entry (toc_kind
)
1877 enum toc_size_qualifier
*toc_kind
;
1882 enum toc_size_qualifier t
;
1884 /* Save the input_line_pointer. */
1885 start
= input_line_pointer
;
1887 /* Skip over the '[' , and whitespace. */
1888 ++input_line_pointer
;
1891 /* Find the spelling of the operand. */
1892 toc_spec
= input_line_pointer
;
1893 c
= get_symbol_end ();
1895 if (strcmp (toc_spec
, "toc") == 0)
1899 else if (strcmp (toc_spec
, "tocv") == 0)
1903 else if (strcmp (toc_spec
, "toc32") == 0)
1907 else if (strcmp (toc_spec
, "toc64") == 0)
1913 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1914 *input_line_pointer
= c
;
1915 input_line_pointer
= start
;
1919 /* Now find the ']'. */
1920 *input_line_pointer
= c
;
1922 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1923 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1927 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1928 input_line_pointer
= start
;
1939 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
1941 ppc_apuinfo_section_add (apu
, version
)
1942 unsigned int apu
, version
;
1946 /* Check we don't already exist. */
1947 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1948 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
1951 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
1953 if (ppc_apuinfo_num_alloc
== 0)
1955 ppc_apuinfo_num_alloc
= 4;
1956 ppc_apuinfo_list
= (unsigned long *)
1957 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
1961 ppc_apuinfo_num_alloc
+= 4;
1962 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
1963 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
1966 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
1972 /* We need to keep a list of fixups. We can't simply generate them as
1973 we go, because that would require us to first create the frag, and
1974 that would screw up references to ``.''. */
1980 bfd_reloc_code_real_type reloc
;
1983 #define MAX_INSN_FIXUPS (5)
1985 /* This routine is called for each instruction to be assembled. */
1992 const struct powerpc_opcode
*opcode
;
1994 const unsigned char *opindex_ptr
;
1998 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2003 bfd_reloc_code_real_type reloc
;
2006 /* Get the opcode. */
2007 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2012 /* Look up the opcode in the hash table. */
2013 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2014 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2016 const struct powerpc_macro
*macro
;
2018 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2019 if (macro
== (const struct powerpc_macro
*) NULL
)
2020 as_bad (_("Unrecognized opcode: `%s'"), str
);
2022 ppc_macro (s
, macro
);
2027 insn
= opcode
->opcode
;
2030 while (ISSPACE (*str
))
2033 /* PowerPC operands are just expressions. The only real issue is
2034 that a few operand types are optional. All cases which might use
2035 an optional operand separate the operands only with commas (in
2036 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
2037 cases never have optional operands). There is never more than
2038 one optional operand for an instruction. So, before we start
2039 seriously parsing the operands, we check to see if we have an
2040 optional operand, and, if we do, we count the number of commas to
2041 see whether the operand should be omitted. */
2043 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2045 const struct powerpc_operand
*operand
;
2047 operand
= &powerpc_operands
[*opindex_ptr
];
2048 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2050 unsigned int opcount
;
2052 /* There is an optional operand. Count the number of
2053 commas in the input line. */
2060 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2067 /* If there are fewer operands in the line then are called
2068 for by the instruction, we want to skip the optional
2070 if (opcount
< strlen (opcode
->operands
))
2077 /* Gather the operands. */
2081 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2083 const struct powerpc_operand
*operand
;
2089 if (next_opindex
== 0)
2090 operand
= &powerpc_operands
[*opindex_ptr
];
2093 operand
= &powerpc_operands
[next_opindex
];
2098 /* If this is a fake operand, then we do not expect anything
2100 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2102 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2103 if (errmsg
!= (const char *) NULL
)
2108 /* If this is an optional operand, and we are skipping it, just
2110 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2113 if (operand
->insert
)
2115 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2116 if (errmsg
!= (const char *) NULL
)
2119 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2120 next_opindex
= *opindex_ptr
+ 1;
2124 /* Gather the operand. */
2125 hold
= input_line_pointer
;
2126 input_line_pointer
= str
;
2129 if (*input_line_pointer
== '[')
2131 /* We are expecting something like the second argument here:
2133 * lwz r4,[toc].GS.0.static_int(rtoc)
2134 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2135 * The argument following the `]' must be a symbol name, and the
2136 * register must be the toc register: 'rtoc' or '2'
2138 * The effect is to 0 as the displacement field
2139 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2140 * the appropriate variation) reloc against it based on the symbol.
2141 * The linker will build the toc, and insert the resolved toc offset.
2144 * o The size of the toc entry is currently assumed to be
2145 * 32 bits. This should not be assumed to be a hard coded
2147 * o In an effort to cope with a change from 32 to 64 bits,
2148 * there are also toc entries that are specified to be
2149 * either 32 or 64 bits:
2150 * lwz r4,[toc32].GS.0.static_int(rtoc)
2151 * lwz r4,[toc64].GS.0.static_int(rtoc)
2152 * These demand toc entries of the specified size, and the
2153 * instruction probably requires it.
2157 enum toc_size_qualifier toc_kind
;
2158 bfd_reloc_code_real_type toc_reloc
;
2160 /* Go parse off the [tocXX] part. */
2161 valid_toc
= parse_toc_entry (&toc_kind
);
2165 /* Note: message has already been issued.
2166 FIXME: what sort of recovery should we do?
2167 demand_rest_of_line (); return; ? */
2170 /* Now get the symbol following the ']'. */
2176 /* In this case, we may not have seen the symbol yet,
2177 since it is allowed to appear on a .extern or .globl
2178 or just be a label in the .data section. */
2179 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2182 /* 1. The symbol must be defined and either in the toc
2183 section, or a global.
2184 2. The reloc generated must have the TOCDEFN flag set
2185 in upper bit mess of the reloc type.
2186 FIXME: It's a little confusing what the tocv
2187 qualifier can be used for. At the very least, I've
2188 seen three uses, only one of which I'm sure I can
2190 if (ex
.X_op
== O_symbol
)
2192 assert (ex
.X_add_symbol
!= NULL
);
2193 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2196 as_bad (_("[tocv] symbol is not a toc symbol"));
2200 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2203 /* FIXME: these next two specifically specify 32/64 bit
2204 toc entries. We don't support them today. Is this
2205 the right way to say that? */
2206 toc_reloc
= BFD_RELOC_UNUSED
;
2207 as_bad (_("Unimplemented toc32 expression modifier"));
2210 /* FIXME: see above. */
2211 toc_reloc
= BFD_RELOC_UNUSED
;
2212 as_bad (_("Unimplemented toc64 expression modifier"));
2216 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2222 /* We need to generate a fixup for this expression. */
2223 if (fc
>= MAX_INSN_FIXUPS
)
2224 as_fatal (_("too many fixups"));
2226 fixups
[fc
].reloc
= toc_reloc
;
2227 fixups
[fc
].exp
= ex
;
2228 fixups
[fc
].opindex
= *opindex_ptr
;
2231 /* Ok. We've set up the fixup for the instruction. Now make it
2232 look like the constant 0 was found here. */
2234 ex
.X_op
= O_constant
;
2235 ex
.X_add_number
= 0;
2236 ex
.X_add_symbol
= NULL
;
2237 ex
.X_op_symbol
= NULL
;
2243 if (! register_name (&ex
))
2245 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2252 str
= input_line_pointer
;
2253 input_line_pointer
= hold
;
2255 if (ex
.X_op
== O_illegal
)
2256 as_bad (_("illegal operand"));
2257 else if (ex
.X_op
== O_absent
)
2258 as_bad (_("missing operand"));
2259 else if (ex
.X_op
== O_register
)
2261 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2264 else if (ex
.X_op
== O_constant
)
2267 /* Allow @HA, @L, @H on constants. */
2268 char *orig_str
= str
;
2270 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2277 case BFD_RELOC_LO16
:
2278 /* X_unsigned is the default, so if the user has done
2279 something which cleared it, we always produce a
2281 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2282 ex
.X_add_number
&= 0xffff;
2284 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2287 case BFD_RELOC_HI16
:
2288 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2289 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2291 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2294 case BFD_RELOC_HI16_S
:
2295 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2296 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2298 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2301 case BFD_RELOC_PPC64_HIGHER
:
2302 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2303 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2305 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2308 case BFD_RELOC_PPC64_HIGHER_S
:
2309 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2310 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2312 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2315 case BFD_RELOC_PPC64_HIGHEST
:
2316 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2317 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2319 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2322 case BFD_RELOC_PPC64_HIGHEST_S
:
2323 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2324 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2326 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2329 #endif /* OBJ_ELF */
2330 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2334 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2336 /* For the absolute forms of branches, convert the PC
2337 relative form back into the absolute. */
2338 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2342 case BFD_RELOC_PPC_B26
:
2343 reloc
= BFD_RELOC_PPC_BA26
;
2345 case BFD_RELOC_PPC_B16
:
2346 reloc
= BFD_RELOC_PPC_BA16
;
2348 case BFD_RELOC_PPC_B16_BRTAKEN
:
2349 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2351 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2352 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2360 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2365 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2367 case BFD_RELOC_LO16
:
2368 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2370 case BFD_RELOC_16_GOTOFF
:
2371 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2373 case BFD_RELOC_LO16_GOTOFF
:
2374 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2376 case BFD_RELOC_LO16_PLTOFF
:
2377 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2379 case BFD_RELOC_16_BASEREL
:
2380 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2382 case BFD_RELOC_LO16_BASEREL
:
2383 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2385 case BFD_RELOC_PPC_TOC16
:
2386 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2388 case BFD_RELOC_PPC64_TOC16_LO
:
2389 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2391 case BFD_RELOC_PPC64_PLTGOT16
:
2392 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2394 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2395 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2398 as_bad (_("unsupported relocation for DS offset field"));
2403 /* We need to generate a fixup for this expression. */
2404 if (fc
>= MAX_INSN_FIXUPS
)
2405 as_fatal (_("too many fixups"));
2406 fixups
[fc
].exp
= ex
;
2407 fixups
[fc
].opindex
= 0;
2408 fixups
[fc
].reloc
= reloc
;
2411 #endif /* OBJ_ELF */
2415 /* We need to generate a fixup for this expression. */
2416 if (fc
>= MAX_INSN_FIXUPS
)
2417 as_fatal (_("too many fixups"));
2418 fixups
[fc
].exp
= ex
;
2419 fixups
[fc
].opindex
= *opindex_ptr
;
2420 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2429 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2437 /* The call to expression should have advanced str past any
2440 && (endc
!= ',' || *str
!= '\0'))
2442 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2450 while (ISSPACE (*str
))
2454 as_bad (_("junk at end of line: `%s'"), str
);
2457 /* Do we need/want a APUinfo section? */
2458 if (ppc_cpu
& (PPC_OPCODE_SPE
2459 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
2460 | PPC_OPCODE_BRLOCK
| PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
2461 | PPC_OPCODE_RFMCI
))
2463 /* These are all version "1". */
2464 if (opcode
->flags
& PPC_OPCODE_SPE
)
2465 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2466 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2467 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2468 if (opcode
->flags
& PPC_OPCODE_EFS
)
2469 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2470 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2471 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2472 if (opcode
->flags
& PPC_OPCODE_PMR
)
2473 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2474 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2475 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2476 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2477 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2481 /* Write out the instruction. */
2483 md_number_to_chars (f
, insn
, 4);
2486 dwarf2_emit_insn (4);
2489 /* Create any fixups. At this point we do not use a
2490 bfd_reloc_code_real_type, but instead just use the
2491 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2492 handle fixups for any operand type, although that is admittedly
2493 not a very exciting feature. We pick a BFD reloc type in
2495 for (i
= 0; i
< fc
; i
++)
2497 const struct powerpc_operand
*operand
;
2499 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2500 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2502 reloc_howto_type
*reloc_howto
;
2507 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2511 size
= bfd_get_reloc_size (reloc_howto
);
2512 offset
= target_big_endian
? (4 - size
) : 0;
2514 if (size
< 1 || size
> 4)
2517 fixP
= fix_new_exp (frag_now
,
2518 f
- frag_now
->fr_literal
+ offset
,
2521 reloc_howto
->pc_relative
,
2524 /* Turn off complaints that the addend is too large for things like
2526 switch (fixups
[i
].reloc
)
2528 case BFD_RELOC_16_GOTOFF
:
2529 case BFD_RELOC_PPC_TOC16
:
2530 case BFD_RELOC_LO16
:
2531 case BFD_RELOC_HI16
:
2532 case BFD_RELOC_HI16_S
:
2534 case BFD_RELOC_PPC64_HIGHER
:
2535 case BFD_RELOC_PPC64_HIGHER_S
:
2536 case BFD_RELOC_PPC64_HIGHEST
:
2537 case BFD_RELOC_PPC64_HIGHEST_S
:
2539 fixP
->fx_no_overflow
= 1;
2546 fix_new_exp (frag_now
,
2547 f
- frag_now
->fr_literal
,
2550 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2551 ((bfd_reloc_code_real_type
)
2552 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2556 /* Handle a macro. Gather all the operands, transform them as
2557 described by the macro, and call md_assemble recursively. All the
2558 operands are separated by commas; we don't accept parentheses
2559 around operands here. */
2562 ppc_macro (str
, macro
)
2564 const struct powerpc_macro
*macro
;
2575 /* Gather the users operands into the operands array. */
2580 if (count
>= sizeof operands
/ sizeof operands
[0])
2582 operands
[count
++] = s
;
2583 s
= strchr (s
, ',');
2584 if (s
== (char *) NULL
)
2589 if (count
!= macro
->operands
)
2591 as_bad (_("wrong number of operands"));
2595 /* Work out how large the string must be (the size is unbounded
2596 because it includes user input). */
2598 format
= macro
->format
;
2599 while (*format
!= '\0')
2608 arg
= strtol (format
+ 1, &send
, 10);
2609 know (send
!= format
&& arg
>= 0 && arg
< count
);
2610 len
+= strlen (operands
[arg
]);
2615 /* Put the string together. */
2616 complete
= s
= (char *) alloca (len
+ 1);
2617 format
= macro
->format
;
2618 while (*format
!= '\0')
2624 arg
= strtol (format
+ 1, &send
, 10);
2625 strcpy (s
, operands
[arg
]);
2632 /* Assemble the constructed instruction. */
2633 md_assemble (complete
);
2637 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2640 ppc_section_letter (letter
, ptr_msg
)
2647 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2652 ppc_section_word (str
, len
)
2656 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2663 ppc_section_type (str
, len
)
2667 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2674 ppc_section_flags (flags
, attr
, type
)
2679 if (type
== SHT_ORDERED
)
2680 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2682 if (attr
& SHF_EXCLUDE
)
2683 flags
|= SEC_EXCLUDE
;
2687 #endif /* OBJ_ELF */
2690 /* Pseudo-op handling. */
2692 /* The .byte pseudo-op. This is similar to the normal .byte
2693 pseudo-op, but it can also take a single ASCII string. */
2697 int ignore ATTRIBUTE_UNUSED
;
2699 if (*input_line_pointer
!= '\"')
2705 /* Gather characters. A real double quote is doubled. Unusual
2706 characters are not permitted. */
2707 ++input_line_pointer
;
2712 c
= *input_line_pointer
++;
2716 if (*input_line_pointer
!= '\"')
2718 ++input_line_pointer
;
2721 FRAG_APPEND_1_CHAR (c
);
2724 demand_empty_rest_of_line ();
2729 /* XCOFF specific pseudo-op handling. */
2731 /* This is set if we are creating a .stabx symbol, since we don't want
2732 to handle symbol suffixes for such symbols. */
2733 static boolean ppc_stab_symbol
;
2735 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2736 symbols in the .bss segment as though they were local common
2737 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2738 aligns .comm and .lcomm to 4 bytes. */
2744 asection
*current_seg
= now_seg
;
2745 subsegT current_subseg
= now_subseg
;
2751 symbolS
*lcomm_sym
= NULL
;
2755 name
= input_line_pointer
;
2756 endc
= get_symbol_end ();
2757 end_name
= input_line_pointer
;
2760 if (*input_line_pointer
!= ',')
2762 as_bad (_("missing size"));
2763 ignore_rest_of_line ();
2766 ++input_line_pointer
;
2768 size
= get_absolute_expression ();
2771 as_bad (_("negative size"));
2772 ignore_rest_of_line ();
2778 /* The third argument to .comm is the alignment. */
2779 if (*input_line_pointer
!= ',')
2783 ++input_line_pointer
;
2784 align
= get_absolute_expression ();
2787 as_warn (_("ignoring bad alignment"));
2802 /* The third argument to .lcomm appears to be the real local
2803 common symbol to create. References to the symbol named in
2804 the first argument are turned into references to the third
2806 if (*input_line_pointer
!= ',')
2808 as_bad (_("missing real symbol name"));
2809 ignore_rest_of_line ();
2812 ++input_line_pointer
;
2814 lcomm_name
= input_line_pointer
;
2815 lcomm_endc
= get_symbol_end ();
2817 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2819 *input_line_pointer
= lcomm_endc
;
2823 sym
= symbol_find_or_make (name
);
2826 if (S_IS_DEFINED (sym
)
2827 || S_GET_VALUE (sym
) != 0)
2829 as_bad (_("attempt to redefine symbol"));
2830 ignore_rest_of_line ();
2834 record_alignment (bss_section
, align
);
2837 || ! S_IS_DEFINED (lcomm_sym
))
2846 S_SET_EXTERNAL (sym
);
2850 symbol_get_tc (lcomm_sym
)->output
= 1;
2851 def_sym
= lcomm_sym
;
2855 subseg_set (bss_section
, 1);
2856 frag_align (align
, 0, 0);
2858 symbol_set_frag (def_sym
, frag_now
);
2859 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2860 def_size
, (char *) NULL
);
2862 S_SET_SEGMENT (def_sym
, bss_section
);
2863 symbol_get_tc (def_sym
)->align
= align
;
2867 /* Align the size of lcomm_sym. */
2868 symbol_get_frag (lcomm_sym
)->fr_offset
=
2869 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2870 &~ ((1 << align
) - 1));
2871 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2872 symbol_get_tc (lcomm_sym
)->align
= align
;
2877 /* Make sym an offset from lcomm_sym. */
2878 S_SET_SEGMENT (sym
, bss_section
);
2879 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2880 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2881 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2884 subseg_set (current_seg
, current_subseg
);
2886 demand_empty_rest_of_line ();
2889 /* The .csect pseudo-op. This switches us into a different
2890 subsegment. The first argument is a symbol whose value is the
2891 start of the .csect. In COFF, csect symbols get special aux
2892 entries defined by the x_csect field of union internal_auxent. The
2893 optional second argument is the alignment (the default is 2). */
2897 int ignore ATTRIBUTE_UNUSED
;
2903 name
= input_line_pointer
;
2904 endc
= get_symbol_end ();
2906 sym
= symbol_find_or_make (name
);
2908 *input_line_pointer
= endc
;
2910 if (S_GET_NAME (sym
)[0] == '\0')
2912 /* An unnamed csect is assumed to be [PR]. */
2913 symbol_get_tc (sym
)->class = XMC_PR
;
2916 ppc_change_csect (sym
);
2918 if (*input_line_pointer
== ',')
2920 ++input_line_pointer
;
2921 symbol_get_tc (sym
)->align
= get_absolute_expression ();
2924 demand_empty_rest_of_line ();
2927 /* Change to a different csect. */
2930 ppc_change_csect (sym
)
2933 if (S_IS_DEFINED (sym
))
2934 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
2942 /* This is a new csect. We need to look at the symbol class to
2943 figure out whether it should go in the text section or the
2946 switch (symbol_get_tc (sym
)->class)
2956 S_SET_SEGMENT (sym
, text_section
);
2957 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
2958 ++ppc_text_subsegment
;
2959 list_ptr
= &ppc_text_csects
;
2968 if (ppc_toc_csect
!= NULL
2969 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
2970 == ppc_data_subsegment
))
2972 S_SET_SEGMENT (sym
, data_section
);
2973 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
2974 ++ppc_data_subsegment
;
2975 list_ptr
= &ppc_data_csects
;
2981 /* We set the obstack chunk size to a small value before
2982 changing subsegments, so that we don't use a lot of memory
2983 space for what may be a small section. */
2984 hold_chunksize
= chunksize
;
2987 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
2988 symbol_get_tc (sym
)->subseg
);
2990 chunksize
= hold_chunksize
;
2993 ppc_after_toc_frag
= frag_now
;
2995 symbol_set_frag (sym
, frag_now
);
2996 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2998 symbol_get_tc (sym
)->align
= 2;
2999 symbol_get_tc (sym
)->output
= 1;
3000 symbol_get_tc (sym
)->within
= sym
;
3002 for (list
= *list_ptr
;
3003 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3004 list
= symbol_get_tc (list
)->next
)
3006 symbol_get_tc (list
)->next
= sym
;
3008 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3009 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3013 ppc_current_csect
= sym
;
3016 /* This function handles the .text and .data pseudo-ops. These
3017 pseudo-ops aren't really used by XCOFF; we implement them for the
3018 convenience of people who aren't used to XCOFF. */
3029 else if (type
== 'd')
3034 sym
= symbol_find_or_make (name
);
3036 ppc_change_csect (sym
);
3038 demand_empty_rest_of_line ();
3041 /* This function handles the .section pseudo-op. This is mostly to
3042 give an error, since XCOFF only supports .text, .data and .bss, but
3043 we do permit the user to name the text or data section. */
3046 ppc_named_section (ignore
)
3047 int ignore ATTRIBUTE_UNUSED
;
3050 const char *real_name
;
3054 user_name
= input_line_pointer
;
3055 c
= get_symbol_end ();
3057 if (strcmp (user_name
, ".text") == 0)
3058 real_name
= ".text[PR]";
3059 else if (strcmp (user_name
, ".data") == 0)
3060 real_name
= ".data[RW]";
3063 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3064 *input_line_pointer
= c
;
3065 ignore_rest_of_line ();
3069 *input_line_pointer
= c
;
3071 sym
= symbol_find_or_make (real_name
);
3073 ppc_change_csect (sym
);
3075 demand_empty_rest_of_line ();
3078 /* The .extern pseudo-op. We create an undefined symbol. */
3082 int ignore ATTRIBUTE_UNUSED
;
3087 name
= input_line_pointer
;
3088 endc
= get_symbol_end ();
3090 (void) symbol_find_or_make (name
);
3092 *input_line_pointer
= endc
;
3094 demand_empty_rest_of_line ();
3097 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3101 int ignore ATTRIBUTE_UNUSED
;
3107 name
= input_line_pointer
;
3108 endc
= get_symbol_end ();
3110 sym
= symbol_find_or_make (name
);
3112 *input_line_pointer
= endc
;
3114 symbol_get_tc (sym
)->output
= 1;
3116 demand_empty_rest_of_line ();
3119 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3120 although I don't know why it bothers. */
3124 int ignore ATTRIBUTE_UNUSED
;
3131 name
= input_line_pointer
;
3132 endc
= get_symbol_end ();
3134 sym
= symbol_find_or_make (name
);
3136 *input_line_pointer
= endc
;
3138 if (*input_line_pointer
!= ',')
3140 as_bad (_("missing rename string"));
3141 ignore_rest_of_line ();
3144 ++input_line_pointer
;
3146 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3148 demand_empty_rest_of_line ();
3151 /* The .stabx pseudo-op. This is similar to a normal .stabs
3152 pseudo-op, but slightly different. A sample is
3153 .stabx "main:F-1",.main,142,0
3154 The first argument is the symbol name to create. The second is the
3155 value, and the third is the storage class. The fourth seems to be
3156 always zero, and I am assuming it is the type. */
3160 int ignore ATTRIBUTE_UNUSED
;
3167 name
= demand_copy_C_string (&len
);
3169 if (*input_line_pointer
!= ',')
3171 as_bad (_("missing value"));
3174 ++input_line_pointer
;
3176 ppc_stab_symbol
= true;
3177 sym
= symbol_make (name
);
3178 ppc_stab_symbol
= false;
3180 symbol_get_tc (sym
)->real_name
= name
;
3182 (void) expression (&exp
);
3189 as_bad (_("illegal .stabx expression; zero assumed"));
3190 exp
.X_add_number
= 0;
3193 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3194 symbol_set_frag (sym
, &zero_address_frag
);
3198 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3199 symbol_set_value_expression (sym
, &exp
);
3203 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3204 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3209 /* The value is some complex expression. This will probably
3210 fail at some later point, but this is probably the right
3211 thing to do here. */
3212 symbol_set_value_expression (sym
, &exp
);
3216 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3217 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3219 if (*input_line_pointer
!= ',')
3221 as_bad (_("missing class"));
3224 ++input_line_pointer
;
3226 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3228 if (*input_line_pointer
!= ',')
3230 as_bad (_("missing type"));
3233 ++input_line_pointer
;
3235 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3237 symbol_get_tc (sym
)->output
= 1;
3239 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3241 symbol_get_tc (sym
)->within
= ppc_current_block
;
3246 .stabx "z",arrays_,133,0
3249 .comm arrays_,13768,3
3251 resolve_symbol_value will copy the exp's "within" into sym's when the
3252 offset is 0. Since this seems to be corner case problem,
3253 only do the correction for storage class C_STSYM. A better solution
3254 would be to have the tc field updated in ppc_symbol_new_hook. */
3256 if (exp
.X_op
== O_symbol
)
3258 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3262 if (exp
.X_op
!= O_symbol
3263 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3264 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3265 ppc_frob_label (sym
);
3268 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3269 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3270 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3271 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3274 demand_empty_rest_of_line ();
3277 /* The .function pseudo-op. This takes several arguments. The first
3278 argument seems to be the external name of the symbol. The second
3279 argment seems to be the label for the start of the function. gcc
3280 uses the same name for both. I have no idea what the third and
3281 fourth arguments are meant to be. The optional fifth argument is
3282 an expression for the size of the function. In COFF this symbol
3283 gets an aux entry like that used for a csect. */
3286 ppc_function (ignore
)
3287 int ignore ATTRIBUTE_UNUSED
;
3295 name
= input_line_pointer
;
3296 endc
= get_symbol_end ();
3298 /* Ignore any [PR] suffix. */
3299 name
= ppc_canonicalize_symbol_name (name
);
3300 s
= strchr (name
, '[');
3301 if (s
!= (char *) NULL
3302 && strcmp (s
+ 1, "PR]") == 0)
3305 ext_sym
= symbol_find_or_make (name
);
3307 *input_line_pointer
= endc
;
3309 if (*input_line_pointer
!= ',')
3311 as_bad (_("missing symbol name"));
3312 ignore_rest_of_line ();
3315 ++input_line_pointer
;
3317 name
= input_line_pointer
;
3318 endc
= get_symbol_end ();
3320 lab_sym
= symbol_find_or_make (name
);
3322 *input_line_pointer
= endc
;
3324 if (ext_sym
!= lab_sym
)
3328 exp
.X_op
= O_symbol
;
3329 exp
.X_add_symbol
= lab_sym
;
3330 exp
.X_op_symbol
= NULL
;
3331 exp
.X_add_number
= 0;
3333 symbol_set_value_expression (ext_sym
, &exp
);
3336 if (symbol_get_tc (ext_sym
)->class == -1)
3337 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3338 symbol_get_tc (ext_sym
)->output
= 1;
3340 if (*input_line_pointer
== ',')
3344 /* Ignore the third argument. */
3345 ++input_line_pointer
;
3346 expression (&ignore
);
3347 if (*input_line_pointer
== ',')
3349 /* Ignore the fourth argument. */
3350 ++input_line_pointer
;
3351 expression (&ignore
);
3352 if (*input_line_pointer
== ',')
3354 /* The fifth argument is the function size. */
3355 ++input_line_pointer
;
3356 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3359 &zero_address_frag
);
3360 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3365 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3366 SF_SET_FUNCTION (ext_sym
);
3367 SF_SET_PROCESS (ext_sym
);
3368 coff_add_linesym (ext_sym
);
3370 demand_empty_rest_of_line ();
3373 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3374 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3375 with the correct line number */
3377 static symbolS
*saved_bi_sym
= 0;
3381 int ignore ATTRIBUTE_UNUSED
;
3385 sym
= symbol_make (".bf");
3386 S_SET_SEGMENT (sym
, text_section
);
3387 symbol_set_frag (sym
, frag_now
);
3388 S_SET_VALUE (sym
, frag_now_fix ());
3389 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3391 coff_line_base
= get_absolute_expression ();
3393 S_SET_NUMBER_AUXILIARY (sym
, 1);
3394 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3396 /* Line number for bi. */
3399 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3404 symbol_get_tc (sym
)->output
= 1;
3406 ppc_frob_label (sym
);
3408 demand_empty_rest_of_line ();
3411 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3412 ".ef", except that the line number is absolute, not relative to the
3413 most recent ".bf" symbol. */
3417 int ignore ATTRIBUTE_UNUSED
;
3421 sym
= symbol_make (".ef");
3422 S_SET_SEGMENT (sym
, text_section
);
3423 symbol_set_frag (sym
, frag_now
);
3424 S_SET_VALUE (sym
, frag_now_fix ());
3425 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3426 S_SET_NUMBER_AUXILIARY (sym
, 1);
3427 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3428 symbol_get_tc (sym
)->output
= 1;
3430 ppc_frob_label (sym
);
3432 demand_empty_rest_of_line ();
3435 /* The .bi and .ei pseudo-ops. These take a string argument and
3436 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3437 the symbol list. The value of .bi will be know when the next .bf
3444 static symbolS
*last_biei
;
3451 name
= demand_copy_C_string (&len
);
3453 /* The value of these symbols is actually file offset. Here we set
3454 the value to the index into the line number entries. In
3455 ppc_frob_symbols we set the fix_line field, which will cause BFD
3456 to do the right thing. */
3458 sym
= symbol_make (name
);
3459 /* obj-coff.c currently only handles line numbers correctly in the
3461 S_SET_SEGMENT (sym
, text_section
);
3462 S_SET_VALUE (sym
, coff_n_line_nos
);
3463 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3465 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3466 symbol_get_tc (sym
)->output
= 1;
3474 for (look
= last_biei
? last_biei
: symbol_rootP
;
3475 (look
!= (symbolS
*) NULL
3476 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3477 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3478 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3479 look
= symbol_next (look
))
3481 if (look
!= (symbolS
*) NULL
)
3483 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3484 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3488 demand_empty_rest_of_line ();
3491 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3492 There is one argument, which is a csect symbol. The value of the
3493 .bs symbol is the index of this csect symbol. */
3497 int ignore ATTRIBUTE_UNUSED
;
3504 if (ppc_current_block
!= NULL
)
3505 as_bad (_("nested .bs blocks"));
3507 name
= input_line_pointer
;
3508 endc
= get_symbol_end ();
3510 csect
= symbol_find_or_make (name
);
3512 *input_line_pointer
= endc
;
3514 sym
= symbol_make (".bs");
3515 S_SET_SEGMENT (sym
, now_seg
);
3516 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3517 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3518 symbol_get_tc (sym
)->output
= 1;
3520 symbol_get_tc (sym
)->within
= csect
;
3522 ppc_frob_label (sym
);
3524 ppc_current_block
= sym
;
3526 demand_empty_rest_of_line ();
3529 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3533 int ignore ATTRIBUTE_UNUSED
;
3537 if (ppc_current_block
== NULL
)
3538 as_bad (_(".es without preceding .bs"));
3540 sym
= symbol_make (".es");
3541 S_SET_SEGMENT (sym
, now_seg
);
3542 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3543 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3544 symbol_get_tc (sym
)->output
= 1;
3546 ppc_frob_label (sym
);
3548 ppc_current_block
= NULL
;
3550 demand_empty_rest_of_line ();
3553 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3558 int ignore ATTRIBUTE_UNUSED
;
3562 sym
= symbol_make (".bb");
3563 S_SET_SEGMENT (sym
, text_section
);
3564 symbol_set_frag (sym
, frag_now
);
3565 S_SET_VALUE (sym
, frag_now_fix ());
3566 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3568 S_SET_NUMBER_AUXILIARY (sym
, 1);
3569 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3571 symbol_get_tc (sym
)->output
= 1;
3573 SF_SET_PROCESS (sym
);
3575 ppc_frob_label (sym
);
3577 demand_empty_rest_of_line ();
3580 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3585 int ignore ATTRIBUTE_UNUSED
;
3589 sym
= symbol_make (".eb");
3590 S_SET_SEGMENT (sym
, text_section
);
3591 symbol_set_frag (sym
, frag_now
);
3592 S_SET_VALUE (sym
, frag_now_fix ());
3593 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3594 S_SET_NUMBER_AUXILIARY (sym
, 1);
3595 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3596 symbol_get_tc (sym
)->output
= 1;
3598 SF_SET_PROCESS (sym
);
3600 ppc_frob_label (sym
);
3602 demand_empty_rest_of_line ();
3605 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3610 int ignore ATTRIBUTE_UNUSED
;
3616 name
= demand_copy_C_string (&len
);
3617 sym
= symbol_make (name
);
3618 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3619 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3620 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3621 S_SET_VALUE (sym
, 0);
3622 symbol_get_tc (sym
)->output
= 1;
3624 ppc_frob_label (sym
);
3626 demand_empty_rest_of_line ();
3629 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3633 int ignore ATTRIBUTE_UNUSED
;
3637 sym
= symbol_make (".ec");
3638 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3639 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3640 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3641 S_SET_VALUE (sym
, 0);
3642 symbol_get_tc (sym
)->output
= 1;
3644 ppc_frob_label (sym
);
3646 demand_empty_rest_of_line ();
3649 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3653 int ignore ATTRIBUTE_UNUSED
;
3655 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3656 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3663 subseg
= ppc_data_subsegment
;
3664 ++ppc_data_subsegment
;
3666 subseg_new (segment_name (data_section
), subseg
);
3667 ppc_toc_frag
= frag_now
;
3669 sym
= symbol_find_or_make ("TOC[TC0]");
3670 symbol_set_frag (sym
, frag_now
);
3671 S_SET_SEGMENT (sym
, data_section
);
3672 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3673 symbol_get_tc (sym
)->subseg
= subseg
;
3674 symbol_get_tc (sym
)->output
= 1;
3675 symbol_get_tc (sym
)->within
= sym
;
3677 ppc_toc_csect
= sym
;
3679 for (list
= ppc_data_csects
;
3680 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3681 list
= symbol_get_tc (list
)->next
)
3683 symbol_get_tc (list
)->next
= sym
;
3685 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3686 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3690 ppc_current_csect
= ppc_toc_csect
;
3692 demand_empty_rest_of_line ();
3695 /* The AIX assembler automatically aligns the operands of a .long or
3696 .short pseudo-op, and we want to be compatible. */
3699 ppc_xcoff_cons (log_size
)
3702 frag_align (log_size
, 0, 0);
3703 record_alignment (now_seg
, log_size
);
3704 cons (1 << log_size
);
3709 int dummy ATTRIBUTE_UNUSED
;
3714 (void) expression (&exp
);
3716 if (exp
.X_op
!= O_constant
)
3718 as_bad (_("non-constant byte count"));
3722 byte_count
= exp
.X_add_number
;
3724 if (*input_line_pointer
!= ',')
3726 as_bad (_("missing value"));
3730 ++input_line_pointer
;
3734 #endif /* OBJ_XCOFF */
3735 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3737 /* The .tc pseudo-op. This is used when generating either XCOFF or
3738 ELF. This takes two or more arguments.
3740 When generating XCOFF output, the first argument is the name to
3741 give to this location in the toc; this will be a symbol with class
3742 TC. The rest of the arguments are N-byte values to actually put at
3743 this location in the TOC; often there is just one more argument, a
3744 relocateable symbol reference. The size of the value to store
3745 depends on target word size. A 32-bit target uses 4-byte values, a
3746 64-bit target uses 8-byte values.
3748 When not generating XCOFF output, the arguments are the same, but
3749 the first argument is simply ignored. */
3753 int ignore ATTRIBUTE_UNUSED
;
3757 /* Define the TOC symbol name. */
3763 if (ppc_toc_csect
== (symbolS
*) NULL
3764 || ppc_toc_csect
!= ppc_current_csect
)
3766 as_bad (_(".tc not in .toc section"));
3767 ignore_rest_of_line ();
3771 name
= input_line_pointer
;
3772 endc
= get_symbol_end ();
3774 sym
= symbol_find_or_make (name
);
3776 *input_line_pointer
= endc
;
3778 if (S_IS_DEFINED (sym
))
3782 label
= symbol_get_tc (ppc_current_csect
)->within
;
3783 if (symbol_get_tc (label
)->class != XMC_TC0
)
3785 as_bad (_(".tc with no label"));
3786 ignore_rest_of_line ();
3790 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3791 symbol_set_frag (label
, symbol_get_frag (sym
));
3792 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3794 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3795 ++input_line_pointer
;
3800 S_SET_SEGMENT (sym
, now_seg
);
3801 symbol_set_frag (sym
, frag_now
);
3802 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3803 symbol_get_tc (sym
)->class = XMC_TC
;
3804 symbol_get_tc (sym
)->output
= 1;
3806 ppc_frob_label (sym
);
3809 #endif /* OBJ_XCOFF */
3813 /* Skip the TOC symbol name. */
3814 while (is_part_of_name (*input_line_pointer
)
3815 || *input_line_pointer
== '['
3816 || *input_line_pointer
== ']'
3817 || *input_line_pointer
== '{'
3818 || *input_line_pointer
== '}')
3819 ++input_line_pointer
;
3821 /* Align to a four/eight byte boundary. */
3822 align
= ppc_obj64
? 3 : 2;
3823 frag_align (align
, 0, 0);
3824 record_alignment (now_seg
, align
);
3825 #endif /* OBJ_ELF */
3827 if (*input_line_pointer
!= ',')
3828 demand_empty_rest_of_line ();
3831 ++input_line_pointer
;
3832 cons (ppc_obj64
? 8 : 4);
3836 /* Pseudo-op .machine. */
3837 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3838 accept this directive on the first line of input and set ppc_obj64
3839 and the target format accordingly. Unfortunately, the target
3840 format is selected in output-file.c:output_file_create before we
3841 even get to md_begin, so it's not possible without changing
3845 ppc_machine (ignore
)
3846 int ignore ATTRIBUTE_UNUSED
;
3848 discard_rest_of_line ();
3851 /* See whether a symbol is in the TOC section. */
3854 ppc_is_toc_sym (sym
)
3858 return symbol_get_tc (sym
)->class == XMC_TC
;
3861 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3863 return strcmp (sname
, ".toc") == 0;
3865 return strcmp (sname
, ".got") == 0;
3868 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3872 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3874 /* Set the current section. */
3876 ppc_set_current_section (new)
3879 ppc_previous_section
= ppc_current_section
;
3880 ppc_current_section
= new;
3883 /* pseudo-op: .previous
3884 behaviour: toggles the current section with the previous section.
3886 warnings: "No previous section" */
3889 ppc_previous (ignore
)
3890 int ignore ATTRIBUTE_UNUSED
;
3894 if (ppc_previous_section
== NULL
)
3896 as_warn (_("No previous section to return to. Directive ignored."));
3900 subseg_set (ppc_previous_section
, 0);
3902 ppc_set_current_section (ppc_previous_section
);
3905 /* pseudo-op: .pdata
3906 behaviour: predefined read only data section
3910 initial: .section .pdata "adr3"
3911 a - don't know -- maybe a misprint
3912 d - initialized data
3914 3 - double word aligned (that would be 4 byte boundary)
3917 Tag index tables (also known as the function table) for exception
3918 handling, debugging, etc. */
3922 int ignore ATTRIBUTE_UNUSED
;
3924 if (pdata_section
== 0)
3926 pdata_section
= subseg_new (".pdata", 0);
3928 bfd_set_section_flags (stdoutput
, pdata_section
,
3929 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3930 | SEC_READONLY
| SEC_DATA
));
3932 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
3936 pdata_section
= subseg_new (".pdata", 0);
3938 ppc_set_current_section (pdata_section
);
3941 /* pseudo-op: .ydata
3942 behaviour: predefined read only data section
3946 initial: .section .ydata "drw3"
3947 a - don't know -- maybe a misprint
3948 d - initialized data
3950 3 - double word aligned (that would be 4 byte boundary)
3952 Tag tables (also known as the scope table) for exception handling,
3957 int ignore ATTRIBUTE_UNUSED
;
3959 if (ydata_section
== 0)
3961 ydata_section
= subseg_new (".ydata", 0);
3962 bfd_set_section_flags (stdoutput
, ydata_section
,
3963 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3964 | SEC_READONLY
| SEC_DATA
));
3966 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
3970 ydata_section
= subseg_new (".ydata", 0);
3972 ppc_set_current_section (ydata_section
);
3975 /* pseudo-op: .reldata
3976 behaviour: predefined read write data section
3977 double word aligned (4-byte)
3978 FIXME: relocation is applied to it
3979 FIXME: what's the difference between this and .data?
3982 initial: .section .reldata "drw3"
3983 d - initialized data
3986 3 - double word aligned (that would be 8 byte boundary)
3989 Like .data, but intended to hold data subject to relocation, such as
3990 function descriptors, etc. */
3993 ppc_reldata (ignore
)
3994 int ignore ATTRIBUTE_UNUSED
;
3996 if (reldata_section
== 0)
3998 reldata_section
= subseg_new (".reldata", 0);
4000 bfd_set_section_flags (stdoutput
, reldata_section
,
4001 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4004 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4008 reldata_section
= subseg_new (".reldata", 0);
4010 ppc_set_current_section (reldata_section
);
4013 /* pseudo-op: .rdata
4014 behaviour: predefined read only data section
4018 initial: .section .rdata "dr3"
4019 d - initialized data
4021 3 - double word aligned (that would be 4 byte boundary) */
4025 int ignore ATTRIBUTE_UNUSED
;
4027 if (rdata_section
== 0)
4029 rdata_section
= subseg_new (".rdata", 0);
4030 bfd_set_section_flags (stdoutput
, rdata_section
,
4031 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4032 | SEC_READONLY
| SEC_DATA
));
4034 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4038 rdata_section
= subseg_new (".rdata", 0);
4040 ppc_set_current_section (rdata_section
);
4043 /* pseudo-op: .ualong
4044 behaviour: much like .int, with the exception that no alignment is
4046 FIXME: test the alignment statement
4052 int ignore ATTRIBUTE_UNUSED
;
4058 /* pseudo-op: .znop <symbol name>
4059 behaviour: Issue a nop instruction
4060 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4061 the supplied symbol name.
4063 warnings: Missing symbol name */
4067 int ignore ATTRIBUTE_UNUSED
;
4070 const struct powerpc_opcode
*opcode
;
4081 /* Strip out the symbol name. */
4082 symbol_name
= input_line_pointer
;
4083 c
= get_symbol_end ();
4085 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4086 strcpy (name
, symbol_name
);
4088 sym
= symbol_find_or_make (name
);
4090 *input_line_pointer
= c
;
4094 /* Look up the opcode in the hash table. */
4095 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4097 /* Stick in the nop. */
4098 insn
= opcode
->opcode
;
4100 /* Write out the instruction. */
4102 md_number_to_chars (f
, insn
, 4);
4104 f
- frag_now
->fr_literal
,
4109 BFD_RELOC_16_GOT_PCREL
);
4122 register char *name
;
4126 register symbolS
*symbolP
;
4129 name
= input_line_pointer
;
4130 c
= get_symbol_end ();
4132 /* just after name is now '\0'. */
4133 p
= input_line_pointer
;
4136 if (*input_line_pointer
!= ',')
4138 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4139 ignore_rest_of_line ();
4143 input_line_pointer
++; /* skip ',' */
4144 if ((temp
= get_absolute_expression ()) < 0)
4146 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4147 ignore_rest_of_line ();
4153 /* The third argument to .comm is the alignment. */
4154 if (*input_line_pointer
!= ',')
4158 ++input_line_pointer
;
4159 align
= get_absolute_expression ();
4162 as_warn (_("ignoring bad alignment"));
4169 symbolP
= symbol_find_or_make (name
);
4172 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4174 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4175 S_GET_NAME (symbolP
));
4176 ignore_rest_of_line ();
4180 if (S_GET_VALUE (symbolP
))
4182 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4183 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4184 S_GET_NAME (symbolP
),
4185 (long) S_GET_VALUE (symbolP
),
4190 S_SET_VALUE (symbolP
, (valueT
) temp
);
4191 S_SET_EXTERNAL (symbolP
);
4194 demand_empty_rest_of_line ();
4198 * implement the .section pseudo op:
4199 * .section name {, "flags"}
4201 * | +--- optional flags: 'b' for bss
4203 * +-- section name 'l' for lib
4207 * 'd' (apparently m88k for data)
4209 * But if the argument is not a quoted string, treat it as a
4210 * subsegment number.
4212 * FIXME: this is a copy of the section processing from obj-coff.c, with
4213 * additions/changes for the moto-pas assembler support. There are three
4216 * FIXME: I just noticed this. This doesn't work at all really. It it
4217 * setting bits that bfd probably neither understands or uses. The
4218 * correct approach (?) will have to incorporate extra fields attached
4219 * to the section to hold the system specific stuff. (krk)
4222 * 'a' - unknown - referred to in documentation, but no definition supplied
4223 * 'c' - section has code
4224 * 'd' - section has initialized data
4225 * 'u' - section has uninitialized data
4226 * 'i' - section contains directives (info)
4227 * 'n' - section can be discarded
4228 * 'R' - remove section at link time
4230 * Section Protection:
4231 * 'r' - section is readable
4232 * 'w' - section is writeable
4233 * 'x' - section is executable
4234 * 's' - section is sharable
4236 * Section Alignment:
4237 * '0' - align to byte boundary
4238 * '1' - align to halfword undary
4239 * '2' - align to word boundary
4240 * '3' - align to doubleword boundary
4241 * '4' - align to quadword boundary
4242 * '5' - align to 32 byte boundary
4243 * '6' - align to 64 byte boundary
4248 ppc_pe_section (ignore
)
4249 int ignore ATTRIBUTE_UNUSED
;
4251 /* Strip out the section name. */
4260 section_name
= input_line_pointer
;
4261 c
= get_symbol_end ();
4263 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4264 strcpy (name
, section_name
);
4266 *input_line_pointer
= c
;
4271 flags
= SEC_NO_FLAGS
;
4273 if (strcmp (name
, ".idata$2") == 0)
4277 else if (strcmp (name
, ".idata$3") == 0)
4281 else if (strcmp (name
, ".idata$4") == 0)
4285 else if (strcmp (name
, ".idata$5") == 0)
4289 else if (strcmp (name
, ".idata$6") == 0)
4294 /* Default alignment to 16 byte boundary. */
4297 if (*input_line_pointer
== ',')
4299 ++input_line_pointer
;
4301 if (*input_line_pointer
!= '"')
4302 exp
= get_absolute_expression ();
4305 ++input_line_pointer
;
4306 while (*input_line_pointer
!= '"'
4307 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4309 switch (*input_line_pointer
)
4311 /* Section Contents */
4312 case 'a': /* unknown */
4313 as_bad (_("Unsupported section attribute -- 'a'"));
4315 case 'c': /* code section */
4318 case 'd': /* section has initialized data */
4321 case 'u': /* section has uninitialized data */
4322 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4326 case 'i': /* section contains directives (info) */
4327 /* FIXME: This is IMAGE_SCN_LNK_INFO
4329 flags
|= SEC_HAS_CONTENTS
;
4331 case 'n': /* section can be discarded */
4334 case 'R': /* Remove section at link time */
4335 flags
|= SEC_NEVER_LOAD
;
4338 /* Section Protection */
4339 case 'r': /* section is readable */
4340 flags
|= IMAGE_SCN_MEM_READ
;
4342 case 'w': /* section is writeable */
4343 flags
|= IMAGE_SCN_MEM_WRITE
;
4345 case 'x': /* section is executable */
4346 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4348 case 's': /* section is sharable */
4349 flags
|= IMAGE_SCN_MEM_SHARED
;
4352 /* Section Alignment */
4353 case '0': /* align to byte boundary */
4354 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4357 case '1': /* align to halfword boundary */
4358 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4361 case '2': /* align to word boundary */
4362 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4365 case '3': /* align to doubleword boundary */
4366 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4369 case '4': /* align to quadword boundary */
4370 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4373 case '5': /* align to 32 byte boundary */
4374 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4377 case '6': /* align to 64 byte boundary */
4378 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4383 as_bad (_("unknown section attribute '%c'"),
4384 *input_line_pointer
);
4387 ++input_line_pointer
;
4389 if (*input_line_pointer
== '"')
4390 ++input_line_pointer
;
4394 sec
= subseg_new (name
, (subsegT
) exp
);
4396 ppc_set_current_section (sec
);
4398 if (flags
!= SEC_NO_FLAGS
)
4400 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4401 as_bad (_("error setting flags for \"%s\": %s"),
4402 bfd_section_name (stdoutput
, sec
),
4403 bfd_errmsg (bfd_get_error ()));
4406 bfd_set_section_alignment (stdoutput
, sec
, align
);
4411 ppc_pe_function (ignore
)
4412 int ignore ATTRIBUTE_UNUSED
;
4418 name
= input_line_pointer
;
4419 endc
= get_symbol_end ();
4421 ext_sym
= symbol_find_or_make (name
);
4423 *input_line_pointer
= endc
;
4425 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4426 SF_SET_FUNCTION (ext_sym
);
4427 SF_SET_PROCESS (ext_sym
);
4428 coff_add_linesym (ext_sym
);
4430 demand_empty_rest_of_line ();
4434 ppc_pe_tocd (ignore
)
4435 int ignore ATTRIBUTE_UNUSED
;
4437 if (tocdata_section
== 0)
4439 tocdata_section
= subseg_new (".tocd", 0);
4440 /* FIXME: section flags won't work. */
4441 bfd_set_section_flags (stdoutput
, tocdata_section
,
4442 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4443 | SEC_READONLY
| SEC_DATA
));
4445 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4449 rdata_section
= subseg_new (".tocd", 0);
4452 ppc_set_current_section (tocdata_section
);
4454 demand_empty_rest_of_line ();
4457 /* Don't adjust TOC relocs to use the section symbol. */
4460 ppc_pe_fix_adjustable (fix
)
4463 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4470 /* XCOFF specific symbol and file handling. */
4472 /* Canonicalize the symbol name. We use the to force the suffix, if
4473 any, to use square brackets, and to be in upper case. */
4476 ppc_canonicalize_symbol_name (name
)
4481 if (ppc_stab_symbol
)
4484 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4498 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4501 if (*s
== '\0' || s
[1] != '\0')
4502 as_bad (_("bad symbol suffix"));
4510 /* Set the class of a symbol based on the suffix, if any. This is
4511 called whenever a new symbol is created. */
4514 ppc_symbol_new_hook (sym
)
4517 struct ppc_tc_sy
*tc
;
4520 tc
= symbol_get_tc (sym
);
4524 tc
->real_name
= NULL
;
4530 if (ppc_stab_symbol
)
4533 s
= strchr (S_GET_NAME (sym
), '[');
4534 if (s
== (const char *) NULL
)
4536 /* There is no suffix. */
4545 if (strcmp (s
, "BS]") == 0)
4549 if (strcmp (s
, "DB]") == 0)
4551 else if (strcmp (s
, "DS]") == 0)
4555 if (strcmp (s
, "GL]") == 0)
4559 if (strcmp (s
, "PR]") == 0)
4563 if (strcmp (s
, "RO]") == 0)
4565 else if (strcmp (s
, "RW]") == 0)
4569 if (strcmp (s
, "SV]") == 0)
4573 if (strcmp (s
, "TC]") == 0)
4575 else if (strcmp (s
, "TI]") == 0)
4577 else if (strcmp (s
, "TB]") == 0)
4579 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4580 tc
->class = XMC_TC0
;
4583 if (strcmp (s
, "UA]") == 0)
4585 else if (strcmp (s
, "UC]") == 0)
4589 if (strcmp (s
, "XO]") == 0)
4594 if (tc
->class == -1)
4595 as_bad (_("Unrecognized symbol suffix"));
4598 /* Set the class of a label based on where it is defined. This
4599 handles symbols without suffixes. Also, move the symbol so that it
4600 follows the csect symbol. */
4603 ppc_frob_label (sym
)
4606 if (ppc_current_csect
!= (symbolS
*) NULL
)
4608 if (symbol_get_tc (sym
)->class == -1)
4609 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4611 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4612 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4613 &symbol_rootP
, &symbol_lastP
);
4614 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4618 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4619 seen. It tells ppc_adjust_symtab whether it needs to look through
4622 static boolean ppc_saw_abs
;
4624 /* Change the name of a symbol just before writing it out. Set the
4625 real name if the .rename pseudo-op was used. Otherwise, remove any
4626 class suffix. Return 1 if the symbol should not be included in the
4630 ppc_frob_symbol (sym
)
4633 static symbolS
*ppc_last_function
;
4634 static symbolS
*set_end
;
4636 /* Discard symbols that should not be included in the output symbol
4638 if (! symbol_used_in_reloc_p (sym
)
4639 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4640 || (! S_IS_EXTERNAL (sym
)
4641 && ! symbol_get_tc (sym
)->output
4642 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4645 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4646 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4652 name
= S_GET_NAME (sym
);
4653 s
= strchr (name
, '[');
4654 if (s
!= (char *) NULL
)
4660 snew
= xmalloc (len
+ 1);
4661 memcpy (snew
, name
, len
);
4664 S_SET_NAME (sym
, snew
);
4668 if (set_end
!= (symbolS
*) NULL
)
4670 SA_SET_SYM_ENDNDX (set_end
, sym
);
4674 if (SF_GET_FUNCTION (sym
))
4676 if (ppc_last_function
!= (symbolS
*) NULL
)
4677 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4678 ppc_last_function
= sym
;
4679 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4681 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4682 SA_SET_SYM_FSIZE (sym
,
4683 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4686 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4687 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4689 if (ppc_last_function
== (symbolS
*) NULL
)
4690 as_bad (_(".ef with no preceding .function"));
4693 set_end
= ppc_last_function
;
4694 ppc_last_function
= NULL
;
4696 /* We don't have a C_EFCN symbol, but we need to force the
4697 COFF backend to believe that it has seen one. */
4698 coff_last_function
= NULL
;
4702 if (! S_IS_EXTERNAL (sym
)
4703 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4704 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4705 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4706 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4707 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4708 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4709 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4710 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4711 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4712 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4714 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4715 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4718 union internal_auxent
*a
;
4720 /* Create a csect aux. */
4721 i
= S_GET_NUMBER_AUXILIARY (sym
);
4722 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4723 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4724 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4726 /* This is the TOC table. */
4727 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4728 a
->x_csect
.x_scnlen
.l
= 0;
4729 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4731 else if (symbol_get_tc (sym
)->subseg
!= 0)
4733 /* This is a csect symbol. x_scnlen is the size of the
4735 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4736 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4737 S_GET_SEGMENT (sym
))
4738 - S_GET_VALUE (sym
));
4741 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4742 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4743 - S_GET_VALUE (sym
));
4745 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4747 else if (S_GET_SEGMENT (sym
) == bss_section
)
4749 /* This is a common symbol. */
4750 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4751 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4752 if (S_IS_EXTERNAL (sym
))
4753 symbol_get_tc (sym
)->class = XMC_RW
;
4755 symbol_get_tc (sym
)->class = XMC_BS
;
4757 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4759 /* This is an absolute symbol. The csect will be created by
4760 ppc_adjust_symtab. */
4762 a
->x_csect
.x_smtyp
= XTY_LD
;
4763 if (symbol_get_tc (sym
)->class == -1)
4764 symbol_get_tc (sym
)->class = XMC_XO
;
4766 else if (! S_IS_DEFINED (sym
))
4768 /* This is an external symbol. */
4769 a
->x_csect
.x_scnlen
.l
= 0;
4770 a
->x_csect
.x_smtyp
= XTY_ER
;
4772 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4776 /* This is a TOC definition. x_scnlen is the size of the
4778 next
= symbol_next (sym
);
4779 while (symbol_get_tc (next
)->class == XMC_TC0
)
4780 next
= symbol_next (next
);
4781 if (next
== (symbolS
*) NULL
4782 || symbol_get_tc (next
)->class != XMC_TC
)
4784 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4785 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4787 - S_GET_VALUE (sym
));
4789 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4790 - S_GET_VALUE (sym
));
4794 resolve_symbol_value (next
);
4795 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4796 - S_GET_VALUE (sym
));
4798 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4804 /* This is a normal symbol definition. x_scnlen is the
4805 symbol index of the containing csect. */
4806 if (S_GET_SEGMENT (sym
) == text_section
)
4807 csect
= ppc_text_csects
;
4808 else if (S_GET_SEGMENT (sym
) == data_section
)
4809 csect
= ppc_data_csects
;
4813 /* Skip the initial dummy symbol. */
4814 csect
= symbol_get_tc (csect
)->next
;
4816 if (csect
== (symbolS
*) NULL
)
4818 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4819 a
->x_csect
.x_scnlen
.l
= 0;
4823 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4825 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4826 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4827 > S_GET_VALUE (sym
))
4829 csect
= symbol_get_tc (csect
)->next
;
4832 a
->x_csect
.x_scnlen
.p
=
4833 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4834 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4837 a
->x_csect
.x_smtyp
= XTY_LD
;
4840 a
->x_csect
.x_parmhash
= 0;
4841 a
->x_csect
.x_snhash
= 0;
4842 if (symbol_get_tc (sym
)->class == -1)
4843 a
->x_csect
.x_smclas
= XMC_PR
;
4845 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4846 a
->x_csect
.x_stab
= 0;
4847 a
->x_csect
.x_snstab
= 0;
4849 /* Don't let the COFF backend resort these symbols. */
4850 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4852 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4854 /* We want the value to be the symbol index of the referenced
4855 csect symbol. BFD will do that for us if we set the right
4859 coffsymbol (symbol_get_bfdsym
4860 (symbol_get_tc (sym
)->within
))->native
));
4861 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4863 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4868 /* The value is the offset from the enclosing csect. */
4869 block
= symbol_get_tc (sym
)->within
;
4870 csect
= symbol_get_tc (block
)->within
;
4871 resolve_symbol_value (csect
);
4872 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4874 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4875 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4877 /* We want the value to be a file offset into the line numbers.
4878 BFD will do that for us if we set the right flags. We have
4879 already set the value correctly. */
4880 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4886 /* Adjust the symbol table. This creates csect symbols for all
4887 absolute symbols. */
4890 ppc_adjust_symtab ()
4897 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
4901 union internal_auxent
*a
;
4903 if (S_GET_SEGMENT (sym
) != absolute_section
)
4906 csect
= symbol_create (".abs[XO]", absolute_section
,
4907 S_GET_VALUE (sym
), &zero_address_frag
);
4908 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
4909 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
4910 i
= S_GET_NUMBER_AUXILIARY (csect
);
4911 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
4912 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
4913 a
->x_csect
.x_scnlen
.l
= 0;
4914 a
->x_csect
.x_smtyp
= XTY_SD
;
4915 a
->x_csect
.x_parmhash
= 0;
4916 a
->x_csect
.x_snhash
= 0;
4917 a
->x_csect
.x_smclas
= XMC_XO
;
4918 a
->x_csect
.x_stab
= 0;
4919 a
->x_csect
.x_snstab
= 0;
4921 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
4923 i
= S_GET_NUMBER_AUXILIARY (sym
);
4924 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
4925 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
4926 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
4929 ppc_saw_abs
= false;
4932 /* Set the VMA for a section. This is called on all the sections in
4936 ppc_frob_section (sec
)
4939 static bfd_size_type vma
= 0;
4941 bfd_set_section_vma (stdoutput
, sec
, vma
);
4942 vma
+= bfd_section_size (stdoutput
, sec
);
4945 #endif /* OBJ_XCOFF */
4947 /* Turn a string in input_line_pointer into a floating point constant
4948 of type TYPE, and store the appropriate bytes in *LITP. The number
4949 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4950 returned, or NULL on OK. */
4953 md_atof (type
, litp
, sizep
)
4959 LITTLENUM_TYPE words
[4];
4975 return _("bad call to md_atof");
4978 t
= atof_ieee (input_line_pointer
, type
, words
);
4980 input_line_pointer
= t
;
4984 if (target_big_endian
)
4986 for (i
= 0; i
< prec
; i
++)
4988 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4994 for (i
= prec
- 1; i
>= 0; i
--)
4996 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5004 /* Write a value out to the object file, using the appropriate
5008 md_number_to_chars (buf
, val
, n
)
5013 if (target_big_endian
)
5014 number_to_chars_bigendian (buf
, val
, n
);
5016 number_to_chars_littleendian (buf
, val
, n
);
5019 /* Align a section (I don't know why this is machine dependent). */
5022 md_section_align (seg
, addr
)
5026 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5028 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5031 /* We don't have any form of relaxing. */
5034 md_estimate_size_before_relax (fragp
, seg
)
5035 fragS
*fragp ATTRIBUTE_UNUSED
;
5036 asection
*seg ATTRIBUTE_UNUSED
;
5042 /* Convert a machine dependent frag. We never generate these. */
5045 md_convert_frag (abfd
, sec
, fragp
)
5046 bfd
*abfd ATTRIBUTE_UNUSED
;
5047 asection
*sec ATTRIBUTE_UNUSED
;
5048 fragS
*fragp ATTRIBUTE_UNUSED
;
5053 /* We have no need to default values of symbols. */
5056 md_undefined_symbol (name
)
5057 char *name ATTRIBUTE_UNUSED
;
5062 /* Functions concerning relocs. */
5064 /* The location from which a PC relative jump should be calculated,
5065 given a PC relative reloc. */
5068 md_pcrel_from_section (fixp
, sec
)
5070 segT sec ATTRIBUTE_UNUSED
;
5072 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5077 /* This is called to see whether a fixup should be adjusted to use a
5078 section symbol. We take the opportunity to change a fixup against
5079 a symbol in the TOC subsegment into a reloc against the
5080 corresponding .tc symbol. */
5083 ppc_fix_adjustable (fix
)
5088 resolve_symbol_value (fix
->fx_addsy
);
5089 val
= S_GET_VALUE (fix
->fx_addsy
);
5090 if (ppc_toc_csect
!= (symbolS
*) NULL
5091 && fix
->fx_addsy
!= (symbolS
*) NULL
5092 && fix
->fx_addsy
!= ppc_toc_csect
5093 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
5094 && val
>= ppc_toc_frag
->fr_address
5095 && (ppc_after_toc_frag
== (fragS
*) NULL
5096 || val
< ppc_after_toc_frag
->fr_address
))
5100 for (sy
= symbol_next (ppc_toc_csect
);
5101 sy
!= (symbolS
*) NULL
;
5102 sy
= symbol_next (sy
))
5104 if (symbol_get_tc (sy
)->class == XMC_TC0
)
5106 if (symbol_get_tc (sy
)->class != XMC_TC
)
5108 resolve_symbol_value (sy
);
5109 if (val
== S_GET_VALUE (sy
))
5112 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5117 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5118 _("symbol in .toc does not match any .tc"));
5121 /* Possibly adjust the reloc to be against the csect. */
5122 if (fix
->fx_addsy
!= (symbolS
*) NULL
5123 && symbol_get_tc (fix
->fx_addsy
)->subseg
== 0
5124 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC0
5125 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC
5126 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
5127 /* Don't adjust if this is a reloc in the toc section. */
5128 && (S_GET_SEGMENT (fix
->fx_addsy
) != data_section
5129 || ppc_toc_csect
== NULL
5130 || val
< ppc_toc_frag
->fr_address
5131 || (ppc_after_toc_frag
!= NULL
5132 && val
>= ppc_after_toc_frag
->fr_address
)))
5136 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
5137 csect
= ppc_text_csects
;
5138 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
5139 csect
= ppc_data_csects
;
5143 /* Skip the initial dummy symbol. */
5144 csect
= symbol_get_tc (csect
)->next
;
5146 if (csect
!= (symbolS
*) NULL
)
5148 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
5149 && (symbol_get_frag (symbol_get_tc (csect
)->next
)->fr_address
5152 /* If the csect address equals the symbol value, then we
5153 have to look through the full symbol table to see
5154 whether this is the csect we want. Note that we will
5155 only get here if the csect has zero length. */
5156 if ((symbol_get_frag (csect
)->fr_address
== val
)
5157 && S_GET_VALUE (csect
) == S_GET_VALUE (fix
->fx_addsy
))
5161 for (scan
= symbol_next (csect
);
5163 scan
= symbol_next (scan
))
5165 if (symbol_get_tc (scan
)->subseg
!= 0)
5167 if (scan
== fix
->fx_addsy
)
5171 /* If we found the symbol before the next csect
5172 symbol, then this is the csect we want. */
5173 if (scan
== fix
->fx_addsy
)
5177 csect
= symbol_get_tc (csect
)->next
;
5180 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
5181 - symbol_get_frag (csect
)->fr_address
);
5182 fix
->fx_addsy
= csect
;
5186 /* Adjust a reloc against a .lcomm symbol to be against the base
5188 if (fix
->fx_addsy
!= (symbolS
*) NULL
5189 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
5190 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5192 resolve_symbol_value (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
);
5194 (S_GET_VALUE (fix
->fx_addsy
)
5195 - S_GET_VALUE (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
));
5196 fix
->fx_addsy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5202 /* A reloc from one csect to another must be kept. The assembler
5203 will, of course, keep relocs between sections, and it will keep
5204 absolute relocs, but we need to force it to keep PC relative relocs
5205 between two csects in the same section. */
5208 ppc_force_relocation (fix
)
5211 /* At this point fix->fx_addsy should already have been converted to
5212 a csect symbol. If the csect does not include the fragment, then
5213 we need to force the relocation. */
5215 && fix
->fx_addsy
!= NULL
5216 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5217 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5218 > fix
->fx_frag
->fr_address
)
5219 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5220 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5221 <= fix
->fx_frag
->fr_address
))))
5227 #endif /* OBJ_XCOFF */
5231 ppc_fix_adjustable (fix
)
5234 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5235 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5236 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5237 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5238 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5239 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5240 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5241 && ! S_IS_EXTERNAL (fix
->fx_addsy
)
5242 && ! S_IS_WEAK (fix
->fx_addsy
)
5244 || (fix
->fx_subsy
!= NULL
5245 && (S_GET_SEGMENT (fix
->fx_subsy
)
5246 == S_GET_SEGMENT (fix
->fx_addsy
)))
5247 || S_IS_LOCAL (fix
->fx_addsy
)));
5251 /* Apply a fixup to the object code. This is called for all the
5252 fixups we generated by the call to fix_new_exp, above. In the call
5253 above we used a reloc code which was the largest legal reloc code
5254 plus the operand index. Here we undo that to recover the operand
5255 index. At this point all symbol values should be fully resolved,
5256 and we attempt to completely resolve the reloc. If we can not do
5257 that, we determine the correct reloc code and put it back in the
5261 md_apply_fix3 (fixP
, valP
, seg
)
5264 segT seg ATTRIBUTE_UNUSED
;
5266 valueT value
= * valP
;
5269 if (fixP
->fx_addsy
!= NULL
)
5271 /* `*valuep' may contain the value of the symbol on which the reloc
5272 will be based; we have to remove it. */
5273 if (symbol_used_in_reloc_p (fixP
->fx_addsy
)
5274 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
5275 && S_GET_SEGMENT (fixP
->fx_addsy
) != undefined_section
5276 && ! bfd_is_com_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
5277 value
-= S_GET_VALUE (fixP
->fx_addsy
);
5279 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
5280 supposed to be? I think this is related to various similar
5281 FIXMEs in tc-i386.c and tc-sparc.c. */
5283 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5288 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
5289 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5290 doing this relocation the code in write.c is going to call
5291 bfd_install_relocation, which is also going to use the symbol
5292 value. That means that if the reloc is fully resolved we want to
5293 use *valuep since bfd_install_relocation is not being used.
5294 However, if the reloc is not fully resolved we do not want to use
5295 *valuep, and must use fx_offset instead. However, if the reloc
5296 is PC relative, we do want to use *valuep since it includes the
5297 result of md_pcrel_from. This is confusing. */
5298 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5301 else if (fixP
->fx_pcrel
)
5306 value
= fixP
->fx_offset
;
5307 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5309 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
5310 value
-= S_GET_VALUE (fixP
->fx_subsy
);
5313 /* We can't actually support subtracting a symbol. */
5314 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5315 _("expression too complex"));
5321 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5324 const struct powerpc_operand
*operand
;
5328 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5330 operand
= &powerpc_operands
[opindex
];
5333 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5334 does not generate a reloc. It uses the offset of `sym' within its
5335 csect. Other usages, such as `.long sym', generate relocs. This
5336 is the documented behaviour of non-TOC symbols. */
5337 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5338 && operand
->bits
== 16
5339 && operand
->shift
== 0
5340 && (operand
->insert
== NULL
|| ppc_obj64
)
5341 && fixP
->fx_addsy
!= NULL
5342 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5343 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5344 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5345 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5347 value
= fixP
->fx_offset
;
5352 /* Fetch the instruction, insert the fully resolved operand
5353 value, and stuff the instruction back again. */
5354 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5355 if (target_big_endian
)
5356 insn
= bfd_getb32 ((unsigned char *) where
);
5358 insn
= bfd_getl32 ((unsigned char *) where
);
5359 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5360 fixP
->fx_file
, fixP
->fx_line
);
5361 if (target_big_endian
)
5362 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5364 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5367 /* Nothing else to do here. */
5370 assert (fixP
->fx_addsy
!= NULL
);
5372 /* Determine a BFD reloc value based on the operand information.
5373 We are only prepared to turn a few of the operands into
5375 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5376 && operand
->bits
== 26
5377 && operand
->shift
== 0)
5378 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5379 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5380 && operand
->bits
== 16
5381 && operand
->shift
== 0)
5383 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5386 if (target_big_endian
)
5387 fixP
->fx_where
+= 2;
5390 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5391 && operand
->bits
== 26
5392 && operand
->shift
== 0)
5393 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5394 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5395 && operand
->bits
== 16
5396 && operand
->shift
== 0)
5398 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5401 if (target_big_endian
)
5402 fixP
->fx_where
+= 2;
5405 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5406 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5407 && operand
->bits
== 16
5408 && operand
->shift
== 0
5409 && ppc_is_toc_sym (fixP
->fx_addsy
))
5411 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5414 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5415 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5418 if (target_big_endian
)
5419 fixP
->fx_where
+= 2;
5421 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5427 /* Use expr_symbol_where to see if this is an expression
5429 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5430 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5431 _("unresolved expression that must be resolved"));
5433 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5434 _("unsupported relocation against %s"),
5435 S_GET_NAME (fixP
->fx_addsy
));
5443 ppc_elf_validate_fix (fixP
, seg
);
5445 switch (fixP
->fx_r_type
)
5447 case BFD_RELOC_CTOR
:
5454 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5458 case BFD_RELOC_32_PCREL
:
5459 case BFD_RELOC_PPC_EMB_NADDR32
:
5460 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5467 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5470 case BFD_RELOC_64_PCREL
:
5471 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5475 case BFD_RELOC_LO16
:
5477 case BFD_RELOC_GPREL16
:
5478 case BFD_RELOC_16_GOT_PCREL
:
5479 case BFD_RELOC_16_GOTOFF
:
5480 case BFD_RELOC_LO16_GOTOFF
:
5481 case BFD_RELOC_HI16_GOTOFF
:
5482 case BFD_RELOC_HI16_S_GOTOFF
:
5483 case BFD_RELOC_16_BASEREL
:
5484 case BFD_RELOC_LO16_BASEREL
:
5485 case BFD_RELOC_HI16_BASEREL
:
5486 case BFD_RELOC_HI16_S_BASEREL
:
5487 case BFD_RELOC_PPC_EMB_NADDR16
:
5488 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5489 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5490 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5491 case BFD_RELOC_PPC_EMB_SDAI16
:
5492 case BFD_RELOC_PPC_EMB_SDA2REL
:
5493 case BFD_RELOC_PPC_EMB_SDA2I16
:
5494 case BFD_RELOC_PPC_EMB_RELSEC16
:
5495 case BFD_RELOC_PPC_EMB_RELST_LO
:
5496 case BFD_RELOC_PPC_EMB_RELST_HI
:
5497 case BFD_RELOC_PPC_EMB_RELST_HA
:
5498 case BFD_RELOC_PPC_EMB_RELSDA
:
5499 case BFD_RELOC_PPC_TOC16
:
5501 case BFD_RELOC_PPC64_TOC16_LO
:
5502 case BFD_RELOC_PPC64_TOC16_HI
:
5503 case BFD_RELOC_PPC64_TOC16_HA
:
5507 if (fixP
->fx_addsy
!= NULL
)
5508 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5509 _("cannot emit PC relative %s relocation against %s"),
5510 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5511 S_GET_NAME (fixP
->fx_addsy
));
5513 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5514 _("cannot emit PC relative %s relocation"),
5515 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5518 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5522 /* This case happens when you write, for example,
5524 where L1 and L2 are defined later. */
5525 case BFD_RELOC_HI16
:
5528 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5532 case BFD_RELOC_HI16_S
:
5535 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5540 case BFD_RELOC_PPC64_HIGHER
:
5543 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5544 PPC_HIGHER (value
), 2);
5547 case BFD_RELOC_PPC64_HIGHER_S
:
5550 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5551 PPC_HIGHERA (value
), 2);
5554 case BFD_RELOC_PPC64_HIGHEST
:
5557 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5558 PPC_HIGHEST (value
), 2);
5561 case BFD_RELOC_PPC64_HIGHEST_S
:
5564 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5565 PPC_HIGHESTA (value
), 2);
5568 case BFD_RELOC_PPC64_ADDR16_DS
:
5569 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5570 case BFD_RELOC_PPC64_GOT16_DS
:
5571 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5572 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5573 case BFD_RELOC_PPC64_SECTOFF_DS
:
5574 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5575 case BFD_RELOC_PPC64_TOC16_DS
:
5576 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5577 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5578 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5582 unsigned char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5585 if (target_big_endian
)
5586 val
= bfd_getb16 (where
);
5588 val
= bfd_getl16 (where
);
5589 val
|= (value
& 0xfffc);
5590 if (target_big_endian
)
5591 bfd_putb16 ((bfd_vma
) val
, where
);
5593 bfd_putl16 ((bfd_vma
) val
, where
);
5597 /* Because SDA21 modifies the register field, the size is set to 4
5598 bytes, rather than 2, so offset it here appropriately. */
5599 case BFD_RELOC_PPC_EMB_SDA21
:
5603 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5604 + ((target_big_endian
) ? 2 : 0),
5612 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5616 case BFD_RELOC_24_PLT_PCREL
:
5617 case BFD_RELOC_PPC_LOCAL24PC
:
5618 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5626 /* Fetch the instruction, insert the fully resolved operand
5627 value, and stuff the instruction back again. */
5628 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5629 if (target_big_endian
)
5630 insn
= bfd_getb32 ((unsigned char *) where
);
5632 insn
= bfd_getl32 ((unsigned char *) where
);
5633 if ((value
& 3) != 0)
5634 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5635 _("must branch to an address a multiple of 4"));
5636 if ((offsetT
) value
< -0x40000000
5637 || (offsetT
) value
>= 0x40000000)
5638 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5639 _("@local or @plt branch destination is too far away, %ld bytes"),
5641 insn
= insn
| (value
& 0x03fffffc);
5642 if (target_big_endian
)
5643 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5645 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5649 case BFD_RELOC_VTABLE_INHERIT
:
5652 && !S_IS_DEFINED (fixP
->fx_addsy
)
5653 && !S_IS_WEAK (fixP
->fx_addsy
))
5654 S_SET_WEAK (fixP
->fx_addsy
);
5657 case BFD_RELOC_VTABLE_ENTRY
:
5662 /* Generated by reference to `sym@tocbase'. The sym is
5663 ignored by the linker. */
5664 case BFD_RELOC_PPC64_TOC
:
5670 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
5677 fixP
->fx_addnumber
= value
;
5679 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5680 fixP
->fx_addnumber
= 0;
5684 fixP
->fx_addnumber
= 0;
5686 /* We want to use the offset within the data segment of the
5687 symbol, not the actual VMA of the symbol. */
5688 fixP
->fx_addnumber
=
5689 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
5695 /* Generate a reloc for a fixup. */
5698 tc_gen_reloc (seg
, fixp
)
5699 asection
*seg ATTRIBUTE_UNUSED
;
5704 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5706 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5707 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5708 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5709 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5710 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5712 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5713 _("reloc %d not supported by object file format"),
5714 (int) fixp
->fx_r_type
);
5717 reloc
->addend
= fixp
->fx_addnumber
;