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 /* Certain instructions (eg: extsw) do not exist in the
1211 32-bit BookE instruction set, but they do exist in the
1212 64-bit BookE instruction set, and other PPC instruction
1213 sets. Check to see if the opcode has the BOOKE64 flag set.
1214 If it does make sure that the target CPU is not the BookE32. */
1215 && ((op
->flags
& PPC_OPCODE_BOOKE64
) == 0
1216 || (ppc_cpu
& PPC_OPCODE_BOOKE64
) == PPC_OPCODE_BOOKE64
1217 || (ppc_cpu
& PPC_OPCODE_BOOKE
) == 0)
1218 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1219 || ((op
->flags
& PPC_OPCODE_POWER4
)
1220 == (ppc_cpu
& PPC_OPCODE_POWER4
))))
1224 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1225 if (retval
!= (const char *) NULL
)
1227 /* Ignore Power duplicates for -m601. */
1228 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1229 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1232 as_bad (_("Internal assembler error for instruction %s"),
1239 /* Insert the macros into a hash table. */
1240 ppc_macro_hash
= hash_new ();
1242 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1243 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1245 if ((macro
->flags
& ppc_cpu
) != 0)
1249 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1250 if (retval
!= (const char *) NULL
)
1252 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1261 /* Tell the main code what the endianness is if it is not overidden
1263 if (!set_target_endian
)
1265 set_target_endian
= 1;
1266 target_big_endian
= PPC_BIG_ENDIAN
;
1270 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1272 /* Create dummy symbols to serve as initial csects. This forces the
1273 text csects to precede the data csects. These symbols will not
1275 ppc_text_csects
= symbol_make ("dummy\001");
1276 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1277 ppc_data_csects
= symbol_make ("dummy\001");
1278 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1283 ppc_current_section
= text_section
;
1284 ppc_previous_section
= 0;
1293 if (ppc_apuinfo_list
== NULL
)
1296 /* Ok, so write the section info out. We have this layout:
1300 0 8 length of "APUinfo\0"
1301 4 (n*4) number of APU's (4 bytes each)
1304 20 APU#1 first APU's info
1305 24 APU#2 second APU's info
1310 asection
*seg
= now_seg
;
1311 subsegT subseg
= now_subseg
;
1312 asection
*apuinfo_secp
= (asection
*) NULL
;
1315 /* Create the .PPC.EMB.apuinfo section. */
1316 apuinfo_secp
= subseg_new (".PPC.EMB.apuinfo", 0);
1317 bfd_set_section_flags (stdoutput
,
1319 SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_MERGE
);
1322 md_number_to_chars (p
, (valueT
) 8, 4);
1325 md_number_to_chars (p
, (valueT
) ppc_apuinfo_num
, 4);
1328 md_number_to_chars (p
, (valueT
) 2, 4);
1331 strcpy (p
, "APUinfo");
1333 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1336 md_number_to_chars (p
, (valueT
) ppc_apuinfo_list
[i
], 4);
1339 frag_align (2, 0, 0);
1341 /* We probably can't restore the current segment, for there likely
1344 subseg_set (seg
, subseg
);
1349 /* Insert an operand value into an instruction. */
1351 static unsigned long
1352 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1354 const struct powerpc_operand
*operand
;
1359 if (operand
->bits
!= 32)
1364 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1366 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1367 max
= (1 << operand
->bits
) - 1;
1369 max
= (1 << (operand
->bits
- 1)) - 1;
1370 min
= - (1 << (operand
->bits
- 1));
1374 /* Some people write 32 bit hex constants with the sign
1375 extension done by hand. This shouldn't really be
1376 valid, but, to permit this code to assemble on a 64
1377 bit host, we sign extend the 32 bit value. */
1379 && (val
& (offsetT
) 0x80000000) != 0
1380 && (val
& (offsetT
) 0xffffffff) == val
)
1389 max
= (1 << operand
->bits
) - 1;
1393 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1398 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1401 _("operand out of range (%s not between %ld and %ld)");
1404 sprint_value (buf
, test
);
1405 as_bad_where (file
, line
, err
, buf
, min
, max
);
1409 if (operand
->insert
)
1414 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1415 if (errmsg
!= (const char *) NULL
)
1416 as_bad_where (file
, line
, errmsg
);
1419 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1427 /* Parse @got, etc. and return the desired relocation. */
1428 static bfd_reloc_code_real_type
1429 ppc_elf_suffix (str_p
, exp_p
)
1444 const struct map_bfd
*ptr
;
1446 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1448 static const struct map_bfd mapping
[] = {
1449 MAP ("l", (int) BFD_RELOC_LO16
),
1450 MAP ("h", (int) BFD_RELOC_HI16
),
1451 MAP ("ha", (int) BFD_RELOC_HI16_S
),
1452 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN
),
1453 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN
),
1454 MAP ("got", (int) BFD_RELOC_16_GOTOFF
),
1455 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF
),
1456 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF
),
1457 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF
),
1458 MAP ("fixup", (int) BFD_RELOC_CTOR
), /* warning with -mrelocatable */
1459 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL
),
1460 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL
),
1461 MAP ("copy", (int) BFD_RELOC_PPC_COPY
),
1462 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT
),
1463 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC
),
1464 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC
),
1465 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL
),
1466 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF
),
1467 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF
),
1468 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF
),
1469 MAP ("sdarel", (int) BFD_RELOC_GPREL16
),
1470 MAP ("sectoff", (int) BFD_RELOC_16_BASEREL
),
1471 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL
),
1472 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL
),
1473 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL
),
1474 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32
),
1475 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16
),
1476 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO
),
1477 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI
),
1478 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA
),
1479 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16
),
1480 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL
),
1481 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16
),
1482 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21
),
1483 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF
),
1484 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16
),
1485 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO
),
1486 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI
),
1487 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA
),
1488 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD
),
1489 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA
),
1490 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16
),
1491 /* The following are only valid for ppc64. Negative values are
1492 used instead of a flag. */
1493 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER
),
1494 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S
),
1495 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST
),
1496 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S
),
1497 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC
),
1498 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16
),
1499 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO
),
1500 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI
),
1501 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA
),
1502 { (char *) 0, 0, (int) BFD_RELOC_UNUSED
}
1506 return BFD_RELOC_UNUSED
;
1508 for (ch
= *str
, str2
= ident
;
1509 (str2
< ident
+ sizeof (ident
) - 1
1510 && (ISALNUM (ch
) || ch
== '@'));
1513 *str2
++ = TOLOWER (ch
);
1520 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1521 if (ch
== ptr
->string
[0]
1522 && len
== ptr
->length
1523 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1525 int reloc
= ptr
->reloc
;
1530 return BFD_RELOC_UNUSED
;
1534 if (exp_p
->X_add_number
!= 0
1535 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1536 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1537 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1538 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1539 as_warn (_("identifier+constant@got means identifier@got+constant"));
1541 /* Now check for identifier@suffix+constant. */
1542 if (*str
== '-' || *str
== '+')
1544 char *orig_line
= input_line_pointer
;
1545 expressionS new_exp
;
1547 input_line_pointer
= str
;
1548 expression (&new_exp
);
1549 if (new_exp
.X_op
== O_constant
)
1551 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1552 str
= input_line_pointer
;
1555 if (&input_line_pointer
!= str_p
)
1556 input_line_pointer
= orig_line
;
1560 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1561 && exp_p
->X_op
== O_symbol
)
1563 /* This reloc type ignores the symbol. Change the symbol
1564 so that the dummy .TOC. symbol can be omitted from the
1566 exp_p
->X_add_symbol
= &abs_symbol
;
1569 return (bfd_reloc_code_real_type
) reloc
;
1572 return BFD_RELOC_UNUSED
;
1575 /* Like normal .long/.short/.word, except support @got, etc.
1576 Clobbers input_line_pointer, checks end-of-line. */
1578 ppc_elf_cons (nbytes
)
1579 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1582 bfd_reloc_code_real_type reloc
;
1584 if (is_it_end_of_statement ())
1586 demand_empty_rest_of_line ();
1593 if (exp
.X_op
== O_symbol
1594 && *input_line_pointer
== '@'
1595 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1596 &exp
)) != BFD_RELOC_UNUSED
)
1598 reloc_howto_type
*reloc_howto
;
1601 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1602 size
= bfd_get_reloc_size (reloc_howto
);
1606 as_bad (_("%s relocations do not fit in %d bytes\n"),
1607 reloc_howto
->name
, nbytes
);
1614 p
= frag_more (nbytes
);
1616 if (target_big_endian
)
1617 offset
= nbytes
- size
;
1618 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1623 emit_expr (&exp
, (unsigned int) nbytes
);
1625 while (*input_line_pointer
++ == ',');
1627 /* Put terminator back into stream. */
1628 input_line_pointer
--;
1629 demand_empty_rest_of_line ();
1632 /* Solaris pseduo op to change to the .rodata section. */
1637 char *save_line
= input_line_pointer
;
1638 static char section
[] = ".rodata\n";
1640 /* Just pretend this is .section .rodata */
1641 input_line_pointer
= section
;
1642 obj_elf_section (xxx
);
1644 input_line_pointer
= save_line
;
1647 /* Pseudo op to make file scope bss items. */
1650 int xxx ATTRIBUTE_UNUSED
;
1652 register char *name
;
1656 register symbolS
*symbolP
;
1663 name
= input_line_pointer
;
1664 c
= get_symbol_end ();
1666 /* just after name is now '\0'. */
1667 p
= input_line_pointer
;
1670 if (*input_line_pointer
!= ',')
1672 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1673 ignore_rest_of_line ();
1677 input_line_pointer
++; /* skip ',' */
1678 if ((size
= get_absolute_expression ()) < 0)
1680 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1681 ignore_rest_of_line ();
1685 /* The third argument to .lcomm is the alignment. */
1686 if (*input_line_pointer
!= ',')
1690 ++input_line_pointer
;
1691 align
= get_absolute_expression ();
1694 as_warn (_("ignoring bad alignment"));
1700 symbolP
= symbol_find_or_make (name
);
1703 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1705 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1706 S_GET_NAME (symbolP
));
1707 ignore_rest_of_line ();
1711 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1713 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1714 S_GET_NAME (symbolP
),
1715 (long) S_GET_VALUE (symbolP
),
1718 ignore_rest_of_line ();
1724 old_subsec
= now_subseg
;
1727 /* Convert to a power of 2 alignment. */
1728 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1731 as_bad (_("Common alignment not a power of 2"));
1732 ignore_rest_of_line ();
1739 record_alignment (bss_section
, align2
);
1740 subseg_set (bss_section
, 0);
1742 frag_align (align2
, 0, 0);
1743 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1744 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1745 symbol_set_frag (symbolP
, frag_now
);
1746 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1749 S_SET_SIZE (symbolP
, size
);
1750 S_SET_SEGMENT (symbolP
, bss_section
);
1751 subseg_set (old_sec
, old_subsec
);
1752 demand_empty_rest_of_line ();
1755 /* Validate any relocations emitted for -mrelocatable, possibly adding
1756 fixups for word relocations in writable segments, so we can adjust
1759 ppc_elf_validate_fix (fixp
, seg
)
1763 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1772 case SHLIB_MRELOCATABLE
:
1773 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1774 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1775 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1776 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1777 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1778 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1779 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1780 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1781 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1782 && (seg
->flags
& SEC_LOAD
) != 0
1783 && strcmp (segment_name (seg
), ".got2") != 0
1784 && strcmp (segment_name (seg
), ".dtors") != 0
1785 && strcmp (segment_name (seg
), ".ctors") != 0
1786 && strcmp (segment_name (seg
), ".fixup") != 0
1787 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1788 && strcmp (segment_name (seg
), ".eh_frame") != 0
1789 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1791 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1792 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1794 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1795 _("Relocation cannot be done when using -mrelocatable"));
1802 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1803 function descriptor sym if the corresponding code sym is used. */
1806 ppc_frob_file_before_adjust ()
1813 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1820 name
= S_GET_NAME (symp
);
1824 if (! S_IS_WEAK (symp
)
1825 || S_IS_DEFINED (symp
))
1828 len
= strlen (name
) + 1;
1829 dotname
= xmalloc (len
+ 1);
1831 memcpy (dotname
+ 1, name
, len
);
1832 dotsym
= symbol_find (dotname
);
1834 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1835 || symbol_used_in_reloc_p (dotsym
)))
1837 symbol_mark_used (symp
);
1841 /* Don't emit .TOC. symbol. */
1842 symp
= symbol_find (".TOC.");
1844 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1846 #endif /* OBJ_ELF */
1851 * Summary of parse_toc_entry.
1853 * in: Input_line_pointer points to the '[' in one of:
1855 * [toc] [tocv] [toc32] [toc64]
1857 * Anything else is an error of one kind or another.
1860 * return value: success or failure
1861 * toc_kind: kind of toc reference
1862 * input_line_pointer:
1863 * success: first char after the ']'
1864 * failure: unchanged
1868 * [toc] - rv == success, toc_kind = default_toc
1869 * [tocv] - rv == success, toc_kind = data_in_toc
1870 * [toc32] - rv == success, toc_kind = must_be_32
1871 * [toc64] - rv == success, toc_kind = must_be_64
1875 enum toc_size_qualifier
1877 default_toc
, /* The toc cell constructed should be the system default size */
1878 data_in_toc
, /* This is a direct reference to a toc cell */
1879 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1880 must_be_64
/* The toc cell constructed must be 64 bits wide */
1884 parse_toc_entry (toc_kind
)
1885 enum toc_size_qualifier
*toc_kind
;
1890 enum toc_size_qualifier t
;
1892 /* Save the input_line_pointer. */
1893 start
= input_line_pointer
;
1895 /* Skip over the '[' , and whitespace. */
1896 ++input_line_pointer
;
1899 /* Find the spelling of the operand. */
1900 toc_spec
= input_line_pointer
;
1901 c
= get_symbol_end ();
1903 if (strcmp (toc_spec
, "toc") == 0)
1907 else if (strcmp (toc_spec
, "tocv") == 0)
1911 else if (strcmp (toc_spec
, "toc32") == 0)
1915 else if (strcmp (toc_spec
, "toc64") == 0)
1921 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1922 *input_line_pointer
= c
;
1923 input_line_pointer
= start
;
1927 /* Now find the ']'. */
1928 *input_line_pointer
= c
;
1930 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1931 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1935 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1936 input_line_pointer
= start
;
1947 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
1949 ppc_apuinfo_section_add (apu
, version
)
1950 unsigned int apu
, version
;
1954 /* Check we don't already exist. */
1955 for (i
= 0; i
< ppc_apuinfo_num
; i
++)
1956 if (ppc_apuinfo_list
[i
] == APUID (apu
, version
))
1959 if (ppc_apuinfo_num
== ppc_apuinfo_num_alloc
)
1961 if (ppc_apuinfo_num_alloc
== 0)
1963 ppc_apuinfo_num_alloc
= 4;
1964 ppc_apuinfo_list
= (unsigned long *)
1965 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
1969 ppc_apuinfo_num_alloc
+= 4;
1970 ppc_apuinfo_list
= (unsigned long *) xrealloc (ppc_apuinfo_list
,
1971 sizeof (unsigned long) * ppc_apuinfo_num_alloc
);
1974 ppc_apuinfo_list
[ppc_apuinfo_num
++] = APUID (apu
, version
);
1980 /* We need to keep a list of fixups. We can't simply generate them as
1981 we go, because that would require us to first create the frag, and
1982 that would screw up references to ``.''. */
1988 bfd_reloc_code_real_type reloc
;
1991 #define MAX_INSN_FIXUPS (5)
1993 /* This routine is called for each instruction to be assembled. */
2000 const struct powerpc_opcode
*opcode
;
2002 const unsigned char *opindex_ptr
;
2006 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
2011 bfd_reloc_code_real_type reloc
;
2014 /* Get the opcode. */
2015 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
2020 /* Look up the opcode in the hash table. */
2021 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
2022 if (opcode
== (const struct powerpc_opcode
*) NULL
)
2024 const struct powerpc_macro
*macro
;
2026 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
2027 if (macro
== (const struct powerpc_macro
*) NULL
)
2028 as_bad (_("Unrecognized opcode: `%s'"), str
);
2030 ppc_macro (s
, macro
);
2035 insn
= opcode
->opcode
;
2038 while (ISSPACE (*str
))
2041 /* PowerPC operands are just expressions. The only real issue is
2042 that a few operand types are optional. All cases which might use
2043 an optional operand separate the operands only with commas (in
2044 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
2045 cases never have optional operands). There is never more than
2046 one optional operand for an instruction. So, before we start
2047 seriously parsing the operands, we check to see if we have an
2048 optional operand, and, if we do, we count the number of commas to
2049 see whether the operand should be omitted. */
2051 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2053 const struct powerpc_operand
*operand
;
2055 operand
= &powerpc_operands
[*opindex_ptr
];
2056 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
2058 unsigned int opcount
;
2060 /* There is an optional operand. Count the number of
2061 commas in the input line. */
2068 while ((s
= strchr (s
, ',')) != (char *) NULL
)
2075 /* If there are fewer operands in the line then are called
2076 for by the instruction, we want to skip the optional
2078 if (opcount
< strlen (opcode
->operands
))
2085 /* Gather the operands. */
2089 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2091 const struct powerpc_operand
*operand
;
2097 if (next_opindex
== 0)
2098 operand
= &powerpc_operands
[*opindex_ptr
];
2101 operand
= &powerpc_operands
[next_opindex
];
2106 /* If this is a fake operand, then we do not expect anything
2108 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
2110 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2111 if (errmsg
!= (const char *) NULL
)
2116 /* If this is an optional operand, and we are skipping it, just
2118 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
2121 if (operand
->insert
)
2123 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
2124 if (errmsg
!= (const char *) NULL
)
2127 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
2128 next_opindex
= *opindex_ptr
+ 1;
2132 /* Gather the operand. */
2133 hold
= input_line_pointer
;
2134 input_line_pointer
= str
;
2137 if (*input_line_pointer
== '[')
2139 /* We are expecting something like the second argument here:
2141 * lwz r4,[toc].GS.0.static_int(rtoc)
2142 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2143 * The argument following the `]' must be a symbol name, and the
2144 * register must be the toc register: 'rtoc' or '2'
2146 * The effect is to 0 as the displacement field
2147 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2148 * the appropriate variation) reloc against it based on the symbol.
2149 * The linker will build the toc, and insert the resolved toc offset.
2152 * o The size of the toc entry is currently assumed to be
2153 * 32 bits. This should not be assumed to be a hard coded
2155 * o In an effort to cope with a change from 32 to 64 bits,
2156 * there are also toc entries that are specified to be
2157 * either 32 or 64 bits:
2158 * lwz r4,[toc32].GS.0.static_int(rtoc)
2159 * lwz r4,[toc64].GS.0.static_int(rtoc)
2160 * These demand toc entries of the specified size, and the
2161 * instruction probably requires it.
2165 enum toc_size_qualifier toc_kind
;
2166 bfd_reloc_code_real_type toc_reloc
;
2168 /* Go parse off the [tocXX] part. */
2169 valid_toc
= parse_toc_entry (&toc_kind
);
2173 /* Note: message has already been issued.
2174 FIXME: what sort of recovery should we do?
2175 demand_rest_of_line (); return; ? */
2178 /* Now get the symbol following the ']'. */
2184 /* In this case, we may not have seen the symbol yet,
2185 since it is allowed to appear on a .extern or .globl
2186 or just be a label in the .data section. */
2187 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2190 /* 1. The symbol must be defined and either in the toc
2191 section, or a global.
2192 2. The reloc generated must have the TOCDEFN flag set
2193 in upper bit mess of the reloc type.
2194 FIXME: It's a little confusing what the tocv
2195 qualifier can be used for. At the very least, I've
2196 seen three uses, only one of which I'm sure I can
2198 if (ex
.X_op
== O_symbol
)
2200 assert (ex
.X_add_symbol
!= NULL
);
2201 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2204 as_bad (_("[tocv] symbol is not a toc symbol"));
2208 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2211 /* FIXME: these next two specifically specify 32/64 bit
2212 toc entries. We don't support them today. Is this
2213 the right way to say that? */
2214 toc_reloc
= BFD_RELOC_UNUSED
;
2215 as_bad (_("Unimplemented toc32 expression modifier"));
2218 /* FIXME: see above. */
2219 toc_reloc
= BFD_RELOC_UNUSED
;
2220 as_bad (_("Unimplemented toc64 expression modifier"));
2224 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2230 /* We need to generate a fixup for this expression. */
2231 if (fc
>= MAX_INSN_FIXUPS
)
2232 as_fatal (_("too many fixups"));
2234 fixups
[fc
].reloc
= toc_reloc
;
2235 fixups
[fc
].exp
= ex
;
2236 fixups
[fc
].opindex
= *opindex_ptr
;
2239 /* Ok. We've set up the fixup for the instruction. Now make it
2240 look like the constant 0 was found here. */
2242 ex
.X_op
= O_constant
;
2243 ex
.X_add_number
= 0;
2244 ex
.X_add_symbol
= NULL
;
2245 ex
.X_op_symbol
= NULL
;
2251 if (! register_name (&ex
))
2253 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2260 str
= input_line_pointer
;
2261 input_line_pointer
= hold
;
2263 if (ex
.X_op
== O_illegal
)
2264 as_bad (_("illegal operand"));
2265 else if (ex
.X_op
== O_absent
)
2266 as_bad (_("missing operand"));
2267 else if (ex
.X_op
== O_register
)
2269 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2272 else if (ex
.X_op
== O_constant
)
2275 /* Allow @HA, @L, @H on constants. */
2276 char *orig_str
= str
;
2278 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2285 case BFD_RELOC_LO16
:
2286 /* X_unsigned is the default, so if the user has done
2287 something which cleared it, we always produce a
2289 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2290 ex
.X_add_number
&= 0xffff;
2292 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2295 case BFD_RELOC_HI16
:
2296 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2297 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2299 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2302 case BFD_RELOC_HI16_S
:
2303 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2304 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2306 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2309 case BFD_RELOC_PPC64_HIGHER
:
2310 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2311 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2313 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2316 case BFD_RELOC_PPC64_HIGHER_S
:
2317 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2318 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2320 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2323 case BFD_RELOC_PPC64_HIGHEST
:
2324 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2325 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2327 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2330 case BFD_RELOC_PPC64_HIGHEST_S
:
2331 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2332 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2334 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2337 #endif /* OBJ_ELF */
2338 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2342 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2344 /* For the absolute forms of branches, convert the PC
2345 relative form back into the absolute. */
2346 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2350 case BFD_RELOC_PPC_B26
:
2351 reloc
= BFD_RELOC_PPC_BA26
;
2353 case BFD_RELOC_PPC_B16
:
2354 reloc
= BFD_RELOC_PPC_BA16
;
2356 case BFD_RELOC_PPC_B16_BRTAKEN
:
2357 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2359 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2360 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2368 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2373 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2375 case BFD_RELOC_LO16
:
2376 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2378 case BFD_RELOC_16_GOTOFF
:
2379 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2381 case BFD_RELOC_LO16_GOTOFF
:
2382 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2384 case BFD_RELOC_LO16_PLTOFF
:
2385 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2387 case BFD_RELOC_16_BASEREL
:
2388 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2390 case BFD_RELOC_LO16_BASEREL
:
2391 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2393 case BFD_RELOC_PPC_TOC16
:
2394 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2396 case BFD_RELOC_PPC64_TOC16_LO
:
2397 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2399 case BFD_RELOC_PPC64_PLTGOT16
:
2400 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2402 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2403 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2406 as_bad (_("unsupported relocation for DS offset field"));
2411 /* We need to generate a fixup for this expression. */
2412 if (fc
>= MAX_INSN_FIXUPS
)
2413 as_fatal (_("too many fixups"));
2414 fixups
[fc
].exp
= ex
;
2415 fixups
[fc
].opindex
= 0;
2416 fixups
[fc
].reloc
= reloc
;
2419 #endif /* OBJ_ELF */
2423 /* We need to generate a fixup for this expression. */
2424 if (fc
>= MAX_INSN_FIXUPS
)
2425 as_fatal (_("too many fixups"));
2426 fixups
[fc
].exp
= ex
;
2427 fixups
[fc
].opindex
= *opindex_ptr
;
2428 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2437 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2445 /* The call to expression should have advanced str past any
2448 && (endc
!= ',' || *str
!= '\0'))
2450 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2458 while (ISSPACE (*str
))
2462 as_bad (_("junk at end of line: `%s'"), str
);
2465 /* Do we need/want a APUinfo section? */
2466 if (ppc_cpu
& (PPC_OPCODE_SPE
2467 | PPC_OPCODE_ISEL
| PPC_OPCODE_EFS
2468 | PPC_OPCODE_BRLOCK
| PPC_OPCODE_PMR
| PPC_OPCODE_CACHELCK
2469 | PPC_OPCODE_RFMCI
))
2471 /* These are all version "1". */
2472 if (opcode
->flags
& PPC_OPCODE_SPE
)
2473 ppc_apuinfo_section_add (PPC_APUINFO_SPE
, 1);
2474 if (opcode
->flags
& PPC_OPCODE_ISEL
)
2475 ppc_apuinfo_section_add (PPC_APUINFO_ISEL
, 1);
2476 if (opcode
->flags
& PPC_OPCODE_EFS
)
2477 ppc_apuinfo_section_add (PPC_APUINFO_EFS
, 1);
2478 if (opcode
->flags
& PPC_OPCODE_BRLOCK
)
2479 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK
, 1);
2480 if (opcode
->flags
& PPC_OPCODE_PMR
)
2481 ppc_apuinfo_section_add (PPC_APUINFO_PMR
, 1);
2482 if (opcode
->flags
& PPC_OPCODE_CACHELCK
)
2483 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK
, 1);
2484 if (opcode
->flags
& PPC_OPCODE_RFMCI
)
2485 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI
, 1);
2489 /* Write out the instruction. */
2491 md_number_to_chars (f
, insn
, 4);
2494 dwarf2_emit_insn (4);
2497 /* Create any fixups. At this point we do not use a
2498 bfd_reloc_code_real_type, but instead just use the
2499 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2500 handle fixups for any operand type, although that is admittedly
2501 not a very exciting feature. We pick a BFD reloc type in
2503 for (i
= 0; i
< fc
; i
++)
2505 const struct powerpc_operand
*operand
;
2507 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2508 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2510 reloc_howto_type
*reloc_howto
;
2515 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2519 size
= bfd_get_reloc_size (reloc_howto
);
2520 offset
= target_big_endian
? (4 - size
) : 0;
2522 if (size
< 1 || size
> 4)
2525 fixP
= fix_new_exp (frag_now
,
2526 f
- frag_now
->fr_literal
+ offset
,
2529 reloc_howto
->pc_relative
,
2532 /* Turn off complaints that the addend is too large for things like
2534 switch (fixups
[i
].reloc
)
2536 case BFD_RELOC_16_GOTOFF
:
2537 case BFD_RELOC_PPC_TOC16
:
2538 case BFD_RELOC_LO16
:
2539 case BFD_RELOC_HI16
:
2540 case BFD_RELOC_HI16_S
:
2542 case BFD_RELOC_PPC64_HIGHER
:
2543 case BFD_RELOC_PPC64_HIGHER_S
:
2544 case BFD_RELOC_PPC64_HIGHEST
:
2545 case BFD_RELOC_PPC64_HIGHEST_S
:
2547 fixP
->fx_no_overflow
= 1;
2554 fix_new_exp (frag_now
,
2555 f
- frag_now
->fr_literal
,
2558 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2559 ((bfd_reloc_code_real_type
)
2560 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2564 /* Handle a macro. Gather all the operands, transform them as
2565 described by the macro, and call md_assemble recursively. All the
2566 operands are separated by commas; we don't accept parentheses
2567 around operands here. */
2570 ppc_macro (str
, macro
)
2572 const struct powerpc_macro
*macro
;
2583 /* Gather the users operands into the operands array. */
2588 if (count
>= sizeof operands
/ sizeof operands
[0])
2590 operands
[count
++] = s
;
2591 s
= strchr (s
, ',');
2592 if (s
== (char *) NULL
)
2597 if (count
!= macro
->operands
)
2599 as_bad (_("wrong number of operands"));
2603 /* Work out how large the string must be (the size is unbounded
2604 because it includes user input). */
2606 format
= macro
->format
;
2607 while (*format
!= '\0')
2616 arg
= strtol (format
+ 1, &send
, 10);
2617 know (send
!= format
&& arg
>= 0 && arg
< count
);
2618 len
+= strlen (operands
[arg
]);
2623 /* Put the string together. */
2624 complete
= s
= (char *) alloca (len
+ 1);
2625 format
= macro
->format
;
2626 while (*format
!= '\0')
2632 arg
= strtol (format
+ 1, &send
, 10);
2633 strcpy (s
, operands
[arg
]);
2640 /* Assemble the constructed instruction. */
2641 md_assemble (complete
);
2645 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2648 ppc_section_letter (letter
, ptr_msg
)
2655 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2660 ppc_section_word (str
, len
)
2664 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2671 ppc_section_type (str
, len
)
2675 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2682 ppc_section_flags (flags
, attr
, type
)
2687 if (type
== SHT_ORDERED
)
2688 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2690 if (attr
& SHF_EXCLUDE
)
2691 flags
|= SEC_EXCLUDE
;
2695 #endif /* OBJ_ELF */
2698 /* Pseudo-op handling. */
2700 /* The .byte pseudo-op. This is similar to the normal .byte
2701 pseudo-op, but it can also take a single ASCII string. */
2705 int ignore ATTRIBUTE_UNUSED
;
2707 if (*input_line_pointer
!= '\"')
2713 /* Gather characters. A real double quote is doubled. Unusual
2714 characters are not permitted. */
2715 ++input_line_pointer
;
2720 c
= *input_line_pointer
++;
2724 if (*input_line_pointer
!= '\"')
2726 ++input_line_pointer
;
2729 FRAG_APPEND_1_CHAR (c
);
2732 demand_empty_rest_of_line ();
2737 /* XCOFF specific pseudo-op handling. */
2739 /* This is set if we are creating a .stabx symbol, since we don't want
2740 to handle symbol suffixes for such symbols. */
2741 static boolean ppc_stab_symbol
;
2743 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2744 symbols in the .bss segment as though they were local common
2745 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2746 aligns .comm and .lcomm to 4 bytes. */
2752 asection
*current_seg
= now_seg
;
2753 subsegT current_subseg
= now_subseg
;
2759 symbolS
*lcomm_sym
= NULL
;
2763 name
= input_line_pointer
;
2764 endc
= get_symbol_end ();
2765 end_name
= input_line_pointer
;
2768 if (*input_line_pointer
!= ',')
2770 as_bad (_("missing size"));
2771 ignore_rest_of_line ();
2774 ++input_line_pointer
;
2776 size
= get_absolute_expression ();
2779 as_bad (_("negative size"));
2780 ignore_rest_of_line ();
2786 /* The third argument to .comm is the alignment. */
2787 if (*input_line_pointer
!= ',')
2791 ++input_line_pointer
;
2792 align
= get_absolute_expression ();
2795 as_warn (_("ignoring bad alignment"));
2810 /* The third argument to .lcomm appears to be the real local
2811 common symbol to create. References to the symbol named in
2812 the first argument are turned into references to the third
2814 if (*input_line_pointer
!= ',')
2816 as_bad (_("missing real symbol name"));
2817 ignore_rest_of_line ();
2820 ++input_line_pointer
;
2822 lcomm_name
= input_line_pointer
;
2823 lcomm_endc
= get_symbol_end ();
2825 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2827 *input_line_pointer
= lcomm_endc
;
2831 sym
= symbol_find_or_make (name
);
2834 if (S_IS_DEFINED (sym
)
2835 || S_GET_VALUE (sym
) != 0)
2837 as_bad (_("attempt to redefine symbol"));
2838 ignore_rest_of_line ();
2842 record_alignment (bss_section
, align
);
2845 || ! S_IS_DEFINED (lcomm_sym
))
2854 S_SET_EXTERNAL (sym
);
2858 symbol_get_tc (lcomm_sym
)->output
= 1;
2859 def_sym
= lcomm_sym
;
2863 subseg_set (bss_section
, 1);
2864 frag_align (align
, 0, 0);
2866 symbol_set_frag (def_sym
, frag_now
);
2867 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2868 def_size
, (char *) NULL
);
2870 S_SET_SEGMENT (def_sym
, bss_section
);
2871 symbol_get_tc (def_sym
)->align
= align
;
2875 /* Align the size of lcomm_sym. */
2876 symbol_get_frag (lcomm_sym
)->fr_offset
=
2877 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2878 &~ ((1 << align
) - 1));
2879 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2880 symbol_get_tc (lcomm_sym
)->align
= align
;
2885 /* Make sym an offset from lcomm_sym. */
2886 S_SET_SEGMENT (sym
, bss_section
);
2887 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2888 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2889 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2892 subseg_set (current_seg
, current_subseg
);
2894 demand_empty_rest_of_line ();
2897 /* The .csect pseudo-op. This switches us into a different
2898 subsegment. The first argument is a symbol whose value is the
2899 start of the .csect. In COFF, csect symbols get special aux
2900 entries defined by the x_csect field of union internal_auxent. The
2901 optional second argument is the alignment (the default is 2). */
2905 int ignore ATTRIBUTE_UNUSED
;
2911 name
= input_line_pointer
;
2912 endc
= get_symbol_end ();
2914 sym
= symbol_find_or_make (name
);
2916 *input_line_pointer
= endc
;
2918 if (S_GET_NAME (sym
)[0] == '\0')
2920 /* An unnamed csect is assumed to be [PR]. */
2921 symbol_get_tc (sym
)->class = XMC_PR
;
2924 ppc_change_csect (sym
);
2926 if (*input_line_pointer
== ',')
2928 ++input_line_pointer
;
2929 symbol_get_tc (sym
)->align
= get_absolute_expression ();
2932 demand_empty_rest_of_line ();
2935 /* Change to a different csect. */
2938 ppc_change_csect (sym
)
2941 if (S_IS_DEFINED (sym
))
2942 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
2950 /* This is a new csect. We need to look at the symbol class to
2951 figure out whether it should go in the text section or the
2954 switch (symbol_get_tc (sym
)->class)
2964 S_SET_SEGMENT (sym
, text_section
);
2965 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
2966 ++ppc_text_subsegment
;
2967 list_ptr
= &ppc_text_csects
;
2976 if (ppc_toc_csect
!= NULL
2977 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
2978 == ppc_data_subsegment
))
2980 S_SET_SEGMENT (sym
, data_section
);
2981 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
2982 ++ppc_data_subsegment
;
2983 list_ptr
= &ppc_data_csects
;
2989 /* We set the obstack chunk size to a small value before
2990 changing subsegments, so that we don't use a lot of memory
2991 space for what may be a small section. */
2992 hold_chunksize
= chunksize
;
2995 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
2996 symbol_get_tc (sym
)->subseg
);
2998 chunksize
= hold_chunksize
;
3001 ppc_after_toc_frag
= frag_now
;
3003 symbol_set_frag (sym
, frag_now
);
3004 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3006 symbol_get_tc (sym
)->align
= 2;
3007 symbol_get_tc (sym
)->output
= 1;
3008 symbol_get_tc (sym
)->within
= sym
;
3010 for (list
= *list_ptr
;
3011 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3012 list
= symbol_get_tc (list
)->next
)
3014 symbol_get_tc (list
)->next
= sym
;
3016 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3017 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3021 ppc_current_csect
= sym
;
3024 /* This function handles the .text and .data pseudo-ops. These
3025 pseudo-ops aren't really used by XCOFF; we implement them for the
3026 convenience of people who aren't used to XCOFF. */
3037 else if (type
== 'd')
3042 sym
= symbol_find_or_make (name
);
3044 ppc_change_csect (sym
);
3046 demand_empty_rest_of_line ();
3049 /* This function handles the .section pseudo-op. This is mostly to
3050 give an error, since XCOFF only supports .text, .data and .bss, but
3051 we do permit the user to name the text or data section. */
3054 ppc_named_section (ignore
)
3055 int ignore ATTRIBUTE_UNUSED
;
3058 const char *real_name
;
3062 user_name
= input_line_pointer
;
3063 c
= get_symbol_end ();
3065 if (strcmp (user_name
, ".text") == 0)
3066 real_name
= ".text[PR]";
3067 else if (strcmp (user_name
, ".data") == 0)
3068 real_name
= ".data[RW]";
3071 as_bad (_("The XCOFF file format does not support arbitrary sections"));
3072 *input_line_pointer
= c
;
3073 ignore_rest_of_line ();
3077 *input_line_pointer
= c
;
3079 sym
= symbol_find_or_make (real_name
);
3081 ppc_change_csect (sym
);
3083 demand_empty_rest_of_line ();
3086 /* The .extern pseudo-op. We create an undefined symbol. */
3090 int ignore ATTRIBUTE_UNUSED
;
3095 name
= input_line_pointer
;
3096 endc
= get_symbol_end ();
3098 (void) symbol_find_or_make (name
);
3100 *input_line_pointer
= endc
;
3102 demand_empty_rest_of_line ();
3105 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3109 int ignore ATTRIBUTE_UNUSED
;
3115 name
= input_line_pointer
;
3116 endc
= get_symbol_end ();
3118 sym
= symbol_find_or_make (name
);
3120 *input_line_pointer
= endc
;
3122 symbol_get_tc (sym
)->output
= 1;
3124 demand_empty_rest_of_line ();
3127 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
3128 although I don't know why it bothers. */
3132 int ignore ATTRIBUTE_UNUSED
;
3139 name
= input_line_pointer
;
3140 endc
= get_symbol_end ();
3142 sym
= symbol_find_or_make (name
);
3144 *input_line_pointer
= endc
;
3146 if (*input_line_pointer
!= ',')
3148 as_bad (_("missing rename string"));
3149 ignore_rest_of_line ();
3152 ++input_line_pointer
;
3154 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
3156 demand_empty_rest_of_line ();
3159 /* The .stabx pseudo-op. This is similar to a normal .stabs
3160 pseudo-op, but slightly different. A sample is
3161 .stabx "main:F-1",.main,142,0
3162 The first argument is the symbol name to create. The second is the
3163 value, and the third is the storage class. The fourth seems to be
3164 always zero, and I am assuming it is the type. */
3168 int ignore ATTRIBUTE_UNUSED
;
3175 name
= demand_copy_C_string (&len
);
3177 if (*input_line_pointer
!= ',')
3179 as_bad (_("missing value"));
3182 ++input_line_pointer
;
3184 ppc_stab_symbol
= true;
3185 sym
= symbol_make (name
);
3186 ppc_stab_symbol
= false;
3188 symbol_get_tc (sym
)->real_name
= name
;
3190 (void) expression (&exp
);
3197 as_bad (_("illegal .stabx expression; zero assumed"));
3198 exp
.X_add_number
= 0;
3201 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3202 symbol_set_frag (sym
, &zero_address_frag
);
3206 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3207 symbol_set_value_expression (sym
, &exp
);
3211 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3212 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3217 /* The value is some complex expression. This will probably
3218 fail at some later point, but this is probably the right
3219 thing to do here. */
3220 symbol_set_value_expression (sym
, &exp
);
3224 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3225 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3227 if (*input_line_pointer
!= ',')
3229 as_bad (_("missing class"));
3232 ++input_line_pointer
;
3234 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3236 if (*input_line_pointer
!= ',')
3238 as_bad (_("missing type"));
3241 ++input_line_pointer
;
3243 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3245 symbol_get_tc (sym
)->output
= 1;
3247 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3249 symbol_get_tc (sym
)->within
= ppc_current_block
;
3254 .stabx "z",arrays_,133,0
3257 .comm arrays_,13768,3
3259 resolve_symbol_value will copy the exp's "within" into sym's when the
3260 offset is 0. Since this seems to be corner case problem,
3261 only do the correction for storage class C_STSYM. A better solution
3262 would be to have the tc field updated in ppc_symbol_new_hook. */
3264 if (exp
.X_op
== O_symbol
)
3266 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3270 if (exp
.X_op
!= O_symbol
3271 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3272 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3273 ppc_frob_label (sym
);
3276 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3277 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3278 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3279 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3282 demand_empty_rest_of_line ();
3285 /* The .function pseudo-op. This takes several arguments. The first
3286 argument seems to be the external name of the symbol. The second
3287 argment seems to be the label for the start of the function. gcc
3288 uses the same name for both. I have no idea what the third and
3289 fourth arguments are meant to be. The optional fifth argument is
3290 an expression for the size of the function. In COFF this symbol
3291 gets an aux entry like that used for a csect. */
3294 ppc_function (ignore
)
3295 int ignore ATTRIBUTE_UNUSED
;
3303 name
= input_line_pointer
;
3304 endc
= get_symbol_end ();
3306 /* Ignore any [PR] suffix. */
3307 name
= ppc_canonicalize_symbol_name (name
);
3308 s
= strchr (name
, '[');
3309 if (s
!= (char *) NULL
3310 && strcmp (s
+ 1, "PR]") == 0)
3313 ext_sym
= symbol_find_or_make (name
);
3315 *input_line_pointer
= endc
;
3317 if (*input_line_pointer
!= ',')
3319 as_bad (_("missing symbol name"));
3320 ignore_rest_of_line ();
3323 ++input_line_pointer
;
3325 name
= input_line_pointer
;
3326 endc
= get_symbol_end ();
3328 lab_sym
= symbol_find_or_make (name
);
3330 *input_line_pointer
= endc
;
3332 if (ext_sym
!= lab_sym
)
3336 exp
.X_op
= O_symbol
;
3337 exp
.X_add_symbol
= lab_sym
;
3338 exp
.X_op_symbol
= NULL
;
3339 exp
.X_add_number
= 0;
3341 symbol_set_value_expression (ext_sym
, &exp
);
3344 if (symbol_get_tc (ext_sym
)->class == -1)
3345 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3346 symbol_get_tc (ext_sym
)->output
= 1;
3348 if (*input_line_pointer
== ',')
3352 /* Ignore the third argument. */
3353 ++input_line_pointer
;
3354 expression (&ignore
);
3355 if (*input_line_pointer
== ',')
3357 /* Ignore the fourth argument. */
3358 ++input_line_pointer
;
3359 expression (&ignore
);
3360 if (*input_line_pointer
== ',')
3362 /* The fifth argument is the function size. */
3363 ++input_line_pointer
;
3364 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3367 &zero_address_frag
);
3368 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3373 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3374 SF_SET_FUNCTION (ext_sym
);
3375 SF_SET_PROCESS (ext_sym
);
3376 coff_add_linesym (ext_sym
);
3378 demand_empty_rest_of_line ();
3381 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3382 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3383 with the correct line number */
3385 static symbolS
*saved_bi_sym
= 0;
3389 int ignore ATTRIBUTE_UNUSED
;
3393 sym
= symbol_make (".bf");
3394 S_SET_SEGMENT (sym
, text_section
);
3395 symbol_set_frag (sym
, frag_now
);
3396 S_SET_VALUE (sym
, frag_now_fix ());
3397 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3399 coff_line_base
= get_absolute_expression ();
3401 S_SET_NUMBER_AUXILIARY (sym
, 1);
3402 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3404 /* Line number for bi. */
3407 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3412 symbol_get_tc (sym
)->output
= 1;
3414 ppc_frob_label (sym
);
3416 demand_empty_rest_of_line ();
3419 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3420 ".ef", except that the line number is absolute, not relative to the
3421 most recent ".bf" symbol. */
3425 int ignore ATTRIBUTE_UNUSED
;
3429 sym
= symbol_make (".ef");
3430 S_SET_SEGMENT (sym
, text_section
);
3431 symbol_set_frag (sym
, frag_now
);
3432 S_SET_VALUE (sym
, frag_now_fix ());
3433 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3434 S_SET_NUMBER_AUXILIARY (sym
, 1);
3435 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3436 symbol_get_tc (sym
)->output
= 1;
3438 ppc_frob_label (sym
);
3440 demand_empty_rest_of_line ();
3443 /* The .bi and .ei pseudo-ops. These take a string argument and
3444 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3445 the symbol list. The value of .bi will be know when the next .bf
3452 static symbolS
*last_biei
;
3459 name
= demand_copy_C_string (&len
);
3461 /* The value of these symbols is actually file offset. Here we set
3462 the value to the index into the line number entries. In
3463 ppc_frob_symbols we set the fix_line field, which will cause BFD
3464 to do the right thing. */
3466 sym
= symbol_make (name
);
3467 /* obj-coff.c currently only handles line numbers correctly in the
3469 S_SET_SEGMENT (sym
, text_section
);
3470 S_SET_VALUE (sym
, coff_n_line_nos
);
3471 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3473 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3474 symbol_get_tc (sym
)->output
= 1;
3482 for (look
= last_biei
? last_biei
: symbol_rootP
;
3483 (look
!= (symbolS
*) NULL
3484 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3485 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3486 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3487 look
= symbol_next (look
))
3489 if (look
!= (symbolS
*) NULL
)
3491 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3492 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3496 demand_empty_rest_of_line ();
3499 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3500 There is one argument, which is a csect symbol. The value of the
3501 .bs symbol is the index of this csect symbol. */
3505 int ignore ATTRIBUTE_UNUSED
;
3512 if (ppc_current_block
!= NULL
)
3513 as_bad (_("nested .bs blocks"));
3515 name
= input_line_pointer
;
3516 endc
= get_symbol_end ();
3518 csect
= symbol_find_or_make (name
);
3520 *input_line_pointer
= endc
;
3522 sym
= symbol_make (".bs");
3523 S_SET_SEGMENT (sym
, now_seg
);
3524 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3525 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3526 symbol_get_tc (sym
)->output
= 1;
3528 symbol_get_tc (sym
)->within
= csect
;
3530 ppc_frob_label (sym
);
3532 ppc_current_block
= sym
;
3534 demand_empty_rest_of_line ();
3537 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3541 int ignore ATTRIBUTE_UNUSED
;
3545 if (ppc_current_block
== NULL
)
3546 as_bad (_(".es without preceding .bs"));
3548 sym
= symbol_make (".es");
3549 S_SET_SEGMENT (sym
, now_seg
);
3550 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3551 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3552 symbol_get_tc (sym
)->output
= 1;
3554 ppc_frob_label (sym
);
3556 ppc_current_block
= NULL
;
3558 demand_empty_rest_of_line ();
3561 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3566 int ignore ATTRIBUTE_UNUSED
;
3570 sym
= symbol_make (".bb");
3571 S_SET_SEGMENT (sym
, text_section
);
3572 symbol_set_frag (sym
, frag_now
);
3573 S_SET_VALUE (sym
, frag_now_fix ());
3574 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3576 S_SET_NUMBER_AUXILIARY (sym
, 1);
3577 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3579 symbol_get_tc (sym
)->output
= 1;
3581 SF_SET_PROCESS (sym
);
3583 ppc_frob_label (sym
);
3585 demand_empty_rest_of_line ();
3588 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3593 int ignore ATTRIBUTE_UNUSED
;
3597 sym
= symbol_make (".eb");
3598 S_SET_SEGMENT (sym
, text_section
);
3599 symbol_set_frag (sym
, frag_now
);
3600 S_SET_VALUE (sym
, frag_now_fix ());
3601 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3602 S_SET_NUMBER_AUXILIARY (sym
, 1);
3603 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3604 symbol_get_tc (sym
)->output
= 1;
3606 SF_SET_PROCESS (sym
);
3608 ppc_frob_label (sym
);
3610 demand_empty_rest_of_line ();
3613 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3618 int ignore ATTRIBUTE_UNUSED
;
3624 name
= demand_copy_C_string (&len
);
3625 sym
= symbol_make (name
);
3626 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3627 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3628 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3629 S_SET_VALUE (sym
, 0);
3630 symbol_get_tc (sym
)->output
= 1;
3632 ppc_frob_label (sym
);
3634 demand_empty_rest_of_line ();
3637 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3641 int ignore ATTRIBUTE_UNUSED
;
3645 sym
= symbol_make (".ec");
3646 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3647 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3648 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3649 S_SET_VALUE (sym
, 0);
3650 symbol_get_tc (sym
)->output
= 1;
3652 ppc_frob_label (sym
);
3654 demand_empty_rest_of_line ();
3657 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3661 int ignore ATTRIBUTE_UNUSED
;
3663 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3664 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3671 subseg
= ppc_data_subsegment
;
3672 ++ppc_data_subsegment
;
3674 subseg_new (segment_name (data_section
), subseg
);
3675 ppc_toc_frag
= frag_now
;
3677 sym
= symbol_find_or_make ("TOC[TC0]");
3678 symbol_set_frag (sym
, frag_now
);
3679 S_SET_SEGMENT (sym
, data_section
);
3680 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3681 symbol_get_tc (sym
)->subseg
= subseg
;
3682 symbol_get_tc (sym
)->output
= 1;
3683 symbol_get_tc (sym
)->within
= sym
;
3685 ppc_toc_csect
= sym
;
3687 for (list
= ppc_data_csects
;
3688 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3689 list
= symbol_get_tc (list
)->next
)
3691 symbol_get_tc (list
)->next
= sym
;
3693 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3694 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3698 ppc_current_csect
= ppc_toc_csect
;
3700 demand_empty_rest_of_line ();
3703 /* The AIX assembler automatically aligns the operands of a .long or
3704 .short pseudo-op, and we want to be compatible. */
3707 ppc_xcoff_cons (log_size
)
3710 frag_align (log_size
, 0, 0);
3711 record_alignment (now_seg
, log_size
);
3712 cons (1 << log_size
);
3717 int dummy ATTRIBUTE_UNUSED
;
3722 (void) expression (&exp
);
3724 if (exp
.X_op
!= O_constant
)
3726 as_bad (_("non-constant byte count"));
3730 byte_count
= exp
.X_add_number
;
3732 if (*input_line_pointer
!= ',')
3734 as_bad (_("missing value"));
3738 ++input_line_pointer
;
3742 #endif /* OBJ_XCOFF */
3743 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3745 /* The .tc pseudo-op. This is used when generating either XCOFF or
3746 ELF. This takes two or more arguments.
3748 When generating XCOFF output, the first argument is the name to
3749 give to this location in the toc; this will be a symbol with class
3750 TC. The rest of the arguments are N-byte values to actually put at
3751 this location in the TOC; often there is just one more argument, a
3752 relocateable symbol reference. The size of the value to store
3753 depends on target word size. A 32-bit target uses 4-byte values, a
3754 64-bit target uses 8-byte values.
3756 When not generating XCOFF output, the arguments are the same, but
3757 the first argument is simply ignored. */
3761 int ignore ATTRIBUTE_UNUSED
;
3765 /* Define the TOC symbol name. */
3771 if (ppc_toc_csect
== (symbolS
*) NULL
3772 || ppc_toc_csect
!= ppc_current_csect
)
3774 as_bad (_(".tc not in .toc section"));
3775 ignore_rest_of_line ();
3779 name
= input_line_pointer
;
3780 endc
= get_symbol_end ();
3782 sym
= symbol_find_or_make (name
);
3784 *input_line_pointer
= endc
;
3786 if (S_IS_DEFINED (sym
))
3790 label
= symbol_get_tc (ppc_current_csect
)->within
;
3791 if (symbol_get_tc (label
)->class != XMC_TC0
)
3793 as_bad (_(".tc with no label"));
3794 ignore_rest_of_line ();
3798 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3799 symbol_set_frag (label
, symbol_get_frag (sym
));
3800 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3802 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3803 ++input_line_pointer
;
3808 S_SET_SEGMENT (sym
, now_seg
);
3809 symbol_set_frag (sym
, frag_now
);
3810 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3811 symbol_get_tc (sym
)->class = XMC_TC
;
3812 symbol_get_tc (sym
)->output
= 1;
3814 ppc_frob_label (sym
);
3817 #endif /* OBJ_XCOFF */
3821 /* Skip the TOC symbol name. */
3822 while (is_part_of_name (*input_line_pointer
)
3823 || *input_line_pointer
== '['
3824 || *input_line_pointer
== ']'
3825 || *input_line_pointer
== '{'
3826 || *input_line_pointer
== '}')
3827 ++input_line_pointer
;
3829 /* Align to a four/eight byte boundary. */
3830 align
= ppc_obj64
? 3 : 2;
3831 frag_align (align
, 0, 0);
3832 record_alignment (now_seg
, align
);
3833 #endif /* OBJ_ELF */
3835 if (*input_line_pointer
!= ',')
3836 demand_empty_rest_of_line ();
3839 ++input_line_pointer
;
3840 cons (ppc_obj64
? 8 : 4);
3844 /* Pseudo-op .machine. */
3845 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3846 accept this directive on the first line of input and set ppc_obj64
3847 and the target format accordingly. Unfortunately, the target
3848 format is selected in output-file.c:output_file_create before we
3849 even get to md_begin, so it's not possible without changing
3853 ppc_machine (ignore
)
3854 int ignore ATTRIBUTE_UNUSED
;
3856 discard_rest_of_line ();
3859 /* See whether a symbol is in the TOC section. */
3862 ppc_is_toc_sym (sym
)
3866 return symbol_get_tc (sym
)->class == XMC_TC
;
3869 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3871 return strcmp (sname
, ".toc") == 0;
3873 return strcmp (sname
, ".got") == 0;
3876 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3880 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3882 /* Set the current section. */
3884 ppc_set_current_section (new)
3887 ppc_previous_section
= ppc_current_section
;
3888 ppc_current_section
= new;
3891 /* pseudo-op: .previous
3892 behaviour: toggles the current section with the previous section.
3894 warnings: "No previous section" */
3897 ppc_previous (ignore
)
3898 int ignore ATTRIBUTE_UNUSED
;
3902 if (ppc_previous_section
== NULL
)
3904 as_warn (_("No previous section to return to. Directive ignored."));
3908 subseg_set (ppc_previous_section
, 0);
3910 ppc_set_current_section (ppc_previous_section
);
3913 /* pseudo-op: .pdata
3914 behaviour: predefined read only data section
3918 initial: .section .pdata "adr3"
3919 a - don't know -- maybe a misprint
3920 d - initialized data
3922 3 - double word aligned (that would be 4 byte boundary)
3925 Tag index tables (also known as the function table) for exception
3926 handling, debugging, etc. */
3930 int ignore ATTRIBUTE_UNUSED
;
3932 if (pdata_section
== 0)
3934 pdata_section
= subseg_new (".pdata", 0);
3936 bfd_set_section_flags (stdoutput
, pdata_section
,
3937 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3938 | SEC_READONLY
| SEC_DATA
));
3940 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
3944 pdata_section
= subseg_new (".pdata", 0);
3946 ppc_set_current_section (pdata_section
);
3949 /* pseudo-op: .ydata
3950 behaviour: predefined read only data section
3954 initial: .section .ydata "drw3"
3955 a - don't know -- maybe a misprint
3956 d - initialized data
3958 3 - double word aligned (that would be 4 byte boundary)
3960 Tag tables (also known as the scope table) for exception handling,
3965 int ignore ATTRIBUTE_UNUSED
;
3967 if (ydata_section
== 0)
3969 ydata_section
= subseg_new (".ydata", 0);
3970 bfd_set_section_flags (stdoutput
, ydata_section
,
3971 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3972 | SEC_READONLY
| SEC_DATA
));
3974 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
3978 ydata_section
= subseg_new (".ydata", 0);
3980 ppc_set_current_section (ydata_section
);
3983 /* pseudo-op: .reldata
3984 behaviour: predefined read write data section
3985 double word aligned (4-byte)
3986 FIXME: relocation is applied to it
3987 FIXME: what's the difference between this and .data?
3990 initial: .section .reldata "drw3"
3991 d - initialized data
3994 3 - double word aligned (that would be 8 byte boundary)
3997 Like .data, but intended to hold data subject to relocation, such as
3998 function descriptors, etc. */
4001 ppc_reldata (ignore
)
4002 int ignore ATTRIBUTE_UNUSED
;
4004 if (reldata_section
== 0)
4006 reldata_section
= subseg_new (".reldata", 0);
4008 bfd_set_section_flags (stdoutput
, reldata_section
,
4009 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4012 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
4016 reldata_section
= subseg_new (".reldata", 0);
4018 ppc_set_current_section (reldata_section
);
4021 /* pseudo-op: .rdata
4022 behaviour: predefined read only data section
4026 initial: .section .rdata "dr3"
4027 d - initialized data
4029 3 - double word aligned (that would be 4 byte boundary) */
4033 int ignore ATTRIBUTE_UNUSED
;
4035 if (rdata_section
== 0)
4037 rdata_section
= subseg_new (".rdata", 0);
4038 bfd_set_section_flags (stdoutput
, rdata_section
,
4039 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4040 | SEC_READONLY
| SEC_DATA
));
4042 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
4046 rdata_section
= subseg_new (".rdata", 0);
4048 ppc_set_current_section (rdata_section
);
4051 /* pseudo-op: .ualong
4052 behaviour: much like .int, with the exception that no alignment is
4054 FIXME: test the alignment statement
4060 int ignore ATTRIBUTE_UNUSED
;
4066 /* pseudo-op: .znop <symbol name>
4067 behaviour: Issue a nop instruction
4068 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4069 the supplied symbol name.
4071 warnings: Missing symbol name */
4075 int ignore ATTRIBUTE_UNUSED
;
4078 const struct powerpc_opcode
*opcode
;
4089 /* Strip out the symbol name. */
4090 symbol_name
= input_line_pointer
;
4091 c
= get_symbol_end ();
4093 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
4094 strcpy (name
, symbol_name
);
4096 sym
= symbol_find_or_make (name
);
4098 *input_line_pointer
= c
;
4102 /* Look up the opcode in the hash table. */
4103 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
4105 /* Stick in the nop. */
4106 insn
= opcode
->opcode
;
4108 /* Write out the instruction. */
4110 md_number_to_chars (f
, insn
, 4);
4112 f
- frag_now
->fr_literal
,
4117 BFD_RELOC_16_GOT_PCREL
);
4130 register char *name
;
4134 register symbolS
*symbolP
;
4137 name
= input_line_pointer
;
4138 c
= get_symbol_end ();
4140 /* just after name is now '\0'. */
4141 p
= input_line_pointer
;
4144 if (*input_line_pointer
!= ',')
4146 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4147 ignore_rest_of_line ();
4151 input_line_pointer
++; /* skip ',' */
4152 if ((temp
= get_absolute_expression ()) < 0)
4154 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
4155 ignore_rest_of_line ();
4161 /* The third argument to .comm is the alignment. */
4162 if (*input_line_pointer
!= ',')
4166 ++input_line_pointer
;
4167 align
= get_absolute_expression ();
4170 as_warn (_("ignoring bad alignment"));
4177 symbolP
= symbol_find_or_make (name
);
4180 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4182 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4183 S_GET_NAME (symbolP
));
4184 ignore_rest_of_line ();
4188 if (S_GET_VALUE (symbolP
))
4190 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4191 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4192 S_GET_NAME (symbolP
),
4193 (long) S_GET_VALUE (symbolP
),
4198 S_SET_VALUE (symbolP
, (valueT
) temp
);
4199 S_SET_EXTERNAL (symbolP
);
4202 demand_empty_rest_of_line ();
4206 * implement the .section pseudo op:
4207 * .section name {, "flags"}
4209 * | +--- optional flags: 'b' for bss
4211 * +-- section name 'l' for lib
4215 * 'd' (apparently m88k for data)
4217 * But if the argument is not a quoted string, treat it as a
4218 * subsegment number.
4220 * FIXME: this is a copy of the section processing from obj-coff.c, with
4221 * additions/changes for the moto-pas assembler support. There are three
4224 * FIXME: I just noticed this. This doesn't work at all really. It it
4225 * setting bits that bfd probably neither understands or uses. The
4226 * correct approach (?) will have to incorporate extra fields attached
4227 * to the section to hold the system specific stuff. (krk)
4230 * 'a' - unknown - referred to in documentation, but no definition supplied
4231 * 'c' - section has code
4232 * 'd' - section has initialized data
4233 * 'u' - section has uninitialized data
4234 * 'i' - section contains directives (info)
4235 * 'n' - section can be discarded
4236 * 'R' - remove section at link time
4238 * Section Protection:
4239 * 'r' - section is readable
4240 * 'w' - section is writeable
4241 * 'x' - section is executable
4242 * 's' - section is sharable
4244 * Section Alignment:
4245 * '0' - align to byte boundary
4246 * '1' - align to halfword undary
4247 * '2' - align to word boundary
4248 * '3' - align to doubleword boundary
4249 * '4' - align to quadword boundary
4250 * '5' - align to 32 byte boundary
4251 * '6' - align to 64 byte boundary
4256 ppc_pe_section (ignore
)
4257 int ignore ATTRIBUTE_UNUSED
;
4259 /* Strip out the section name. */
4268 section_name
= input_line_pointer
;
4269 c
= get_symbol_end ();
4271 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4272 strcpy (name
, section_name
);
4274 *input_line_pointer
= c
;
4279 flags
= SEC_NO_FLAGS
;
4281 if (strcmp (name
, ".idata$2") == 0)
4285 else if (strcmp (name
, ".idata$3") == 0)
4289 else if (strcmp (name
, ".idata$4") == 0)
4293 else if (strcmp (name
, ".idata$5") == 0)
4297 else if (strcmp (name
, ".idata$6") == 0)
4302 /* Default alignment to 16 byte boundary. */
4305 if (*input_line_pointer
== ',')
4307 ++input_line_pointer
;
4309 if (*input_line_pointer
!= '"')
4310 exp
= get_absolute_expression ();
4313 ++input_line_pointer
;
4314 while (*input_line_pointer
!= '"'
4315 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4317 switch (*input_line_pointer
)
4319 /* Section Contents */
4320 case 'a': /* unknown */
4321 as_bad (_("Unsupported section attribute -- 'a'"));
4323 case 'c': /* code section */
4326 case 'd': /* section has initialized data */
4329 case 'u': /* section has uninitialized data */
4330 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4334 case 'i': /* section contains directives (info) */
4335 /* FIXME: This is IMAGE_SCN_LNK_INFO
4337 flags
|= SEC_HAS_CONTENTS
;
4339 case 'n': /* section can be discarded */
4342 case 'R': /* Remove section at link time */
4343 flags
|= SEC_NEVER_LOAD
;
4346 /* Section Protection */
4347 case 'r': /* section is readable */
4348 flags
|= IMAGE_SCN_MEM_READ
;
4350 case 'w': /* section is writeable */
4351 flags
|= IMAGE_SCN_MEM_WRITE
;
4353 case 'x': /* section is executable */
4354 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4356 case 's': /* section is sharable */
4357 flags
|= IMAGE_SCN_MEM_SHARED
;
4360 /* Section Alignment */
4361 case '0': /* align to byte boundary */
4362 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4365 case '1': /* align to halfword boundary */
4366 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4369 case '2': /* align to word boundary */
4370 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4373 case '3': /* align to doubleword boundary */
4374 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4377 case '4': /* align to quadword boundary */
4378 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4381 case '5': /* align to 32 byte boundary */
4382 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4385 case '6': /* align to 64 byte boundary */
4386 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4391 as_bad (_("unknown section attribute '%c'"),
4392 *input_line_pointer
);
4395 ++input_line_pointer
;
4397 if (*input_line_pointer
== '"')
4398 ++input_line_pointer
;
4402 sec
= subseg_new (name
, (subsegT
) exp
);
4404 ppc_set_current_section (sec
);
4406 if (flags
!= SEC_NO_FLAGS
)
4408 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4409 as_bad (_("error setting flags for \"%s\": %s"),
4410 bfd_section_name (stdoutput
, sec
),
4411 bfd_errmsg (bfd_get_error ()));
4414 bfd_set_section_alignment (stdoutput
, sec
, align
);
4419 ppc_pe_function (ignore
)
4420 int ignore ATTRIBUTE_UNUSED
;
4426 name
= input_line_pointer
;
4427 endc
= get_symbol_end ();
4429 ext_sym
= symbol_find_or_make (name
);
4431 *input_line_pointer
= endc
;
4433 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4434 SF_SET_FUNCTION (ext_sym
);
4435 SF_SET_PROCESS (ext_sym
);
4436 coff_add_linesym (ext_sym
);
4438 demand_empty_rest_of_line ();
4442 ppc_pe_tocd (ignore
)
4443 int ignore ATTRIBUTE_UNUSED
;
4445 if (tocdata_section
== 0)
4447 tocdata_section
= subseg_new (".tocd", 0);
4448 /* FIXME: section flags won't work. */
4449 bfd_set_section_flags (stdoutput
, tocdata_section
,
4450 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4451 | SEC_READONLY
| SEC_DATA
));
4453 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4457 rdata_section
= subseg_new (".tocd", 0);
4460 ppc_set_current_section (tocdata_section
);
4462 demand_empty_rest_of_line ();
4465 /* Don't adjust TOC relocs to use the section symbol. */
4468 ppc_pe_fix_adjustable (fix
)
4471 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4478 /* XCOFF specific symbol and file handling. */
4480 /* Canonicalize the symbol name. We use the to force the suffix, if
4481 any, to use square brackets, and to be in upper case. */
4484 ppc_canonicalize_symbol_name (name
)
4489 if (ppc_stab_symbol
)
4492 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4506 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4509 if (*s
== '\0' || s
[1] != '\0')
4510 as_bad (_("bad symbol suffix"));
4518 /* Set the class of a symbol based on the suffix, if any. This is
4519 called whenever a new symbol is created. */
4522 ppc_symbol_new_hook (sym
)
4525 struct ppc_tc_sy
*tc
;
4528 tc
= symbol_get_tc (sym
);
4532 tc
->real_name
= NULL
;
4538 if (ppc_stab_symbol
)
4541 s
= strchr (S_GET_NAME (sym
), '[');
4542 if (s
== (const char *) NULL
)
4544 /* There is no suffix. */
4553 if (strcmp (s
, "BS]") == 0)
4557 if (strcmp (s
, "DB]") == 0)
4559 else if (strcmp (s
, "DS]") == 0)
4563 if (strcmp (s
, "GL]") == 0)
4567 if (strcmp (s
, "PR]") == 0)
4571 if (strcmp (s
, "RO]") == 0)
4573 else if (strcmp (s
, "RW]") == 0)
4577 if (strcmp (s
, "SV]") == 0)
4581 if (strcmp (s
, "TC]") == 0)
4583 else if (strcmp (s
, "TI]") == 0)
4585 else if (strcmp (s
, "TB]") == 0)
4587 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4588 tc
->class = XMC_TC0
;
4591 if (strcmp (s
, "UA]") == 0)
4593 else if (strcmp (s
, "UC]") == 0)
4597 if (strcmp (s
, "XO]") == 0)
4602 if (tc
->class == -1)
4603 as_bad (_("Unrecognized symbol suffix"));
4606 /* Set the class of a label based on where it is defined. This
4607 handles symbols without suffixes. Also, move the symbol so that it
4608 follows the csect symbol. */
4611 ppc_frob_label (sym
)
4614 if (ppc_current_csect
!= (symbolS
*) NULL
)
4616 if (symbol_get_tc (sym
)->class == -1)
4617 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4619 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4620 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4621 &symbol_rootP
, &symbol_lastP
);
4622 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4626 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4627 seen. It tells ppc_adjust_symtab whether it needs to look through
4630 static boolean ppc_saw_abs
;
4632 /* Change the name of a symbol just before writing it out. Set the
4633 real name if the .rename pseudo-op was used. Otherwise, remove any
4634 class suffix. Return 1 if the symbol should not be included in the
4638 ppc_frob_symbol (sym
)
4641 static symbolS
*ppc_last_function
;
4642 static symbolS
*set_end
;
4644 /* Discard symbols that should not be included in the output symbol
4646 if (! symbol_used_in_reloc_p (sym
)
4647 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4648 || (! S_IS_EXTERNAL (sym
)
4649 && ! symbol_get_tc (sym
)->output
4650 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4653 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4654 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4660 name
= S_GET_NAME (sym
);
4661 s
= strchr (name
, '[');
4662 if (s
!= (char *) NULL
)
4668 snew
= xmalloc (len
+ 1);
4669 memcpy (snew
, name
, len
);
4672 S_SET_NAME (sym
, snew
);
4676 if (set_end
!= (symbolS
*) NULL
)
4678 SA_SET_SYM_ENDNDX (set_end
, sym
);
4682 if (SF_GET_FUNCTION (sym
))
4684 if (ppc_last_function
!= (symbolS
*) NULL
)
4685 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4686 ppc_last_function
= sym
;
4687 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4689 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4690 SA_SET_SYM_FSIZE (sym
,
4691 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4694 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4695 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4697 if (ppc_last_function
== (symbolS
*) NULL
)
4698 as_bad (_(".ef with no preceding .function"));
4701 set_end
= ppc_last_function
;
4702 ppc_last_function
= NULL
;
4704 /* We don't have a C_EFCN symbol, but we need to force the
4705 COFF backend to believe that it has seen one. */
4706 coff_last_function
= NULL
;
4710 if (! S_IS_EXTERNAL (sym
)
4711 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4712 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4713 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4714 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4715 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4716 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4717 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4718 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4719 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4720 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4722 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4723 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4726 union internal_auxent
*a
;
4728 /* Create a csect aux. */
4729 i
= S_GET_NUMBER_AUXILIARY (sym
);
4730 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4731 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4732 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4734 /* This is the TOC table. */
4735 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4736 a
->x_csect
.x_scnlen
.l
= 0;
4737 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4739 else if (symbol_get_tc (sym
)->subseg
!= 0)
4741 /* This is a csect symbol. x_scnlen is the size of the
4743 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4744 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4745 S_GET_SEGMENT (sym
))
4746 - S_GET_VALUE (sym
));
4749 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4750 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4751 - S_GET_VALUE (sym
));
4753 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4755 else if (S_GET_SEGMENT (sym
) == bss_section
)
4757 /* This is a common symbol. */
4758 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4759 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4760 if (S_IS_EXTERNAL (sym
))
4761 symbol_get_tc (sym
)->class = XMC_RW
;
4763 symbol_get_tc (sym
)->class = XMC_BS
;
4765 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4767 /* This is an absolute symbol. The csect will be created by
4768 ppc_adjust_symtab. */
4770 a
->x_csect
.x_smtyp
= XTY_LD
;
4771 if (symbol_get_tc (sym
)->class == -1)
4772 symbol_get_tc (sym
)->class = XMC_XO
;
4774 else if (! S_IS_DEFINED (sym
))
4776 /* This is an external symbol. */
4777 a
->x_csect
.x_scnlen
.l
= 0;
4778 a
->x_csect
.x_smtyp
= XTY_ER
;
4780 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4784 /* This is a TOC definition. x_scnlen is the size of the
4786 next
= symbol_next (sym
);
4787 while (symbol_get_tc (next
)->class == XMC_TC0
)
4788 next
= symbol_next (next
);
4789 if (next
== (symbolS
*) NULL
4790 || symbol_get_tc (next
)->class != XMC_TC
)
4792 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4793 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4795 - S_GET_VALUE (sym
));
4797 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4798 - S_GET_VALUE (sym
));
4802 resolve_symbol_value (next
);
4803 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4804 - S_GET_VALUE (sym
));
4806 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4812 /* This is a normal symbol definition. x_scnlen is the
4813 symbol index of the containing csect. */
4814 if (S_GET_SEGMENT (sym
) == text_section
)
4815 csect
= ppc_text_csects
;
4816 else if (S_GET_SEGMENT (sym
) == data_section
)
4817 csect
= ppc_data_csects
;
4821 /* Skip the initial dummy symbol. */
4822 csect
= symbol_get_tc (csect
)->next
;
4824 if (csect
== (symbolS
*) NULL
)
4826 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4827 a
->x_csect
.x_scnlen
.l
= 0;
4831 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4833 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4834 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4835 > S_GET_VALUE (sym
))
4837 csect
= symbol_get_tc (csect
)->next
;
4840 a
->x_csect
.x_scnlen
.p
=
4841 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4842 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4845 a
->x_csect
.x_smtyp
= XTY_LD
;
4848 a
->x_csect
.x_parmhash
= 0;
4849 a
->x_csect
.x_snhash
= 0;
4850 if (symbol_get_tc (sym
)->class == -1)
4851 a
->x_csect
.x_smclas
= XMC_PR
;
4853 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4854 a
->x_csect
.x_stab
= 0;
4855 a
->x_csect
.x_snstab
= 0;
4857 /* Don't let the COFF backend resort these symbols. */
4858 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4860 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4862 /* We want the value to be the symbol index of the referenced
4863 csect symbol. BFD will do that for us if we set the right
4867 coffsymbol (symbol_get_bfdsym
4868 (symbol_get_tc (sym
)->within
))->native
));
4869 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4871 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4876 /* The value is the offset from the enclosing csect. */
4877 block
= symbol_get_tc (sym
)->within
;
4878 csect
= symbol_get_tc (block
)->within
;
4879 resolve_symbol_value (csect
);
4880 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4882 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4883 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4885 /* We want the value to be a file offset into the line numbers.
4886 BFD will do that for us if we set the right flags. We have
4887 already set the value correctly. */
4888 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4894 /* Adjust the symbol table. This creates csect symbols for all
4895 absolute symbols. */
4898 ppc_adjust_symtab ()
4905 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
4909 union internal_auxent
*a
;
4911 if (S_GET_SEGMENT (sym
) != absolute_section
)
4914 csect
= symbol_create (".abs[XO]", absolute_section
,
4915 S_GET_VALUE (sym
), &zero_address_frag
);
4916 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
4917 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
4918 i
= S_GET_NUMBER_AUXILIARY (csect
);
4919 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
4920 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
4921 a
->x_csect
.x_scnlen
.l
= 0;
4922 a
->x_csect
.x_smtyp
= XTY_SD
;
4923 a
->x_csect
.x_parmhash
= 0;
4924 a
->x_csect
.x_snhash
= 0;
4925 a
->x_csect
.x_smclas
= XMC_XO
;
4926 a
->x_csect
.x_stab
= 0;
4927 a
->x_csect
.x_snstab
= 0;
4929 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
4931 i
= S_GET_NUMBER_AUXILIARY (sym
);
4932 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
4933 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
4934 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
4937 ppc_saw_abs
= false;
4940 /* Set the VMA for a section. This is called on all the sections in
4944 ppc_frob_section (sec
)
4947 static bfd_size_type vma
= 0;
4949 bfd_set_section_vma (stdoutput
, sec
, vma
);
4950 vma
+= bfd_section_size (stdoutput
, sec
);
4953 #endif /* OBJ_XCOFF */
4955 /* Turn a string in input_line_pointer into a floating point constant
4956 of type TYPE, and store the appropriate bytes in *LITP. The number
4957 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4958 returned, or NULL on OK. */
4961 md_atof (type
, litp
, sizep
)
4967 LITTLENUM_TYPE words
[4];
4983 return _("bad call to md_atof");
4986 t
= atof_ieee (input_line_pointer
, type
, words
);
4988 input_line_pointer
= t
;
4992 if (target_big_endian
)
4994 for (i
= 0; i
< prec
; i
++)
4996 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5002 for (i
= prec
- 1; i
>= 0; i
--)
5004 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
5012 /* Write a value out to the object file, using the appropriate
5016 md_number_to_chars (buf
, val
, n
)
5021 if (target_big_endian
)
5022 number_to_chars_bigendian (buf
, val
, n
);
5024 number_to_chars_littleendian (buf
, val
, n
);
5027 /* Align a section (I don't know why this is machine dependent). */
5030 md_section_align (seg
, addr
)
5034 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5036 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
5039 /* We don't have any form of relaxing. */
5042 md_estimate_size_before_relax (fragp
, seg
)
5043 fragS
*fragp ATTRIBUTE_UNUSED
;
5044 asection
*seg ATTRIBUTE_UNUSED
;
5050 /* Convert a machine dependent frag. We never generate these. */
5053 md_convert_frag (abfd
, sec
, fragp
)
5054 bfd
*abfd ATTRIBUTE_UNUSED
;
5055 asection
*sec ATTRIBUTE_UNUSED
;
5056 fragS
*fragp ATTRIBUTE_UNUSED
;
5061 /* We have no need to default values of symbols. */
5064 md_undefined_symbol (name
)
5065 char *name ATTRIBUTE_UNUSED
;
5070 /* Functions concerning relocs. */
5072 /* The location from which a PC relative jump should be calculated,
5073 given a PC relative reloc. */
5076 md_pcrel_from_section (fixp
, sec
)
5078 segT sec ATTRIBUTE_UNUSED
;
5080 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5085 /* This is called to see whether a fixup should be adjusted to use a
5086 section symbol. We take the opportunity to change a fixup against
5087 a symbol in the TOC subsegment into a reloc against the
5088 corresponding .tc symbol. */
5091 ppc_fix_adjustable (fix
)
5096 resolve_symbol_value (fix
->fx_addsy
);
5097 val
= S_GET_VALUE (fix
->fx_addsy
);
5098 if (ppc_toc_csect
!= (symbolS
*) NULL
5099 && fix
->fx_addsy
!= (symbolS
*) NULL
5100 && fix
->fx_addsy
!= ppc_toc_csect
5101 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
5102 && val
>= ppc_toc_frag
->fr_address
5103 && (ppc_after_toc_frag
== (fragS
*) NULL
5104 || val
< ppc_after_toc_frag
->fr_address
))
5108 for (sy
= symbol_next (ppc_toc_csect
);
5109 sy
!= (symbolS
*) NULL
;
5110 sy
= symbol_next (sy
))
5112 if (symbol_get_tc (sy
)->class == XMC_TC0
)
5114 if (symbol_get_tc (sy
)->class != XMC_TC
)
5116 resolve_symbol_value (sy
);
5117 if (val
== S_GET_VALUE (sy
))
5120 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
5125 as_bad_where (fix
->fx_file
, fix
->fx_line
,
5126 _("symbol in .toc does not match any .tc"));
5129 /* Possibly adjust the reloc to be against the csect. */
5130 if (fix
->fx_addsy
!= (symbolS
*) NULL
5131 && symbol_get_tc (fix
->fx_addsy
)->subseg
== 0
5132 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC0
5133 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC
5134 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
5135 /* Don't adjust if this is a reloc in the toc section. */
5136 && (S_GET_SEGMENT (fix
->fx_addsy
) != data_section
5137 || ppc_toc_csect
== NULL
5138 || val
< ppc_toc_frag
->fr_address
5139 || (ppc_after_toc_frag
!= NULL
5140 && val
>= ppc_after_toc_frag
->fr_address
)))
5144 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
5145 csect
= ppc_text_csects
;
5146 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
5147 csect
= ppc_data_csects
;
5151 /* Skip the initial dummy symbol. */
5152 csect
= symbol_get_tc (csect
)->next
;
5154 if (csect
!= (symbolS
*) NULL
)
5156 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
5157 && (symbol_get_frag (symbol_get_tc (csect
)->next
)->fr_address
5160 /* If the csect address equals the symbol value, then we
5161 have to look through the full symbol table to see
5162 whether this is the csect we want. Note that we will
5163 only get here if the csect has zero length. */
5164 if ((symbol_get_frag (csect
)->fr_address
== val
)
5165 && S_GET_VALUE (csect
) == S_GET_VALUE (fix
->fx_addsy
))
5169 for (scan
= symbol_next (csect
);
5171 scan
= symbol_next (scan
))
5173 if (symbol_get_tc (scan
)->subseg
!= 0)
5175 if (scan
== fix
->fx_addsy
)
5179 /* If we found the symbol before the next csect
5180 symbol, then this is the csect we want. */
5181 if (scan
== fix
->fx_addsy
)
5185 csect
= symbol_get_tc (csect
)->next
;
5188 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
5189 - symbol_get_frag (csect
)->fr_address
);
5190 fix
->fx_addsy
= csect
;
5194 /* Adjust a reloc against a .lcomm symbol to be against the base
5196 if (fix
->fx_addsy
!= (symbolS
*) NULL
5197 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
5198 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5200 resolve_symbol_value (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
);
5202 (S_GET_VALUE (fix
->fx_addsy
)
5203 - S_GET_VALUE (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
));
5204 fix
->fx_addsy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5210 /* A reloc from one csect to another must be kept. The assembler
5211 will, of course, keep relocs between sections, and it will keep
5212 absolute relocs, but we need to force it to keep PC relative relocs
5213 between two csects in the same section. */
5216 ppc_force_relocation (fix
)
5219 /* At this point fix->fx_addsy should already have been converted to
5220 a csect symbol. If the csect does not include the fragment, then
5221 we need to force the relocation. */
5223 && fix
->fx_addsy
!= NULL
5224 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5225 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5226 > fix
->fx_frag
->fr_address
)
5227 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5228 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5229 <= fix
->fx_frag
->fr_address
))))
5235 #endif /* OBJ_XCOFF */
5239 ppc_fix_adjustable (fix
)
5242 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5243 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5244 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5245 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5246 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5247 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5248 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5249 && ! S_IS_EXTERNAL (fix
->fx_addsy
)
5250 && ! S_IS_WEAK (fix
->fx_addsy
)
5252 || (fix
->fx_subsy
!= NULL
5253 && (S_GET_SEGMENT (fix
->fx_subsy
)
5254 == S_GET_SEGMENT (fix
->fx_addsy
)))
5255 || S_IS_LOCAL (fix
->fx_addsy
)));
5259 /* Apply a fixup to the object code. This is called for all the
5260 fixups we generated by the call to fix_new_exp, above. In the call
5261 above we used a reloc code which was the largest legal reloc code
5262 plus the operand index. Here we undo that to recover the operand
5263 index. At this point all symbol values should be fully resolved,
5264 and we attempt to completely resolve the reloc. If we can not do
5265 that, we determine the correct reloc code and put it back in the
5269 md_apply_fix3 (fixP
, valP
, seg
)
5272 segT seg ATTRIBUTE_UNUSED
;
5274 valueT value
= * valP
;
5277 if (fixP
->fx_addsy
!= NULL
)
5279 /* `*valuep' may contain the value of the symbol on which the reloc
5280 will be based; we have to remove it. */
5281 if (symbol_used_in_reloc_p (fixP
->fx_addsy
)
5282 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
5283 && S_GET_SEGMENT (fixP
->fx_addsy
) != undefined_section
5284 && ! bfd_is_com_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
5285 value
-= S_GET_VALUE (fixP
->fx_addsy
);
5287 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
5288 supposed to be? I think this is related to various similar
5289 FIXMEs in tc-i386.c and tc-sparc.c. */
5291 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5296 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
5297 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5298 doing this relocation the code in write.c is going to call
5299 bfd_install_relocation, which is also going to use the symbol
5300 value. That means that if the reloc is fully resolved we want to
5301 use *valuep since bfd_install_relocation is not being used.
5302 However, if the reloc is not fully resolved we do not want to use
5303 *valuep, and must use fx_offset instead. However, if the reloc
5304 is PC relative, we do want to use *valuep since it includes the
5305 result of md_pcrel_from. This is confusing. */
5306 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5309 else if (fixP
->fx_pcrel
)
5314 value
= fixP
->fx_offset
;
5315 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5317 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
5318 value
-= S_GET_VALUE (fixP
->fx_subsy
);
5321 /* We can't actually support subtracting a symbol. */
5322 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5323 _("expression too complex"));
5329 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5332 const struct powerpc_operand
*operand
;
5336 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5338 operand
= &powerpc_operands
[opindex
];
5341 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5342 does not generate a reloc. It uses the offset of `sym' within its
5343 csect. Other usages, such as `.long sym', generate relocs. This
5344 is the documented behaviour of non-TOC symbols. */
5345 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5346 && operand
->bits
== 16
5347 && operand
->shift
== 0
5348 && (operand
->insert
== NULL
|| ppc_obj64
)
5349 && fixP
->fx_addsy
!= NULL
5350 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5351 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5352 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5353 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5355 value
= fixP
->fx_offset
;
5360 /* Fetch the instruction, insert the fully resolved operand
5361 value, and stuff the instruction back again. */
5362 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5363 if (target_big_endian
)
5364 insn
= bfd_getb32 ((unsigned char *) where
);
5366 insn
= bfd_getl32 ((unsigned char *) where
);
5367 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5368 fixP
->fx_file
, fixP
->fx_line
);
5369 if (target_big_endian
)
5370 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5372 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5375 /* Nothing else to do here. */
5378 assert (fixP
->fx_addsy
!= NULL
);
5380 /* Determine a BFD reloc value based on the operand information.
5381 We are only prepared to turn a few of the operands into
5383 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5384 && operand
->bits
== 26
5385 && operand
->shift
== 0)
5386 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5387 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5388 && operand
->bits
== 16
5389 && operand
->shift
== 0)
5391 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5394 if (target_big_endian
)
5395 fixP
->fx_where
+= 2;
5398 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5399 && operand
->bits
== 26
5400 && operand
->shift
== 0)
5401 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5402 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5403 && operand
->bits
== 16
5404 && operand
->shift
== 0)
5406 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5409 if (target_big_endian
)
5410 fixP
->fx_where
+= 2;
5413 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5414 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5415 && operand
->bits
== 16
5416 && operand
->shift
== 0
5417 && ppc_is_toc_sym (fixP
->fx_addsy
))
5419 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5422 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5423 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5426 if (target_big_endian
)
5427 fixP
->fx_where
+= 2;
5429 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5435 /* Use expr_symbol_where to see if this is an expression
5437 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5438 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5439 _("unresolved expression that must be resolved"));
5441 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5442 _("unsupported relocation against %s"),
5443 S_GET_NAME (fixP
->fx_addsy
));
5451 ppc_elf_validate_fix (fixP
, seg
);
5453 switch (fixP
->fx_r_type
)
5455 case BFD_RELOC_CTOR
:
5462 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5466 case BFD_RELOC_32_PCREL
:
5467 case BFD_RELOC_PPC_EMB_NADDR32
:
5468 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5475 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5478 case BFD_RELOC_64_PCREL
:
5479 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5483 case BFD_RELOC_LO16
:
5485 case BFD_RELOC_GPREL16
:
5486 case BFD_RELOC_16_GOT_PCREL
:
5487 case BFD_RELOC_16_GOTOFF
:
5488 case BFD_RELOC_LO16_GOTOFF
:
5489 case BFD_RELOC_HI16_GOTOFF
:
5490 case BFD_RELOC_HI16_S_GOTOFF
:
5491 case BFD_RELOC_16_BASEREL
:
5492 case BFD_RELOC_LO16_BASEREL
:
5493 case BFD_RELOC_HI16_BASEREL
:
5494 case BFD_RELOC_HI16_S_BASEREL
:
5495 case BFD_RELOC_PPC_EMB_NADDR16
:
5496 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5497 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5498 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5499 case BFD_RELOC_PPC_EMB_SDAI16
:
5500 case BFD_RELOC_PPC_EMB_SDA2REL
:
5501 case BFD_RELOC_PPC_EMB_SDA2I16
:
5502 case BFD_RELOC_PPC_EMB_RELSEC16
:
5503 case BFD_RELOC_PPC_EMB_RELST_LO
:
5504 case BFD_RELOC_PPC_EMB_RELST_HI
:
5505 case BFD_RELOC_PPC_EMB_RELST_HA
:
5506 case BFD_RELOC_PPC_EMB_RELSDA
:
5507 case BFD_RELOC_PPC_TOC16
:
5509 case BFD_RELOC_PPC64_TOC16_LO
:
5510 case BFD_RELOC_PPC64_TOC16_HI
:
5511 case BFD_RELOC_PPC64_TOC16_HA
:
5515 if (fixP
->fx_addsy
!= NULL
)
5516 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5517 _("cannot emit PC relative %s relocation against %s"),
5518 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5519 S_GET_NAME (fixP
->fx_addsy
));
5521 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5522 _("cannot emit PC relative %s relocation"),
5523 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5526 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5530 /* This case happens when you write, for example,
5532 where L1 and L2 are defined later. */
5533 case BFD_RELOC_HI16
:
5536 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5540 case BFD_RELOC_HI16_S
:
5543 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5548 case BFD_RELOC_PPC64_HIGHER
:
5551 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5552 PPC_HIGHER (value
), 2);
5555 case BFD_RELOC_PPC64_HIGHER_S
:
5558 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5559 PPC_HIGHERA (value
), 2);
5562 case BFD_RELOC_PPC64_HIGHEST
:
5565 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5566 PPC_HIGHEST (value
), 2);
5569 case BFD_RELOC_PPC64_HIGHEST_S
:
5572 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5573 PPC_HIGHESTA (value
), 2);
5576 case BFD_RELOC_PPC64_ADDR16_DS
:
5577 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5578 case BFD_RELOC_PPC64_GOT16_DS
:
5579 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5580 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5581 case BFD_RELOC_PPC64_SECTOFF_DS
:
5582 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5583 case BFD_RELOC_PPC64_TOC16_DS
:
5584 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5585 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5586 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5590 unsigned char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5593 if (target_big_endian
)
5594 val
= bfd_getb16 (where
);
5596 val
= bfd_getl16 (where
);
5597 val
|= (value
& 0xfffc);
5598 if (target_big_endian
)
5599 bfd_putb16 ((bfd_vma
) val
, where
);
5601 bfd_putl16 ((bfd_vma
) val
, where
);
5605 /* Because SDA21 modifies the register field, the size is set to 4
5606 bytes, rather than 2, so offset it here appropriately. */
5607 case BFD_RELOC_PPC_EMB_SDA21
:
5611 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5612 + ((target_big_endian
) ? 2 : 0),
5620 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5624 case BFD_RELOC_24_PLT_PCREL
:
5625 case BFD_RELOC_PPC_LOCAL24PC
:
5626 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5634 /* Fetch the instruction, insert the fully resolved operand
5635 value, and stuff the instruction back again. */
5636 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5637 if (target_big_endian
)
5638 insn
= bfd_getb32 ((unsigned char *) where
);
5640 insn
= bfd_getl32 ((unsigned char *) where
);
5641 if ((value
& 3) != 0)
5642 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5643 _("must branch to an address a multiple of 4"));
5644 if ((offsetT
) value
< -0x40000000
5645 || (offsetT
) value
>= 0x40000000)
5646 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5647 _("@local or @plt branch destination is too far away, %ld bytes"),
5649 insn
= insn
| (value
& 0x03fffffc);
5650 if (target_big_endian
)
5651 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5653 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5657 case BFD_RELOC_VTABLE_INHERIT
:
5660 && !S_IS_DEFINED (fixP
->fx_addsy
)
5661 && !S_IS_WEAK (fixP
->fx_addsy
))
5662 S_SET_WEAK (fixP
->fx_addsy
);
5665 case BFD_RELOC_VTABLE_ENTRY
:
5670 /* Generated by reference to `sym@tocbase'. The sym is
5671 ignored by the linker. */
5672 case BFD_RELOC_PPC64_TOC
:
5678 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
5685 fixP
->fx_addnumber
= value
;
5687 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5688 fixP
->fx_addnumber
= 0;
5692 fixP
->fx_addnumber
= 0;
5694 /* We want to use the offset within the data segment of the
5695 symbol, not the actual VMA of the symbol. */
5696 fixP
->fx_addnumber
=
5697 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
5703 /* Generate a reloc for a fixup. */
5706 tc_gen_reloc (seg
, fixp
)
5707 asection
*seg ATTRIBUTE_UNUSED
;
5712 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5714 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5715 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5716 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5717 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5718 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5720 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5721 _("reloc %d not supported by object file format"),
5722 (int) fixp
->fx_r_type
);
5725 reloc
->addend
= fixp
->fx_addnumber
;