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
));
136 static void ppc_set_current_section
PARAMS ((segT
));
137 static void ppc_previous
PARAMS ((int));
138 static void ppc_pdata
PARAMS ((int));
139 static void ppc_ydata
PARAMS ((int));
140 static void ppc_reldata
PARAMS ((int));
141 static void ppc_rdata
PARAMS ((int));
142 static void ppc_ualong
PARAMS ((int));
143 static void ppc_znop
PARAMS ((int));
144 static void ppc_pe_comm
PARAMS ((int));
145 static void ppc_pe_section
PARAMS ((int));
146 static void ppc_pe_function
PARAMS ((int));
147 static void ppc_pe_tocd
PARAMS ((int));
150 /* Generic assembler global variables which must be defined by all
154 /* This string holds the chars that always start a comment. If the
155 pre-processor is disabled, these aren't very useful. The macro
156 tc_comment_chars points to this. We use this, rather than the
157 usual comment_chars, so that we can switch for Solaris conventions. */
158 static const char ppc_solaris_comment_chars
[] = "#!";
159 static const char ppc_eabi_comment_chars
[] = "#";
161 #ifdef TARGET_SOLARIS_COMMENT
162 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
164 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
167 const char comment_chars
[] = "#";
170 /* Characters which start a comment at the beginning of a line. */
171 const char line_comment_chars
[] = "#";
173 /* Characters which may be used to separate multiple commands on a
175 const char line_separator_chars
[] = ";";
177 /* Characters which are used to indicate an exponent in a floating
179 const char EXP_CHARS
[] = "eE";
181 /* Characters which mean that a number is a floating point constant,
183 const char FLT_CHARS
[] = "dD";
185 /* The target specific pseudo-ops which we support. */
187 const pseudo_typeS md_pseudo_table
[] =
189 /* Pseudo-ops which must be overridden. */
190 { "byte", ppc_byte
, 0 },
193 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
194 legitimately belong in the obj-*.c file. However, XCOFF is based
195 on COFF, and is only implemented for the RS/6000. We just use
196 obj-coff.c, and add what we need here. */
197 { "comm", ppc_comm
, 0 },
198 { "lcomm", ppc_comm
, 1 },
202 { "bi", ppc_biei
, 0 },
204 { "csect", ppc_csect
, 0 },
205 { "data", ppc_section
, 'd' },
209 { "ei", ppc_biei
, 1 },
211 { "extern", ppc_extern
, 0 },
212 { "function", ppc_function
, 0 },
213 { "lglobl", ppc_lglobl
, 0 },
214 { "rename", ppc_rename
, 0 },
215 { "section", ppc_named_section
, 0 },
216 { "stabx", ppc_stabx
, 0 },
217 { "text", ppc_section
, 't' },
218 { "toc", ppc_toc
, 0 },
219 { "long", ppc_xcoff_cons
, 2 },
220 { "llong", ppc_xcoff_cons
, 3 },
221 { "word", ppc_xcoff_cons
, 1 },
222 { "short", ppc_xcoff_cons
, 1 },
223 { "vbyte", ppc_vbyte
, 0 },
227 { "llong", ppc_elf_cons
, 8 },
228 { "quad", ppc_elf_cons
, 8 },
229 { "long", ppc_elf_cons
, 4 },
230 { "word", ppc_elf_cons
, 2 },
231 { "short", ppc_elf_cons
, 2 },
232 { "rdata", ppc_elf_rdata
, 0 },
233 { "rodata", ppc_elf_rdata
, 0 },
234 { "lcomm", ppc_elf_lcomm
, 0 },
235 { "file", dwarf2_directive_file
, 0 },
236 { "loc", dwarf2_directive_loc
, 0 },
240 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
241 { "previous", ppc_previous
, 0 },
242 { "pdata", ppc_pdata
, 0 },
243 { "ydata", ppc_ydata
, 0 },
244 { "reldata", ppc_reldata
, 0 },
245 { "rdata", ppc_rdata
, 0 },
246 { "ualong", ppc_ualong
, 0 },
247 { "znop", ppc_znop
, 0 },
248 { "comm", ppc_pe_comm
, 0 },
249 { "lcomm", ppc_pe_comm
, 1 },
250 { "section", ppc_pe_section
, 0 },
251 { "function", ppc_pe_function
,0 },
252 { "tocd", ppc_pe_tocd
, 0 },
255 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
257 { "machine", ppc_machine
, 0 },
264 /* Predefined register names if -mregnames (or default for Windows NT).
265 In general, there are lots of them, in an attempt to be compatible
266 with a number of other Windows NT assemblers. */
268 /* Structure to hold information about predefined registers. */
275 /* List of registers that are pre-defined:
277 Each general register has predefined names of the form:
278 1. r<reg_num> which has the value <reg_num>.
279 2. r.<reg_num> which has the value <reg_num>.
281 Each floating point register has predefined names of the form:
282 1. f<reg_num> which has the value <reg_num>.
283 2. f.<reg_num> which has the value <reg_num>.
285 Each vector unit register has predefined names of the form:
286 1. v<reg_num> which has the value <reg_num>.
287 2. v.<reg_num> which has the value <reg_num>.
289 Each condition register has predefined names of the form:
290 1. cr<reg_num> which has the value <reg_num>.
291 2. cr.<reg_num> which has the value <reg_num>.
293 There are individual registers as well:
294 sp or r.sp has the value 1
295 rtoc or r.toc has the value 2
296 fpscr has the value 0
302 dsisr has the value 18
304 sdr1 has the value 25
305 srr0 has the value 26
306 srr1 has the value 27
308 The table is sorted. Suitable for searching by a binary search. */
310 static const struct pd_reg pre_defined_registers
[] =
312 { "cr.0", 0 }, /* Condition Registers */
332 { "dar", 19 }, /* Data Access Register */
333 { "dec", 22 }, /* Decrementer */
334 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
336 { "f.0", 0 }, /* Floating point registers */
404 { "lr", 8 }, /* Link Register */
408 { "r.0", 0 }, /* General Purpose Registers */
441 { "r.sp", 1 }, /* Stack Pointer */
443 { "r.toc", 2 }, /* Pointer to the table of contents */
445 { "r0", 0 }, /* More general purpose registers */
478 { "rtoc", 2 }, /* Table of contents */
480 { "sdr1", 25 }, /* Storage Description Register 1 */
484 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
485 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
487 { "v.0", 0 }, /* Vector registers */
557 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
559 /* Given NAME, find the register number associated with that name, return
560 the integer value associated with the given name or -1 on failure. */
562 static int reg_name_search
563 PARAMS ((const struct pd_reg
*, int, const char * name
));
566 reg_name_search (regs
, regcount
, name
)
567 const struct pd_reg
*regs
;
571 int middle
, low
, high
;
579 middle
= (low
+ high
) / 2;
580 cmp
= strcasecmp (name
, regs
[middle
].name
);
586 return regs
[middle
].value
;
594 * Summary of register_name.
596 * in: Input_line_pointer points to 1st char of operand.
598 * out: A expressionS.
599 * The operand may have been a register: in this case, X_op == O_register,
600 * X_add_number is set to the register number, and truth is returned.
601 * Input_line_pointer->(next non-blank) char after operand, or is in its
606 register_name (expressionP
)
607 expressionS
*expressionP
;
614 /* Find the spelling of the operand. */
615 start
= name
= input_line_pointer
;
616 if (name
[0] == '%' && ISALPHA (name
[1]))
617 name
= ++input_line_pointer
;
619 else if (!reg_names_p
|| !ISALPHA (name
[0]))
622 c
= get_symbol_end ();
623 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
625 /* Put back the delimiting char. */
626 *input_line_pointer
= c
;
628 /* Look to see if it's in the register table. */
631 expressionP
->X_op
= O_register
;
632 expressionP
->X_add_number
= reg_number
;
634 /* Make the rest nice. */
635 expressionP
->X_add_symbol
= NULL
;
636 expressionP
->X_op_symbol
= NULL
;
640 /* Reset the line as if we had not done anything. */
641 input_line_pointer
= start
;
645 /* This function is called for each symbol seen in an expression. It
646 handles the special parsing which PowerPC assemblers are supposed
647 to use for condition codes. */
649 /* Whether to do the special parsing. */
650 static boolean cr_operand
;
652 /* Names to recognize in a condition code. This table is sorted. */
653 static const struct pd_reg cr_names
[] =
670 /* Parsing function. This returns non-zero if it recognized an
674 ppc_parse_name (name
, expr
)
683 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
688 expr
->X_op
= O_constant
;
689 expr
->X_add_number
= val
;
694 /* Local variables. */
696 /* The type of processor we are assembling for. This is one or more
697 of the PPC_OPCODE flags defined in opcode/ppc.h. */
698 static int ppc_cpu
= 0;
700 /* The size of the processor we are assembling for. This is either
701 PPC_OPCODE_32 or PPC_OPCODE_64. */
702 static unsigned long ppc_size
= (BFD_DEFAULT_TARGET_SIZE
== 64
706 /* Whether to target xcoff64. */
707 static int ppc_xcoff64
= 0;
709 /* Opcode hash table. */
710 static struct hash_control
*ppc_hash
;
712 /* Macro hash table. */
713 static struct hash_control
*ppc_macro_hash
;
716 /* What type of shared library support to use. */
717 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
719 /* Flags to set in the elf header. */
720 static flagword ppc_flags
= 0;
722 /* Whether this is Solaris or not. */
723 #ifdef TARGET_SOLARIS_COMMENT
724 #define SOLARIS_P true
726 #define SOLARIS_P false
729 static boolean msolaris
= SOLARIS_P
;
734 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
735 using a bunch of different sections. These assembler sections,
736 however, are all encompassed within the .text or .data sections of
737 the final output file. We handle this by using different
738 subsegments within these main segments. */
740 /* Next subsegment to allocate within the .text segment. */
741 static subsegT ppc_text_subsegment
= 2;
743 /* Linked list of csects in the text section. */
744 static symbolS
*ppc_text_csects
;
746 /* Next subsegment to allocate within the .data segment. */
747 static subsegT ppc_data_subsegment
= 2;
749 /* Linked list of csects in the data section. */
750 static symbolS
*ppc_data_csects
;
752 /* The current csect. */
753 static symbolS
*ppc_current_csect
;
755 /* The RS/6000 assembler uses a TOC which holds addresses of functions
756 and variables. Symbols are put in the TOC with the .tc pseudo-op.
757 A special relocation is used when accessing TOC entries. We handle
758 the TOC as a subsegment within the .data segment. We set it up if
759 we see a .toc pseudo-op, and save the csect symbol here. */
760 static symbolS
*ppc_toc_csect
;
762 /* The first frag in the TOC subsegment. */
763 static fragS
*ppc_toc_frag
;
765 /* The first frag in the first subsegment after the TOC in the .data
766 segment. NULL if there are no subsegments after the TOC. */
767 static fragS
*ppc_after_toc_frag
;
769 /* The current static block. */
770 static symbolS
*ppc_current_block
;
772 /* The COFF debugging section; set by md_begin. This is not the
773 .debug section, but is instead the secret BFD section which will
774 cause BFD to set the section number of a symbol to N_DEBUG. */
775 static asection
*ppc_coff_debug_section
;
777 #endif /* OBJ_XCOFF */
781 /* Various sections that we need for PE coff support. */
782 static segT ydata_section
;
783 static segT pdata_section
;
784 static segT reldata_section
;
785 static segT rdata_section
;
786 static segT tocdata_section
;
788 /* The current section and the previous section. See ppc_previous. */
789 static segT ppc_previous_section
;
790 static segT ppc_current_section
;
795 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
799 const char *const md_shortopts
= "b:l:usm:K:VQ:";
801 const char *const md_shortopts
= "um:";
803 const struct option md_longopts
[] = {
804 {NULL
, no_argument
, NULL
, 0}
806 const size_t md_longopts_size
= sizeof (md_longopts
);
809 md_parse_option (c
, arg
)
816 /* -u means that any undefined symbols should be treated as
817 external, which is the default for gas anyhow. */
822 /* Solaris as takes -le (presumably for little endian). For completeness
823 sake, recognize -be also. */
824 if (strcmp (arg
, "e") == 0)
826 target_big_endian
= 0;
827 set_target_endian
= 1;
835 if (strcmp (arg
, "e") == 0)
837 target_big_endian
= 1;
838 set_target_endian
= 1;
846 /* Recognize -K PIC. */
847 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
850 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
858 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
860 if (strcmp (arg
, "64") == 0)
862 else if (strcmp (arg
, "32") == 0)
869 /* Most CPU's are 32 bit. Exceptions are listed below. */
870 ppc_size
= PPC_OPCODE_32
;
872 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
874 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
875 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
;
876 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
877 else if (strcmp (arg
, "pwr") == 0)
878 ppc_cpu
= PPC_OPCODE_POWER
;
879 /* -m601 means to assemble for the PowerPC 601, which includes
880 instructions that are holdovers from the Power. */
881 else if (strcmp (arg
, "601") == 0)
882 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_601
;
883 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
885 else if (strcmp (arg
, "ppc") == 0
886 || strcmp (arg
, "ppc32") == 0
887 || strcmp (arg
, "603") == 0
888 || strcmp (arg
, "604") == 0)
889 ppc_cpu
= PPC_OPCODE_PPC
;
890 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
891 else if (strcmp (arg
, "403") == 0
892 || strcmp (arg
, "405") == 0)
893 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_403
;
894 else if (strcmp (arg
, "7400") == 0
895 || strcmp (arg
, "7410") == 0
896 || strcmp (arg
, "7450") == 0
897 || strcmp (arg
, "7455") == 0)
898 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_ALTIVEC
;
899 else if (strcmp (arg
, "altivec") == 0)
902 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_ALTIVEC
;
904 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
906 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
908 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
910 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
911 ppc_size
= PPC_OPCODE_64
;
913 else if (strcmp (arg
, "ppc64bridge") == 0)
915 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
;
916 ppc_size
= PPC_OPCODE_64
;
918 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
919 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
920 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
;
921 /* -mbooke64 means enable 64-bit BookE support. */
922 else if (strcmp (arg
, "booke64") == 0)
924 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
|
925 PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
;
926 ppc_size
= PPC_OPCODE_64
;
928 else if (strcmp (arg
, "power4") == 0)
930 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64
| PPC_OPCODE_POWER4
;
931 ppc_size
= PPC_OPCODE_64
;
933 /* -mcom means assemble for the common intersection between Power
934 and PowerPC. At present, we just allow the union, rather
935 than the intersection. */
936 else if (strcmp (arg
, "com") == 0)
937 ppc_cpu
= PPC_OPCODE_COMMON
;
938 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
939 else if (strcmp (arg
, "any") == 0)
940 ppc_cpu
= PPC_OPCODE_ANY
;
942 else if (strcmp (arg
, "regnames") == 0)
945 else if (strcmp (arg
, "no-regnames") == 0)
949 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
950 that require relocation. */
951 else if (strcmp (arg
, "relocatable") == 0)
953 shlib
= SHLIB_MRELOCATABLE
;
954 ppc_flags
|= EF_PPC_RELOCATABLE
;
957 else if (strcmp (arg
, "relocatable-lib") == 0)
959 shlib
= SHLIB_MRELOCATABLE
;
960 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
963 /* -memb, set embedded bit. */
964 else if (strcmp (arg
, "emb") == 0)
965 ppc_flags
|= EF_PPC_EMB
;
967 /* -mlittle/-mbig set the endianess. */
968 else if (strcmp (arg
, "little") == 0
969 || strcmp (arg
, "little-endian") == 0)
971 target_big_endian
= 0;
972 set_target_endian
= 1;
975 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
977 target_big_endian
= 1;
978 set_target_endian
= 1;
981 else if (strcmp (arg
, "solaris") == 0)
984 ppc_comment_chars
= ppc_solaris_comment_chars
;
987 else if (strcmp (arg
, "no-solaris") == 0)
990 ppc_comment_chars
= ppc_eabi_comment_chars
;
995 as_bad (_("invalid switch -m%s"), arg
);
1001 /* -V: SVR4 argument to print version ID. */
1003 print_version_id ();
1006 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1007 should be emitted or not. FIXME: Not implemented. */
1011 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1012 rather than .stabs.excl, which is ignored by the linker.
1013 FIXME: Not implemented. */
1029 md_show_usage (stream
)
1032 fprintf (stream
, _("\
1035 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1036 -mpwr generate code for POWER (RIOS1)\n\
1037 -m601 generate code for PowerPC 601\n\
1038 -mppc, -mppc32, -m603, -m604\n\
1039 generate code for PowerPC 603/604\n\
1040 -m403, -m405 generate code for PowerPC 403/405\n\
1041 -m7400, -m7410, -m7450, -m7455\n\
1042 generate code For PowerPC 7400/7410/7450/7455\n\
1043 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1044 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1045 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1046 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1047 -mpower4 generate code for Power4 architecture\n\
1048 -maltivec generate code for AltiVec\n\
1049 -mcom generate code Power/PowerPC common instructions\n\
1050 -many generate code for any architecture (PWR/PWRX/PPC)\n\
1051 -mregnames Allow symbolic names for registers\n\
1052 -mno-regnames Do not allow symbolic names for registers\n"));
1054 fprintf (stream
, _("\
1055 -mrelocatable support for GCC's -mrelocatble option\n\
1056 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1057 -memb set PPC_EMB bit in ELF flags\n\
1058 -mlittle, -mlittle-endian\n\
1059 generate code for a little endian machine\n\
1060 -mbig, -mbig-endian generate code for a big endian machine\n\
1061 -msolaris generate code for Solaris\n\
1062 -mno-solaris do not generate code for Solaris\n\
1063 -V print assembler version number\n\
1064 -Qy, -Qn ignored\n"));
1068 /* Set ppc_cpu if it is not already set. */
1073 const char *default_os
= TARGET_OS
;
1074 const char *default_cpu
= TARGET_CPU
;
1078 if (strncmp (default_os
, "aix", 3) == 0
1079 && default_os
[3] >= '4' && default_os
[3] <= '9')
1080 ppc_cpu
= PPC_OPCODE_COMMON
;
1081 else if (strncmp (default_os
, "aix3", 4) == 0)
1082 ppc_cpu
= PPC_OPCODE_POWER
;
1083 else if (strcmp (default_cpu
, "rs6000") == 0)
1084 ppc_cpu
= PPC_OPCODE_POWER
;
1085 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1086 ppc_cpu
= PPC_OPCODE_PPC
;
1088 as_fatal (_("Unknown default cpu = %s, os = %s"),
1089 default_cpu
, default_os
);
1093 /* Figure out the BFD architecture to use. */
1095 enum bfd_architecture
1098 const char *default_cpu
= TARGET_CPU
;
1101 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1102 return bfd_arch_powerpc
;
1103 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1104 return bfd_arch_rs6000
;
1105 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1107 if (strcmp (default_cpu
, "rs6000") == 0)
1108 return bfd_arch_rs6000
;
1109 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1110 return bfd_arch_powerpc
;
1113 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1114 return bfd_arch_unknown
;
1120 return ppc_size
== PPC_OPCODE_64
? 620 : 0;
1124 ppc_target_format ()
1128 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1130 return "xcoff-powermac";
1133 return (ppc_xcoff64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1135 return (ppc_xcoff64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1140 boolean is64
= BFD_DEFAULT_TARGET_SIZE
== 64 && ppc_size
== PPC_OPCODE_64
;
1142 return (target_big_endian
1143 ? (is64
? "elf64-powerpc" : "elf32-powerpc")
1144 : (is64
? "elf64-powerpcle" : "elf32-powerpcle"));
1148 /* This function is called when the assembler starts up. It is called
1149 after the options have been parsed and the output file has been
1155 register const struct powerpc_opcode
*op
;
1156 const struct powerpc_opcode
*op_end
;
1157 const struct powerpc_macro
*macro
;
1158 const struct powerpc_macro
*macro_end
;
1159 boolean dup_insn
= false;
1164 /* Set the ELF flags if desired. */
1165 if (ppc_flags
&& !msolaris
)
1166 bfd_set_private_flags (stdoutput
, ppc_flags
);
1169 /* Insert the opcodes into a hash table. */
1170 ppc_hash
= hash_new ();
1172 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1173 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1175 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1177 if ((op
->flags
& ppc_cpu
) != 0
1178 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1179 || (op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == ppc_size
1180 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1181 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1182 || ((op
->flags
& PPC_OPCODE_POWER4
)
1183 == (ppc_cpu
& PPC_OPCODE_POWER4
))))
1187 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1188 if (retval
!= (const char *) NULL
)
1190 /* Ignore Power duplicates for -m601. */
1191 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1192 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1195 as_bad (_("Internal assembler error for instruction %s"),
1202 /* Insert the macros into a hash table. */
1203 ppc_macro_hash
= hash_new ();
1205 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1206 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1208 if ((macro
->flags
& ppc_cpu
) != 0)
1212 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1213 if (retval
!= (const char *) NULL
)
1215 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1224 /* Tell the main code what the endianness is if it is not overidden
1226 if (!set_target_endian
)
1228 set_target_endian
= 1;
1229 target_big_endian
= PPC_BIG_ENDIAN
;
1233 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1235 /* Create dummy symbols to serve as initial csects. This forces the
1236 text csects to precede the data csects. These symbols will not
1238 ppc_text_csects
= symbol_make ("dummy\001");
1239 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1240 ppc_data_csects
= symbol_make ("dummy\001");
1241 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1246 ppc_current_section
= text_section
;
1247 ppc_previous_section
= 0;
1252 /* Insert an operand value into an instruction. */
1254 static unsigned long
1255 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1257 const struct powerpc_operand
*operand
;
1262 if (operand
->bits
!= 32)
1267 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1269 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1270 max
= (1 << operand
->bits
) - 1;
1272 max
= (1 << (operand
->bits
- 1)) - 1;
1273 min
= - (1 << (operand
->bits
- 1));
1275 if (ppc_size
== PPC_OPCODE_32
)
1277 /* Some people write 32 bit hex constants with the sign
1278 extension done by hand. This shouldn't really be
1279 valid, but, to permit this code to assemble on a 64
1280 bit host, we sign extend the 32 bit value. */
1282 && (val
& (offsetT
) 0x80000000) != 0
1283 && (val
& (offsetT
) 0xffffffff) == val
)
1292 max
= (1 << operand
->bits
) - 1;
1296 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1301 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1304 _("operand out of range (%s not between %ld and %ld)");
1307 sprint_value (buf
, test
);
1308 as_bad_where (file
, line
, err
, buf
, min
, max
);
1312 if (operand
->insert
)
1317 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
| ppc_size
, &errmsg
);
1318 if (errmsg
!= (const char *) NULL
)
1319 as_bad_where (file
, line
, errmsg
);
1322 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1330 /* Parse @got, etc. and return the desired relocation. */
1331 static bfd_reloc_code_real_type
1332 ppc_elf_suffix (str_p
, exp_p
)
1347 const struct map_bfd
*ptr
;
1349 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1351 static const struct map_bfd mapping
[] = {
1352 MAP ("l", (int) BFD_RELOC_LO16
),
1353 MAP ("h", (int) BFD_RELOC_HI16
),
1354 MAP ("ha", (int) BFD_RELOC_HI16_S
),
1355 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN
),
1356 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN
),
1357 MAP ("got", (int) BFD_RELOC_16_GOTOFF
),
1358 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF
),
1359 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF
),
1360 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF
),
1361 MAP ("fixup", (int) BFD_RELOC_CTOR
), /* warning with -mrelocatable */
1362 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL
),
1363 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL
),
1364 MAP ("copy", (int) BFD_RELOC_PPC_COPY
),
1365 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT
),
1366 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC
),
1367 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC
),
1368 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL
),
1369 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF
),
1370 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF
),
1371 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF
),
1372 MAP ("sdarel", (int) BFD_RELOC_GPREL16
),
1373 MAP ("sectoff", (int) BFD_RELOC_16_BASEREL
),
1374 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL
),
1375 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL
),
1376 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL
),
1377 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32
),
1378 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16
),
1379 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO
),
1380 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI
),
1381 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA
),
1382 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16
),
1383 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL
),
1384 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16
),
1385 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21
),
1386 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF
),
1387 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16
),
1388 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO
),
1389 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI
),
1390 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA
),
1391 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD
),
1392 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA
),
1393 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16
),
1394 #if BFD_DEFAULT_TARGET_SIZE == 64
1395 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER
),
1396 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S
),
1397 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST
),
1398 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S
),
1399 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC
),
1400 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16
),
1401 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO
),
1402 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI
),
1403 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA
),
1405 { (char *) 0, 0, (int) BFD_RELOC_UNUSED
}
1409 return BFD_RELOC_UNUSED
;
1411 for (ch
= *str
, str2
= ident
;
1412 (str2
< ident
+ sizeof (ident
) - 1
1413 && (ISALNUM (ch
) || ch
== '@'));
1416 *str2
++ = TOLOWER (ch
);
1423 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1424 if (ch
== ptr
->string
[0]
1425 && len
== ptr
->length
1426 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1428 int reloc
= ptr
->reloc
;
1430 if (BFD_DEFAULT_TARGET_SIZE
== 64 && reloc
< 0)
1432 if (ppc_size
!= PPC_OPCODE_64
)
1433 return BFD_RELOC_UNUSED
;
1437 if (exp_p
->X_add_number
!= 0
1438 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1439 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1440 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1441 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1442 as_warn (_("identifier+constant@got means identifier@got+constant"));
1444 /* Now check for identifier@suffix+constant. */
1445 if (*str
== '-' || *str
== '+')
1447 char *orig_line
= input_line_pointer
;
1448 expressionS new_exp
;
1450 input_line_pointer
= str
;
1451 expression (&new_exp
);
1452 if (new_exp
.X_op
== O_constant
)
1454 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1455 str
= input_line_pointer
;
1458 if (&input_line_pointer
!= str_p
)
1459 input_line_pointer
= orig_line
;
1463 if (BFD_DEFAULT_TARGET_SIZE
== 64
1464 && reloc
== (int) BFD_RELOC_PPC64_TOC
1465 && exp_p
->X_op
== O_symbol
)
1467 /* This reloc type ignores the symbol. Change the symbol
1468 so that the dummy .TOC. symbol can be omitted from the
1470 exp_p
->X_add_symbol
= &abs_symbol
;
1473 return (bfd_reloc_code_real_type
) reloc
;
1476 return BFD_RELOC_UNUSED
;
1479 /* Like normal .long/.short/.word, except support @got, etc.
1480 Clobbers input_line_pointer, checks end-of-line. */
1482 ppc_elf_cons (nbytes
)
1483 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1486 bfd_reloc_code_real_type reloc
;
1488 if (is_it_end_of_statement ())
1490 demand_empty_rest_of_line ();
1497 if (exp
.X_op
== O_symbol
1498 && *input_line_pointer
== '@'
1499 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1500 &exp
)) != BFD_RELOC_UNUSED
)
1502 reloc_howto_type
*reloc_howto
;
1505 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1506 size
= bfd_get_reloc_size (reloc_howto
);
1510 as_bad (_("%s relocations do not fit in %d bytes\n"),
1511 reloc_howto
->name
, nbytes
);
1518 p
= frag_more (nbytes
);
1520 if (target_big_endian
)
1521 offset
= nbytes
- size
;
1522 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1527 emit_expr (&exp
, (unsigned int) nbytes
);
1529 while (*input_line_pointer
++ == ',');
1531 /* Put terminator back into stream. */
1532 input_line_pointer
--;
1533 demand_empty_rest_of_line ();
1536 /* Solaris pseduo op to change to the .rodata section. */
1541 char *save_line
= input_line_pointer
;
1542 static char section
[] = ".rodata\n";
1544 /* Just pretend this is .section .rodata */
1545 input_line_pointer
= section
;
1546 obj_elf_section (xxx
);
1548 input_line_pointer
= save_line
;
1551 /* Pseudo op to make file scope bss items. */
1554 int xxx ATTRIBUTE_UNUSED
;
1556 register char *name
;
1560 register symbolS
*symbolP
;
1567 name
= input_line_pointer
;
1568 c
= get_symbol_end ();
1570 /* just after name is now '\0'. */
1571 p
= input_line_pointer
;
1574 if (*input_line_pointer
!= ',')
1576 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1577 ignore_rest_of_line ();
1581 input_line_pointer
++; /* skip ',' */
1582 if ((size
= get_absolute_expression ()) < 0)
1584 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1585 ignore_rest_of_line ();
1589 /* The third argument to .lcomm is the alignment. */
1590 if (*input_line_pointer
!= ',')
1594 ++input_line_pointer
;
1595 align
= get_absolute_expression ();
1598 as_warn (_("ignoring bad alignment"));
1604 symbolP
= symbol_find_or_make (name
);
1607 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1609 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1610 S_GET_NAME (symbolP
));
1611 ignore_rest_of_line ();
1615 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1617 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1618 S_GET_NAME (symbolP
),
1619 (long) S_GET_VALUE (symbolP
),
1622 ignore_rest_of_line ();
1628 old_subsec
= now_subseg
;
1631 /* Convert to a power of 2 alignment. */
1632 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1635 as_bad (_("Common alignment not a power of 2"));
1636 ignore_rest_of_line ();
1643 record_alignment (bss_section
, align2
);
1644 subseg_set (bss_section
, 0);
1646 frag_align (align2
, 0, 0);
1647 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1648 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1649 symbol_set_frag (symbolP
, frag_now
);
1650 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1653 S_SET_SIZE (symbolP
, size
);
1654 S_SET_SEGMENT (symbolP
, bss_section
);
1655 subseg_set (old_sec
, old_subsec
);
1656 demand_empty_rest_of_line ();
1659 /* Validate any relocations emitted for -mrelocatable, possibly adding
1660 fixups for word relocations in writable segments, so we can adjust
1663 ppc_elf_validate_fix (fixp
, seg
)
1667 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1676 case SHLIB_MRELOCATABLE
:
1677 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1678 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1679 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1680 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1681 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1682 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1683 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1684 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1685 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1686 && (seg
->flags
& SEC_LOAD
) != 0
1687 && strcmp (segment_name (seg
), ".got2") != 0
1688 && strcmp (segment_name (seg
), ".dtors") != 0
1689 && strcmp (segment_name (seg
), ".ctors") != 0
1690 && strcmp (segment_name (seg
), ".fixup") != 0
1691 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1692 && strcmp (segment_name (seg
), ".eh_frame") != 0
1693 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1695 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1696 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1698 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1699 _("Relocation cannot be done when using -mrelocatable"));
1706 #if BFD_DEFAULT_TARGET_SIZE == 64
1707 /* Don't emit .TOC. symbol. */
1709 ppc_elf_frob_symbol (sym
)
1714 name
= S_GET_NAME (sym
);
1715 if (name
!= NULL
&& strcmp (name
, ".TOC.") == 0)
1717 S_CLEAR_EXTERNAL (sym
);
1724 #endif /* OBJ_ELF */
1729 * Summary of parse_toc_entry.
1731 * in: Input_line_pointer points to the '[' in one of:
1733 * [toc] [tocv] [toc32] [toc64]
1735 * Anything else is an error of one kind or another.
1738 * return value: success or failure
1739 * toc_kind: kind of toc reference
1740 * input_line_pointer:
1741 * success: first char after the ']'
1742 * failure: unchanged
1746 * [toc] - rv == success, toc_kind = default_toc
1747 * [tocv] - rv == success, toc_kind = data_in_toc
1748 * [toc32] - rv == success, toc_kind = must_be_32
1749 * [toc64] - rv == success, toc_kind = must_be_64
1753 enum toc_size_qualifier
1755 default_toc
, /* The toc cell constructed should be the system default size */
1756 data_in_toc
, /* This is a direct reference to a toc cell */
1757 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1758 must_be_64
/* The toc cell constructed must be 64 bits wide */
1762 parse_toc_entry (toc_kind
)
1763 enum toc_size_qualifier
*toc_kind
;
1768 enum toc_size_qualifier t
;
1770 /* Save the input_line_pointer. */
1771 start
= input_line_pointer
;
1773 /* Skip over the '[' , and whitespace. */
1774 ++input_line_pointer
;
1777 /* Find the spelling of the operand. */
1778 toc_spec
= input_line_pointer
;
1779 c
= get_symbol_end ();
1781 if (strcmp (toc_spec
, "toc") == 0)
1785 else if (strcmp (toc_spec
, "tocv") == 0)
1789 else if (strcmp (toc_spec
, "toc32") == 0)
1793 else if (strcmp (toc_spec
, "toc64") == 0)
1799 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1800 *input_line_pointer
= c
;
1801 input_line_pointer
= start
;
1805 /* Now find the ']'. */
1806 *input_line_pointer
= c
;
1808 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1809 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1813 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1814 input_line_pointer
= start
;
1824 /* We need to keep a list of fixups. We can't simply generate them as
1825 we go, because that would require us to first create the frag, and
1826 that would screw up references to ``.''. */
1832 bfd_reloc_code_real_type reloc
;
1835 #define MAX_INSN_FIXUPS (5)
1837 /* This routine is called for each instruction to be assembled. */
1844 const struct powerpc_opcode
*opcode
;
1846 const unsigned char *opindex_ptr
;
1850 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
1855 bfd_reloc_code_real_type reloc
;
1858 /* Get the opcode. */
1859 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1864 /* Look up the opcode in the hash table. */
1865 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
1866 if (opcode
== (const struct powerpc_opcode
*) NULL
)
1868 const struct powerpc_macro
*macro
;
1870 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
1871 if (macro
== (const struct powerpc_macro
*) NULL
)
1872 as_bad (_("Unrecognized opcode: `%s'"), str
);
1874 ppc_macro (s
, macro
);
1879 insn
= opcode
->opcode
;
1882 while (ISSPACE (*str
))
1885 /* PowerPC operands are just expressions. The only real issue is
1886 that a few operand types are optional. All cases which might use
1887 an optional operand separate the operands only with commas (in
1888 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1889 cases never have optional operands). There is never more than
1890 one optional operand for an instruction. So, before we start
1891 seriously parsing the operands, we check to see if we have an
1892 optional operand, and, if we do, we count the number of commas to
1893 see whether the operand should be omitted. */
1895 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1897 const struct powerpc_operand
*operand
;
1899 operand
= &powerpc_operands
[*opindex_ptr
];
1900 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
1902 unsigned int opcount
;
1904 /* There is an optional operand. Count the number of
1905 commas in the input line. */
1912 while ((s
= strchr (s
, ',')) != (char *) NULL
)
1919 /* If there are fewer operands in the line then are called
1920 for by the instruction, we want to skip the optional
1922 if (opcount
< strlen (opcode
->operands
))
1929 /* Gather the operands. */
1933 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1935 const struct powerpc_operand
*operand
;
1941 if (next_opindex
== 0)
1942 operand
= &powerpc_operands
[*opindex_ptr
];
1945 operand
= &powerpc_operands
[next_opindex
];
1951 /* If this is a fake operand, then we do not expect anything
1953 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
1955 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
| ppc_size
, &errmsg
);
1956 if (errmsg
!= (const char *) NULL
)
1961 /* If this is an optional operand, and we are skipping it, just
1963 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
1966 if (operand
->insert
)
1968 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
| ppc_size
, &errmsg
);
1969 if (errmsg
!= (const char *) NULL
)
1972 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
1973 next_opindex
= *opindex_ptr
+ 1;
1977 /* Gather the operand. */
1978 hold
= input_line_pointer
;
1979 input_line_pointer
= str
;
1982 if (*input_line_pointer
== '[')
1984 /* We are expecting something like the second argument here:
1986 * lwz r4,[toc].GS.0.static_int(rtoc)
1987 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1988 * The argument following the `]' must be a symbol name, and the
1989 * register must be the toc register: 'rtoc' or '2'
1991 * The effect is to 0 as the displacement field
1992 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1993 * the appropriate variation) reloc against it based on the symbol.
1994 * The linker will build the toc, and insert the resolved toc offset.
1997 * o The size of the toc entry is currently assumed to be
1998 * 32 bits. This should not be assumed to be a hard coded
2000 * o In an effort to cope with a change from 32 to 64 bits,
2001 * there are also toc entries that are specified to be
2002 * either 32 or 64 bits:
2003 * lwz r4,[toc32].GS.0.static_int(rtoc)
2004 * lwz r4,[toc64].GS.0.static_int(rtoc)
2005 * These demand toc entries of the specified size, and the
2006 * instruction probably requires it.
2010 enum toc_size_qualifier toc_kind
;
2011 bfd_reloc_code_real_type toc_reloc
;
2013 /* Go parse off the [tocXX] part. */
2014 valid_toc
= parse_toc_entry (&toc_kind
);
2018 /* Note: message has already been issued.
2019 FIXME: what sort of recovery should we do?
2020 demand_rest_of_line (); return; ? */
2023 /* Now get the symbol following the ']'. */
2029 /* In this case, we may not have seen the symbol yet,
2030 since it is allowed to appear on a .extern or .globl
2031 or just be a label in the .data section. */
2032 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2035 /* 1. The symbol must be defined and either in the toc
2036 section, or a global.
2037 2. The reloc generated must have the TOCDEFN flag set
2038 in upper bit mess of the reloc type.
2039 FIXME: It's a little confusing what the tocv
2040 qualifier can be used for. At the very least, I've
2041 seen three uses, only one of which I'm sure I can
2043 if (ex
.X_op
== O_symbol
)
2045 assert (ex
.X_add_symbol
!= NULL
);
2046 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2049 as_bad (_("[tocv] symbol is not a toc symbol"));
2053 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2056 /* FIXME: these next two specifically specify 32/64 bit
2057 toc entries. We don't support them today. Is this
2058 the right way to say that? */
2059 toc_reloc
= BFD_RELOC_UNUSED
;
2060 as_bad (_("Unimplemented toc32 expression modifier"));
2063 /* FIXME: see above. */
2064 toc_reloc
= BFD_RELOC_UNUSED
;
2065 as_bad (_("Unimplemented toc64 expression modifier"));
2069 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2075 /* We need to generate a fixup for this expression. */
2076 if (fc
>= MAX_INSN_FIXUPS
)
2077 as_fatal (_("too many fixups"));
2079 fixups
[fc
].reloc
= toc_reloc
;
2080 fixups
[fc
].exp
= ex
;
2081 fixups
[fc
].opindex
= *opindex_ptr
;
2084 /* Ok. We've set up the fixup for the instruction. Now make it
2085 look like the constant 0 was found here. */
2087 ex
.X_op
= O_constant
;
2088 ex
.X_add_number
= 0;
2089 ex
.X_add_symbol
= NULL
;
2090 ex
.X_op_symbol
= NULL
;
2096 if (! register_name (&ex
))
2098 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2105 str
= input_line_pointer
;
2106 input_line_pointer
= hold
;
2108 if (ex
.X_op
== O_illegal
)
2109 as_bad (_("illegal operand"));
2110 else if (ex
.X_op
== O_absent
)
2111 as_bad (_("missing operand"));
2112 else if (ex
.X_op
== O_register
)
2114 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2117 else if (ex
.X_op
== O_constant
)
2120 /* Allow @HA, @L, @H on constants. */
2121 char *orig_str
= str
;
2123 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2130 case BFD_RELOC_LO16
:
2131 /* X_unsigned is the default, so if the user has done
2132 something which cleared it, we always produce a
2134 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2135 ex
.X_add_number
&= 0xffff;
2137 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2140 case BFD_RELOC_HI16
:
2141 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2142 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2144 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2147 case BFD_RELOC_HI16_S
:
2148 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2149 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2151 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2154 #if BFD_DEFAULT_TARGET_SIZE == 64
2155 case BFD_RELOC_PPC64_HIGHER
:
2156 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2157 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2159 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2162 case BFD_RELOC_PPC64_HIGHER_S
:
2163 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2164 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2166 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2169 case BFD_RELOC_PPC64_HIGHEST
:
2170 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2171 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2173 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2176 case BFD_RELOC_PPC64_HIGHEST_S
:
2177 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2178 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2180 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2182 #endif /* BFD_DEFAULT_TARGET_SIZE == 64 */
2184 #endif /* OBJ_ELF */
2185 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2189 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2191 /* For the absolute forms of branches, convert the PC
2192 relative form back into the absolute. */
2193 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2197 case BFD_RELOC_PPC_B26
:
2198 reloc
= BFD_RELOC_PPC_BA26
;
2200 case BFD_RELOC_PPC_B16
:
2201 reloc
= BFD_RELOC_PPC_BA16
;
2203 case BFD_RELOC_PPC_B16_BRTAKEN
:
2204 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2206 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2207 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2214 if (BFD_DEFAULT_TARGET_SIZE
== 64
2215 && ppc_size
== PPC_OPCODE_64
2216 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2221 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2223 case BFD_RELOC_LO16
:
2224 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2226 case BFD_RELOC_16_GOTOFF
:
2227 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2229 case BFD_RELOC_LO16_GOTOFF
:
2230 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2232 case BFD_RELOC_LO16_PLTOFF
:
2233 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2235 case BFD_RELOC_16_BASEREL
:
2236 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2238 case BFD_RELOC_LO16_BASEREL
:
2239 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2241 case BFD_RELOC_PPC_TOC16
:
2242 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2244 case BFD_RELOC_PPC64_TOC16_LO
:
2245 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2247 case BFD_RELOC_PPC64_PLTGOT16
:
2248 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2250 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2251 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2254 as_bad (_("unsupported relocation for DS offset field"));
2259 /* We need to generate a fixup for this expression. */
2260 if (fc
>= MAX_INSN_FIXUPS
)
2261 as_fatal (_("too many fixups"));
2262 fixups
[fc
].exp
= ex
;
2263 fixups
[fc
].opindex
= 0;
2264 fixups
[fc
].reloc
= reloc
;
2267 #endif /* OBJ_ELF */
2271 /* We need to generate a fixup for this expression. */
2272 if (fc
>= MAX_INSN_FIXUPS
)
2273 as_fatal (_("too many fixups"));
2274 fixups
[fc
].exp
= ex
;
2275 fixups
[fc
].opindex
= *opindex_ptr
;
2276 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2285 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2293 /* The call to expression should have advanced str past any
2296 && (endc
!= ',' || *str
!= '\0'))
2298 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2306 while (ISSPACE (*str
))
2310 as_bad (_("junk at end of line: `%s'"), str
);
2312 /* Write out the instruction. */
2314 md_number_to_chars (f
, insn
, 4);
2317 dwarf2_emit_insn (4);
2320 /* Create any fixups. At this point we do not use a
2321 bfd_reloc_code_real_type, but instead just use the
2322 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2323 handle fixups for any operand type, although that is admittedly
2324 not a very exciting feature. We pick a BFD reloc type in
2326 for (i
= 0; i
< fc
; i
++)
2328 const struct powerpc_operand
*operand
;
2330 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2331 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2333 reloc_howto_type
*reloc_howto
;
2338 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2342 size
= bfd_get_reloc_size (reloc_howto
);
2343 offset
= target_big_endian
? (4 - size
) : 0;
2345 if (size
< 1 || size
> 4)
2348 fixP
= fix_new_exp (frag_now
,
2349 f
- frag_now
->fr_literal
+ offset
,
2352 reloc_howto
->pc_relative
,
2355 /* Turn off complaints that the addend is too large for things like
2357 switch (fixups
[i
].reloc
)
2359 case BFD_RELOC_16_GOTOFF
:
2360 case BFD_RELOC_PPC_TOC16
:
2361 case BFD_RELOC_LO16
:
2362 case BFD_RELOC_HI16
:
2363 case BFD_RELOC_HI16_S
:
2365 #if BFD_DEFAULT_TARGET_SIZE == 64
2366 case BFD_RELOC_PPC64_HIGHER
:
2367 case BFD_RELOC_PPC64_HIGHER_S
:
2368 case BFD_RELOC_PPC64_HIGHEST
:
2369 case BFD_RELOC_PPC64_HIGHEST_S
:
2372 fixP
->fx_no_overflow
= 1;
2379 fix_new_exp (frag_now
,
2380 f
- frag_now
->fr_literal
,
2383 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2384 ((bfd_reloc_code_real_type
)
2385 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2389 /* Handle a macro. Gather all the operands, transform them as
2390 described by the macro, and call md_assemble recursively. All the
2391 operands are separated by commas; we don't accept parentheses
2392 around operands here. */
2395 ppc_macro (str
, macro
)
2397 const struct powerpc_macro
*macro
;
2408 /* Gather the users operands into the operands array. */
2413 if (count
>= sizeof operands
/ sizeof operands
[0])
2415 operands
[count
++] = s
;
2416 s
= strchr (s
, ',');
2417 if (s
== (char *) NULL
)
2422 if (count
!= macro
->operands
)
2424 as_bad (_("wrong number of operands"));
2428 /* Work out how large the string must be (the size is unbounded
2429 because it includes user input). */
2431 format
= macro
->format
;
2432 while (*format
!= '\0')
2441 arg
= strtol (format
+ 1, &send
, 10);
2442 know (send
!= format
&& arg
>= 0 && arg
< count
);
2443 len
+= strlen (operands
[arg
]);
2448 /* Put the string together. */
2449 complete
= s
= (char *) alloca (len
+ 1);
2450 format
= macro
->format
;
2451 while (*format
!= '\0')
2457 arg
= strtol (format
+ 1, &send
, 10);
2458 strcpy (s
, operands
[arg
]);
2465 /* Assemble the constructed instruction. */
2466 md_assemble (complete
);
2470 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2473 ppc_section_letter (letter
, ptr_msg
)
2480 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2485 ppc_section_word (str
, len
)
2489 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2496 ppc_section_type (str
, len
)
2500 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2507 ppc_section_flags (flags
, attr
, type
)
2512 if (type
== SHT_ORDERED
)
2513 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2515 if (attr
& SHF_EXCLUDE
)
2516 flags
|= SEC_EXCLUDE
;
2520 #endif /* OBJ_ELF */
2523 /* Pseudo-op handling. */
2525 /* The .byte pseudo-op. This is similar to the normal .byte
2526 pseudo-op, but it can also take a single ASCII string. */
2530 int ignore ATTRIBUTE_UNUSED
;
2532 if (*input_line_pointer
!= '\"')
2538 /* Gather characters. A real double quote is doubled. Unusual
2539 characters are not permitted. */
2540 ++input_line_pointer
;
2545 c
= *input_line_pointer
++;
2549 if (*input_line_pointer
!= '\"')
2551 ++input_line_pointer
;
2554 FRAG_APPEND_1_CHAR (c
);
2557 demand_empty_rest_of_line ();
2562 /* XCOFF specific pseudo-op handling. */
2564 /* This is set if we are creating a .stabx symbol, since we don't want
2565 to handle symbol suffixes for such symbols. */
2566 static boolean ppc_stab_symbol
;
2568 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2569 symbols in the .bss segment as though they were local common
2570 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2571 aligns .comm and .lcomm to 4 bytes. */
2577 asection
*current_seg
= now_seg
;
2578 subsegT current_subseg
= now_subseg
;
2584 symbolS
*lcomm_sym
= NULL
;
2588 name
= input_line_pointer
;
2589 endc
= get_symbol_end ();
2590 end_name
= input_line_pointer
;
2593 if (*input_line_pointer
!= ',')
2595 as_bad (_("missing size"));
2596 ignore_rest_of_line ();
2599 ++input_line_pointer
;
2601 size
= get_absolute_expression ();
2604 as_bad (_("negative size"));
2605 ignore_rest_of_line ();
2611 /* The third argument to .comm is the alignment. */
2612 if (*input_line_pointer
!= ',')
2616 ++input_line_pointer
;
2617 align
= get_absolute_expression ();
2620 as_warn (_("ignoring bad alignment"));
2635 /* The third argument to .lcomm appears to be the real local
2636 common symbol to create. References to the symbol named in
2637 the first argument are turned into references to the third
2639 if (*input_line_pointer
!= ',')
2641 as_bad (_("missing real symbol name"));
2642 ignore_rest_of_line ();
2645 ++input_line_pointer
;
2647 lcomm_name
= input_line_pointer
;
2648 lcomm_endc
= get_symbol_end ();
2650 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2652 *input_line_pointer
= lcomm_endc
;
2656 sym
= symbol_find_or_make (name
);
2659 if (S_IS_DEFINED (sym
)
2660 || S_GET_VALUE (sym
) != 0)
2662 as_bad (_("attempt to redefine symbol"));
2663 ignore_rest_of_line ();
2667 record_alignment (bss_section
, align
);
2670 || ! S_IS_DEFINED (lcomm_sym
))
2679 S_SET_EXTERNAL (sym
);
2683 symbol_get_tc (lcomm_sym
)->output
= 1;
2684 def_sym
= lcomm_sym
;
2688 subseg_set (bss_section
, 1);
2689 frag_align (align
, 0, 0);
2691 symbol_set_frag (def_sym
, frag_now
);
2692 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2693 def_size
, (char *) NULL
);
2695 S_SET_SEGMENT (def_sym
, bss_section
);
2696 symbol_get_tc (def_sym
)->align
= align
;
2700 /* Align the size of lcomm_sym. */
2701 symbol_get_frag (lcomm_sym
)->fr_offset
=
2702 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2703 &~ ((1 << align
) - 1));
2704 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2705 symbol_get_tc (lcomm_sym
)->align
= align
;
2710 /* Make sym an offset from lcomm_sym. */
2711 S_SET_SEGMENT (sym
, bss_section
);
2712 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2713 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2714 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2717 subseg_set (current_seg
, current_subseg
);
2719 demand_empty_rest_of_line ();
2722 /* The .csect pseudo-op. This switches us into a different
2723 subsegment. The first argument is a symbol whose value is the
2724 start of the .csect. In COFF, csect symbols get special aux
2725 entries defined by the x_csect field of union internal_auxent. The
2726 optional second argument is the alignment (the default is 2). */
2730 int ignore ATTRIBUTE_UNUSED
;
2736 name
= input_line_pointer
;
2737 endc
= get_symbol_end ();
2739 sym
= symbol_find_or_make (name
);
2741 *input_line_pointer
= endc
;
2743 if (S_GET_NAME (sym
)[0] == '\0')
2745 /* An unnamed csect is assumed to be [PR]. */
2746 symbol_get_tc (sym
)->class = XMC_PR
;
2749 ppc_change_csect (sym
);
2751 if (*input_line_pointer
== ',')
2753 ++input_line_pointer
;
2754 symbol_get_tc (sym
)->align
= get_absolute_expression ();
2757 demand_empty_rest_of_line ();
2760 /* Change to a different csect. */
2763 ppc_change_csect (sym
)
2766 if (S_IS_DEFINED (sym
))
2767 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
2775 /* This is a new csect. We need to look at the symbol class to
2776 figure out whether it should go in the text section or the
2779 switch (symbol_get_tc (sym
)->class)
2789 S_SET_SEGMENT (sym
, text_section
);
2790 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
2791 ++ppc_text_subsegment
;
2792 list_ptr
= &ppc_text_csects
;
2801 if (ppc_toc_csect
!= NULL
2802 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
2803 == ppc_data_subsegment
))
2805 S_SET_SEGMENT (sym
, data_section
);
2806 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
2807 ++ppc_data_subsegment
;
2808 list_ptr
= &ppc_data_csects
;
2814 /* We set the obstack chunk size to a small value before
2815 changing subsegments, so that we don't use a lot of memory
2816 space for what may be a small section. */
2817 hold_chunksize
= chunksize
;
2820 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
2821 symbol_get_tc (sym
)->subseg
);
2823 chunksize
= hold_chunksize
;
2826 ppc_after_toc_frag
= frag_now
;
2828 symbol_set_frag (sym
, frag_now
);
2829 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2831 symbol_get_tc (sym
)->align
= 2;
2832 symbol_get_tc (sym
)->output
= 1;
2833 symbol_get_tc (sym
)->within
= sym
;
2835 for (list
= *list_ptr
;
2836 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
2837 list
= symbol_get_tc (list
)->next
)
2839 symbol_get_tc (list
)->next
= sym
;
2841 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2842 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
2846 ppc_current_csect
= sym
;
2849 /* This function handles the .text and .data pseudo-ops. These
2850 pseudo-ops aren't really used by XCOFF; we implement them for the
2851 convenience of people who aren't used to XCOFF. */
2862 else if (type
== 'd')
2867 sym
= symbol_find_or_make (name
);
2869 ppc_change_csect (sym
);
2871 demand_empty_rest_of_line ();
2874 /* This function handles the .section pseudo-op. This is mostly to
2875 give an error, since XCOFF only supports .text, .data and .bss, but
2876 we do permit the user to name the text or data section. */
2879 ppc_named_section (ignore
)
2880 int ignore ATTRIBUTE_UNUSED
;
2883 const char *real_name
;
2887 user_name
= input_line_pointer
;
2888 c
= get_symbol_end ();
2890 if (strcmp (user_name
, ".text") == 0)
2891 real_name
= ".text[PR]";
2892 else if (strcmp (user_name
, ".data") == 0)
2893 real_name
= ".data[RW]";
2896 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2897 *input_line_pointer
= c
;
2898 ignore_rest_of_line ();
2902 *input_line_pointer
= c
;
2904 sym
= symbol_find_or_make (real_name
);
2906 ppc_change_csect (sym
);
2908 demand_empty_rest_of_line ();
2911 /* The .extern pseudo-op. We create an undefined symbol. */
2915 int ignore ATTRIBUTE_UNUSED
;
2920 name
= input_line_pointer
;
2921 endc
= get_symbol_end ();
2923 (void) symbol_find_or_make (name
);
2925 *input_line_pointer
= endc
;
2927 demand_empty_rest_of_line ();
2930 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2934 int ignore ATTRIBUTE_UNUSED
;
2940 name
= input_line_pointer
;
2941 endc
= get_symbol_end ();
2943 sym
= symbol_find_or_make (name
);
2945 *input_line_pointer
= endc
;
2947 symbol_get_tc (sym
)->output
= 1;
2949 demand_empty_rest_of_line ();
2952 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2953 although I don't know why it bothers. */
2957 int ignore ATTRIBUTE_UNUSED
;
2964 name
= input_line_pointer
;
2965 endc
= get_symbol_end ();
2967 sym
= symbol_find_or_make (name
);
2969 *input_line_pointer
= endc
;
2971 if (*input_line_pointer
!= ',')
2973 as_bad (_("missing rename string"));
2974 ignore_rest_of_line ();
2977 ++input_line_pointer
;
2979 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
2981 demand_empty_rest_of_line ();
2984 /* The .stabx pseudo-op. This is similar to a normal .stabs
2985 pseudo-op, but slightly different. A sample is
2986 .stabx "main:F-1",.main,142,0
2987 The first argument is the symbol name to create. The second is the
2988 value, and the third is the storage class. The fourth seems to be
2989 always zero, and I am assuming it is the type. */
2993 int ignore ATTRIBUTE_UNUSED
;
3000 name
= demand_copy_C_string (&len
);
3002 if (*input_line_pointer
!= ',')
3004 as_bad (_("missing value"));
3007 ++input_line_pointer
;
3009 ppc_stab_symbol
= true;
3010 sym
= symbol_make (name
);
3011 ppc_stab_symbol
= false;
3013 symbol_get_tc (sym
)->real_name
= name
;
3015 (void) expression (&exp
);
3022 as_bad (_("illegal .stabx expression; zero assumed"));
3023 exp
.X_add_number
= 0;
3026 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3027 symbol_set_frag (sym
, &zero_address_frag
);
3031 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3032 symbol_set_value_expression (sym
, &exp
);
3036 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3037 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3042 /* The value is some complex expression. This will probably
3043 fail at some later point, but this is probably the right
3044 thing to do here. */
3045 symbol_set_value_expression (sym
, &exp
);
3049 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3050 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3052 if (*input_line_pointer
!= ',')
3054 as_bad (_("missing class"));
3057 ++input_line_pointer
;
3059 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3061 if (*input_line_pointer
!= ',')
3063 as_bad (_("missing type"));
3066 ++input_line_pointer
;
3068 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3070 symbol_get_tc (sym
)->output
= 1;
3072 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3074 symbol_get_tc (sym
)->within
= ppc_current_block
;
3079 .stabx "z",arrays_,133,0
3082 .comm arrays_,13768,3
3084 resolve_symbol_value will copy the exp's "within" into sym's when the
3085 offset is 0. Since this seems to be corner case problem,
3086 only do the correction for storage class C_STSYM. A better solution
3087 would be to have the tc field updated in ppc_symbol_new_hook. */
3089 if (exp
.X_op
== O_symbol
)
3091 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3095 if (exp
.X_op
!= O_symbol
3096 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3097 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3098 ppc_frob_label (sym
);
3101 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3102 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3103 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3104 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3107 demand_empty_rest_of_line ();
3110 /* The .function pseudo-op. This takes several arguments. The first
3111 argument seems to be the external name of the symbol. The second
3112 argment seems to be the label for the start of the function. gcc
3113 uses the same name for both. I have no idea what the third and
3114 fourth arguments are meant to be. The optional fifth argument is
3115 an expression for the size of the function. In COFF this symbol
3116 gets an aux entry like that used for a csect. */
3119 ppc_function (ignore
)
3120 int ignore ATTRIBUTE_UNUSED
;
3128 name
= input_line_pointer
;
3129 endc
= get_symbol_end ();
3131 /* Ignore any [PR] suffix. */
3132 name
= ppc_canonicalize_symbol_name (name
);
3133 s
= strchr (name
, '[');
3134 if (s
!= (char *) NULL
3135 && strcmp (s
+ 1, "PR]") == 0)
3138 ext_sym
= symbol_find_or_make (name
);
3140 *input_line_pointer
= endc
;
3142 if (*input_line_pointer
!= ',')
3144 as_bad (_("missing symbol name"));
3145 ignore_rest_of_line ();
3148 ++input_line_pointer
;
3150 name
= input_line_pointer
;
3151 endc
= get_symbol_end ();
3153 lab_sym
= symbol_find_or_make (name
);
3155 *input_line_pointer
= endc
;
3157 if (ext_sym
!= lab_sym
)
3161 exp
.X_op
= O_symbol
;
3162 exp
.X_add_symbol
= lab_sym
;
3163 exp
.X_op_symbol
= NULL
;
3164 exp
.X_add_number
= 0;
3166 symbol_set_value_expression (ext_sym
, &exp
);
3169 if (symbol_get_tc (ext_sym
)->class == -1)
3170 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3171 symbol_get_tc (ext_sym
)->output
= 1;
3173 if (*input_line_pointer
== ',')
3177 /* Ignore the third argument. */
3178 ++input_line_pointer
;
3179 expression (&ignore
);
3180 if (*input_line_pointer
== ',')
3182 /* Ignore the fourth argument. */
3183 ++input_line_pointer
;
3184 expression (&ignore
);
3185 if (*input_line_pointer
== ',')
3187 /* The fifth argument is the function size. */
3188 ++input_line_pointer
;
3189 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3192 &zero_address_frag
);
3193 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3198 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3199 SF_SET_FUNCTION (ext_sym
);
3200 SF_SET_PROCESS (ext_sym
);
3201 coff_add_linesym (ext_sym
);
3203 demand_empty_rest_of_line ();
3206 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3207 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3208 with the correct line number */
3210 static symbolS
*saved_bi_sym
= 0;
3214 int ignore ATTRIBUTE_UNUSED
;
3218 sym
= symbol_make (".bf");
3219 S_SET_SEGMENT (sym
, text_section
);
3220 symbol_set_frag (sym
, frag_now
);
3221 S_SET_VALUE (sym
, frag_now_fix ());
3222 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3224 coff_line_base
= get_absolute_expression ();
3226 S_SET_NUMBER_AUXILIARY (sym
, 1);
3227 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3229 /* Line number for bi. */
3232 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3237 symbol_get_tc (sym
)->output
= 1;
3239 ppc_frob_label (sym
);
3241 demand_empty_rest_of_line ();
3244 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3245 ".ef", except that the line number is absolute, not relative to the
3246 most recent ".bf" symbol. */
3250 int ignore ATTRIBUTE_UNUSED
;
3254 sym
= symbol_make (".ef");
3255 S_SET_SEGMENT (sym
, text_section
);
3256 symbol_set_frag (sym
, frag_now
);
3257 S_SET_VALUE (sym
, frag_now_fix ());
3258 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3259 S_SET_NUMBER_AUXILIARY (sym
, 1);
3260 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3261 symbol_get_tc (sym
)->output
= 1;
3263 ppc_frob_label (sym
);
3265 demand_empty_rest_of_line ();
3268 /* The .bi and .ei pseudo-ops. These take a string argument and
3269 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3270 the symbol list. The value of .bi will be know when the next .bf
3277 static symbolS
*last_biei
;
3284 name
= demand_copy_C_string (&len
);
3286 /* The value of these symbols is actually file offset. Here we set
3287 the value to the index into the line number entries. In
3288 ppc_frob_symbols we set the fix_line field, which will cause BFD
3289 to do the right thing. */
3291 sym
= symbol_make (name
);
3292 /* obj-coff.c currently only handles line numbers correctly in the
3294 S_SET_SEGMENT (sym
, text_section
);
3295 S_SET_VALUE (sym
, coff_n_line_nos
);
3296 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3298 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3299 symbol_get_tc (sym
)->output
= 1;
3307 for (look
= last_biei
? last_biei
: symbol_rootP
;
3308 (look
!= (symbolS
*) NULL
3309 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3310 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3311 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3312 look
= symbol_next (look
))
3314 if (look
!= (symbolS
*) NULL
)
3316 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3317 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3321 demand_empty_rest_of_line ();
3324 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3325 There is one argument, which is a csect symbol. The value of the
3326 .bs symbol is the index of this csect symbol. */
3330 int ignore ATTRIBUTE_UNUSED
;
3337 if (ppc_current_block
!= NULL
)
3338 as_bad (_("nested .bs blocks"));
3340 name
= input_line_pointer
;
3341 endc
= get_symbol_end ();
3343 csect
= symbol_find_or_make (name
);
3345 *input_line_pointer
= endc
;
3347 sym
= symbol_make (".bs");
3348 S_SET_SEGMENT (sym
, now_seg
);
3349 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3350 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3351 symbol_get_tc (sym
)->output
= 1;
3353 symbol_get_tc (sym
)->within
= csect
;
3355 ppc_frob_label (sym
);
3357 ppc_current_block
= sym
;
3359 demand_empty_rest_of_line ();
3362 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3366 int ignore ATTRIBUTE_UNUSED
;
3370 if (ppc_current_block
== NULL
)
3371 as_bad (_(".es without preceding .bs"));
3373 sym
= symbol_make (".es");
3374 S_SET_SEGMENT (sym
, now_seg
);
3375 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3376 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3377 symbol_get_tc (sym
)->output
= 1;
3379 ppc_frob_label (sym
);
3381 ppc_current_block
= NULL
;
3383 demand_empty_rest_of_line ();
3386 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3391 int ignore ATTRIBUTE_UNUSED
;
3395 sym
= symbol_make (".bb");
3396 S_SET_SEGMENT (sym
, text_section
);
3397 symbol_set_frag (sym
, frag_now
);
3398 S_SET_VALUE (sym
, frag_now_fix ());
3399 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3401 S_SET_NUMBER_AUXILIARY (sym
, 1);
3402 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3404 symbol_get_tc (sym
)->output
= 1;
3406 SF_SET_PROCESS (sym
);
3408 ppc_frob_label (sym
);
3410 demand_empty_rest_of_line ();
3413 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3418 int ignore ATTRIBUTE_UNUSED
;
3422 sym
= symbol_make (".eb");
3423 S_SET_SEGMENT (sym
, text_section
);
3424 symbol_set_frag (sym
, frag_now
);
3425 S_SET_VALUE (sym
, frag_now_fix ());
3426 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3427 S_SET_NUMBER_AUXILIARY (sym
, 1);
3428 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3429 symbol_get_tc (sym
)->output
= 1;
3431 SF_SET_PROCESS (sym
);
3433 ppc_frob_label (sym
);
3435 demand_empty_rest_of_line ();
3438 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3443 int ignore ATTRIBUTE_UNUSED
;
3449 name
= demand_copy_C_string (&len
);
3450 sym
= symbol_make (name
);
3451 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3452 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3453 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3454 S_SET_VALUE (sym
, 0);
3455 symbol_get_tc (sym
)->output
= 1;
3457 ppc_frob_label (sym
);
3459 demand_empty_rest_of_line ();
3462 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3466 int ignore ATTRIBUTE_UNUSED
;
3470 sym
= symbol_make (".ec");
3471 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3472 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3473 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3474 S_SET_VALUE (sym
, 0);
3475 symbol_get_tc (sym
)->output
= 1;
3477 ppc_frob_label (sym
);
3479 demand_empty_rest_of_line ();
3482 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3486 int ignore ATTRIBUTE_UNUSED
;
3488 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3489 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3496 subseg
= ppc_data_subsegment
;
3497 ++ppc_data_subsegment
;
3499 subseg_new (segment_name (data_section
), subseg
);
3500 ppc_toc_frag
= frag_now
;
3502 sym
= symbol_find_or_make ("TOC[TC0]");
3503 symbol_set_frag (sym
, frag_now
);
3504 S_SET_SEGMENT (sym
, data_section
);
3505 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3506 symbol_get_tc (sym
)->subseg
= subseg
;
3507 symbol_get_tc (sym
)->output
= 1;
3508 symbol_get_tc (sym
)->within
= sym
;
3510 ppc_toc_csect
= sym
;
3512 for (list
= ppc_data_csects
;
3513 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3514 list
= symbol_get_tc (list
)->next
)
3516 symbol_get_tc (list
)->next
= sym
;
3518 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3519 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3523 ppc_current_csect
= ppc_toc_csect
;
3525 demand_empty_rest_of_line ();
3528 /* The AIX assembler automatically aligns the operands of a .long or
3529 .short pseudo-op, and we want to be compatible. */
3532 ppc_xcoff_cons (log_size
)
3535 frag_align (log_size
, 0, 0);
3536 record_alignment (now_seg
, log_size
);
3537 cons (1 << log_size
);
3542 int dummy ATTRIBUTE_UNUSED
;
3547 (void) expression (&exp
);
3549 if (exp
.X_op
!= O_constant
)
3551 as_bad (_("non-constant byte count"));
3555 byte_count
= exp
.X_add_number
;
3557 if (*input_line_pointer
!= ',')
3559 as_bad (_("missing value"));
3563 ++input_line_pointer
;
3567 #endif /* OBJ_XCOFF */
3568 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3570 /* The .tc pseudo-op. This is used when generating either XCOFF or
3571 ELF. This takes two or more arguments.
3573 When generating XCOFF output, the first argument is the name to
3574 give to this location in the toc; this will be a symbol with class
3575 TC. The rest of the arguments are N-byte values to actually put at
3576 this location in the TOC; often there is just one more argument, a
3577 relocateable symbol reference. The size of the value to store
3578 depends on target word size. A 32-bit target uses 4-byte values, a
3579 64-bit target uses 8-byte values.
3581 When not generating XCOFF output, the arguments are the same, but
3582 the first argument is simply ignored. */
3586 int ignore ATTRIBUTE_UNUSED
;
3590 /* Define the TOC symbol name. */
3596 if (ppc_toc_csect
== (symbolS
*) NULL
3597 || ppc_toc_csect
!= ppc_current_csect
)
3599 as_bad (_(".tc not in .toc section"));
3600 ignore_rest_of_line ();
3604 name
= input_line_pointer
;
3605 endc
= get_symbol_end ();
3607 sym
= symbol_find_or_make (name
);
3609 *input_line_pointer
= endc
;
3611 if (S_IS_DEFINED (sym
))
3615 label
= symbol_get_tc (ppc_current_csect
)->within
;
3616 if (symbol_get_tc (label
)->class != XMC_TC0
)
3618 as_bad (_(".tc with no label"));
3619 ignore_rest_of_line ();
3623 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3624 symbol_set_frag (label
, symbol_get_frag (sym
));
3625 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3627 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3628 ++input_line_pointer
;
3633 S_SET_SEGMENT (sym
, now_seg
);
3634 symbol_set_frag (sym
, frag_now
);
3635 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3636 symbol_get_tc (sym
)->class = XMC_TC
;
3637 symbol_get_tc (sym
)->output
= 1;
3639 ppc_frob_label (sym
);
3642 #endif /* OBJ_XCOFF */
3646 /* Skip the TOC symbol name. */
3647 while (is_part_of_name (*input_line_pointer
)
3648 || *input_line_pointer
== '['
3649 || *input_line_pointer
== ']'
3650 || *input_line_pointer
== '{'
3651 || *input_line_pointer
== '}')
3652 ++input_line_pointer
;
3654 /* Align to a four/eight byte boundary. */
3655 align
= BFD_DEFAULT_TARGET_SIZE
== 64 && ppc_size
== PPC_OPCODE_64
? 3 : 2;
3656 frag_align (align
, 0, 0);
3657 record_alignment (now_seg
, align
);
3658 #endif /* OBJ_ELF */
3660 if (*input_line_pointer
!= ',')
3661 demand_empty_rest_of_line ();
3664 ++input_line_pointer
;
3665 cons ((ppc_size
== PPC_OPCODE_64
) ? 8 : 4);
3669 /* Pseudo-op .machine. */
3670 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3671 accept this directive on the first line of input and set ppc_size
3672 and the target format accordingly. Unfortunately, the target
3673 format is selected in output-file.c:output_file_create before we
3674 even get to md_begin, so it's not possible without changing
3678 ppc_machine (ignore
)
3679 int ignore ATTRIBUTE_UNUSED
;
3681 discard_rest_of_line ();
3684 /* See whether a symbol is in the TOC section. */
3687 ppc_is_toc_sym (sym
)
3691 return symbol_get_tc (sym
)->class == XMC_TC
;
3694 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3695 if (BFD_DEFAULT_TARGET_SIZE
== 64 && ppc_size
== PPC_OPCODE_64
)
3696 return strcmp (sname
, ".toc") == 0;
3698 return strcmp (sname
, ".got") == 0;
3701 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3705 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3707 /* Set the current section. */
3709 ppc_set_current_section (new)
3712 ppc_previous_section
= ppc_current_section
;
3713 ppc_current_section
= new;
3716 /* pseudo-op: .previous
3717 behaviour: toggles the current section with the previous section.
3719 warnings: "No previous section" */
3722 ppc_previous (ignore
)
3723 int ignore ATTRIBUTE_UNUSED
;
3727 if (ppc_previous_section
== NULL
)
3729 as_warn (_("No previous section to return to. Directive ignored."));
3733 subseg_set (ppc_previous_section
, 0);
3735 ppc_set_current_section (ppc_previous_section
);
3738 /* pseudo-op: .pdata
3739 behaviour: predefined read only data section
3743 initial: .section .pdata "adr3"
3744 a - don't know -- maybe a misprint
3745 d - initialized data
3747 3 - double word aligned (that would be 4 byte boundary)
3750 Tag index tables (also known as the function table) for exception
3751 handling, debugging, etc. */
3755 int ignore ATTRIBUTE_UNUSED
;
3757 if (pdata_section
== 0)
3759 pdata_section
= subseg_new (".pdata", 0);
3761 bfd_set_section_flags (stdoutput
, pdata_section
,
3762 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3763 | SEC_READONLY
| SEC_DATA
));
3765 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
3769 pdata_section
= subseg_new (".pdata", 0);
3771 ppc_set_current_section (pdata_section
);
3774 /* pseudo-op: .ydata
3775 behaviour: predefined read only data section
3779 initial: .section .ydata "drw3"
3780 a - don't know -- maybe a misprint
3781 d - initialized data
3783 3 - double word aligned (that would be 4 byte boundary)
3785 Tag tables (also known as the scope table) for exception handling,
3790 int ignore ATTRIBUTE_UNUSED
;
3792 if (ydata_section
== 0)
3794 ydata_section
= subseg_new (".ydata", 0);
3795 bfd_set_section_flags (stdoutput
, ydata_section
,
3796 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3797 | SEC_READONLY
| SEC_DATA
));
3799 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
3803 ydata_section
= subseg_new (".ydata", 0);
3805 ppc_set_current_section (ydata_section
);
3808 /* pseudo-op: .reldata
3809 behaviour: predefined read write data section
3810 double word aligned (4-byte)
3811 FIXME: relocation is applied to it
3812 FIXME: what's the difference between this and .data?
3815 initial: .section .reldata "drw3"
3816 d - initialized data
3819 3 - double word aligned (that would be 8 byte boundary)
3822 Like .data, but intended to hold data subject to relocation, such as
3823 function descriptors, etc. */
3826 ppc_reldata (ignore
)
3827 int ignore ATTRIBUTE_UNUSED
;
3829 if (reldata_section
== 0)
3831 reldata_section
= subseg_new (".reldata", 0);
3833 bfd_set_section_flags (stdoutput
, reldata_section
,
3834 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3837 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
3841 reldata_section
= subseg_new (".reldata", 0);
3843 ppc_set_current_section (reldata_section
);
3846 /* pseudo-op: .rdata
3847 behaviour: predefined read only data section
3851 initial: .section .rdata "dr3"
3852 d - initialized data
3854 3 - double word aligned (that would be 4 byte boundary) */
3858 int ignore ATTRIBUTE_UNUSED
;
3860 if (rdata_section
== 0)
3862 rdata_section
= subseg_new (".rdata", 0);
3863 bfd_set_section_flags (stdoutput
, rdata_section
,
3864 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3865 | SEC_READONLY
| SEC_DATA
));
3867 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
3871 rdata_section
= subseg_new (".rdata", 0);
3873 ppc_set_current_section (rdata_section
);
3876 /* pseudo-op: .ualong
3877 behaviour: much like .int, with the exception that no alignment is
3879 FIXME: test the alignment statement
3885 int ignore ATTRIBUTE_UNUSED
;
3891 /* pseudo-op: .znop <symbol name>
3892 behaviour: Issue a nop instruction
3893 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3894 the supplied symbol name.
3896 warnings: Missing symbol name */
3900 int ignore ATTRIBUTE_UNUSED
;
3903 const struct powerpc_opcode
*opcode
;
3914 /* Strip out the symbol name. */
3915 symbol_name
= input_line_pointer
;
3916 c
= get_symbol_end ();
3918 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
3919 strcpy (name
, symbol_name
);
3921 sym
= symbol_find_or_make (name
);
3923 *input_line_pointer
= c
;
3927 /* Look up the opcode in the hash table. */
3928 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
3930 /* Stick in the nop. */
3931 insn
= opcode
->opcode
;
3933 /* Write out the instruction. */
3935 md_number_to_chars (f
, insn
, 4);
3937 f
- frag_now
->fr_literal
,
3942 BFD_RELOC_16_GOT_PCREL
);
3955 register char *name
;
3959 register symbolS
*symbolP
;
3962 name
= input_line_pointer
;
3963 c
= get_symbol_end ();
3965 /* just after name is now '\0'. */
3966 p
= input_line_pointer
;
3969 if (*input_line_pointer
!= ',')
3971 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3972 ignore_rest_of_line ();
3976 input_line_pointer
++; /* skip ',' */
3977 if ((temp
= get_absolute_expression ()) < 0)
3979 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
3980 ignore_rest_of_line ();
3986 /* The third argument to .comm is the alignment. */
3987 if (*input_line_pointer
!= ',')
3991 ++input_line_pointer
;
3992 align
= get_absolute_expression ();
3995 as_warn (_("ignoring bad alignment"));
4002 symbolP
= symbol_find_or_make (name
);
4005 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4007 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4008 S_GET_NAME (symbolP
));
4009 ignore_rest_of_line ();
4013 if (S_GET_VALUE (symbolP
))
4015 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4016 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4017 S_GET_NAME (symbolP
),
4018 (long) S_GET_VALUE (symbolP
),
4023 S_SET_VALUE (symbolP
, (valueT
) temp
);
4024 S_SET_EXTERNAL (symbolP
);
4027 demand_empty_rest_of_line ();
4031 * implement the .section pseudo op:
4032 * .section name {, "flags"}
4034 * | +--- optional flags: 'b' for bss
4036 * +-- section name 'l' for lib
4040 * 'd' (apparently m88k for data)
4042 * But if the argument is not a quoted string, treat it as a
4043 * subsegment number.
4045 * FIXME: this is a copy of the section processing from obj-coff.c, with
4046 * additions/changes for the moto-pas assembler support. There are three
4049 * FIXME: I just noticed this. This doesn't work at all really. It it
4050 * setting bits that bfd probably neither understands or uses. The
4051 * correct approach (?) will have to incorporate extra fields attached
4052 * to the section to hold the system specific stuff. (krk)
4055 * 'a' - unknown - referred to in documentation, but no definition supplied
4056 * 'c' - section has code
4057 * 'd' - section has initialized data
4058 * 'u' - section has uninitialized data
4059 * 'i' - section contains directives (info)
4060 * 'n' - section can be discarded
4061 * 'R' - remove section at link time
4063 * Section Protection:
4064 * 'r' - section is readable
4065 * 'w' - section is writeable
4066 * 'x' - section is executable
4067 * 's' - section is sharable
4069 * Section Alignment:
4070 * '0' - align to byte boundary
4071 * '1' - align to halfword undary
4072 * '2' - align to word boundary
4073 * '3' - align to doubleword boundary
4074 * '4' - align to quadword boundary
4075 * '5' - align to 32 byte boundary
4076 * '6' - align to 64 byte boundary
4081 ppc_pe_section (ignore
)
4082 int ignore ATTRIBUTE_UNUSED
;
4084 /* Strip out the section name. */
4093 section_name
= input_line_pointer
;
4094 c
= get_symbol_end ();
4096 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4097 strcpy (name
, section_name
);
4099 *input_line_pointer
= c
;
4104 flags
= SEC_NO_FLAGS
;
4106 if (strcmp (name
, ".idata$2") == 0)
4110 else if (strcmp (name
, ".idata$3") == 0)
4114 else if (strcmp (name
, ".idata$4") == 0)
4118 else if (strcmp (name
, ".idata$5") == 0)
4122 else if (strcmp (name
, ".idata$6") == 0)
4127 /* Default alignment to 16 byte boundary. */
4130 if (*input_line_pointer
== ',')
4132 ++input_line_pointer
;
4134 if (*input_line_pointer
!= '"')
4135 exp
= get_absolute_expression ();
4138 ++input_line_pointer
;
4139 while (*input_line_pointer
!= '"'
4140 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4142 switch (*input_line_pointer
)
4144 /* Section Contents */
4145 case 'a': /* unknown */
4146 as_bad (_("Unsupported section attribute -- 'a'"));
4148 case 'c': /* code section */
4151 case 'd': /* section has initialized data */
4154 case 'u': /* section has uninitialized data */
4155 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4159 case 'i': /* section contains directives (info) */
4160 /* FIXME: This is IMAGE_SCN_LNK_INFO
4162 flags
|= SEC_HAS_CONTENTS
;
4164 case 'n': /* section can be discarded */
4167 case 'R': /* Remove section at link time */
4168 flags
|= SEC_NEVER_LOAD
;
4171 /* Section Protection */
4172 case 'r': /* section is readable */
4173 flags
|= IMAGE_SCN_MEM_READ
;
4175 case 'w': /* section is writeable */
4176 flags
|= IMAGE_SCN_MEM_WRITE
;
4178 case 'x': /* section is executable */
4179 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4181 case 's': /* section is sharable */
4182 flags
|= IMAGE_SCN_MEM_SHARED
;
4185 /* Section Alignment */
4186 case '0': /* align to byte boundary */
4187 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4190 case '1': /* align to halfword boundary */
4191 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4194 case '2': /* align to word boundary */
4195 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4198 case '3': /* align to doubleword boundary */
4199 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4202 case '4': /* align to quadword boundary */
4203 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4206 case '5': /* align to 32 byte boundary */
4207 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4210 case '6': /* align to 64 byte boundary */
4211 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4216 as_bad (_("unknown section attribute '%c'"),
4217 *input_line_pointer
);
4220 ++input_line_pointer
;
4222 if (*input_line_pointer
== '"')
4223 ++input_line_pointer
;
4227 sec
= subseg_new (name
, (subsegT
) exp
);
4229 ppc_set_current_section (sec
);
4231 if (flags
!= SEC_NO_FLAGS
)
4233 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4234 as_bad (_("error setting flags for \"%s\": %s"),
4235 bfd_section_name (stdoutput
, sec
),
4236 bfd_errmsg (bfd_get_error ()));
4239 bfd_set_section_alignment (stdoutput
, sec
, align
);
4244 ppc_pe_function (ignore
)
4245 int ignore ATTRIBUTE_UNUSED
;
4251 name
= input_line_pointer
;
4252 endc
= get_symbol_end ();
4254 ext_sym
= symbol_find_or_make (name
);
4256 *input_line_pointer
= endc
;
4258 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4259 SF_SET_FUNCTION (ext_sym
);
4260 SF_SET_PROCESS (ext_sym
);
4261 coff_add_linesym (ext_sym
);
4263 demand_empty_rest_of_line ();
4267 ppc_pe_tocd (ignore
)
4268 int ignore ATTRIBUTE_UNUSED
;
4270 if (tocdata_section
== 0)
4272 tocdata_section
= subseg_new (".tocd", 0);
4273 /* FIXME: section flags won't work. */
4274 bfd_set_section_flags (stdoutput
, tocdata_section
,
4275 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4276 | SEC_READONLY
| SEC_DATA
));
4278 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4282 rdata_section
= subseg_new (".tocd", 0);
4285 ppc_set_current_section (tocdata_section
);
4287 demand_empty_rest_of_line ();
4290 /* Don't adjust TOC relocs to use the section symbol. */
4293 ppc_pe_fix_adjustable (fix
)
4296 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4303 /* XCOFF specific symbol and file handling. */
4305 /* Canonicalize the symbol name. We use the to force the suffix, if
4306 any, to use square brackets, and to be in upper case. */
4309 ppc_canonicalize_symbol_name (name
)
4314 if (ppc_stab_symbol
)
4317 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4331 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4334 if (*s
== '\0' || s
[1] != '\0')
4335 as_bad (_("bad symbol suffix"));
4343 /* Set the class of a symbol based on the suffix, if any. This is
4344 called whenever a new symbol is created. */
4347 ppc_symbol_new_hook (sym
)
4350 struct ppc_tc_sy
*tc
;
4353 tc
= symbol_get_tc (sym
);
4357 tc
->real_name
= NULL
;
4363 if (ppc_stab_symbol
)
4366 s
= strchr (S_GET_NAME (sym
), '[');
4367 if (s
== (const char *) NULL
)
4369 /* There is no suffix. */
4378 if (strcmp (s
, "BS]") == 0)
4382 if (strcmp (s
, "DB]") == 0)
4384 else if (strcmp (s
, "DS]") == 0)
4388 if (strcmp (s
, "GL]") == 0)
4392 if (strcmp (s
, "PR]") == 0)
4396 if (strcmp (s
, "RO]") == 0)
4398 else if (strcmp (s
, "RW]") == 0)
4402 if (strcmp (s
, "SV]") == 0)
4406 if (strcmp (s
, "TC]") == 0)
4408 else if (strcmp (s
, "TI]") == 0)
4410 else if (strcmp (s
, "TB]") == 0)
4412 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4413 tc
->class = XMC_TC0
;
4416 if (strcmp (s
, "UA]") == 0)
4418 else if (strcmp (s
, "UC]") == 0)
4422 if (strcmp (s
, "XO]") == 0)
4427 if (tc
->class == -1)
4428 as_bad (_("Unrecognized symbol suffix"));
4431 /* Set the class of a label based on where it is defined. This
4432 handles symbols without suffixes. Also, move the symbol so that it
4433 follows the csect symbol. */
4436 ppc_frob_label (sym
)
4439 if (ppc_current_csect
!= (symbolS
*) NULL
)
4441 if (symbol_get_tc (sym
)->class == -1)
4442 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4444 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4445 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4446 &symbol_rootP
, &symbol_lastP
);
4447 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4451 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4452 seen. It tells ppc_adjust_symtab whether it needs to look through
4455 static boolean ppc_saw_abs
;
4457 /* Change the name of a symbol just before writing it out. Set the
4458 real name if the .rename pseudo-op was used. Otherwise, remove any
4459 class suffix. Return 1 if the symbol should not be included in the
4463 ppc_frob_symbol (sym
)
4466 static symbolS
*ppc_last_function
;
4467 static symbolS
*set_end
;
4469 /* Discard symbols that should not be included in the output symbol
4471 if (! symbol_used_in_reloc_p (sym
)
4472 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4473 || (! S_IS_EXTERNAL (sym
)
4474 && ! symbol_get_tc (sym
)->output
4475 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4478 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4479 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4485 name
= S_GET_NAME (sym
);
4486 s
= strchr (name
, '[');
4487 if (s
!= (char *) NULL
)
4493 snew
= xmalloc (len
+ 1);
4494 memcpy (snew
, name
, len
);
4497 S_SET_NAME (sym
, snew
);
4501 if (set_end
!= (symbolS
*) NULL
)
4503 SA_SET_SYM_ENDNDX (set_end
, sym
);
4507 if (SF_GET_FUNCTION (sym
))
4509 if (ppc_last_function
!= (symbolS
*) NULL
)
4510 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4511 ppc_last_function
= sym
;
4512 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4514 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4515 SA_SET_SYM_FSIZE (sym
,
4516 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4519 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4520 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4522 if (ppc_last_function
== (symbolS
*) NULL
)
4523 as_bad (_(".ef with no preceding .function"));
4526 set_end
= ppc_last_function
;
4527 ppc_last_function
= NULL
;
4529 /* We don't have a C_EFCN symbol, but we need to force the
4530 COFF backend to believe that it has seen one. */
4531 coff_last_function
= NULL
;
4535 if (! S_IS_EXTERNAL (sym
)
4536 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4537 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4538 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4539 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4540 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4541 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4542 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4543 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4544 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4545 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4547 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4548 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4551 union internal_auxent
*a
;
4553 /* Create a csect aux. */
4554 i
= S_GET_NUMBER_AUXILIARY (sym
);
4555 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4556 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4557 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4559 /* This is the TOC table. */
4560 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4561 a
->x_csect
.x_scnlen
.l
= 0;
4562 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4564 else if (symbol_get_tc (sym
)->subseg
!= 0)
4566 /* This is a csect symbol. x_scnlen is the size of the
4568 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4569 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4570 S_GET_SEGMENT (sym
))
4571 - S_GET_VALUE (sym
));
4574 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4575 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4576 - S_GET_VALUE (sym
));
4578 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4580 else if (S_GET_SEGMENT (sym
) == bss_section
)
4582 /* This is a common symbol. */
4583 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4584 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4585 if (S_IS_EXTERNAL (sym
))
4586 symbol_get_tc (sym
)->class = XMC_RW
;
4588 symbol_get_tc (sym
)->class = XMC_BS
;
4590 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4592 /* This is an absolute symbol. The csect will be created by
4593 ppc_adjust_symtab. */
4595 a
->x_csect
.x_smtyp
= XTY_LD
;
4596 if (symbol_get_tc (sym
)->class == -1)
4597 symbol_get_tc (sym
)->class = XMC_XO
;
4599 else if (! S_IS_DEFINED (sym
))
4601 /* This is an external symbol. */
4602 a
->x_csect
.x_scnlen
.l
= 0;
4603 a
->x_csect
.x_smtyp
= XTY_ER
;
4605 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4609 /* This is a TOC definition. x_scnlen is the size of the
4611 next
= symbol_next (sym
);
4612 while (symbol_get_tc (next
)->class == XMC_TC0
)
4613 next
= symbol_next (next
);
4614 if (next
== (symbolS
*) NULL
4615 || symbol_get_tc (next
)->class != XMC_TC
)
4617 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4618 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4620 - S_GET_VALUE (sym
));
4622 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4623 - S_GET_VALUE (sym
));
4627 resolve_symbol_value (next
);
4628 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4629 - S_GET_VALUE (sym
));
4631 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4637 /* This is a normal symbol definition. x_scnlen is the
4638 symbol index of the containing csect. */
4639 if (S_GET_SEGMENT (sym
) == text_section
)
4640 csect
= ppc_text_csects
;
4641 else if (S_GET_SEGMENT (sym
) == data_section
)
4642 csect
= ppc_data_csects
;
4646 /* Skip the initial dummy symbol. */
4647 csect
= symbol_get_tc (csect
)->next
;
4649 if (csect
== (symbolS
*) NULL
)
4651 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4652 a
->x_csect
.x_scnlen
.l
= 0;
4656 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4658 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4659 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4660 > S_GET_VALUE (sym
))
4662 csect
= symbol_get_tc (csect
)->next
;
4665 a
->x_csect
.x_scnlen
.p
=
4666 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4667 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4670 a
->x_csect
.x_smtyp
= XTY_LD
;
4673 a
->x_csect
.x_parmhash
= 0;
4674 a
->x_csect
.x_snhash
= 0;
4675 if (symbol_get_tc (sym
)->class == -1)
4676 a
->x_csect
.x_smclas
= XMC_PR
;
4678 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4679 a
->x_csect
.x_stab
= 0;
4680 a
->x_csect
.x_snstab
= 0;
4682 /* Don't let the COFF backend resort these symbols. */
4683 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4685 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4687 /* We want the value to be the symbol index of the referenced
4688 csect symbol. BFD will do that for us if we set the right
4692 coffsymbol (symbol_get_bfdsym
4693 (symbol_get_tc (sym
)->within
))->native
));
4694 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4696 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4701 /* The value is the offset from the enclosing csect. */
4702 block
= symbol_get_tc (sym
)->within
;
4703 csect
= symbol_get_tc (block
)->within
;
4704 resolve_symbol_value (csect
);
4705 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4707 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4708 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4710 /* We want the value to be a file offset into the line numbers.
4711 BFD will do that for us if we set the right flags. We have
4712 already set the value correctly. */
4713 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4719 /* Adjust the symbol table. This creates csect symbols for all
4720 absolute symbols. */
4723 ppc_adjust_symtab ()
4730 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
4734 union internal_auxent
*a
;
4736 if (S_GET_SEGMENT (sym
) != absolute_section
)
4739 csect
= symbol_create (".abs[XO]", absolute_section
,
4740 S_GET_VALUE (sym
), &zero_address_frag
);
4741 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
4742 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
4743 i
= S_GET_NUMBER_AUXILIARY (csect
);
4744 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
4745 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
4746 a
->x_csect
.x_scnlen
.l
= 0;
4747 a
->x_csect
.x_smtyp
= XTY_SD
;
4748 a
->x_csect
.x_parmhash
= 0;
4749 a
->x_csect
.x_snhash
= 0;
4750 a
->x_csect
.x_smclas
= XMC_XO
;
4751 a
->x_csect
.x_stab
= 0;
4752 a
->x_csect
.x_snstab
= 0;
4754 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
4756 i
= S_GET_NUMBER_AUXILIARY (sym
);
4757 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
4758 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
4759 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
4762 ppc_saw_abs
= false;
4765 /* Set the VMA for a section. This is called on all the sections in
4769 ppc_frob_section (sec
)
4772 static bfd_size_type vma
= 0;
4774 bfd_set_section_vma (stdoutput
, sec
, vma
);
4775 vma
+= bfd_section_size (stdoutput
, sec
);
4778 #endif /* OBJ_XCOFF */
4780 /* Turn a string in input_line_pointer into a floating point constant
4781 of type TYPE, and store the appropriate bytes in *LITP. The number
4782 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4783 returned, or NULL on OK. */
4786 md_atof (type
, litp
, sizep
)
4792 LITTLENUM_TYPE words
[4];
4808 return _("bad call to md_atof");
4811 t
= atof_ieee (input_line_pointer
, type
, words
);
4813 input_line_pointer
= t
;
4817 if (target_big_endian
)
4819 for (i
= 0; i
< prec
; i
++)
4821 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4827 for (i
= prec
- 1; i
>= 0; i
--)
4829 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4837 /* Write a value out to the object file, using the appropriate
4841 md_number_to_chars (buf
, val
, n
)
4846 if (target_big_endian
)
4847 number_to_chars_bigendian (buf
, val
, n
);
4849 number_to_chars_littleendian (buf
, val
, n
);
4852 /* Align a section (I don't know why this is machine dependent). */
4855 md_section_align (seg
, addr
)
4859 int align
= bfd_get_section_alignment (stdoutput
, seg
);
4861 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
4864 /* We don't have any form of relaxing. */
4867 md_estimate_size_before_relax (fragp
, seg
)
4868 fragS
*fragp ATTRIBUTE_UNUSED
;
4869 asection
*seg ATTRIBUTE_UNUSED
;
4875 /* Convert a machine dependent frag. We never generate these. */
4878 md_convert_frag (abfd
, sec
, fragp
)
4879 bfd
*abfd ATTRIBUTE_UNUSED
;
4880 asection
*sec ATTRIBUTE_UNUSED
;
4881 fragS
*fragp ATTRIBUTE_UNUSED
;
4886 /* We have no need to default values of symbols. */
4889 md_undefined_symbol (name
)
4890 char *name ATTRIBUTE_UNUSED
;
4895 /* Functions concerning relocs. */
4897 /* The location from which a PC relative jump should be calculated,
4898 given a PC relative reloc. */
4901 md_pcrel_from_section (fixp
, sec
)
4903 segT sec ATTRIBUTE_UNUSED
;
4905 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4910 /* This is called to see whether a fixup should be adjusted to use a
4911 section symbol. We take the opportunity to change a fixup against
4912 a symbol in the TOC subsegment into a reloc against the
4913 corresponding .tc symbol. */
4916 ppc_fix_adjustable (fix
)
4921 resolve_symbol_value (fix
->fx_addsy
);
4922 val
= S_GET_VALUE (fix
->fx_addsy
);
4923 if (ppc_toc_csect
!= (symbolS
*) NULL
4924 && fix
->fx_addsy
!= (symbolS
*) NULL
4925 && fix
->fx_addsy
!= ppc_toc_csect
4926 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
4927 && val
>= ppc_toc_frag
->fr_address
4928 && (ppc_after_toc_frag
== (fragS
*) NULL
4929 || val
< ppc_after_toc_frag
->fr_address
))
4933 for (sy
= symbol_next (ppc_toc_csect
);
4934 sy
!= (symbolS
*) NULL
;
4935 sy
= symbol_next (sy
))
4937 if (symbol_get_tc (sy
)->class == XMC_TC0
)
4939 if (symbol_get_tc (sy
)->class != XMC_TC
)
4941 resolve_symbol_value (sy
);
4942 if (val
== S_GET_VALUE (sy
))
4945 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
4950 as_bad_where (fix
->fx_file
, fix
->fx_line
,
4951 _("symbol in .toc does not match any .tc"));
4954 /* Possibly adjust the reloc to be against the csect. */
4955 if (fix
->fx_addsy
!= (symbolS
*) NULL
4956 && symbol_get_tc (fix
->fx_addsy
)->subseg
== 0
4957 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC0
4958 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC
4959 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
4960 /* Don't adjust if this is a reloc in the toc section. */
4961 && (S_GET_SEGMENT (fix
->fx_addsy
) != data_section
4962 || ppc_toc_csect
== NULL
4963 || val
< ppc_toc_frag
->fr_address
4964 || (ppc_after_toc_frag
!= NULL
4965 && val
>= ppc_after_toc_frag
->fr_address
)))
4969 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
4970 csect
= ppc_text_csects
;
4971 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
4972 csect
= ppc_data_csects
;
4976 /* Skip the initial dummy symbol. */
4977 csect
= symbol_get_tc (csect
)->next
;
4979 if (csect
!= (symbolS
*) NULL
)
4981 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
4982 && (symbol_get_frag (symbol_get_tc (csect
)->next
)->fr_address
4985 /* If the csect address equals the symbol value, then we
4986 have to look through the full symbol table to see
4987 whether this is the csect we want. Note that we will
4988 only get here if the csect has zero length. */
4989 if ((symbol_get_frag (csect
)->fr_address
== val
)
4990 && S_GET_VALUE (csect
) == S_GET_VALUE (fix
->fx_addsy
))
4994 for (scan
= symbol_next (csect
);
4996 scan
= symbol_next (scan
))
4998 if (symbol_get_tc (scan
)->subseg
!= 0)
5000 if (scan
== fix
->fx_addsy
)
5004 /* If we found the symbol before the next csect
5005 symbol, then this is the csect we want. */
5006 if (scan
== fix
->fx_addsy
)
5010 csect
= symbol_get_tc (csect
)->next
;
5013 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
5014 - symbol_get_frag (csect
)->fr_address
);
5015 fix
->fx_addsy
= csect
;
5019 /* Adjust a reloc against a .lcomm symbol to be against the base
5021 if (fix
->fx_addsy
!= (symbolS
*) NULL
5022 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
5023 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5025 resolve_symbol_value (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
);
5027 (S_GET_VALUE (fix
->fx_addsy
)
5028 - S_GET_VALUE (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
));
5029 fix
->fx_addsy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5035 /* A reloc from one csect to another must be kept. The assembler
5036 will, of course, keep relocs between sections, and it will keep
5037 absolute relocs, but we need to force it to keep PC relative relocs
5038 between two csects in the same section. */
5041 ppc_force_relocation (fix
)
5044 /* At this point fix->fx_addsy should already have been converted to
5045 a csect symbol. If the csect does not include the fragment, then
5046 we need to force the relocation. */
5048 && fix
->fx_addsy
!= NULL
5049 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5050 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5051 > fix
->fx_frag
->fr_address
)
5052 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5053 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5054 <= fix
->fx_frag
->fr_address
))))
5060 #endif /* OBJ_XCOFF */
5064 ppc_fix_adjustable (fix
)
5067 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5068 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5069 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5070 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5071 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5072 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5073 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5074 && ! S_IS_EXTERNAL (fix
->fx_addsy
)
5075 && ! S_IS_WEAK (fix
->fx_addsy
)
5077 || (fix
->fx_subsy
!= NULL
5078 && (S_GET_SEGMENT (fix
->fx_subsy
)
5079 == S_GET_SEGMENT (fix
->fx_addsy
)))
5080 || S_IS_LOCAL (fix
->fx_addsy
)));
5084 /* Apply a fixup to the object code. This is called for all the
5085 fixups we generated by the call to fix_new_exp, above. In the call
5086 above we used a reloc code which was the largest legal reloc code
5087 plus the operand index. Here we undo that to recover the operand
5088 index. At this point all symbol values should be fully resolved,
5089 and we attempt to completely resolve the reloc. If we can not do
5090 that, we determine the correct reloc code and put it back in the
5094 md_apply_fix3 (fixP
, valP
, seg
)
5097 segT seg ATTRIBUTE_UNUSED
;
5099 valueT value
= * valP
;
5102 if (fixP
->fx_addsy
!= NULL
)
5104 /* `*valuep' may contain the value of the symbol on which the reloc
5105 will be based; we have to remove it. */
5106 if (symbol_used_in_reloc_p (fixP
->fx_addsy
)
5107 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
5108 && S_GET_SEGMENT (fixP
->fx_addsy
) != undefined_section
5109 && ! bfd_is_com_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
5110 value
-= S_GET_VALUE (fixP
->fx_addsy
);
5112 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
5113 supposed to be? I think this is related to various similar
5114 FIXMEs in tc-i386.c and tc-sparc.c. */
5116 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5121 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
5122 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5123 doing this relocation the code in write.c is going to call
5124 bfd_install_relocation, which is also going to use the symbol
5125 value. That means that if the reloc is fully resolved we want to
5126 use *valuep since bfd_install_relocation is not being used.
5127 However, if the reloc is not fully resolved we do not want to use
5128 *valuep, and must use fx_offset instead. However, if the reloc
5129 is PC relative, we do want to use *valuep since it includes the
5130 result of md_pcrel_from. This is confusing. */
5131 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5134 else if (fixP
->fx_pcrel
)
5139 value
= fixP
->fx_offset
;
5140 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5142 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
5143 value
-= S_GET_VALUE (fixP
->fx_subsy
);
5146 /* We can't actually support subtracting a symbol. */
5147 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5148 _("expression too complex"));
5154 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5157 const struct powerpc_operand
*operand
;
5161 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5163 operand
= &powerpc_operands
[opindex
];
5166 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5167 does not generate a reloc. It uses the offset of `sym' within its
5168 csect. Other usages, such as `.long sym', generate relocs. This
5169 is the documented behaviour of non-TOC symbols. */
5170 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5171 && operand
->bits
== 16
5172 && operand
->shift
== 0
5173 && (operand
->insert
== NULL
|| ppc_xcoff64
)
5174 && fixP
->fx_addsy
!= NULL
5175 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5176 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5177 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5178 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5180 value
= fixP
->fx_offset
;
5185 /* Fetch the instruction, insert the fully resolved operand
5186 value, and stuff the instruction back again. */
5187 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5188 if (target_big_endian
)
5189 insn
= bfd_getb32 ((unsigned char *) where
);
5191 insn
= bfd_getl32 ((unsigned char *) where
);
5192 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5193 fixP
->fx_file
, fixP
->fx_line
);
5194 if (target_big_endian
)
5195 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5197 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5200 /* Nothing else to do here. */
5203 assert (fixP
->fx_addsy
!= NULL
);
5205 /* Determine a BFD reloc value based on the operand information.
5206 We are only prepared to turn a few of the operands into
5208 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5209 && operand
->bits
== 26
5210 && operand
->shift
== 0)
5211 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5212 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5213 && operand
->bits
== 16
5214 && operand
->shift
== 0)
5215 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5216 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5217 && operand
->bits
== 26
5218 && operand
->shift
== 0)
5219 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5220 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5221 && operand
->bits
== 16
5222 && operand
->shift
== 0)
5223 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5224 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5225 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5226 && operand
->bits
== 16
5227 && operand
->shift
== 0
5228 && ppc_is_toc_sym (fixP
->fx_addsy
))
5230 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5232 if (BFD_DEFAULT_TARGET_SIZE
== 64
5233 && ppc_size
== PPC_OPCODE_64
5234 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5235 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5238 if (target_big_endian
)
5239 fixP
->fx_where
+= 2;
5241 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5247 /* Use expr_symbol_where to see if this is an expression
5249 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5250 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5251 _("unresolved expression that must be resolved"));
5253 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5254 _("unsupported relocation against %s"),
5255 S_GET_NAME (fixP
->fx_addsy
));
5263 ppc_elf_validate_fix (fixP
, seg
);
5265 switch (fixP
->fx_r_type
)
5267 case BFD_RELOC_CTOR
:
5268 if (BFD_DEFAULT_TARGET_SIZE
== 64 && ppc_size
== PPC_OPCODE_64
)
5274 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5278 case BFD_RELOC_32_PCREL
:
5279 case BFD_RELOC_PPC_EMB_NADDR32
:
5280 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5287 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5290 case BFD_RELOC_64_PCREL
:
5291 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5295 case BFD_RELOC_LO16
:
5297 case BFD_RELOC_GPREL16
:
5298 case BFD_RELOC_16_GOT_PCREL
:
5299 case BFD_RELOC_16_GOTOFF
:
5300 case BFD_RELOC_LO16_GOTOFF
:
5301 case BFD_RELOC_HI16_GOTOFF
:
5302 case BFD_RELOC_HI16_S_GOTOFF
:
5303 case BFD_RELOC_16_BASEREL
:
5304 case BFD_RELOC_LO16_BASEREL
:
5305 case BFD_RELOC_HI16_BASEREL
:
5306 case BFD_RELOC_HI16_S_BASEREL
:
5307 case BFD_RELOC_PPC_EMB_NADDR16
:
5308 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5309 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5310 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5311 case BFD_RELOC_PPC_EMB_SDAI16
:
5312 case BFD_RELOC_PPC_EMB_SDA2REL
:
5313 case BFD_RELOC_PPC_EMB_SDA2I16
:
5314 case BFD_RELOC_PPC_EMB_RELSEC16
:
5315 case BFD_RELOC_PPC_EMB_RELST_LO
:
5316 case BFD_RELOC_PPC_EMB_RELST_HI
:
5317 case BFD_RELOC_PPC_EMB_RELST_HA
:
5318 case BFD_RELOC_PPC_EMB_RELSDA
:
5319 case BFD_RELOC_PPC_TOC16
:
5321 #if BFD_DEFAULT_TARGET_SIZE == 64
5322 case BFD_RELOC_PPC64_TOC16_LO
:
5323 case BFD_RELOC_PPC64_TOC16_HI
:
5324 case BFD_RELOC_PPC64_TOC16_HA
:
5329 if (fixP
->fx_addsy
!= NULL
)
5330 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5331 _("cannot emit PC relative %s relocation against %s"),
5332 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5333 S_GET_NAME (fixP
->fx_addsy
));
5335 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5336 _("cannot emit PC relative %s relocation"),
5337 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5340 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5344 /* This case happens when you write, for example,
5346 where L1 and L2 are defined later. */
5347 case BFD_RELOC_HI16
:
5350 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5354 case BFD_RELOC_HI16_S
:
5357 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5362 #if BFD_DEFAULT_TARGET_SIZE == 64
5363 case BFD_RELOC_PPC64_HIGHER
:
5366 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5367 PPC_HIGHER (value
), 2);
5370 case BFD_RELOC_PPC64_HIGHER_S
:
5373 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5374 PPC_HIGHERA (value
), 2);
5377 case BFD_RELOC_PPC64_HIGHEST
:
5380 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5381 PPC_HIGHEST (value
), 2);
5384 case BFD_RELOC_PPC64_HIGHEST_S
:
5387 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5388 PPC_HIGHESTA (value
), 2);
5391 case BFD_RELOC_PPC64_ADDR16_DS
:
5392 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5393 case BFD_RELOC_PPC64_GOT16_DS
:
5394 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5395 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5396 case BFD_RELOC_PPC64_SECTOFF_DS
:
5397 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5398 case BFD_RELOC_PPC64_TOC16_DS
:
5399 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5400 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5401 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5405 unsigned char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5408 if (target_big_endian
)
5409 val
= bfd_getb16 (where
);
5411 val
= bfd_getl16 (where
);
5412 val
|= (value
& 0xfffc);
5413 if (target_big_endian
)
5414 bfd_putb16 ((bfd_vma
) val
, where
);
5416 bfd_putl16 ((bfd_vma
) val
, where
);
5421 /* Because SDA21 modifies the register field, the size is set to 4
5422 bytes, rather than 2, so offset it here appropriately. */
5423 case BFD_RELOC_PPC_EMB_SDA21
:
5427 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5428 + ((target_big_endian
) ? 2 : 0),
5436 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5440 case BFD_RELOC_24_PLT_PCREL
:
5441 case BFD_RELOC_PPC_LOCAL24PC
:
5442 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5450 /* Fetch the instruction, insert the fully resolved operand
5451 value, and stuff the instruction back again. */
5452 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5453 if (target_big_endian
)
5454 insn
= bfd_getb32 ((unsigned char *) where
);
5456 insn
= bfd_getl32 ((unsigned char *) where
);
5457 if ((value
& 3) != 0)
5458 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5459 _("must branch to an address a multiple of 4"));
5460 if ((offsetT
) value
< -0x40000000
5461 || (offsetT
) value
>= 0x40000000)
5462 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5463 _("@local or @plt branch destination is too far away, %ld bytes"),
5465 insn
= insn
| (value
& 0x03fffffc);
5466 if (target_big_endian
)
5467 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5469 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5473 case BFD_RELOC_VTABLE_INHERIT
:
5476 && !S_IS_DEFINED (fixP
->fx_addsy
)
5477 && !S_IS_WEAK (fixP
->fx_addsy
))
5478 S_SET_WEAK (fixP
->fx_addsy
);
5481 case BFD_RELOC_VTABLE_ENTRY
:
5486 #if BFD_DEFAULT_TARGET_SIZE == 64
5487 /* Generated by reference to `sym@tocbase'. The sym is
5488 ignored by the linker. */
5489 case BFD_RELOC_PPC64_TOC
:
5496 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
5503 fixP
->fx_addnumber
= value
;
5505 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5506 fixP
->fx_addnumber
= 0;
5510 fixP
->fx_addnumber
= 0;
5512 /* We want to use the offset within the data segment of the
5513 symbol, not the actual VMA of the symbol. */
5514 fixP
->fx_addnumber
=
5515 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
5521 /* Generate a reloc for a fixup. */
5524 tc_gen_reloc (seg
, fixp
)
5525 asection
*seg ATTRIBUTE_UNUSED
;
5530 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5532 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5533 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5534 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5535 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5536 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5538 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5539 _("reloc %d not supported by object file format"),
5540 (int) fixp
->fx_r_type
);
5543 reloc
->addend
= fixp
->fx_addnumber
;