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", (void (*) PARAMS ((int))) 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 unsigned long ppc_cpu
= 0;
700 /* Whether to target xcoff64/elf64. */
701 static unsigned int ppc_obj64
= BFD_DEFAULT_TARGET_SIZE
== 64;
703 /* Opcode hash table. */
704 static struct hash_control
*ppc_hash
;
706 /* Macro hash table. */
707 static struct hash_control
*ppc_macro_hash
;
710 /* What type of shared library support to use. */
711 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
713 /* Flags to set in the elf header. */
714 static flagword ppc_flags
= 0;
716 /* Whether this is Solaris or not. */
717 #ifdef TARGET_SOLARIS_COMMENT
718 #define SOLARIS_P true
720 #define SOLARIS_P false
723 static boolean msolaris
= SOLARIS_P
;
728 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
729 using a bunch of different sections. These assembler sections,
730 however, are all encompassed within the .text or .data sections of
731 the final output file. We handle this by using different
732 subsegments within these main segments. */
734 /* Next subsegment to allocate within the .text segment. */
735 static subsegT ppc_text_subsegment
= 2;
737 /* Linked list of csects in the text section. */
738 static symbolS
*ppc_text_csects
;
740 /* Next subsegment to allocate within the .data segment. */
741 static subsegT ppc_data_subsegment
= 2;
743 /* Linked list of csects in the data section. */
744 static symbolS
*ppc_data_csects
;
746 /* The current csect. */
747 static symbolS
*ppc_current_csect
;
749 /* The RS/6000 assembler uses a TOC which holds addresses of functions
750 and variables. Symbols are put in the TOC with the .tc pseudo-op.
751 A special relocation is used when accessing TOC entries. We handle
752 the TOC as a subsegment within the .data segment. We set it up if
753 we see a .toc pseudo-op, and save the csect symbol here. */
754 static symbolS
*ppc_toc_csect
;
756 /* The first frag in the TOC subsegment. */
757 static fragS
*ppc_toc_frag
;
759 /* The first frag in the first subsegment after the TOC in the .data
760 segment. NULL if there are no subsegments after the TOC. */
761 static fragS
*ppc_after_toc_frag
;
763 /* The current static block. */
764 static symbolS
*ppc_current_block
;
766 /* The COFF debugging section; set by md_begin. This is not the
767 .debug section, but is instead the secret BFD section which will
768 cause BFD to set the section number of a symbol to N_DEBUG. */
769 static asection
*ppc_coff_debug_section
;
771 #endif /* OBJ_XCOFF */
775 /* Various sections that we need for PE coff support. */
776 static segT ydata_section
;
777 static segT pdata_section
;
778 static segT reldata_section
;
779 static segT rdata_section
;
780 static segT tocdata_section
;
782 /* The current section and the previous section. See ppc_previous. */
783 static segT ppc_previous_section
;
784 static segT ppc_current_section
;
789 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
793 const char *const md_shortopts
= "b:l:usm:K:VQ:";
795 const char *const md_shortopts
= "um:";
797 const struct option md_longopts
[] = {
798 {NULL
, no_argument
, NULL
, 0}
800 const size_t md_longopts_size
= sizeof (md_longopts
);
803 md_parse_option (c
, arg
)
810 /* -u means that any undefined symbols should be treated as
811 external, which is the default for gas anyhow. */
816 /* Solaris as takes -le (presumably for little endian). For completeness
817 sake, recognize -be also. */
818 if (strcmp (arg
, "e") == 0)
820 target_big_endian
= 0;
821 set_target_endian
= 1;
829 if (strcmp (arg
, "e") == 0)
831 target_big_endian
= 1;
832 set_target_endian
= 1;
840 /* Recognize -K PIC. */
841 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
844 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
852 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
854 if (strcmp (arg
, "64") == 0)
856 else if (strcmp (arg
, "32") == 0)
863 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
865 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
866 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
| PPC_OPCODE_32
;
867 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
868 else if (strcmp (arg
, "pwr") == 0)
869 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
870 /* -m601 means to assemble for the PowerPC 601, which includes
871 instructions that are holdovers from the Power. */
872 else if (strcmp (arg
, "601") == 0)
873 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_601
| PPC_OPCODE_32
;
874 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
876 else if (strcmp (arg
, "ppc") == 0
877 || strcmp (arg
, "ppc32") == 0
878 || strcmp (arg
, "603") == 0
879 || strcmp (arg
, "604") == 0)
880 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_32
;
881 /* -m403 and -m405 mean to assemble for the PowerPC 403/405. */
882 else if (strcmp (arg
, "403") == 0
883 || strcmp (arg
, "405") == 0)
884 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_403
| PPC_OPCODE_32
;
885 else if (strcmp (arg
, "7400") == 0
886 || strcmp (arg
, "7410") == 0
887 || strcmp (arg
, "7450") == 0
888 || strcmp (arg
, "7455") == 0)
889 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_ALTIVEC
| PPC_OPCODE_32
;
890 else if (strcmp (arg
, "altivec") == 0)
893 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_ALTIVEC
;
895 ppc_cpu
|= PPC_OPCODE_ALTIVEC
;
897 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
899 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
901 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64
;
903 else if (strcmp (arg
, "ppc64bridge") == 0)
905 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64_BRIDGE
| PPC_OPCODE_64
;
907 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
908 else if (strcmp (arg
, "booke") == 0 || strcmp (arg
, "booke32") == 0)
909 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
| PPC_OPCODE_32
;
910 /* -mbooke64 means enable 64-bit BookE support. */
911 else if (strcmp (arg
, "booke64") == 0)
913 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_BOOKE
|
914 PPC_OPCODE_BOOKE64
| PPC_OPCODE_64
;
916 else if (strcmp (arg
, "power4") == 0)
918 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64
| PPC_OPCODE_POWER4
;
920 /* -mcom means assemble for the common intersection between Power
921 and PowerPC. At present, we just allow the union, rather
922 than the intersection. */
923 else if (strcmp (arg
, "com") == 0)
924 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
925 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
926 else if (strcmp (arg
, "any") == 0)
927 ppc_cpu
= PPC_OPCODE_ANY
| PPC_OPCODE_32
;
929 else if (strcmp (arg
, "regnames") == 0)
932 else if (strcmp (arg
, "no-regnames") == 0)
936 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
937 that require relocation. */
938 else if (strcmp (arg
, "relocatable") == 0)
940 shlib
= SHLIB_MRELOCATABLE
;
941 ppc_flags
|= EF_PPC_RELOCATABLE
;
944 else if (strcmp (arg
, "relocatable-lib") == 0)
946 shlib
= SHLIB_MRELOCATABLE
;
947 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
950 /* -memb, set embedded bit. */
951 else if (strcmp (arg
, "emb") == 0)
952 ppc_flags
|= EF_PPC_EMB
;
954 /* -mlittle/-mbig set the endianess. */
955 else if (strcmp (arg
, "little") == 0
956 || strcmp (arg
, "little-endian") == 0)
958 target_big_endian
= 0;
959 set_target_endian
= 1;
962 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
964 target_big_endian
= 1;
965 set_target_endian
= 1;
968 else if (strcmp (arg
, "solaris") == 0)
971 ppc_comment_chars
= ppc_solaris_comment_chars
;
974 else if (strcmp (arg
, "no-solaris") == 0)
977 ppc_comment_chars
= ppc_eabi_comment_chars
;
982 as_bad (_("invalid switch -m%s"), arg
);
988 /* -V: SVR4 argument to print version ID. */
993 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
994 should be emitted or not. FIXME: Not implemented. */
998 /* Solaris takes -s to specify that .stabs go in a .stabs section,
999 rather than .stabs.excl, which is ignored by the linker.
1000 FIXME: Not implemented. */
1016 md_show_usage (stream
)
1019 fprintf (stream
, _("\
1022 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1023 -mpwr generate code for POWER (RIOS1)\n\
1024 -m601 generate code for PowerPC 601\n\
1025 -mppc, -mppc32, -m603, -m604\n\
1026 generate code for PowerPC 603/604\n\
1027 -m403, -m405 generate code for PowerPC 403/405\n\
1028 -m7400, -m7410, -m7450, -m7455\n\
1029 generate code For PowerPC 7400/7410/7450/7455\n\
1030 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1031 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1032 -mbooke64 generate code for 64-bit PowerPC BookE\n\
1033 -mbooke, mbooke32 generate code for 32-bit PowerPC BookE\n\
1034 -mpower4 generate code for Power4 architecture\n\
1035 -maltivec generate code for AltiVec\n\
1036 -mcom generate code Power/PowerPC common instructions\n\
1037 -many generate code for any architecture (PWR/PWRX/PPC)\n\
1038 -mregnames Allow symbolic names for registers\n\
1039 -mno-regnames Do not allow symbolic names for registers\n"));
1041 fprintf (stream
, _("\
1042 -mrelocatable support for GCC's -mrelocatble option\n\
1043 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1044 -memb set PPC_EMB bit in ELF flags\n\
1045 -mlittle, -mlittle-endian\n\
1046 generate code for a little endian machine\n\
1047 -mbig, -mbig-endian generate code for a big endian machine\n\
1048 -msolaris generate code for Solaris\n\
1049 -mno-solaris do not generate code for Solaris\n\
1050 -V print assembler version number\n\
1051 -Qy, -Qn ignored\n"));
1055 /* Set ppc_cpu if it is not already set. */
1060 const char *default_os
= TARGET_OS
;
1061 const char *default_cpu
= TARGET_CPU
;
1065 if (strncmp (default_os
, "aix", 3) == 0
1066 && default_os
[3] >= '4' && default_os
[3] <= '9')
1067 ppc_cpu
= PPC_OPCODE_COMMON
| PPC_OPCODE_32
;
1068 else if (strncmp (default_os
, "aix3", 4) == 0)
1069 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1070 else if (strcmp (default_cpu
, "rs6000") == 0)
1071 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_32
;
1072 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1073 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_32
;
1075 as_fatal (_("Unknown default cpu = %s, os = %s"),
1076 default_cpu
, default_os
);
1080 /* Figure out the BFD architecture to use. */
1082 enum bfd_architecture
1085 const char *default_cpu
= TARGET_CPU
;
1088 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1089 return bfd_arch_powerpc
;
1090 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1091 return bfd_arch_rs6000
;
1092 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1094 if (strcmp (default_cpu
, "rs6000") == 0)
1095 return bfd_arch_rs6000
;
1096 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1097 return bfd_arch_powerpc
;
1100 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1101 return bfd_arch_unknown
;
1107 return ppc_obj64
? bfd_mach_ppc64
: bfd_mach_ppc
;
1111 ppc_target_format ()
1115 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1117 return "xcoff-powermac";
1120 return (ppc_obj64
? "aix5coff64-rs6000" : "aixcoff-rs6000");
1122 return (ppc_obj64
? "aixcoff64-rs6000" : "aixcoff-rs6000");
1127 return (target_big_endian
1128 ? (ppc_obj64
? "elf64-powerpc" : "elf32-powerpc")
1129 : (ppc_obj64
? "elf64-powerpcle" : "elf32-powerpcle"));
1133 /* This function is called when the assembler starts up. It is called
1134 after the options have been parsed and the output file has been
1140 register const struct powerpc_opcode
*op
;
1141 const struct powerpc_opcode
*op_end
;
1142 const struct powerpc_macro
*macro
;
1143 const struct powerpc_macro
*macro_end
;
1144 boolean dup_insn
= false;
1149 /* Set the ELF flags if desired. */
1150 if (ppc_flags
&& !msolaris
)
1151 bfd_set_private_flags (stdoutput
, ppc_flags
);
1154 /* Insert the opcodes into a hash table. */
1155 ppc_hash
= hash_new ();
1157 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1158 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1160 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1162 if ((op
->flags
& ppc_cpu
& ~(PPC_OPCODE_32
| PPC_OPCODE_64
)) != 0
1163 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1164 || ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
))
1165 == (ppc_cpu
& (PPC_OPCODE_32
| PPC_OPCODE_64
)))
1166 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0)
1167 && ((op
->flags
& (PPC_OPCODE_POWER4
| PPC_OPCODE_NOPOWER4
)) == 0
1168 || ((op
->flags
& PPC_OPCODE_POWER4
)
1169 == (ppc_cpu
& PPC_OPCODE_POWER4
))))
1173 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1174 if (retval
!= (const char *) NULL
)
1176 /* Ignore Power duplicates for -m601. */
1177 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1178 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1181 as_bad (_("Internal assembler error for instruction %s"),
1188 /* Insert the macros into a hash table. */
1189 ppc_macro_hash
= hash_new ();
1191 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1192 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1194 if ((macro
->flags
& ppc_cpu
) != 0)
1198 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1199 if (retval
!= (const char *) NULL
)
1201 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1210 /* Tell the main code what the endianness is if it is not overidden
1212 if (!set_target_endian
)
1214 set_target_endian
= 1;
1215 target_big_endian
= PPC_BIG_ENDIAN
;
1219 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1221 /* Create dummy symbols to serve as initial csects. This forces the
1222 text csects to precede the data csects. These symbols will not
1224 ppc_text_csects
= symbol_make ("dummy\001");
1225 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1226 ppc_data_csects
= symbol_make ("dummy\001");
1227 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1232 ppc_current_section
= text_section
;
1233 ppc_previous_section
= 0;
1238 /* Insert an operand value into an instruction. */
1240 static unsigned long
1241 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1243 const struct powerpc_operand
*operand
;
1248 if (operand
->bits
!= 32)
1253 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1255 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1256 max
= (1 << operand
->bits
) - 1;
1258 max
= (1 << (operand
->bits
- 1)) - 1;
1259 min
= - (1 << (operand
->bits
- 1));
1263 /* Some people write 32 bit hex constants with the sign
1264 extension done by hand. This shouldn't really be
1265 valid, but, to permit this code to assemble on a 64
1266 bit host, we sign extend the 32 bit value. */
1268 && (val
& (offsetT
) 0x80000000) != 0
1269 && (val
& (offsetT
) 0xffffffff) == val
)
1278 max
= (1 << operand
->bits
) - 1;
1282 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1287 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1290 _("operand out of range (%s not between %ld and %ld)");
1293 sprint_value (buf
, test
);
1294 as_bad_where (file
, line
, err
, buf
, min
, max
);
1298 if (operand
->insert
)
1303 insn
= (*operand
->insert
) (insn
, (long) val
, ppc_cpu
, &errmsg
);
1304 if (errmsg
!= (const char *) NULL
)
1305 as_bad_where (file
, line
, errmsg
);
1308 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1316 /* Parse @got, etc. and return the desired relocation. */
1317 static bfd_reloc_code_real_type
1318 ppc_elf_suffix (str_p
, exp_p
)
1333 const struct map_bfd
*ptr
;
1335 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1337 static const struct map_bfd mapping
[] = {
1338 MAP ("l", (int) BFD_RELOC_LO16
),
1339 MAP ("h", (int) BFD_RELOC_HI16
),
1340 MAP ("ha", (int) BFD_RELOC_HI16_S
),
1341 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN
),
1342 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN
),
1343 MAP ("got", (int) BFD_RELOC_16_GOTOFF
),
1344 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF
),
1345 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF
),
1346 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF
),
1347 MAP ("fixup", (int) BFD_RELOC_CTOR
), /* warning with -mrelocatable */
1348 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL
),
1349 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL
),
1350 MAP ("copy", (int) BFD_RELOC_PPC_COPY
),
1351 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT
),
1352 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC
),
1353 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC
),
1354 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL
),
1355 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF
),
1356 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF
),
1357 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF
),
1358 MAP ("sdarel", (int) BFD_RELOC_GPREL16
),
1359 MAP ("sectoff", (int) BFD_RELOC_16_BASEREL
),
1360 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL
),
1361 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL
),
1362 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL
),
1363 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32
),
1364 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16
),
1365 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO
),
1366 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI
),
1367 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA
),
1368 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16
),
1369 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL
),
1370 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16
),
1371 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21
),
1372 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF
),
1373 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16
),
1374 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO
),
1375 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI
),
1376 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA
),
1377 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD
),
1378 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA
),
1379 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16
),
1380 /* The following are only valid for ppc64. Negative values are
1381 used instead of a flag. */
1382 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER
),
1383 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S
),
1384 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST
),
1385 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S
),
1386 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC
),
1387 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16
),
1388 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO
),
1389 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI
),
1390 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA
),
1391 { (char *) 0, 0, (int) BFD_RELOC_UNUSED
}
1395 return BFD_RELOC_UNUSED
;
1397 for (ch
= *str
, str2
= ident
;
1398 (str2
< ident
+ sizeof (ident
) - 1
1399 && (ISALNUM (ch
) || ch
== '@'));
1402 *str2
++ = TOLOWER (ch
);
1409 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1410 if (ch
== ptr
->string
[0]
1411 && len
== ptr
->length
1412 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1414 int reloc
= ptr
->reloc
;
1419 return BFD_RELOC_UNUSED
;
1423 if (exp_p
->X_add_number
!= 0
1424 && (reloc
== (int) BFD_RELOC_16_GOTOFF
1425 || reloc
== (int) BFD_RELOC_LO16_GOTOFF
1426 || reloc
== (int) BFD_RELOC_HI16_GOTOFF
1427 || reloc
== (int) BFD_RELOC_HI16_S_GOTOFF
))
1428 as_warn (_("identifier+constant@got means identifier@got+constant"));
1430 /* Now check for identifier@suffix+constant. */
1431 if (*str
== '-' || *str
== '+')
1433 char *orig_line
= input_line_pointer
;
1434 expressionS new_exp
;
1436 input_line_pointer
= str
;
1437 expression (&new_exp
);
1438 if (new_exp
.X_op
== O_constant
)
1440 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1441 str
= input_line_pointer
;
1444 if (&input_line_pointer
!= str_p
)
1445 input_line_pointer
= orig_line
;
1449 if (reloc
== (int) BFD_RELOC_PPC64_TOC
1450 && exp_p
->X_op
== O_symbol
)
1452 /* This reloc type ignores the symbol. Change the symbol
1453 so that the dummy .TOC. symbol can be omitted from the
1455 exp_p
->X_add_symbol
= &abs_symbol
;
1458 return (bfd_reloc_code_real_type
) reloc
;
1461 return BFD_RELOC_UNUSED
;
1464 /* Like normal .long/.short/.word, except support @got, etc.
1465 Clobbers input_line_pointer, checks end-of-line. */
1467 ppc_elf_cons (nbytes
)
1468 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1471 bfd_reloc_code_real_type reloc
;
1473 if (is_it_end_of_statement ())
1475 demand_empty_rest_of_line ();
1482 if (exp
.X_op
== O_symbol
1483 && *input_line_pointer
== '@'
1484 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1485 &exp
)) != BFD_RELOC_UNUSED
)
1487 reloc_howto_type
*reloc_howto
;
1490 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1491 size
= bfd_get_reloc_size (reloc_howto
);
1495 as_bad (_("%s relocations do not fit in %d bytes\n"),
1496 reloc_howto
->name
, nbytes
);
1503 p
= frag_more (nbytes
);
1505 if (target_big_endian
)
1506 offset
= nbytes
- size
;
1507 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1512 emit_expr (&exp
, (unsigned int) nbytes
);
1514 while (*input_line_pointer
++ == ',');
1516 /* Put terminator back into stream. */
1517 input_line_pointer
--;
1518 demand_empty_rest_of_line ();
1521 /* Solaris pseduo op to change to the .rodata section. */
1526 char *save_line
= input_line_pointer
;
1527 static char section
[] = ".rodata\n";
1529 /* Just pretend this is .section .rodata */
1530 input_line_pointer
= section
;
1531 obj_elf_section (xxx
);
1533 input_line_pointer
= save_line
;
1536 /* Pseudo op to make file scope bss items. */
1539 int xxx ATTRIBUTE_UNUSED
;
1541 register char *name
;
1545 register symbolS
*symbolP
;
1552 name
= input_line_pointer
;
1553 c
= get_symbol_end ();
1555 /* just after name is now '\0'. */
1556 p
= input_line_pointer
;
1559 if (*input_line_pointer
!= ',')
1561 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1562 ignore_rest_of_line ();
1566 input_line_pointer
++; /* skip ',' */
1567 if ((size
= get_absolute_expression ()) < 0)
1569 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1570 ignore_rest_of_line ();
1574 /* The third argument to .lcomm is the alignment. */
1575 if (*input_line_pointer
!= ',')
1579 ++input_line_pointer
;
1580 align
= get_absolute_expression ();
1583 as_warn (_("ignoring bad alignment"));
1589 symbolP
= symbol_find_or_make (name
);
1592 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1594 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1595 S_GET_NAME (symbolP
));
1596 ignore_rest_of_line ();
1600 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1602 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1603 S_GET_NAME (symbolP
),
1604 (long) S_GET_VALUE (symbolP
),
1607 ignore_rest_of_line ();
1613 old_subsec
= now_subseg
;
1616 /* Convert to a power of 2 alignment. */
1617 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1620 as_bad (_("Common alignment not a power of 2"));
1621 ignore_rest_of_line ();
1628 record_alignment (bss_section
, align2
);
1629 subseg_set (bss_section
, 0);
1631 frag_align (align2
, 0, 0);
1632 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1633 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1634 symbol_set_frag (symbolP
, frag_now
);
1635 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1638 S_SET_SIZE (symbolP
, size
);
1639 S_SET_SEGMENT (symbolP
, bss_section
);
1640 subseg_set (old_sec
, old_subsec
);
1641 demand_empty_rest_of_line ();
1644 /* Validate any relocations emitted for -mrelocatable, possibly adding
1645 fixups for word relocations in writable segments, so we can adjust
1648 ppc_elf_validate_fix (fixp
, seg
)
1652 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1661 case SHLIB_MRELOCATABLE
:
1662 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1663 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1664 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1665 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1666 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1667 && fixp
->fx_r_type
!= BFD_RELOC_16_BASEREL
1668 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1669 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1670 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1671 && (seg
->flags
& SEC_LOAD
) != 0
1672 && strcmp (segment_name (seg
), ".got2") != 0
1673 && strcmp (segment_name (seg
), ".dtors") != 0
1674 && strcmp (segment_name (seg
), ".ctors") != 0
1675 && strcmp (segment_name (seg
), ".fixup") != 0
1676 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1677 && strcmp (segment_name (seg
), ".eh_frame") != 0
1678 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1680 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1681 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1683 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1684 _("Relocation cannot be done when using -mrelocatable"));
1691 /* Prevent elf_frob_file_before_adjust removing a weak undefined
1692 function descriptor sym if the corresponding code sym is used. */
1695 ppc_frob_file_before_adjust ()
1702 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1709 name
= S_GET_NAME (symp
);
1713 if (! S_IS_WEAK (symp
)
1714 || S_IS_DEFINED (symp
))
1717 len
= strlen (name
) + 1;
1718 dotname
= xmalloc (len
+ 1);
1720 memcpy (dotname
+ 1, name
, len
);
1721 dotsym
= symbol_find (dotname
);
1723 if (dotsym
!= NULL
&& (symbol_used_p (dotsym
)
1724 || symbol_used_in_reloc_p (dotsym
)))
1726 symbol_mark_used (symp
);
1730 /* Don't emit .TOC. symbol. */
1731 symp
= symbol_find (".TOC.");
1733 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1735 #endif /* OBJ_ELF */
1740 * Summary of parse_toc_entry.
1742 * in: Input_line_pointer points to the '[' in one of:
1744 * [toc] [tocv] [toc32] [toc64]
1746 * Anything else is an error of one kind or another.
1749 * return value: success or failure
1750 * toc_kind: kind of toc reference
1751 * input_line_pointer:
1752 * success: first char after the ']'
1753 * failure: unchanged
1757 * [toc] - rv == success, toc_kind = default_toc
1758 * [tocv] - rv == success, toc_kind = data_in_toc
1759 * [toc32] - rv == success, toc_kind = must_be_32
1760 * [toc64] - rv == success, toc_kind = must_be_64
1764 enum toc_size_qualifier
1766 default_toc
, /* The toc cell constructed should be the system default size */
1767 data_in_toc
, /* This is a direct reference to a toc cell */
1768 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1769 must_be_64
/* The toc cell constructed must be 64 bits wide */
1773 parse_toc_entry (toc_kind
)
1774 enum toc_size_qualifier
*toc_kind
;
1779 enum toc_size_qualifier t
;
1781 /* Save the input_line_pointer. */
1782 start
= input_line_pointer
;
1784 /* Skip over the '[' , and whitespace. */
1785 ++input_line_pointer
;
1788 /* Find the spelling of the operand. */
1789 toc_spec
= input_line_pointer
;
1790 c
= get_symbol_end ();
1792 if (strcmp (toc_spec
, "toc") == 0)
1796 else if (strcmp (toc_spec
, "tocv") == 0)
1800 else if (strcmp (toc_spec
, "toc32") == 0)
1804 else if (strcmp (toc_spec
, "toc64") == 0)
1810 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1811 *input_line_pointer
= c
;
1812 input_line_pointer
= start
;
1816 /* Now find the ']'. */
1817 *input_line_pointer
= c
;
1819 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1820 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1824 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1825 input_line_pointer
= start
;
1835 /* We need to keep a list of fixups. We can't simply generate them as
1836 we go, because that would require us to first create the frag, and
1837 that would screw up references to ``.''. */
1843 bfd_reloc_code_real_type reloc
;
1846 #define MAX_INSN_FIXUPS (5)
1848 /* This routine is called for each instruction to be assembled. */
1855 const struct powerpc_opcode
*opcode
;
1857 const unsigned char *opindex_ptr
;
1861 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
1866 bfd_reloc_code_real_type reloc
;
1869 /* Get the opcode. */
1870 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1875 /* Look up the opcode in the hash table. */
1876 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
1877 if (opcode
== (const struct powerpc_opcode
*) NULL
)
1879 const struct powerpc_macro
*macro
;
1881 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
1882 if (macro
== (const struct powerpc_macro
*) NULL
)
1883 as_bad (_("Unrecognized opcode: `%s'"), str
);
1885 ppc_macro (s
, macro
);
1890 insn
= opcode
->opcode
;
1893 while (ISSPACE (*str
))
1896 /* PowerPC operands are just expressions. The only real issue is
1897 that a few operand types are optional. All cases which might use
1898 an optional operand separate the operands only with commas (in
1899 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1900 cases never have optional operands). There is never more than
1901 one optional operand for an instruction. So, before we start
1902 seriously parsing the operands, we check to see if we have an
1903 optional operand, and, if we do, we count the number of commas to
1904 see whether the operand should be omitted. */
1906 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1908 const struct powerpc_operand
*operand
;
1910 operand
= &powerpc_operands
[*opindex_ptr
];
1911 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
1913 unsigned int opcount
;
1915 /* There is an optional operand. Count the number of
1916 commas in the input line. */
1923 while ((s
= strchr (s
, ',')) != (char *) NULL
)
1930 /* If there are fewer operands in the line then are called
1931 for by the instruction, we want to skip the optional
1933 if (opcount
< strlen (opcode
->operands
))
1940 /* Gather the operands. */
1944 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1946 const struct powerpc_operand
*operand
;
1952 if (next_opindex
== 0)
1953 operand
= &powerpc_operands
[*opindex_ptr
];
1956 operand
= &powerpc_operands
[next_opindex
];
1962 /* If this is a fake operand, then we do not expect anything
1964 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
1966 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
1967 if (errmsg
!= (const char *) NULL
)
1972 /* If this is an optional operand, and we are skipping it, just
1974 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
1977 if (operand
->insert
)
1979 insn
= (*operand
->insert
) (insn
, 0L, ppc_cpu
, &errmsg
);
1980 if (errmsg
!= (const char *) NULL
)
1983 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
1984 next_opindex
= *opindex_ptr
+ 1;
1988 /* Gather the operand. */
1989 hold
= input_line_pointer
;
1990 input_line_pointer
= str
;
1993 if (*input_line_pointer
== '[')
1995 /* We are expecting something like the second argument here:
1997 * lwz r4,[toc].GS.0.static_int(rtoc)
1998 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1999 * The argument following the `]' must be a symbol name, and the
2000 * register must be the toc register: 'rtoc' or '2'
2002 * The effect is to 0 as the displacement field
2003 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2004 * the appropriate variation) reloc against it based on the symbol.
2005 * The linker will build the toc, and insert the resolved toc offset.
2008 * o The size of the toc entry is currently assumed to be
2009 * 32 bits. This should not be assumed to be a hard coded
2011 * o In an effort to cope with a change from 32 to 64 bits,
2012 * there are also toc entries that are specified to be
2013 * either 32 or 64 bits:
2014 * lwz r4,[toc32].GS.0.static_int(rtoc)
2015 * lwz r4,[toc64].GS.0.static_int(rtoc)
2016 * These demand toc entries of the specified size, and the
2017 * instruction probably requires it.
2021 enum toc_size_qualifier toc_kind
;
2022 bfd_reloc_code_real_type toc_reloc
;
2024 /* Go parse off the [tocXX] part. */
2025 valid_toc
= parse_toc_entry (&toc_kind
);
2029 /* Note: message has already been issued.
2030 FIXME: what sort of recovery should we do?
2031 demand_rest_of_line (); return; ? */
2034 /* Now get the symbol following the ']'. */
2040 /* In this case, we may not have seen the symbol yet,
2041 since it is allowed to appear on a .extern or .globl
2042 or just be a label in the .data section. */
2043 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2046 /* 1. The symbol must be defined and either in the toc
2047 section, or a global.
2048 2. The reloc generated must have the TOCDEFN flag set
2049 in upper bit mess of the reloc type.
2050 FIXME: It's a little confusing what the tocv
2051 qualifier can be used for. At the very least, I've
2052 seen three uses, only one of which I'm sure I can
2054 if (ex
.X_op
== O_symbol
)
2056 assert (ex
.X_add_symbol
!= NULL
);
2057 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2060 as_bad (_("[tocv] symbol is not a toc symbol"));
2064 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2067 /* FIXME: these next two specifically specify 32/64 bit
2068 toc entries. We don't support them today. Is this
2069 the right way to say that? */
2070 toc_reloc
= BFD_RELOC_UNUSED
;
2071 as_bad (_("Unimplemented toc32 expression modifier"));
2074 /* FIXME: see above. */
2075 toc_reloc
= BFD_RELOC_UNUSED
;
2076 as_bad (_("Unimplemented toc64 expression modifier"));
2080 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2086 /* We need to generate a fixup for this expression. */
2087 if (fc
>= MAX_INSN_FIXUPS
)
2088 as_fatal (_("too many fixups"));
2090 fixups
[fc
].reloc
= toc_reloc
;
2091 fixups
[fc
].exp
= ex
;
2092 fixups
[fc
].opindex
= *opindex_ptr
;
2095 /* Ok. We've set up the fixup for the instruction. Now make it
2096 look like the constant 0 was found here. */
2098 ex
.X_op
= O_constant
;
2099 ex
.X_add_number
= 0;
2100 ex
.X_add_symbol
= NULL
;
2101 ex
.X_op_symbol
= NULL
;
2107 if (! register_name (&ex
))
2109 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2116 str
= input_line_pointer
;
2117 input_line_pointer
= hold
;
2119 if (ex
.X_op
== O_illegal
)
2120 as_bad (_("illegal operand"));
2121 else if (ex
.X_op
== O_absent
)
2122 as_bad (_("missing operand"));
2123 else if (ex
.X_op
== O_register
)
2125 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2128 else if (ex
.X_op
== O_constant
)
2131 /* Allow @HA, @L, @H on constants. */
2132 char *orig_str
= str
;
2134 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2141 case BFD_RELOC_LO16
:
2142 /* X_unsigned is the default, so if the user has done
2143 something which cleared it, we always produce a
2145 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2146 ex
.X_add_number
&= 0xffff;
2148 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2151 case BFD_RELOC_HI16
:
2152 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2153 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2155 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2158 case BFD_RELOC_HI16_S
:
2159 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2160 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2162 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2165 case BFD_RELOC_PPC64_HIGHER
:
2166 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2167 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2169 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2172 case BFD_RELOC_PPC64_HIGHER_S
:
2173 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2174 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2176 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2179 case BFD_RELOC_PPC64_HIGHEST
:
2180 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2181 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2183 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2186 case BFD_RELOC_PPC64_HIGHEST_S
:
2187 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2188 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2190 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2193 #endif /* OBJ_ELF */
2194 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2198 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2200 /* For the absolute forms of branches, convert the PC
2201 relative form back into the absolute. */
2202 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2206 case BFD_RELOC_PPC_B26
:
2207 reloc
= BFD_RELOC_PPC_BA26
;
2209 case BFD_RELOC_PPC_B16
:
2210 reloc
= BFD_RELOC_PPC_BA16
;
2212 case BFD_RELOC_PPC_B16_BRTAKEN
:
2213 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2215 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2216 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2224 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2229 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2231 case BFD_RELOC_LO16
:
2232 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2234 case BFD_RELOC_16_GOTOFF
:
2235 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2237 case BFD_RELOC_LO16_GOTOFF
:
2238 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2240 case BFD_RELOC_LO16_PLTOFF
:
2241 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2243 case BFD_RELOC_16_BASEREL
:
2244 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2246 case BFD_RELOC_LO16_BASEREL
:
2247 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2249 case BFD_RELOC_PPC_TOC16
:
2250 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2252 case BFD_RELOC_PPC64_TOC16_LO
:
2253 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2255 case BFD_RELOC_PPC64_PLTGOT16
:
2256 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2258 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2259 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2262 as_bad (_("unsupported relocation for DS offset field"));
2267 /* We need to generate a fixup for this expression. */
2268 if (fc
>= MAX_INSN_FIXUPS
)
2269 as_fatal (_("too many fixups"));
2270 fixups
[fc
].exp
= ex
;
2271 fixups
[fc
].opindex
= 0;
2272 fixups
[fc
].reloc
= reloc
;
2275 #endif /* OBJ_ELF */
2279 /* We need to generate a fixup for this expression. */
2280 if (fc
>= MAX_INSN_FIXUPS
)
2281 as_fatal (_("too many fixups"));
2282 fixups
[fc
].exp
= ex
;
2283 fixups
[fc
].opindex
= *opindex_ptr
;
2284 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2293 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2301 /* The call to expression should have advanced str past any
2304 && (endc
!= ',' || *str
!= '\0'))
2306 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2314 while (ISSPACE (*str
))
2318 as_bad (_("junk at end of line: `%s'"), str
);
2320 /* Write out the instruction. */
2322 md_number_to_chars (f
, insn
, 4);
2325 dwarf2_emit_insn (4);
2328 /* Create any fixups. At this point we do not use a
2329 bfd_reloc_code_real_type, but instead just use the
2330 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2331 handle fixups for any operand type, although that is admittedly
2332 not a very exciting feature. We pick a BFD reloc type in
2334 for (i
= 0; i
< fc
; i
++)
2336 const struct powerpc_operand
*operand
;
2338 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2339 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2341 reloc_howto_type
*reloc_howto
;
2346 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2350 size
= bfd_get_reloc_size (reloc_howto
);
2351 offset
= target_big_endian
? (4 - size
) : 0;
2353 if (size
< 1 || size
> 4)
2356 fixP
= fix_new_exp (frag_now
,
2357 f
- frag_now
->fr_literal
+ offset
,
2360 reloc_howto
->pc_relative
,
2363 /* Turn off complaints that the addend is too large for things like
2365 switch (fixups
[i
].reloc
)
2367 case BFD_RELOC_16_GOTOFF
:
2368 case BFD_RELOC_PPC_TOC16
:
2369 case BFD_RELOC_LO16
:
2370 case BFD_RELOC_HI16
:
2371 case BFD_RELOC_HI16_S
:
2373 case BFD_RELOC_PPC64_HIGHER
:
2374 case BFD_RELOC_PPC64_HIGHER_S
:
2375 case BFD_RELOC_PPC64_HIGHEST
:
2376 case BFD_RELOC_PPC64_HIGHEST_S
:
2378 fixP
->fx_no_overflow
= 1;
2385 fix_new_exp (frag_now
,
2386 f
- frag_now
->fr_literal
,
2389 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2390 ((bfd_reloc_code_real_type
)
2391 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2395 /* Handle a macro. Gather all the operands, transform them as
2396 described by the macro, and call md_assemble recursively. All the
2397 operands are separated by commas; we don't accept parentheses
2398 around operands here. */
2401 ppc_macro (str
, macro
)
2403 const struct powerpc_macro
*macro
;
2414 /* Gather the users operands into the operands array. */
2419 if (count
>= sizeof operands
/ sizeof operands
[0])
2421 operands
[count
++] = s
;
2422 s
= strchr (s
, ',');
2423 if (s
== (char *) NULL
)
2428 if (count
!= macro
->operands
)
2430 as_bad (_("wrong number of operands"));
2434 /* Work out how large the string must be (the size is unbounded
2435 because it includes user input). */
2437 format
= macro
->format
;
2438 while (*format
!= '\0')
2447 arg
= strtol (format
+ 1, &send
, 10);
2448 know (send
!= format
&& arg
>= 0 && arg
< count
);
2449 len
+= strlen (operands
[arg
]);
2454 /* Put the string together. */
2455 complete
= s
= (char *) alloca (len
+ 1);
2456 format
= macro
->format
;
2457 while (*format
!= '\0')
2463 arg
= strtol (format
+ 1, &send
, 10);
2464 strcpy (s
, operands
[arg
]);
2471 /* Assemble the constructed instruction. */
2472 md_assemble (complete
);
2476 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2479 ppc_section_letter (letter
, ptr_msg
)
2486 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2491 ppc_section_word (str
, len
)
2495 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2502 ppc_section_type (str
, len
)
2506 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2513 ppc_section_flags (flags
, attr
, type
)
2518 if (type
== SHT_ORDERED
)
2519 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2521 if (attr
& SHF_EXCLUDE
)
2522 flags
|= SEC_EXCLUDE
;
2526 #endif /* OBJ_ELF */
2529 /* Pseudo-op handling. */
2531 /* The .byte pseudo-op. This is similar to the normal .byte
2532 pseudo-op, but it can also take a single ASCII string. */
2536 int ignore ATTRIBUTE_UNUSED
;
2538 if (*input_line_pointer
!= '\"')
2544 /* Gather characters. A real double quote is doubled. Unusual
2545 characters are not permitted. */
2546 ++input_line_pointer
;
2551 c
= *input_line_pointer
++;
2555 if (*input_line_pointer
!= '\"')
2557 ++input_line_pointer
;
2560 FRAG_APPEND_1_CHAR (c
);
2563 demand_empty_rest_of_line ();
2568 /* XCOFF specific pseudo-op handling. */
2570 /* This is set if we are creating a .stabx symbol, since we don't want
2571 to handle symbol suffixes for such symbols. */
2572 static boolean ppc_stab_symbol
;
2574 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2575 symbols in the .bss segment as though they were local common
2576 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2577 aligns .comm and .lcomm to 4 bytes. */
2583 asection
*current_seg
= now_seg
;
2584 subsegT current_subseg
= now_subseg
;
2590 symbolS
*lcomm_sym
= NULL
;
2594 name
= input_line_pointer
;
2595 endc
= get_symbol_end ();
2596 end_name
= input_line_pointer
;
2599 if (*input_line_pointer
!= ',')
2601 as_bad (_("missing size"));
2602 ignore_rest_of_line ();
2605 ++input_line_pointer
;
2607 size
= get_absolute_expression ();
2610 as_bad (_("negative size"));
2611 ignore_rest_of_line ();
2617 /* The third argument to .comm is the alignment. */
2618 if (*input_line_pointer
!= ',')
2622 ++input_line_pointer
;
2623 align
= get_absolute_expression ();
2626 as_warn (_("ignoring bad alignment"));
2641 /* The third argument to .lcomm appears to be the real local
2642 common symbol to create. References to the symbol named in
2643 the first argument are turned into references to the third
2645 if (*input_line_pointer
!= ',')
2647 as_bad (_("missing real symbol name"));
2648 ignore_rest_of_line ();
2651 ++input_line_pointer
;
2653 lcomm_name
= input_line_pointer
;
2654 lcomm_endc
= get_symbol_end ();
2656 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2658 *input_line_pointer
= lcomm_endc
;
2662 sym
= symbol_find_or_make (name
);
2665 if (S_IS_DEFINED (sym
)
2666 || S_GET_VALUE (sym
) != 0)
2668 as_bad (_("attempt to redefine symbol"));
2669 ignore_rest_of_line ();
2673 record_alignment (bss_section
, align
);
2676 || ! S_IS_DEFINED (lcomm_sym
))
2685 S_SET_EXTERNAL (sym
);
2689 symbol_get_tc (lcomm_sym
)->output
= 1;
2690 def_sym
= lcomm_sym
;
2694 subseg_set (bss_section
, 1);
2695 frag_align (align
, 0, 0);
2697 symbol_set_frag (def_sym
, frag_now
);
2698 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2699 def_size
, (char *) NULL
);
2701 S_SET_SEGMENT (def_sym
, bss_section
);
2702 symbol_get_tc (def_sym
)->align
= align
;
2706 /* Align the size of lcomm_sym. */
2707 symbol_get_frag (lcomm_sym
)->fr_offset
=
2708 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2709 &~ ((1 << align
) - 1));
2710 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2711 symbol_get_tc (lcomm_sym
)->align
= align
;
2716 /* Make sym an offset from lcomm_sym. */
2717 S_SET_SEGMENT (sym
, bss_section
);
2718 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2719 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2720 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2723 subseg_set (current_seg
, current_subseg
);
2725 demand_empty_rest_of_line ();
2728 /* The .csect pseudo-op. This switches us into a different
2729 subsegment. The first argument is a symbol whose value is the
2730 start of the .csect. In COFF, csect symbols get special aux
2731 entries defined by the x_csect field of union internal_auxent. The
2732 optional second argument is the alignment (the default is 2). */
2736 int ignore ATTRIBUTE_UNUSED
;
2742 name
= input_line_pointer
;
2743 endc
= get_symbol_end ();
2745 sym
= symbol_find_or_make (name
);
2747 *input_line_pointer
= endc
;
2749 if (S_GET_NAME (sym
)[0] == '\0')
2751 /* An unnamed csect is assumed to be [PR]. */
2752 symbol_get_tc (sym
)->class = XMC_PR
;
2755 ppc_change_csect (sym
);
2757 if (*input_line_pointer
== ',')
2759 ++input_line_pointer
;
2760 symbol_get_tc (sym
)->align
= get_absolute_expression ();
2763 demand_empty_rest_of_line ();
2766 /* Change to a different csect. */
2769 ppc_change_csect (sym
)
2772 if (S_IS_DEFINED (sym
))
2773 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
2781 /* This is a new csect. We need to look at the symbol class to
2782 figure out whether it should go in the text section or the
2785 switch (symbol_get_tc (sym
)->class)
2795 S_SET_SEGMENT (sym
, text_section
);
2796 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
2797 ++ppc_text_subsegment
;
2798 list_ptr
= &ppc_text_csects
;
2807 if (ppc_toc_csect
!= NULL
2808 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
2809 == ppc_data_subsegment
))
2811 S_SET_SEGMENT (sym
, data_section
);
2812 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
2813 ++ppc_data_subsegment
;
2814 list_ptr
= &ppc_data_csects
;
2820 /* We set the obstack chunk size to a small value before
2821 changing subsegments, so that we don't use a lot of memory
2822 space for what may be a small section. */
2823 hold_chunksize
= chunksize
;
2826 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
2827 symbol_get_tc (sym
)->subseg
);
2829 chunksize
= hold_chunksize
;
2832 ppc_after_toc_frag
= frag_now
;
2834 symbol_set_frag (sym
, frag_now
);
2835 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2837 symbol_get_tc (sym
)->align
= 2;
2838 symbol_get_tc (sym
)->output
= 1;
2839 symbol_get_tc (sym
)->within
= sym
;
2841 for (list
= *list_ptr
;
2842 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
2843 list
= symbol_get_tc (list
)->next
)
2845 symbol_get_tc (list
)->next
= sym
;
2847 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2848 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
2852 ppc_current_csect
= sym
;
2855 /* This function handles the .text and .data pseudo-ops. These
2856 pseudo-ops aren't really used by XCOFF; we implement them for the
2857 convenience of people who aren't used to XCOFF. */
2868 else if (type
== 'd')
2873 sym
= symbol_find_or_make (name
);
2875 ppc_change_csect (sym
);
2877 demand_empty_rest_of_line ();
2880 /* This function handles the .section pseudo-op. This is mostly to
2881 give an error, since XCOFF only supports .text, .data and .bss, but
2882 we do permit the user to name the text or data section. */
2885 ppc_named_section (ignore
)
2886 int ignore ATTRIBUTE_UNUSED
;
2889 const char *real_name
;
2893 user_name
= input_line_pointer
;
2894 c
= get_symbol_end ();
2896 if (strcmp (user_name
, ".text") == 0)
2897 real_name
= ".text[PR]";
2898 else if (strcmp (user_name
, ".data") == 0)
2899 real_name
= ".data[RW]";
2902 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2903 *input_line_pointer
= c
;
2904 ignore_rest_of_line ();
2908 *input_line_pointer
= c
;
2910 sym
= symbol_find_or_make (real_name
);
2912 ppc_change_csect (sym
);
2914 demand_empty_rest_of_line ();
2917 /* The .extern pseudo-op. We create an undefined symbol. */
2921 int ignore ATTRIBUTE_UNUSED
;
2926 name
= input_line_pointer
;
2927 endc
= get_symbol_end ();
2929 (void) symbol_find_or_make (name
);
2931 *input_line_pointer
= endc
;
2933 demand_empty_rest_of_line ();
2936 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2940 int ignore ATTRIBUTE_UNUSED
;
2946 name
= input_line_pointer
;
2947 endc
= get_symbol_end ();
2949 sym
= symbol_find_or_make (name
);
2951 *input_line_pointer
= endc
;
2953 symbol_get_tc (sym
)->output
= 1;
2955 demand_empty_rest_of_line ();
2958 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2959 although I don't know why it bothers. */
2963 int ignore ATTRIBUTE_UNUSED
;
2970 name
= input_line_pointer
;
2971 endc
= get_symbol_end ();
2973 sym
= symbol_find_or_make (name
);
2975 *input_line_pointer
= endc
;
2977 if (*input_line_pointer
!= ',')
2979 as_bad (_("missing rename string"));
2980 ignore_rest_of_line ();
2983 ++input_line_pointer
;
2985 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
2987 demand_empty_rest_of_line ();
2990 /* The .stabx pseudo-op. This is similar to a normal .stabs
2991 pseudo-op, but slightly different. A sample is
2992 .stabx "main:F-1",.main,142,0
2993 The first argument is the symbol name to create. The second is the
2994 value, and the third is the storage class. The fourth seems to be
2995 always zero, and I am assuming it is the type. */
2999 int ignore ATTRIBUTE_UNUSED
;
3006 name
= demand_copy_C_string (&len
);
3008 if (*input_line_pointer
!= ',')
3010 as_bad (_("missing value"));
3013 ++input_line_pointer
;
3015 ppc_stab_symbol
= true;
3016 sym
= symbol_make (name
);
3017 ppc_stab_symbol
= false;
3019 symbol_get_tc (sym
)->real_name
= name
;
3021 (void) expression (&exp
);
3028 as_bad (_("illegal .stabx expression; zero assumed"));
3029 exp
.X_add_number
= 0;
3032 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
3033 symbol_set_frag (sym
, &zero_address_frag
);
3037 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
3038 symbol_set_value_expression (sym
, &exp
);
3042 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3043 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3048 /* The value is some complex expression. This will probably
3049 fail at some later point, but this is probably the right
3050 thing to do here. */
3051 symbol_set_value_expression (sym
, &exp
);
3055 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3056 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3058 if (*input_line_pointer
!= ',')
3060 as_bad (_("missing class"));
3063 ++input_line_pointer
;
3065 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3067 if (*input_line_pointer
!= ',')
3069 as_bad (_("missing type"));
3072 ++input_line_pointer
;
3074 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3076 symbol_get_tc (sym
)->output
= 1;
3078 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3080 symbol_get_tc (sym
)->within
= ppc_current_block
;
3085 .stabx "z",arrays_,133,0
3088 .comm arrays_,13768,3
3090 resolve_symbol_value will copy the exp's "within" into sym's when the
3091 offset is 0. Since this seems to be corner case problem,
3092 only do the correction for storage class C_STSYM. A better solution
3093 would be to have the tc field updated in ppc_symbol_new_hook. */
3095 if (exp
.X_op
== O_symbol
)
3097 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3101 if (exp
.X_op
!= O_symbol
3102 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3103 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3104 ppc_frob_label (sym
);
3107 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3108 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3109 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3110 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3113 demand_empty_rest_of_line ();
3116 /* The .function pseudo-op. This takes several arguments. The first
3117 argument seems to be the external name of the symbol. The second
3118 argment seems to be the label for the start of the function. gcc
3119 uses the same name for both. I have no idea what the third and
3120 fourth arguments are meant to be. The optional fifth argument is
3121 an expression for the size of the function. In COFF this symbol
3122 gets an aux entry like that used for a csect. */
3125 ppc_function (ignore
)
3126 int ignore ATTRIBUTE_UNUSED
;
3134 name
= input_line_pointer
;
3135 endc
= get_symbol_end ();
3137 /* Ignore any [PR] suffix. */
3138 name
= ppc_canonicalize_symbol_name (name
);
3139 s
= strchr (name
, '[');
3140 if (s
!= (char *) NULL
3141 && strcmp (s
+ 1, "PR]") == 0)
3144 ext_sym
= symbol_find_or_make (name
);
3146 *input_line_pointer
= endc
;
3148 if (*input_line_pointer
!= ',')
3150 as_bad (_("missing symbol name"));
3151 ignore_rest_of_line ();
3154 ++input_line_pointer
;
3156 name
= input_line_pointer
;
3157 endc
= get_symbol_end ();
3159 lab_sym
= symbol_find_or_make (name
);
3161 *input_line_pointer
= endc
;
3163 if (ext_sym
!= lab_sym
)
3167 exp
.X_op
= O_symbol
;
3168 exp
.X_add_symbol
= lab_sym
;
3169 exp
.X_op_symbol
= NULL
;
3170 exp
.X_add_number
= 0;
3172 symbol_set_value_expression (ext_sym
, &exp
);
3175 if (symbol_get_tc (ext_sym
)->class == -1)
3176 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3177 symbol_get_tc (ext_sym
)->output
= 1;
3179 if (*input_line_pointer
== ',')
3183 /* Ignore the third argument. */
3184 ++input_line_pointer
;
3185 expression (&ignore
);
3186 if (*input_line_pointer
== ',')
3188 /* Ignore the fourth argument. */
3189 ++input_line_pointer
;
3190 expression (&ignore
);
3191 if (*input_line_pointer
== ',')
3193 /* The fifth argument is the function size. */
3194 ++input_line_pointer
;
3195 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3198 &zero_address_frag
);
3199 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3204 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3205 SF_SET_FUNCTION (ext_sym
);
3206 SF_SET_PROCESS (ext_sym
);
3207 coff_add_linesym (ext_sym
);
3209 demand_empty_rest_of_line ();
3212 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3213 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3214 with the correct line number */
3216 static symbolS
*saved_bi_sym
= 0;
3220 int ignore ATTRIBUTE_UNUSED
;
3224 sym
= symbol_make (".bf");
3225 S_SET_SEGMENT (sym
, text_section
);
3226 symbol_set_frag (sym
, frag_now
);
3227 S_SET_VALUE (sym
, frag_now_fix ());
3228 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3230 coff_line_base
= get_absolute_expression ();
3232 S_SET_NUMBER_AUXILIARY (sym
, 1);
3233 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3235 /* Line number for bi. */
3238 S_SET_VALUE (saved_bi_sym
, coff_n_line_nos
);
3243 symbol_get_tc (sym
)->output
= 1;
3245 ppc_frob_label (sym
);
3247 demand_empty_rest_of_line ();
3250 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3251 ".ef", except that the line number is absolute, not relative to the
3252 most recent ".bf" symbol. */
3256 int ignore ATTRIBUTE_UNUSED
;
3260 sym
= symbol_make (".ef");
3261 S_SET_SEGMENT (sym
, text_section
);
3262 symbol_set_frag (sym
, frag_now
);
3263 S_SET_VALUE (sym
, frag_now_fix ());
3264 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3265 S_SET_NUMBER_AUXILIARY (sym
, 1);
3266 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3267 symbol_get_tc (sym
)->output
= 1;
3269 ppc_frob_label (sym
);
3271 demand_empty_rest_of_line ();
3274 /* The .bi and .ei pseudo-ops. These take a string argument and
3275 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3276 the symbol list. The value of .bi will be know when the next .bf
3283 static symbolS
*last_biei
;
3290 name
= demand_copy_C_string (&len
);
3292 /* The value of these symbols is actually file offset. Here we set
3293 the value to the index into the line number entries. In
3294 ppc_frob_symbols we set the fix_line field, which will cause BFD
3295 to do the right thing. */
3297 sym
= symbol_make (name
);
3298 /* obj-coff.c currently only handles line numbers correctly in the
3300 S_SET_SEGMENT (sym
, text_section
);
3301 S_SET_VALUE (sym
, coff_n_line_nos
);
3302 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3304 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3305 symbol_get_tc (sym
)->output
= 1;
3313 for (look
= last_biei
? last_biei
: symbol_rootP
;
3314 (look
!= (symbolS
*) NULL
3315 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3316 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3317 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3318 look
= symbol_next (look
))
3320 if (look
!= (symbolS
*) NULL
)
3322 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3323 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3327 demand_empty_rest_of_line ();
3330 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3331 There is one argument, which is a csect symbol. The value of the
3332 .bs symbol is the index of this csect symbol. */
3336 int ignore ATTRIBUTE_UNUSED
;
3343 if (ppc_current_block
!= NULL
)
3344 as_bad (_("nested .bs blocks"));
3346 name
= input_line_pointer
;
3347 endc
= get_symbol_end ();
3349 csect
= symbol_find_or_make (name
);
3351 *input_line_pointer
= endc
;
3353 sym
= symbol_make (".bs");
3354 S_SET_SEGMENT (sym
, now_seg
);
3355 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3356 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3357 symbol_get_tc (sym
)->output
= 1;
3359 symbol_get_tc (sym
)->within
= csect
;
3361 ppc_frob_label (sym
);
3363 ppc_current_block
= sym
;
3365 demand_empty_rest_of_line ();
3368 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3372 int ignore ATTRIBUTE_UNUSED
;
3376 if (ppc_current_block
== NULL
)
3377 as_bad (_(".es without preceding .bs"));
3379 sym
= symbol_make (".es");
3380 S_SET_SEGMENT (sym
, now_seg
);
3381 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3382 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3383 symbol_get_tc (sym
)->output
= 1;
3385 ppc_frob_label (sym
);
3387 ppc_current_block
= NULL
;
3389 demand_empty_rest_of_line ();
3392 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3397 int ignore ATTRIBUTE_UNUSED
;
3401 sym
= symbol_make (".bb");
3402 S_SET_SEGMENT (sym
, text_section
);
3403 symbol_set_frag (sym
, frag_now
);
3404 S_SET_VALUE (sym
, frag_now_fix ());
3405 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3407 S_SET_NUMBER_AUXILIARY (sym
, 1);
3408 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3410 symbol_get_tc (sym
)->output
= 1;
3412 SF_SET_PROCESS (sym
);
3414 ppc_frob_label (sym
);
3416 demand_empty_rest_of_line ();
3419 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3424 int ignore ATTRIBUTE_UNUSED
;
3428 sym
= symbol_make (".eb");
3429 S_SET_SEGMENT (sym
, text_section
);
3430 symbol_set_frag (sym
, frag_now
);
3431 S_SET_VALUE (sym
, frag_now_fix ());
3432 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3433 S_SET_NUMBER_AUXILIARY (sym
, 1);
3434 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3435 symbol_get_tc (sym
)->output
= 1;
3437 SF_SET_PROCESS (sym
);
3439 ppc_frob_label (sym
);
3441 demand_empty_rest_of_line ();
3444 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3449 int ignore ATTRIBUTE_UNUSED
;
3455 name
= demand_copy_C_string (&len
);
3456 sym
= symbol_make (name
);
3457 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3458 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3459 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3460 S_SET_VALUE (sym
, 0);
3461 symbol_get_tc (sym
)->output
= 1;
3463 ppc_frob_label (sym
);
3465 demand_empty_rest_of_line ();
3468 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3472 int ignore ATTRIBUTE_UNUSED
;
3476 sym
= symbol_make (".ec");
3477 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3478 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3479 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3480 S_SET_VALUE (sym
, 0);
3481 symbol_get_tc (sym
)->output
= 1;
3483 ppc_frob_label (sym
);
3485 demand_empty_rest_of_line ();
3488 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3492 int ignore ATTRIBUTE_UNUSED
;
3494 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3495 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3502 subseg
= ppc_data_subsegment
;
3503 ++ppc_data_subsegment
;
3505 subseg_new (segment_name (data_section
), subseg
);
3506 ppc_toc_frag
= frag_now
;
3508 sym
= symbol_find_or_make ("TOC[TC0]");
3509 symbol_set_frag (sym
, frag_now
);
3510 S_SET_SEGMENT (sym
, data_section
);
3511 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3512 symbol_get_tc (sym
)->subseg
= subseg
;
3513 symbol_get_tc (sym
)->output
= 1;
3514 symbol_get_tc (sym
)->within
= sym
;
3516 ppc_toc_csect
= sym
;
3518 for (list
= ppc_data_csects
;
3519 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3520 list
= symbol_get_tc (list
)->next
)
3522 symbol_get_tc (list
)->next
= sym
;
3524 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3525 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3529 ppc_current_csect
= ppc_toc_csect
;
3531 demand_empty_rest_of_line ();
3534 /* The AIX assembler automatically aligns the operands of a .long or
3535 .short pseudo-op, and we want to be compatible. */
3538 ppc_xcoff_cons (log_size
)
3541 frag_align (log_size
, 0, 0);
3542 record_alignment (now_seg
, log_size
);
3543 cons (1 << log_size
);
3548 int dummy ATTRIBUTE_UNUSED
;
3553 (void) expression (&exp
);
3555 if (exp
.X_op
!= O_constant
)
3557 as_bad (_("non-constant byte count"));
3561 byte_count
= exp
.X_add_number
;
3563 if (*input_line_pointer
!= ',')
3565 as_bad (_("missing value"));
3569 ++input_line_pointer
;
3573 #endif /* OBJ_XCOFF */
3574 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3576 /* The .tc pseudo-op. This is used when generating either XCOFF or
3577 ELF. This takes two or more arguments.
3579 When generating XCOFF output, the first argument is the name to
3580 give to this location in the toc; this will be a symbol with class
3581 TC. The rest of the arguments are N-byte values to actually put at
3582 this location in the TOC; often there is just one more argument, a
3583 relocateable symbol reference. The size of the value to store
3584 depends on target word size. A 32-bit target uses 4-byte values, a
3585 64-bit target uses 8-byte values.
3587 When not generating XCOFF output, the arguments are the same, but
3588 the first argument is simply ignored. */
3592 int ignore ATTRIBUTE_UNUSED
;
3596 /* Define the TOC symbol name. */
3602 if (ppc_toc_csect
== (symbolS
*) NULL
3603 || ppc_toc_csect
!= ppc_current_csect
)
3605 as_bad (_(".tc not in .toc section"));
3606 ignore_rest_of_line ();
3610 name
= input_line_pointer
;
3611 endc
= get_symbol_end ();
3613 sym
= symbol_find_or_make (name
);
3615 *input_line_pointer
= endc
;
3617 if (S_IS_DEFINED (sym
))
3621 label
= symbol_get_tc (ppc_current_csect
)->within
;
3622 if (symbol_get_tc (label
)->class != XMC_TC0
)
3624 as_bad (_(".tc with no label"));
3625 ignore_rest_of_line ();
3629 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3630 symbol_set_frag (label
, symbol_get_frag (sym
));
3631 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3633 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3634 ++input_line_pointer
;
3639 S_SET_SEGMENT (sym
, now_seg
);
3640 symbol_set_frag (sym
, frag_now
);
3641 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3642 symbol_get_tc (sym
)->class = XMC_TC
;
3643 symbol_get_tc (sym
)->output
= 1;
3645 ppc_frob_label (sym
);
3648 #endif /* OBJ_XCOFF */
3652 /* Skip the TOC symbol name. */
3653 while (is_part_of_name (*input_line_pointer
)
3654 || *input_line_pointer
== '['
3655 || *input_line_pointer
== ']'
3656 || *input_line_pointer
== '{'
3657 || *input_line_pointer
== '}')
3658 ++input_line_pointer
;
3660 /* Align to a four/eight byte boundary. */
3661 align
= ppc_obj64
? 3 : 2;
3662 frag_align (align
, 0, 0);
3663 record_alignment (now_seg
, align
);
3664 #endif /* OBJ_ELF */
3666 if (*input_line_pointer
!= ',')
3667 demand_empty_rest_of_line ();
3670 ++input_line_pointer
;
3671 cons (ppc_obj64
? 8 : 4);
3675 /* Pseudo-op .machine. */
3676 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3677 accept this directive on the first line of input and set ppc_obj64
3678 and the target format accordingly. Unfortunately, the target
3679 format is selected in output-file.c:output_file_create before we
3680 even get to md_begin, so it's not possible without changing
3684 ppc_machine (ignore
)
3685 int ignore ATTRIBUTE_UNUSED
;
3687 discard_rest_of_line ();
3690 /* See whether a symbol is in the TOC section. */
3693 ppc_is_toc_sym (sym
)
3697 return symbol_get_tc (sym
)->class == XMC_TC
;
3700 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3702 return strcmp (sname
, ".toc") == 0;
3704 return strcmp (sname
, ".got") == 0;
3707 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3711 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3713 /* Set the current section. */
3715 ppc_set_current_section (new)
3718 ppc_previous_section
= ppc_current_section
;
3719 ppc_current_section
= new;
3722 /* pseudo-op: .previous
3723 behaviour: toggles the current section with the previous section.
3725 warnings: "No previous section" */
3728 ppc_previous (ignore
)
3729 int ignore ATTRIBUTE_UNUSED
;
3733 if (ppc_previous_section
== NULL
)
3735 as_warn (_("No previous section to return to. Directive ignored."));
3739 subseg_set (ppc_previous_section
, 0);
3741 ppc_set_current_section (ppc_previous_section
);
3744 /* pseudo-op: .pdata
3745 behaviour: predefined read only data section
3749 initial: .section .pdata "adr3"
3750 a - don't know -- maybe a misprint
3751 d - initialized data
3753 3 - double word aligned (that would be 4 byte boundary)
3756 Tag index tables (also known as the function table) for exception
3757 handling, debugging, etc. */
3761 int ignore ATTRIBUTE_UNUSED
;
3763 if (pdata_section
== 0)
3765 pdata_section
= subseg_new (".pdata", 0);
3767 bfd_set_section_flags (stdoutput
, pdata_section
,
3768 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3769 | SEC_READONLY
| SEC_DATA
));
3771 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
3775 pdata_section
= subseg_new (".pdata", 0);
3777 ppc_set_current_section (pdata_section
);
3780 /* pseudo-op: .ydata
3781 behaviour: predefined read only data section
3785 initial: .section .ydata "drw3"
3786 a - don't know -- maybe a misprint
3787 d - initialized data
3789 3 - double word aligned (that would be 4 byte boundary)
3791 Tag tables (also known as the scope table) for exception handling,
3796 int ignore ATTRIBUTE_UNUSED
;
3798 if (ydata_section
== 0)
3800 ydata_section
= subseg_new (".ydata", 0);
3801 bfd_set_section_flags (stdoutput
, ydata_section
,
3802 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3803 | SEC_READONLY
| SEC_DATA
));
3805 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
3809 ydata_section
= subseg_new (".ydata", 0);
3811 ppc_set_current_section (ydata_section
);
3814 /* pseudo-op: .reldata
3815 behaviour: predefined read write data section
3816 double word aligned (4-byte)
3817 FIXME: relocation is applied to it
3818 FIXME: what's the difference between this and .data?
3821 initial: .section .reldata "drw3"
3822 d - initialized data
3825 3 - double word aligned (that would be 8 byte boundary)
3828 Like .data, but intended to hold data subject to relocation, such as
3829 function descriptors, etc. */
3832 ppc_reldata (ignore
)
3833 int ignore ATTRIBUTE_UNUSED
;
3835 if (reldata_section
== 0)
3837 reldata_section
= subseg_new (".reldata", 0);
3839 bfd_set_section_flags (stdoutput
, reldata_section
,
3840 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3843 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
3847 reldata_section
= subseg_new (".reldata", 0);
3849 ppc_set_current_section (reldata_section
);
3852 /* pseudo-op: .rdata
3853 behaviour: predefined read only data section
3857 initial: .section .rdata "dr3"
3858 d - initialized data
3860 3 - double word aligned (that would be 4 byte boundary) */
3864 int ignore ATTRIBUTE_UNUSED
;
3866 if (rdata_section
== 0)
3868 rdata_section
= subseg_new (".rdata", 0);
3869 bfd_set_section_flags (stdoutput
, rdata_section
,
3870 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3871 | SEC_READONLY
| SEC_DATA
));
3873 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
3877 rdata_section
= subseg_new (".rdata", 0);
3879 ppc_set_current_section (rdata_section
);
3882 /* pseudo-op: .ualong
3883 behaviour: much like .int, with the exception that no alignment is
3885 FIXME: test the alignment statement
3891 int ignore ATTRIBUTE_UNUSED
;
3897 /* pseudo-op: .znop <symbol name>
3898 behaviour: Issue a nop instruction
3899 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3900 the supplied symbol name.
3902 warnings: Missing symbol name */
3906 int ignore ATTRIBUTE_UNUSED
;
3909 const struct powerpc_opcode
*opcode
;
3920 /* Strip out the symbol name. */
3921 symbol_name
= input_line_pointer
;
3922 c
= get_symbol_end ();
3924 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
3925 strcpy (name
, symbol_name
);
3927 sym
= symbol_find_or_make (name
);
3929 *input_line_pointer
= c
;
3933 /* Look up the opcode in the hash table. */
3934 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
3936 /* Stick in the nop. */
3937 insn
= opcode
->opcode
;
3939 /* Write out the instruction. */
3941 md_number_to_chars (f
, insn
, 4);
3943 f
- frag_now
->fr_literal
,
3948 BFD_RELOC_16_GOT_PCREL
);
3961 register char *name
;
3965 register symbolS
*symbolP
;
3968 name
= input_line_pointer
;
3969 c
= get_symbol_end ();
3971 /* just after name is now '\0'. */
3972 p
= input_line_pointer
;
3975 if (*input_line_pointer
!= ',')
3977 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3978 ignore_rest_of_line ();
3982 input_line_pointer
++; /* skip ',' */
3983 if ((temp
= get_absolute_expression ()) < 0)
3985 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
3986 ignore_rest_of_line ();
3992 /* The third argument to .comm is the alignment. */
3993 if (*input_line_pointer
!= ',')
3997 ++input_line_pointer
;
3998 align
= get_absolute_expression ();
4001 as_warn (_("ignoring bad alignment"));
4008 symbolP
= symbol_find_or_make (name
);
4011 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
4013 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4014 S_GET_NAME (symbolP
));
4015 ignore_rest_of_line ();
4019 if (S_GET_VALUE (symbolP
))
4021 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
4022 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4023 S_GET_NAME (symbolP
),
4024 (long) S_GET_VALUE (symbolP
),
4029 S_SET_VALUE (symbolP
, (valueT
) temp
);
4030 S_SET_EXTERNAL (symbolP
);
4033 demand_empty_rest_of_line ();
4037 * implement the .section pseudo op:
4038 * .section name {, "flags"}
4040 * | +--- optional flags: 'b' for bss
4042 * +-- section name 'l' for lib
4046 * 'd' (apparently m88k for data)
4048 * But if the argument is not a quoted string, treat it as a
4049 * subsegment number.
4051 * FIXME: this is a copy of the section processing from obj-coff.c, with
4052 * additions/changes for the moto-pas assembler support. There are three
4055 * FIXME: I just noticed this. This doesn't work at all really. It it
4056 * setting bits that bfd probably neither understands or uses. The
4057 * correct approach (?) will have to incorporate extra fields attached
4058 * to the section to hold the system specific stuff. (krk)
4061 * 'a' - unknown - referred to in documentation, but no definition supplied
4062 * 'c' - section has code
4063 * 'd' - section has initialized data
4064 * 'u' - section has uninitialized data
4065 * 'i' - section contains directives (info)
4066 * 'n' - section can be discarded
4067 * 'R' - remove section at link time
4069 * Section Protection:
4070 * 'r' - section is readable
4071 * 'w' - section is writeable
4072 * 'x' - section is executable
4073 * 's' - section is sharable
4075 * Section Alignment:
4076 * '0' - align to byte boundary
4077 * '1' - align to halfword undary
4078 * '2' - align to word boundary
4079 * '3' - align to doubleword boundary
4080 * '4' - align to quadword boundary
4081 * '5' - align to 32 byte boundary
4082 * '6' - align to 64 byte boundary
4087 ppc_pe_section (ignore
)
4088 int ignore ATTRIBUTE_UNUSED
;
4090 /* Strip out the section name. */
4099 section_name
= input_line_pointer
;
4100 c
= get_symbol_end ();
4102 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4103 strcpy (name
, section_name
);
4105 *input_line_pointer
= c
;
4110 flags
= SEC_NO_FLAGS
;
4112 if (strcmp (name
, ".idata$2") == 0)
4116 else if (strcmp (name
, ".idata$3") == 0)
4120 else if (strcmp (name
, ".idata$4") == 0)
4124 else if (strcmp (name
, ".idata$5") == 0)
4128 else if (strcmp (name
, ".idata$6") == 0)
4133 /* Default alignment to 16 byte boundary. */
4136 if (*input_line_pointer
== ',')
4138 ++input_line_pointer
;
4140 if (*input_line_pointer
!= '"')
4141 exp
= get_absolute_expression ();
4144 ++input_line_pointer
;
4145 while (*input_line_pointer
!= '"'
4146 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4148 switch (*input_line_pointer
)
4150 /* Section Contents */
4151 case 'a': /* unknown */
4152 as_bad (_("Unsupported section attribute -- 'a'"));
4154 case 'c': /* code section */
4157 case 'd': /* section has initialized data */
4160 case 'u': /* section has uninitialized data */
4161 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4165 case 'i': /* section contains directives (info) */
4166 /* FIXME: This is IMAGE_SCN_LNK_INFO
4168 flags
|= SEC_HAS_CONTENTS
;
4170 case 'n': /* section can be discarded */
4173 case 'R': /* Remove section at link time */
4174 flags
|= SEC_NEVER_LOAD
;
4177 /* Section Protection */
4178 case 'r': /* section is readable */
4179 flags
|= IMAGE_SCN_MEM_READ
;
4181 case 'w': /* section is writeable */
4182 flags
|= IMAGE_SCN_MEM_WRITE
;
4184 case 'x': /* section is executable */
4185 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4187 case 's': /* section is sharable */
4188 flags
|= IMAGE_SCN_MEM_SHARED
;
4191 /* Section Alignment */
4192 case '0': /* align to byte boundary */
4193 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4196 case '1': /* align to halfword boundary */
4197 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4200 case '2': /* align to word boundary */
4201 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4204 case '3': /* align to doubleword boundary */
4205 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4208 case '4': /* align to quadword boundary */
4209 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4212 case '5': /* align to 32 byte boundary */
4213 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4216 case '6': /* align to 64 byte boundary */
4217 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4222 as_bad (_("unknown section attribute '%c'"),
4223 *input_line_pointer
);
4226 ++input_line_pointer
;
4228 if (*input_line_pointer
== '"')
4229 ++input_line_pointer
;
4233 sec
= subseg_new (name
, (subsegT
) exp
);
4235 ppc_set_current_section (sec
);
4237 if (flags
!= SEC_NO_FLAGS
)
4239 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4240 as_bad (_("error setting flags for \"%s\": %s"),
4241 bfd_section_name (stdoutput
, sec
),
4242 bfd_errmsg (bfd_get_error ()));
4245 bfd_set_section_alignment (stdoutput
, sec
, align
);
4250 ppc_pe_function (ignore
)
4251 int ignore ATTRIBUTE_UNUSED
;
4257 name
= input_line_pointer
;
4258 endc
= get_symbol_end ();
4260 ext_sym
= symbol_find_or_make (name
);
4262 *input_line_pointer
= endc
;
4264 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4265 SF_SET_FUNCTION (ext_sym
);
4266 SF_SET_PROCESS (ext_sym
);
4267 coff_add_linesym (ext_sym
);
4269 demand_empty_rest_of_line ();
4273 ppc_pe_tocd (ignore
)
4274 int ignore ATTRIBUTE_UNUSED
;
4276 if (tocdata_section
== 0)
4278 tocdata_section
= subseg_new (".tocd", 0);
4279 /* FIXME: section flags won't work. */
4280 bfd_set_section_flags (stdoutput
, tocdata_section
,
4281 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4282 | SEC_READONLY
| SEC_DATA
));
4284 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4288 rdata_section
= subseg_new (".tocd", 0);
4291 ppc_set_current_section (tocdata_section
);
4293 demand_empty_rest_of_line ();
4296 /* Don't adjust TOC relocs to use the section symbol. */
4299 ppc_pe_fix_adjustable (fix
)
4302 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4309 /* XCOFF specific symbol and file handling. */
4311 /* Canonicalize the symbol name. We use the to force the suffix, if
4312 any, to use square brackets, and to be in upper case. */
4315 ppc_canonicalize_symbol_name (name
)
4320 if (ppc_stab_symbol
)
4323 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4337 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4340 if (*s
== '\0' || s
[1] != '\0')
4341 as_bad (_("bad symbol suffix"));
4349 /* Set the class of a symbol based on the suffix, if any. This is
4350 called whenever a new symbol is created. */
4353 ppc_symbol_new_hook (sym
)
4356 struct ppc_tc_sy
*tc
;
4359 tc
= symbol_get_tc (sym
);
4363 tc
->real_name
= NULL
;
4369 if (ppc_stab_symbol
)
4372 s
= strchr (S_GET_NAME (sym
), '[');
4373 if (s
== (const char *) NULL
)
4375 /* There is no suffix. */
4384 if (strcmp (s
, "BS]") == 0)
4388 if (strcmp (s
, "DB]") == 0)
4390 else if (strcmp (s
, "DS]") == 0)
4394 if (strcmp (s
, "GL]") == 0)
4398 if (strcmp (s
, "PR]") == 0)
4402 if (strcmp (s
, "RO]") == 0)
4404 else if (strcmp (s
, "RW]") == 0)
4408 if (strcmp (s
, "SV]") == 0)
4412 if (strcmp (s
, "TC]") == 0)
4414 else if (strcmp (s
, "TI]") == 0)
4416 else if (strcmp (s
, "TB]") == 0)
4418 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4419 tc
->class = XMC_TC0
;
4422 if (strcmp (s
, "UA]") == 0)
4424 else if (strcmp (s
, "UC]") == 0)
4428 if (strcmp (s
, "XO]") == 0)
4433 if (tc
->class == -1)
4434 as_bad (_("Unrecognized symbol suffix"));
4437 /* Set the class of a label based on where it is defined. This
4438 handles symbols without suffixes. Also, move the symbol so that it
4439 follows the csect symbol. */
4442 ppc_frob_label (sym
)
4445 if (ppc_current_csect
!= (symbolS
*) NULL
)
4447 if (symbol_get_tc (sym
)->class == -1)
4448 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4450 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4451 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4452 &symbol_rootP
, &symbol_lastP
);
4453 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4457 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4458 seen. It tells ppc_adjust_symtab whether it needs to look through
4461 static boolean ppc_saw_abs
;
4463 /* Change the name of a symbol just before writing it out. Set the
4464 real name if the .rename pseudo-op was used. Otherwise, remove any
4465 class suffix. Return 1 if the symbol should not be included in the
4469 ppc_frob_symbol (sym
)
4472 static symbolS
*ppc_last_function
;
4473 static symbolS
*set_end
;
4475 /* Discard symbols that should not be included in the output symbol
4477 if (! symbol_used_in_reloc_p (sym
)
4478 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4479 || (! S_IS_EXTERNAL (sym
)
4480 && ! symbol_get_tc (sym
)->output
4481 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4484 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4485 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4491 name
= S_GET_NAME (sym
);
4492 s
= strchr (name
, '[');
4493 if (s
!= (char *) NULL
)
4499 snew
= xmalloc (len
+ 1);
4500 memcpy (snew
, name
, len
);
4503 S_SET_NAME (sym
, snew
);
4507 if (set_end
!= (symbolS
*) NULL
)
4509 SA_SET_SYM_ENDNDX (set_end
, sym
);
4513 if (SF_GET_FUNCTION (sym
))
4515 if (ppc_last_function
!= (symbolS
*) NULL
)
4516 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4517 ppc_last_function
= sym
;
4518 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4520 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4521 SA_SET_SYM_FSIZE (sym
,
4522 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4525 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4526 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4528 if (ppc_last_function
== (symbolS
*) NULL
)
4529 as_bad (_(".ef with no preceding .function"));
4532 set_end
= ppc_last_function
;
4533 ppc_last_function
= NULL
;
4535 /* We don't have a C_EFCN symbol, but we need to force the
4536 COFF backend to believe that it has seen one. */
4537 coff_last_function
= NULL
;
4541 if (! S_IS_EXTERNAL (sym
)
4542 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4543 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4544 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4545 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4546 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4547 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4548 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4549 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4550 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4551 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4553 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4554 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4557 union internal_auxent
*a
;
4559 /* Create a csect aux. */
4560 i
= S_GET_NUMBER_AUXILIARY (sym
);
4561 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4562 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4563 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4565 /* This is the TOC table. */
4566 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4567 a
->x_csect
.x_scnlen
.l
= 0;
4568 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4570 else if (symbol_get_tc (sym
)->subseg
!= 0)
4572 /* This is a csect symbol. x_scnlen is the size of the
4574 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4575 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4576 S_GET_SEGMENT (sym
))
4577 - S_GET_VALUE (sym
));
4580 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4581 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4582 - S_GET_VALUE (sym
));
4584 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4586 else if (S_GET_SEGMENT (sym
) == bss_section
)
4588 /* This is a common symbol. */
4589 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4590 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4591 if (S_IS_EXTERNAL (sym
))
4592 symbol_get_tc (sym
)->class = XMC_RW
;
4594 symbol_get_tc (sym
)->class = XMC_BS
;
4596 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4598 /* This is an absolute symbol. The csect will be created by
4599 ppc_adjust_symtab. */
4601 a
->x_csect
.x_smtyp
= XTY_LD
;
4602 if (symbol_get_tc (sym
)->class == -1)
4603 symbol_get_tc (sym
)->class = XMC_XO
;
4605 else if (! S_IS_DEFINED (sym
))
4607 /* This is an external symbol. */
4608 a
->x_csect
.x_scnlen
.l
= 0;
4609 a
->x_csect
.x_smtyp
= XTY_ER
;
4611 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4615 /* This is a TOC definition. x_scnlen is the size of the
4617 next
= symbol_next (sym
);
4618 while (symbol_get_tc (next
)->class == XMC_TC0
)
4619 next
= symbol_next (next
);
4620 if (next
== (symbolS
*) NULL
4621 || symbol_get_tc (next
)->class != XMC_TC
)
4623 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4624 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4626 - S_GET_VALUE (sym
));
4628 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4629 - S_GET_VALUE (sym
));
4633 resolve_symbol_value (next
);
4634 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4635 - S_GET_VALUE (sym
));
4637 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4643 /* This is a normal symbol definition. x_scnlen is the
4644 symbol index of the containing csect. */
4645 if (S_GET_SEGMENT (sym
) == text_section
)
4646 csect
= ppc_text_csects
;
4647 else if (S_GET_SEGMENT (sym
) == data_section
)
4648 csect
= ppc_data_csects
;
4652 /* Skip the initial dummy symbol. */
4653 csect
= symbol_get_tc (csect
)->next
;
4655 if (csect
== (symbolS
*) NULL
)
4657 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4658 a
->x_csect
.x_scnlen
.l
= 0;
4662 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4664 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4665 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4666 > S_GET_VALUE (sym
))
4668 csect
= symbol_get_tc (csect
)->next
;
4671 a
->x_csect
.x_scnlen
.p
=
4672 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4673 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4676 a
->x_csect
.x_smtyp
= XTY_LD
;
4679 a
->x_csect
.x_parmhash
= 0;
4680 a
->x_csect
.x_snhash
= 0;
4681 if (symbol_get_tc (sym
)->class == -1)
4682 a
->x_csect
.x_smclas
= XMC_PR
;
4684 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4685 a
->x_csect
.x_stab
= 0;
4686 a
->x_csect
.x_snstab
= 0;
4688 /* Don't let the COFF backend resort these symbols. */
4689 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4691 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4693 /* We want the value to be the symbol index of the referenced
4694 csect symbol. BFD will do that for us if we set the right
4698 coffsymbol (symbol_get_bfdsym
4699 (symbol_get_tc (sym
)->within
))->native
));
4700 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4702 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4707 /* The value is the offset from the enclosing csect. */
4708 block
= symbol_get_tc (sym
)->within
;
4709 csect
= symbol_get_tc (block
)->within
;
4710 resolve_symbol_value (csect
);
4711 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4713 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4714 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4716 /* We want the value to be a file offset into the line numbers.
4717 BFD will do that for us if we set the right flags. We have
4718 already set the value correctly. */
4719 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4725 /* Adjust the symbol table. This creates csect symbols for all
4726 absolute symbols. */
4729 ppc_adjust_symtab ()
4736 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
4740 union internal_auxent
*a
;
4742 if (S_GET_SEGMENT (sym
) != absolute_section
)
4745 csect
= symbol_create (".abs[XO]", absolute_section
,
4746 S_GET_VALUE (sym
), &zero_address_frag
);
4747 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
4748 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
4749 i
= S_GET_NUMBER_AUXILIARY (csect
);
4750 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
4751 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
4752 a
->x_csect
.x_scnlen
.l
= 0;
4753 a
->x_csect
.x_smtyp
= XTY_SD
;
4754 a
->x_csect
.x_parmhash
= 0;
4755 a
->x_csect
.x_snhash
= 0;
4756 a
->x_csect
.x_smclas
= XMC_XO
;
4757 a
->x_csect
.x_stab
= 0;
4758 a
->x_csect
.x_snstab
= 0;
4760 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
4762 i
= S_GET_NUMBER_AUXILIARY (sym
);
4763 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
4764 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
4765 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
4768 ppc_saw_abs
= false;
4771 /* Set the VMA for a section. This is called on all the sections in
4775 ppc_frob_section (sec
)
4778 static bfd_size_type vma
= 0;
4780 bfd_set_section_vma (stdoutput
, sec
, vma
);
4781 vma
+= bfd_section_size (stdoutput
, sec
);
4784 #endif /* OBJ_XCOFF */
4786 /* Turn a string in input_line_pointer into a floating point constant
4787 of type TYPE, and store the appropriate bytes in *LITP. The number
4788 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4789 returned, or NULL on OK. */
4792 md_atof (type
, litp
, sizep
)
4798 LITTLENUM_TYPE words
[4];
4814 return _("bad call to md_atof");
4817 t
= atof_ieee (input_line_pointer
, type
, words
);
4819 input_line_pointer
= t
;
4823 if (target_big_endian
)
4825 for (i
= 0; i
< prec
; i
++)
4827 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4833 for (i
= prec
- 1; i
>= 0; i
--)
4835 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4843 /* Write a value out to the object file, using the appropriate
4847 md_number_to_chars (buf
, val
, n
)
4852 if (target_big_endian
)
4853 number_to_chars_bigendian (buf
, val
, n
);
4855 number_to_chars_littleendian (buf
, val
, n
);
4858 /* Align a section (I don't know why this is machine dependent). */
4861 md_section_align (seg
, addr
)
4865 int align
= bfd_get_section_alignment (stdoutput
, seg
);
4867 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
4870 /* We don't have any form of relaxing. */
4873 md_estimate_size_before_relax (fragp
, seg
)
4874 fragS
*fragp ATTRIBUTE_UNUSED
;
4875 asection
*seg ATTRIBUTE_UNUSED
;
4881 /* Convert a machine dependent frag. We never generate these. */
4884 md_convert_frag (abfd
, sec
, fragp
)
4885 bfd
*abfd ATTRIBUTE_UNUSED
;
4886 asection
*sec ATTRIBUTE_UNUSED
;
4887 fragS
*fragp ATTRIBUTE_UNUSED
;
4892 /* We have no need to default values of symbols. */
4895 md_undefined_symbol (name
)
4896 char *name ATTRIBUTE_UNUSED
;
4901 /* Functions concerning relocs. */
4903 /* The location from which a PC relative jump should be calculated,
4904 given a PC relative reloc. */
4907 md_pcrel_from_section (fixp
, sec
)
4909 segT sec ATTRIBUTE_UNUSED
;
4911 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4916 /* This is called to see whether a fixup should be adjusted to use a
4917 section symbol. We take the opportunity to change a fixup against
4918 a symbol in the TOC subsegment into a reloc against the
4919 corresponding .tc symbol. */
4922 ppc_fix_adjustable (fix
)
4927 resolve_symbol_value (fix
->fx_addsy
);
4928 val
= S_GET_VALUE (fix
->fx_addsy
);
4929 if (ppc_toc_csect
!= (symbolS
*) NULL
4930 && fix
->fx_addsy
!= (symbolS
*) NULL
4931 && fix
->fx_addsy
!= ppc_toc_csect
4932 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
4933 && val
>= ppc_toc_frag
->fr_address
4934 && (ppc_after_toc_frag
== (fragS
*) NULL
4935 || val
< ppc_after_toc_frag
->fr_address
))
4939 for (sy
= symbol_next (ppc_toc_csect
);
4940 sy
!= (symbolS
*) NULL
;
4941 sy
= symbol_next (sy
))
4943 if (symbol_get_tc (sy
)->class == XMC_TC0
)
4945 if (symbol_get_tc (sy
)->class != XMC_TC
)
4947 resolve_symbol_value (sy
);
4948 if (val
== S_GET_VALUE (sy
))
4951 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
4956 as_bad_where (fix
->fx_file
, fix
->fx_line
,
4957 _("symbol in .toc does not match any .tc"));
4960 /* Possibly adjust the reloc to be against the csect. */
4961 if (fix
->fx_addsy
!= (symbolS
*) NULL
4962 && symbol_get_tc (fix
->fx_addsy
)->subseg
== 0
4963 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC0
4964 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC
4965 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
4966 /* Don't adjust if this is a reloc in the toc section. */
4967 && (S_GET_SEGMENT (fix
->fx_addsy
) != data_section
4968 || ppc_toc_csect
== NULL
4969 || val
< ppc_toc_frag
->fr_address
4970 || (ppc_after_toc_frag
!= NULL
4971 && val
>= ppc_after_toc_frag
->fr_address
)))
4975 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
4976 csect
= ppc_text_csects
;
4977 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
4978 csect
= ppc_data_csects
;
4982 /* Skip the initial dummy symbol. */
4983 csect
= symbol_get_tc (csect
)->next
;
4985 if (csect
!= (symbolS
*) NULL
)
4987 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
4988 && (symbol_get_frag (symbol_get_tc (csect
)->next
)->fr_address
4991 /* If the csect address equals the symbol value, then we
4992 have to look through the full symbol table to see
4993 whether this is the csect we want. Note that we will
4994 only get here if the csect has zero length. */
4995 if ((symbol_get_frag (csect
)->fr_address
== val
)
4996 && S_GET_VALUE (csect
) == S_GET_VALUE (fix
->fx_addsy
))
5000 for (scan
= symbol_next (csect
);
5002 scan
= symbol_next (scan
))
5004 if (symbol_get_tc (scan
)->subseg
!= 0)
5006 if (scan
== fix
->fx_addsy
)
5010 /* If we found the symbol before the next csect
5011 symbol, then this is the csect we want. */
5012 if (scan
== fix
->fx_addsy
)
5016 csect
= symbol_get_tc (csect
)->next
;
5019 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
5020 - symbol_get_frag (csect
)->fr_address
);
5021 fix
->fx_addsy
= csect
;
5025 /* Adjust a reloc against a .lcomm symbol to be against the base
5027 if (fix
->fx_addsy
!= (symbolS
*) NULL
5028 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
5029 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
5031 resolve_symbol_value (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
);
5033 (S_GET_VALUE (fix
->fx_addsy
)
5034 - S_GET_VALUE (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
));
5035 fix
->fx_addsy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
5041 /* A reloc from one csect to another must be kept. The assembler
5042 will, of course, keep relocs between sections, and it will keep
5043 absolute relocs, but we need to force it to keep PC relative relocs
5044 between two csects in the same section. */
5047 ppc_force_relocation (fix
)
5050 /* At this point fix->fx_addsy should already have been converted to
5051 a csect symbol. If the csect does not include the fragment, then
5052 we need to force the relocation. */
5054 && fix
->fx_addsy
!= NULL
5055 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
5056 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
5057 > fix
->fx_frag
->fr_address
)
5058 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
5059 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
5060 <= fix
->fx_frag
->fr_address
))))
5066 #endif /* OBJ_XCOFF */
5070 ppc_fix_adjustable (fix
)
5073 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5074 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5075 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5076 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5077 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5078 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5079 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5080 && ! S_IS_EXTERNAL (fix
->fx_addsy
)
5081 && ! S_IS_WEAK (fix
->fx_addsy
)
5083 || (fix
->fx_subsy
!= NULL
5084 && (S_GET_SEGMENT (fix
->fx_subsy
)
5085 == S_GET_SEGMENT (fix
->fx_addsy
)))
5086 || S_IS_LOCAL (fix
->fx_addsy
)));
5090 /* Apply a fixup to the object code. This is called for all the
5091 fixups we generated by the call to fix_new_exp, above. In the call
5092 above we used a reloc code which was the largest legal reloc code
5093 plus the operand index. Here we undo that to recover the operand
5094 index. At this point all symbol values should be fully resolved,
5095 and we attempt to completely resolve the reloc. If we can not do
5096 that, we determine the correct reloc code and put it back in the
5100 md_apply_fix3 (fixP
, valP
, seg
)
5103 segT seg ATTRIBUTE_UNUSED
;
5105 valueT value
= * valP
;
5108 if (fixP
->fx_addsy
!= NULL
)
5110 /* `*valuep' may contain the value of the symbol on which the reloc
5111 will be based; we have to remove it. */
5112 if (symbol_used_in_reloc_p (fixP
->fx_addsy
)
5113 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
5114 && S_GET_SEGMENT (fixP
->fx_addsy
) != undefined_section
5115 && ! bfd_is_com_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
5116 value
-= S_GET_VALUE (fixP
->fx_addsy
);
5118 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
5119 supposed to be? I think this is related to various similar
5120 FIXMEs in tc-i386.c and tc-sparc.c. */
5122 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
5127 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
5128 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5129 doing this relocation the code in write.c is going to call
5130 bfd_install_relocation, which is also going to use the symbol
5131 value. That means that if the reloc is fully resolved we want to
5132 use *valuep since bfd_install_relocation is not being used.
5133 However, if the reloc is not fully resolved we do not want to use
5134 *valuep, and must use fx_offset instead. However, if the reloc
5135 is PC relative, we do want to use *valuep since it includes the
5136 result of md_pcrel_from. This is confusing. */
5137 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
5140 else if (fixP
->fx_pcrel
)
5145 value
= fixP
->fx_offset
;
5146 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
5148 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
5149 value
-= S_GET_VALUE (fixP
->fx_subsy
);
5152 /* We can't actually support subtracting a symbol. */
5153 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5154 _("expression too complex"));
5160 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5163 const struct powerpc_operand
*operand
;
5167 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5169 operand
= &powerpc_operands
[opindex
];
5172 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5173 does not generate a reloc. It uses the offset of `sym' within its
5174 csect. Other usages, such as `.long sym', generate relocs. This
5175 is the documented behaviour of non-TOC symbols. */
5176 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5177 && operand
->bits
== 16
5178 && operand
->shift
== 0
5179 && (operand
->insert
== NULL
|| ppc_obj64
)
5180 && fixP
->fx_addsy
!= NULL
5181 && symbol_get_tc (fixP
->fx_addsy
)->subseg
!= 0
5182 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC
5183 && symbol_get_tc (fixP
->fx_addsy
)->class != XMC_TC0
5184 && S_GET_SEGMENT (fixP
->fx_addsy
) != bss_section
)
5186 value
= fixP
->fx_offset
;
5191 /* Fetch the instruction, insert the fully resolved operand
5192 value, and stuff the instruction back again. */
5193 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5194 if (target_big_endian
)
5195 insn
= bfd_getb32 ((unsigned char *) where
);
5197 insn
= bfd_getl32 ((unsigned char *) where
);
5198 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5199 fixP
->fx_file
, fixP
->fx_line
);
5200 if (target_big_endian
)
5201 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5203 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5206 /* Nothing else to do here. */
5209 assert (fixP
->fx_addsy
!= NULL
);
5211 /* Determine a BFD reloc value based on the operand information.
5212 We are only prepared to turn a few of the operands into
5214 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5215 && operand
->bits
== 26
5216 && operand
->shift
== 0)
5217 fixP
->fx_r_type
= BFD_RELOC_PPC_B26
;
5218 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5219 && operand
->bits
== 16
5220 && operand
->shift
== 0)
5221 fixP
->fx_r_type
= BFD_RELOC_PPC_B16
;
5222 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5223 && operand
->bits
== 26
5224 && operand
->shift
== 0)
5225 fixP
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5226 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5227 && operand
->bits
== 16
5228 && operand
->shift
== 0)
5229 fixP
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5230 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5231 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5232 && operand
->bits
== 16
5233 && operand
->shift
== 0
5234 && ppc_is_toc_sym (fixP
->fx_addsy
))
5236 fixP
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5239 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5240 fixP
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5243 if (target_big_endian
)
5244 fixP
->fx_where
+= 2;
5246 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5252 /* Use expr_symbol_where to see if this is an expression
5254 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
5255 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5256 _("unresolved expression that must be resolved"));
5258 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5259 _("unsupported relocation against %s"),
5260 S_GET_NAME (fixP
->fx_addsy
));
5268 ppc_elf_validate_fix (fixP
, seg
);
5270 switch (fixP
->fx_r_type
)
5272 case BFD_RELOC_CTOR
:
5279 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5283 case BFD_RELOC_32_PCREL
:
5284 case BFD_RELOC_PPC_EMB_NADDR32
:
5285 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5292 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5295 case BFD_RELOC_64_PCREL
:
5296 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5300 case BFD_RELOC_LO16
:
5302 case BFD_RELOC_GPREL16
:
5303 case BFD_RELOC_16_GOT_PCREL
:
5304 case BFD_RELOC_16_GOTOFF
:
5305 case BFD_RELOC_LO16_GOTOFF
:
5306 case BFD_RELOC_HI16_GOTOFF
:
5307 case BFD_RELOC_HI16_S_GOTOFF
:
5308 case BFD_RELOC_16_BASEREL
:
5309 case BFD_RELOC_LO16_BASEREL
:
5310 case BFD_RELOC_HI16_BASEREL
:
5311 case BFD_RELOC_HI16_S_BASEREL
:
5312 case BFD_RELOC_PPC_EMB_NADDR16
:
5313 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5314 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5315 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5316 case BFD_RELOC_PPC_EMB_SDAI16
:
5317 case BFD_RELOC_PPC_EMB_SDA2REL
:
5318 case BFD_RELOC_PPC_EMB_SDA2I16
:
5319 case BFD_RELOC_PPC_EMB_RELSEC16
:
5320 case BFD_RELOC_PPC_EMB_RELST_LO
:
5321 case BFD_RELOC_PPC_EMB_RELST_HI
:
5322 case BFD_RELOC_PPC_EMB_RELST_HA
:
5323 case BFD_RELOC_PPC_EMB_RELSDA
:
5324 case BFD_RELOC_PPC_TOC16
:
5326 case BFD_RELOC_PPC64_TOC16_LO
:
5327 case BFD_RELOC_PPC64_TOC16_HI
:
5328 case BFD_RELOC_PPC64_TOC16_HA
:
5332 if (fixP
->fx_addsy
!= NULL
)
5333 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5334 _("cannot emit PC relative %s relocation against %s"),
5335 bfd_get_reloc_code_name (fixP
->fx_r_type
),
5336 S_GET_NAME (fixP
->fx_addsy
));
5338 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5339 _("cannot emit PC relative %s relocation"),
5340 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5343 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5347 /* This case happens when you write, for example,
5349 where L1 and L2 are defined later. */
5350 case BFD_RELOC_HI16
:
5353 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5357 case BFD_RELOC_HI16_S
:
5360 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5365 case BFD_RELOC_PPC64_HIGHER
:
5368 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5369 PPC_HIGHER (value
), 2);
5372 case BFD_RELOC_PPC64_HIGHER_S
:
5375 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5376 PPC_HIGHERA (value
), 2);
5379 case BFD_RELOC_PPC64_HIGHEST
:
5382 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5383 PPC_HIGHEST (value
), 2);
5386 case BFD_RELOC_PPC64_HIGHEST_S
:
5389 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5390 PPC_HIGHESTA (value
), 2);
5393 case BFD_RELOC_PPC64_ADDR16_DS
:
5394 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5395 case BFD_RELOC_PPC64_GOT16_DS
:
5396 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5397 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5398 case BFD_RELOC_PPC64_SECTOFF_DS
:
5399 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5400 case BFD_RELOC_PPC64_TOC16_DS
:
5401 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5402 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5403 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5407 unsigned char *where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5410 if (target_big_endian
)
5411 val
= bfd_getb16 (where
);
5413 val
= bfd_getl16 (where
);
5414 val
|= (value
& 0xfffc);
5415 if (target_big_endian
)
5416 bfd_putb16 ((bfd_vma
) val
, where
);
5418 bfd_putl16 ((bfd_vma
) val
, where
);
5422 /* Because SDA21 modifies the register field, the size is set to 4
5423 bytes, rather than 2, so offset it here appropriately. */
5424 case BFD_RELOC_PPC_EMB_SDA21
:
5428 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
5429 + ((target_big_endian
) ? 2 : 0),
5437 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
5441 case BFD_RELOC_24_PLT_PCREL
:
5442 case BFD_RELOC_PPC_LOCAL24PC
:
5443 if (!fixP
->fx_pcrel
&& !fixP
->fx_done
)
5451 /* Fetch the instruction, insert the fully resolved operand
5452 value, and stuff the instruction back again. */
5453 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5454 if (target_big_endian
)
5455 insn
= bfd_getb32 ((unsigned char *) where
);
5457 insn
= bfd_getl32 ((unsigned char *) where
);
5458 if ((value
& 3) != 0)
5459 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5460 _("must branch to an address a multiple of 4"));
5461 if ((offsetT
) value
< -0x40000000
5462 || (offsetT
) value
>= 0x40000000)
5463 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5464 _("@local or @plt branch destination is too far away, %ld bytes"),
5466 insn
= insn
| (value
& 0x03fffffc);
5467 if (target_big_endian
)
5468 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5470 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5474 case BFD_RELOC_VTABLE_INHERIT
:
5477 && !S_IS_DEFINED (fixP
->fx_addsy
)
5478 && !S_IS_WEAK (fixP
->fx_addsy
))
5479 S_SET_WEAK (fixP
->fx_addsy
);
5482 case BFD_RELOC_VTABLE_ENTRY
:
5487 /* Generated by reference to `sym@tocbase'. The sym is
5488 ignored by the linker. */
5489 case BFD_RELOC_PPC64_TOC
:
5495 _("Gas failure, reloc value %d\n"), fixP
->fx_r_type
);
5502 fixP
->fx_addnumber
= value
;
5504 if (fixP
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5505 fixP
->fx_addnumber
= 0;
5509 fixP
->fx_addnumber
= 0;
5511 /* We want to use the offset within the data segment of the
5512 symbol, not the actual VMA of the symbol. */
5513 fixP
->fx_addnumber
=
5514 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixP
->fx_addsy
));
5520 /* Generate a reloc for a fixup. */
5523 tc_gen_reloc (seg
, fixp
)
5524 asection
*seg ATTRIBUTE_UNUSED
;
5529 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5531 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5532 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5533 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5534 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5535 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5537 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5538 _("reloc %d not supported by object file format"),
5539 (int) fixp
->fx_r_type
);
5542 reloc
->addend
= fixp
->fx_addnumber
;