1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
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) ((((v) >> 16) + (((v) >> 15) & 1)) & 0xffff)
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) \
76 ((((v) >> 32) + (((v) & 0xffff8000) == 0xffff8000)) & 0xffff)
78 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
79 #define PPC_HIGHEST(v) (((v) >> 48) & 0xffff)
81 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
82 compensating for #lo being treated as a signed number.
83 Generate 0xffffffff8000 with arithmetic here, for portability. */
84 #define PPC_HIGHESTA(v) \
86 + (((v) & (((valueT) 1 << 48) - 0x8000)) == ((valueT) 1 << 48) - 0x8000)) \
89 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
91 static boolean reg_names_p
= TARGET_REG_NAMES_P
;
93 static boolean register_name
PARAMS ((expressionS
*));
94 static void ppc_set_cpu
PARAMS ((void));
95 static unsigned long ppc_insert_operand
96 PARAMS ((unsigned long insn
, const struct powerpc_operand
*operand
,
97 offsetT val
, char *file
, unsigned int line
));
98 static void ppc_macro
PARAMS ((char *str
, const struct powerpc_macro
*macro
));
99 static void ppc_byte
PARAMS ((int));
101 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
102 static int ppc_is_toc_sym
PARAMS ((symbolS
*sym
));
103 static void ppc_tc
PARAMS ((int));
104 static void ppc_machine
PARAMS ((int));
108 static void ppc_comm
PARAMS ((int));
109 static void ppc_bb
PARAMS ((int));
110 static void ppc_bc
PARAMS ((int));
111 static void ppc_bf
PARAMS ((int));
112 static void ppc_biei
PARAMS ((int));
113 static void ppc_bs
PARAMS ((int));
114 static void ppc_eb
PARAMS ((int));
115 static void ppc_ec
PARAMS ((int));
116 static void ppc_ef
PARAMS ((int));
117 static void ppc_es
PARAMS ((int));
118 static void ppc_csect
PARAMS ((int));
119 static void ppc_change_csect
PARAMS ((symbolS
*));
120 static void ppc_function
PARAMS ((int));
121 static void ppc_extern
PARAMS ((int));
122 static void ppc_lglobl
PARAMS ((int));
123 static void ppc_section
PARAMS ((int));
124 static void ppc_named_section
PARAMS ((int));
125 static void ppc_stabx
PARAMS ((int));
126 static void ppc_rename
PARAMS ((int));
127 static void ppc_toc
PARAMS ((int));
128 static void ppc_xcoff_cons
PARAMS ((int));
129 static void ppc_vbyte
PARAMS ((int));
133 static bfd_reloc_code_real_type ppc_elf_suffix
PARAMS ((char **, expressionS
*));
134 static void ppc_elf_cons
PARAMS ((int));
135 static void ppc_elf_rdata
PARAMS ((int));
136 static void ppc_elf_lcomm
PARAMS ((int));
137 static void ppc_elf_validate_fix
PARAMS ((fixS
*, segT
));
141 static void ppc_set_current_section
PARAMS ((segT
));
142 static void ppc_previous
PARAMS ((int));
143 static void ppc_pdata
PARAMS ((int));
144 static void ppc_ydata
PARAMS ((int));
145 static void ppc_reldata
PARAMS ((int));
146 static void ppc_rdata
PARAMS ((int));
147 static void ppc_ualong
PARAMS ((int));
148 static void ppc_znop
PARAMS ((int));
149 static void ppc_pe_comm
PARAMS ((int));
150 static void ppc_pe_section
PARAMS ((int));
151 static void ppc_pe_function
PARAMS ((int));
152 static void ppc_pe_tocd
PARAMS ((int));
155 /* Generic assembler global variables which must be defined by all
159 /* This string holds the chars that always start a comment. If the
160 pre-processor is disabled, these aren't very useful. The macro
161 tc_comment_chars points to this. We use this, rather than the
162 usual comment_chars, so that we can switch for Solaris conventions. */
163 static const char ppc_solaris_comment_chars
[] = "#!";
164 static const char ppc_eabi_comment_chars
[] = "#";
166 #ifdef TARGET_SOLARIS_COMMENT
167 const char *ppc_comment_chars
= ppc_solaris_comment_chars
;
169 const char *ppc_comment_chars
= ppc_eabi_comment_chars
;
172 const char comment_chars
[] = "#";
175 /* Characters which start a comment at the beginning of a line. */
176 const char line_comment_chars
[] = "#";
178 /* Characters which may be used to separate multiple commands on a
180 const char line_separator_chars
[] = ";";
182 /* Characters which are used to indicate an exponent in a floating
184 const char EXP_CHARS
[] = "eE";
186 /* Characters which mean that a number is a floating point constant,
188 const char FLT_CHARS
[] = "dD";
190 /* The target specific pseudo-ops which we support. */
192 const pseudo_typeS md_pseudo_table
[] =
194 /* Pseudo-ops which must be overridden. */
195 { "byte", ppc_byte
, 0 },
198 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
199 legitimately belong in the obj-*.c file. However, XCOFF is based
200 on COFF, and is only implemented for the RS/6000. We just use
201 obj-coff.c, and add what we need here. */
202 { "comm", ppc_comm
, 0 },
203 { "lcomm", ppc_comm
, 1 },
207 { "bi", ppc_biei
, 0 },
209 { "csect", ppc_csect
, 0 },
210 { "data", ppc_section
, 'd' },
214 { "ei", ppc_biei
, 1 },
216 { "extern", ppc_extern
, 0 },
217 { "function", ppc_function
, 0 },
218 { "lglobl", ppc_lglobl
, 0 },
219 { "rename", ppc_rename
, 0 },
220 { "section", ppc_named_section
, 0 },
221 { "stabx", ppc_stabx
, 0 },
222 { "text", ppc_section
, 't' },
223 { "toc", ppc_toc
, 0 },
224 { "long", ppc_xcoff_cons
, 2 },
225 { "llong", ppc_xcoff_cons
, 3 },
226 { "word", ppc_xcoff_cons
, 1 },
227 { "short", ppc_xcoff_cons
, 1 },
228 { "vbyte", ppc_vbyte
, 0 },
232 { "llong", ppc_elf_cons
, 8 },
233 { "quad", ppc_elf_cons
, 8 },
234 { "long", ppc_elf_cons
, 4 },
235 { "word", ppc_elf_cons
, 2 },
236 { "short", ppc_elf_cons
, 2 },
237 { "rdata", ppc_elf_rdata
, 0 },
238 { "rodata", ppc_elf_rdata
, 0 },
239 { "lcomm", ppc_elf_lcomm
, 0 },
240 { "file", dwarf2_directive_file
, 0 },
241 { "loc", dwarf2_directive_loc
, 0 },
245 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
246 { "previous", ppc_previous
, 0 },
247 { "pdata", ppc_pdata
, 0 },
248 { "ydata", ppc_ydata
, 0 },
249 { "reldata", ppc_reldata
, 0 },
250 { "rdata", ppc_rdata
, 0 },
251 { "ualong", ppc_ualong
, 0 },
252 { "znop", ppc_znop
, 0 },
253 { "comm", ppc_pe_comm
, 0 },
254 { "lcomm", ppc_pe_comm
, 1 },
255 { "section", ppc_pe_section
, 0 },
256 { "function", ppc_pe_function
,0 },
257 { "tocd", ppc_pe_tocd
, 0 },
260 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
262 { "machine", ppc_machine
, 0 },
269 /* Predefined register names if -mregnames (or default for Windows NT).
270 In general, there are lots of them, in an attempt to be compatible
271 with a number of other Windows NT assemblers. */
273 /* Structure to hold information about predefined registers. */
280 /* List of registers that are pre-defined:
282 Each general register has predefined names of the form:
283 1. r<reg_num> which has the value <reg_num>.
284 2. r.<reg_num> which has the value <reg_num>.
286 Each floating point register has predefined names of the form:
287 1. f<reg_num> which has the value <reg_num>.
288 2. f.<reg_num> which has the value <reg_num>.
290 Each vector unit register has predefined names of the form:
291 1. v<reg_num> which has the value <reg_num>.
292 2. v.<reg_num> which has the value <reg_num>.
294 Each condition register has predefined names of the form:
295 1. cr<reg_num> which has the value <reg_num>.
296 2. cr.<reg_num> which has the value <reg_num>.
298 There are individual registers as well:
299 sp or r.sp has the value 1
300 rtoc or r.toc has the value 2
301 fpscr has the value 0
307 dsisr has the value 18
309 sdr1 has the value 25
310 srr0 has the value 26
311 srr1 has the value 27
313 The table is sorted. Suitable for searching by a binary search. */
315 static const struct pd_reg pre_defined_registers
[] =
317 { "cr.0", 0 }, /* Condition Registers */
337 { "dar", 19 }, /* Data Access Register */
338 { "dec", 22 }, /* Decrementer */
339 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
341 { "f.0", 0 }, /* Floating point registers */
409 { "lr", 8 }, /* Link Register */
413 { "r.0", 0 }, /* General Purpose Registers */
446 { "r.sp", 1 }, /* Stack Pointer */
448 { "r.toc", 2 }, /* Pointer to the table of contents */
450 { "r0", 0 }, /* More general purpose registers */
483 { "rtoc", 2 }, /* Table of contents */
485 { "sdr1", 25 }, /* Storage Description Register 1 */
489 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
490 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
492 { "v.0", 0 }, /* Vector registers */
562 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
564 /* Given NAME, find the register number associated with that name, return
565 the integer value associated with the given name or -1 on failure. */
567 static int reg_name_search
568 PARAMS ((const struct pd_reg
*, int, const char * name
));
571 reg_name_search (regs
, regcount
, name
)
572 const struct pd_reg
*regs
;
576 int middle
, low
, high
;
584 middle
= (low
+ high
) / 2;
585 cmp
= strcasecmp (name
, regs
[middle
].name
);
591 return regs
[middle
].value
;
599 * Summary of register_name.
601 * in: Input_line_pointer points to 1st char of operand.
603 * out: A expressionS.
604 * The operand may have been a register: in this case, X_op == O_register,
605 * X_add_number is set to the register number, and truth is returned.
606 * Input_line_pointer->(next non-blank) char after operand, or is in its
611 register_name (expressionP
)
612 expressionS
*expressionP
;
619 /* Find the spelling of the operand. */
620 start
= name
= input_line_pointer
;
621 if (name
[0] == '%' && ISALPHA (name
[1]))
622 name
= ++input_line_pointer
;
624 else if (!reg_names_p
|| !ISALPHA (name
[0]))
627 c
= get_symbol_end ();
628 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
630 /* Put back the delimiting char. */
631 *input_line_pointer
= c
;
633 /* Look to see if it's in the register table. */
636 expressionP
->X_op
= O_register
;
637 expressionP
->X_add_number
= reg_number
;
639 /* Make the rest nice. */
640 expressionP
->X_add_symbol
= NULL
;
641 expressionP
->X_op_symbol
= NULL
;
645 /* Reset the line as if we had not done anything. */
646 input_line_pointer
= start
;
650 /* This function is called for each symbol seen in an expression. It
651 handles the special parsing which PowerPC assemblers are supposed
652 to use for condition codes. */
654 /* Whether to do the special parsing. */
655 static boolean cr_operand
;
657 /* Names to recognize in a condition code. This table is sorted. */
658 static const struct pd_reg cr_names
[] =
675 /* Parsing function. This returns non-zero if it recognized an
679 ppc_parse_name (name
, expr
)
688 val
= reg_name_search (cr_names
, sizeof cr_names
/ sizeof cr_names
[0],
693 expr
->X_op
= O_constant
;
694 expr
->X_add_number
= val
;
699 /* Local variables. */
701 /* The type of processor we are assembling for. This is one or more
702 of the PPC_OPCODE flags defined in opcode/ppc.h. */
703 static int ppc_cpu
= 0;
705 /* The size of the processor we are assembling for. This is either
706 PPC_OPCODE_32 or PPC_OPCODE_64. */
707 static unsigned long ppc_size
= PPC_OPCODE_32
;
709 /* Whether to target xcoff64. */
710 static int ppc_xcoff64
= 0;
712 /* Opcode hash table. */
713 static struct hash_control
*ppc_hash
;
715 /* Macro hash table. */
716 static struct hash_control
*ppc_macro_hash
;
719 /* What type of shared library support to use. */
720 static enum { SHLIB_NONE
, SHLIB_PIC
, SHLIB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
722 /* Flags to set in the elf header. */
723 static flagword ppc_flags
= 0;
725 /* Whether this is Solaris or not. */
726 #ifdef TARGET_SOLARIS_COMMENT
727 #define SOLARIS_P true
729 #define SOLARIS_P false
732 static boolean msolaris
= SOLARIS_P
;
737 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
738 using a bunch of different sections. These assembler sections,
739 however, are all encompassed within the .text or .data sections of
740 the final output file. We handle this by using different
741 subsegments within these main segments. */
743 /* Next subsegment to allocate within the .text segment. */
744 static subsegT ppc_text_subsegment
= 2;
746 /* Linked list of csects in the text section. */
747 static symbolS
*ppc_text_csects
;
749 /* Next subsegment to allocate within the .data segment. */
750 static subsegT ppc_data_subsegment
= 2;
752 /* Linked list of csects in the data section. */
753 static symbolS
*ppc_data_csects
;
755 /* The current csect. */
756 static symbolS
*ppc_current_csect
;
758 /* The RS/6000 assembler uses a TOC which holds addresses of functions
759 and variables. Symbols are put in the TOC with the .tc pseudo-op.
760 A special relocation is used when accessing TOC entries. We handle
761 the TOC as a subsegment within the .data segment. We set it up if
762 we see a .toc pseudo-op, and save the csect symbol here. */
763 static symbolS
*ppc_toc_csect
;
765 /* The first frag in the TOC subsegment. */
766 static fragS
*ppc_toc_frag
;
768 /* The first frag in the first subsegment after the TOC in the .data
769 segment. NULL if there are no subsegments after the TOC. */
770 static fragS
*ppc_after_toc_frag
;
772 /* The current static block. */
773 static symbolS
*ppc_current_block
;
775 /* The COFF debugging section; set by md_begin. This is not the
776 .debug section, but is instead the secret BFD section which will
777 cause BFD to set the section number of a symbol to N_DEBUG. */
778 static asection
*ppc_coff_debug_section
;
780 #endif /* OBJ_XCOFF */
784 /* Various sections that we need for PE coff support. */
785 static segT ydata_section
;
786 static segT pdata_section
;
787 static segT reldata_section
;
788 static segT rdata_section
;
789 static segT tocdata_section
;
791 /* The current section and the previous section. See ppc_previous. */
792 static segT ppc_previous_section
;
793 static segT ppc_current_section
;
798 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
802 CONST
char *md_shortopts
= "b:l:usm:K:VQ:";
804 CONST
char *md_shortopts
= "um:";
806 struct option md_longopts
[] = {
807 {NULL
, no_argument
, NULL
, 0}
809 size_t md_longopts_size
= sizeof (md_longopts
);
812 md_parse_option (c
, arg
)
819 /* -u means that any undefined symbols should be treated as
820 external, which is the default for gas anyhow. */
825 /* Solaris as takes -le (presumably for little endian). For completeness
826 sake, recognize -be also. */
827 if (strcmp (arg
, "e") == 0)
829 target_big_endian
= 0;
830 set_target_endian
= 1;
838 if (strcmp (arg
, "e") == 0)
840 target_big_endian
= 1;
841 set_target_endian
= 1;
849 /* Recognize -K PIC. */
850 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
853 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
861 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
863 if (strcmp (arg
, "64") == 0)
865 else if (strcmp (arg
, "32") == 0)
872 /* Most CPU's are 32 bit. Exceptions are listed below. */
873 ppc_size
= PPC_OPCODE_32
;
875 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
877 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
878 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
;
879 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
880 else if (strcmp (arg
, "pwr") == 0)
881 ppc_cpu
= PPC_OPCODE_POWER
;
882 /* -m601 means to assemble for the Motorola PowerPC 601, which includes
883 instructions that are holdovers from the Power. */
884 else if (strcmp (arg
, "601") == 0)
885 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_601
;
886 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
887 Motorola PowerPC 603/604. */
888 else if (strcmp (arg
, "ppc") == 0
889 || strcmp (arg
, "ppc32") == 0
890 || strcmp (arg
, "403") == 0
891 || strcmp (arg
, "405") == 0
892 || strcmp (arg
, "603") == 0
893 || strcmp (arg
, "604") == 0)
894 ppc_cpu
= PPC_OPCODE_PPC
;
895 else if (strcmp (arg
, "7400") == 0)
896 ppc_cpu
= PPC_OPCODE_PPC
| 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
;
902 ppc_size
= PPC_OPCODE_64
;
904 else if (strcmp (arg
, "ppc64bridge") == 0)
906 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64_BRIDGE
;
907 ppc_size
= PPC_OPCODE_64
;
909 /* -mcom means assemble for the common intersection between Power
910 and PowerPC. At present, we just allow the union, rather
911 than the intersection. */
912 else if (strcmp (arg
, "com") == 0)
913 ppc_cpu
= PPC_OPCODE_COMMON
;
914 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
915 else if (strcmp (arg
, "any") == 0)
916 ppc_cpu
= PPC_OPCODE_ANY
;
918 else if (strcmp (arg
, "regnames") == 0)
921 else if (strcmp (arg
, "no-regnames") == 0)
925 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
926 that require relocation. */
927 else if (strcmp (arg
, "relocatable") == 0)
929 shlib
= SHLIB_MRELOCATABLE
;
930 ppc_flags
|= EF_PPC_RELOCATABLE
;
933 else if (strcmp (arg
, "relocatable-lib") == 0)
935 shlib
= SHLIB_MRELOCATABLE
;
936 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
939 /* -memb, set embedded bit. */
940 else if (strcmp (arg
, "emb") == 0)
941 ppc_flags
|= EF_PPC_EMB
;
943 /* -mlittle/-mbig set the endianess. */
944 else if (strcmp (arg
, "little") == 0
945 || strcmp (arg
, "little-endian") == 0)
947 target_big_endian
= 0;
948 set_target_endian
= 1;
951 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
953 target_big_endian
= 1;
954 set_target_endian
= 1;
957 else if (strcmp (arg
, "solaris") == 0)
960 ppc_comment_chars
= ppc_solaris_comment_chars
;
963 else if (strcmp (arg
, "no-solaris") == 0)
966 ppc_comment_chars
= ppc_eabi_comment_chars
;
971 as_bad (_("invalid switch -m%s"), arg
);
977 /* -V: SVR4 argument to print version ID. */
982 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
983 should be emitted or not. FIXME: Not implemented. */
987 /* Solaris takes -s to specify that .stabs go in a .stabs section,
988 rather than .stabs.excl, which is ignored by the linker.
989 FIXME: Not implemented. */
1005 md_show_usage (stream
)
1008 fprintf (stream
, _("\
1011 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
1012 -mpwr generate code for IBM POWER (RIOS1)\n\
1013 -m601 generate code for Motorola PowerPC 601\n\
1014 -mppc, -mppc32, -m403, -m405, -m603, -m604\n\
1015 generate code for Motorola PowerPC 603/604\n\
1016 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
1017 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1018 -mcom generate code Power/PowerPC common instructions\n\
1019 -many generate code for any architecture (PWR/PWRX/PPC)\n\
1020 -mregnames Allow symbolic names for registers\n\
1021 -mno-regnames Do not allow symbolic names for registers\n"));
1023 fprintf (stream
, _("\
1024 -mrelocatable support for GCC's -mrelocatble option\n\
1025 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1026 -memb set PPC_EMB bit in ELF flags\n\
1027 -mlittle, -mlittle-endian\n\
1028 generate code for a little endian machine\n\
1029 -mbig, -mbig-endian generate code for a big endian machine\n\
1030 -msolaris generate code for Solaris\n\
1031 -mno-solaris do not generate code for Solaris\n\
1032 -V print assembler version number\n\
1033 -Qy, -Qn ignored\n"));
1037 /* Set ppc_cpu if it is not already set. */
1042 const char *default_os
= TARGET_OS
;
1043 const char *default_cpu
= TARGET_CPU
;
1047 if (strncmp (default_os
, "aix", 3) == 0
1048 && default_os
[3] >= '4' && default_os
[3] <= '9')
1049 ppc_cpu
= PPC_OPCODE_COMMON
;
1050 else if (strncmp (default_os
, "aix3", 4) == 0)
1051 ppc_cpu
= PPC_OPCODE_POWER
;
1052 else if (strcmp (default_cpu
, "rs6000") == 0)
1053 ppc_cpu
= PPC_OPCODE_POWER
;
1054 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1055 ppc_cpu
= PPC_OPCODE_PPC
;
1057 as_fatal (_("Unknown default cpu = %s, os = %s"),
1058 default_cpu
, default_os
);
1062 /* Figure out the BFD architecture to use. */
1064 enum bfd_architecture
1067 const char *default_cpu
= TARGET_CPU
;
1070 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
1071 return bfd_arch_powerpc
;
1072 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
1073 return bfd_arch_rs6000
;
1074 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
1076 if (strcmp (default_cpu
, "rs6000") == 0)
1077 return bfd_arch_rs6000
;
1078 else if (strncmp (default_cpu
, "powerpc", 7) == 0)
1079 return bfd_arch_powerpc
;
1082 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1083 return bfd_arch_unknown
;
1089 return ppc_size
== PPC_OPCODE_64
? 620 : 0;
1096 return ppc_xcoff64
? 3 : 2;
1101 ppc_target_format ()
1105 return target_big_endian
? "pe-powerpc" : "pe-powerpcle";
1107 return "xcoff-powermac";
1109 return ppc_xcoff64
? "aixcoff64-rs6000" : "aixcoff-rs6000";
1113 return (target_big_endian
1114 ? (BFD_DEFAULT_TARGET_SIZE
== 64 ? "elf64-powerpc" : "elf32-powerpc")
1115 : (BFD_DEFAULT_TARGET_SIZE
== 64 ? "elf64-powerpcle" : "elf32-powerpcle"));
1119 /* This function is called when the assembler starts up. It is called
1120 after the options have been parsed and the output file has been
1126 register const struct powerpc_opcode
*op
;
1127 const struct powerpc_opcode
*op_end
;
1128 const struct powerpc_macro
*macro
;
1129 const struct powerpc_macro
*macro_end
;
1130 boolean dup_insn
= false;
1135 /* If we're going to generate a 64-bit ABI file, then we need
1136 the 64-bit capable instructions. */
1137 if (BFD_DEFAULT_TARGET_SIZE
== 64)
1138 ppc_size
= PPC_OPCODE_64
;
1140 /* Set the ELF flags if desired. */
1141 if (ppc_flags
&& !msolaris
)
1142 bfd_set_private_flags (stdoutput
, ppc_flags
);
1145 /* Insert the opcodes into a hash table. */
1146 ppc_hash
= hash_new ();
1148 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
1149 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
1151 know ((op
->opcode
& op
->mask
) == op
->opcode
);
1153 if ((op
->flags
& ppc_cpu
) != 0
1154 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
1155 || (op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == ppc_size
1156 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0))
1160 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
1161 if (retval
!= (const char *) NULL
)
1163 /* Ignore Power duplicates for -m601. */
1164 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
1165 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
1168 as_bad (_("Internal assembler error for instruction %s"),
1175 /* Insert the macros into a hash table. */
1176 ppc_macro_hash
= hash_new ();
1178 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1179 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1181 if ((macro
->flags
& ppc_cpu
) != 0)
1185 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1186 if (retval
!= (const char *) NULL
)
1188 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1197 /* Tell the main code what the endianness is if it is not overidden
1199 if (!set_target_endian
)
1201 set_target_endian
= 1;
1202 target_big_endian
= PPC_BIG_ENDIAN
;
1206 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1208 /* Create dummy symbols to serve as initial csects. This forces the
1209 text csects to precede the data csects. These symbols will not
1211 ppc_text_csects
= symbol_make ("dummy\001");
1212 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1213 ppc_data_csects
= symbol_make ("dummy\001");
1214 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1219 ppc_current_section
= text_section
;
1220 ppc_previous_section
= 0;
1225 /* Insert an operand value into an instruction. */
1227 static unsigned long
1228 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1230 const struct powerpc_operand
*operand
;
1235 if (operand
->bits
!= 32)
1240 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1242 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1243 max
= (1 << operand
->bits
) - 1;
1245 max
= (1 << (operand
->bits
- 1)) - 1;
1246 min
= - (1 << (operand
->bits
- 1));
1248 if (ppc_size
== PPC_OPCODE_32
)
1250 /* Some people write 32 bit hex constants with the sign
1251 extension done by hand. This shouldn't really be
1252 valid, but, to permit this code to assemble on a 64
1253 bit host, we sign extend the 32 bit value. */
1255 && (val
& (offsetT
) 0x80000000) != 0
1256 && (val
& (offsetT
) 0xffffffff) == val
)
1265 max
= (1 << operand
->bits
) - 1;
1269 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1274 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1277 _("operand out of range (%s not between %ld and %ld)");
1280 sprint_value (buf
, test
);
1281 as_bad_where (file
, line
, err
, buf
, min
, max
);
1285 if (operand
->insert
)
1290 insn
= (*operand
->insert
) (insn
, (long) val
, &errmsg
);
1291 if (errmsg
!= (const char *) NULL
)
1292 as_bad_where (file
, line
, errmsg
);
1295 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1303 /* Parse @got, etc. and return the desired relocation. */
1304 static bfd_reloc_code_real_type
1305 ppc_elf_suffix (str_p
, exp_p
)
1312 bfd_reloc_code_real_type reloc
;
1320 struct map_bfd
*ptr
;
1322 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1324 static struct map_bfd mapping
[] = {
1325 MAP ("l", BFD_RELOC_LO16
),
1326 MAP ("h", BFD_RELOC_HI16
),
1327 MAP ("ha", BFD_RELOC_HI16_S
),
1328 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1329 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1330 MAP ("got", BFD_RELOC_16_GOTOFF
),
1331 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1332 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1333 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1334 MAP ("fixup", BFD_RELOC_CTOR
), /* warnings with -mrelocatable */
1335 MAP ("plt", BFD_RELOC_24_PLT_PCREL
),
1336 MAP ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1337 MAP ("copy", BFD_RELOC_PPC_COPY
),
1338 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1339 MAP ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1340 MAP ("local", BFD_RELOC_PPC_LOCAL24PC
),
1341 MAP ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1342 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1343 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1344 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1345 MAP ("sdarel", BFD_RELOC_GPREL16
),
1346 MAP ("sectoff", BFD_RELOC_32_BASEREL
),
1347 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1348 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1349 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1350 MAP ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1351 MAP ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1352 MAP ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1353 MAP ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1354 MAP ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1355 MAP ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1356 MAP ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1357 MAP ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1358 MAP ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1359 MAP ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1360 MAP ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1361 MAP ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1362 MAP ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1363 MAP ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1364 MAP ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1365 MAP ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1366 MAP ("xgot", BFD_RELOC_PPC_TOC16
),
1367 #if BFD_DEFAULT_TARGET_SIZE == 64
1368 MAP ("higher", BFD_RELOC_PPC64_HIGHER
),
1369 MAP ("highera", BFD_RELOC_PPC64_HIGHER_S
),
1370 MAP ("highest", BFD_RELOC_PPC64_HIGHEST
),
1371 MAP ("highesta", BFD_RELOC_PPC64_HIGHEST_S
),
1372 MAP ("tocbase", BFD_RELOC_PPC64_TOC
),
1373 MAP ("toc", BFD_RELOC_PPC_TOC16
),
1374 MAP ("toc@l", BFD_RELOC_PPC64_TOC16_LO
),
1375 MAP ("toc@h", BFD_RELOC_PPC64_TOC16_HI
),
1376 MAP ("toc@ha", BFD_RELOC_PPC64_TOC16_HA
),
1378 { (char *) 0, 0, BFD_RELOC_UNUSED
}
1382 return BFD_RELOC_UNUSED
;
1384 for (ch
= *str
, str2
= ident
;
1385 (str2
< ident
+ sizeof (ident
) - 1
1386 && (ISALNUM (ch
) || ch
== '@'));
1389 *str2
++ = TOLOWER (ch
);
1396 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1397 if (ch
== ptr
->string
[0]
1398 && len
== ptr
->length
1399 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1401 if (exp_p
->X_add_number
!= 0
1402 && (ptr
->reloc
== BFD_RELOC_16_GOTOFF
1403 || ptr
->reloc
== BFD_RELOC_LO16_GOTOFF
1404 || ptr
->reloc
== BFD_RELOC_HI16_GOTOFF
1405 || ptr
->reloc
== BFD_RELOC_HI16_S_GOTOFF
))
1406 as_warn (_("identifier+constant@got means identifier@got+constant"));
1408 /* Now check for identifier@suffix+constant. */
1409 if (*str
== '-' || *str
== '+')
1411 char *orig_line
= input_line_pointer
;
1412 expressionS new_exp
;
1414 input_line_pointer
= str
;
1415 expression (&new_exp
);
1416 if (new_exp
.X_op
== O_constant
)
1418 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1419 str
= input_line_pointer
;
1422 if (&input_line_pointer
!= str_p
)
1423 input_line_pointer
= orig_line
;
1427 if (BFD_DEFAULT_TARGET_SIZE
== 64
1428 && ptr
->reloc
== BFD_RELOC_PPC64_TOC
1429 && exp_p
->X_op
== O_symbol
)
1431 /* This reloc type ignores the symbol. Change the symbol
1432 so that the dummy .TOC. symbol can be omitted from the
1434 exp_p
->X_add_symbol
= &abs_symbol
;
1440 return BFD_RELOC_UNUSED
;
1443 /* Like normal .long/.short/.word, except support @got, etc.
1444 Clobbers input_line_pointer, checks end-of-line. */
1446 ppc_elf_cons (nbytes
)
1447 register int nbytes
; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1450 bfd_reloc_code_real_type reloc
;
1452 if (is_it_end_of_statement ())
1454 demand_empty_rest_of_line ();
1461 if (exp
.X_op
== O_symbol
1462 && *input_line_pointer
== '@'
1463 && (reloc
= ppc_elf_suffix (&input_line_pointer
,
1464 &exp
)) != BFD_RELOC_UNUSED
)
1466 reloc_howto_type
*reloc_howto
;
1469 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1470 size
= bfd_get_reloc_size (reloc_howto
);
1474 as_bad (_("%s relocations do not fit in %d bytes\n"),
1475 reloc_howto
->name
, nbytes
);
1482 p
= frag_more (nbytes
);
1484 if (target_big_endian
)
1485 offset
= nbytes
- size
;
1486 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
,
1491 emit_expr (&exp
, (unsigned int) nbytes
);
1493 while (*input_line_pointer
++ == ',');
1495 /* Put terminator back into stream. */
1496 input_line_pointer
--;
1497 demand_empty_rest_of_line ();
1500 /* Solaris pseduo op to change to the .rodata section. */
1505 char *save_line
= input_line_pointer
;
1506 static char section
[] = ".rodata\n";
1508 /* Just pretend this is .section .rodata */
1509 input_line_pointer
= section
;
1510 obj_elf_section (xxx
);
1512 input_line_pointer
= save_line
;
1515 /* Pseudo op to make file scope bss items. */
1518 int xxx ATTRIBUTE_UNUSED
;
1520 register char *name
;
1524 register symbolS
*symbolP
;
1531 name
= input_line_pointer
;
1532 c
= get_symbol_end ();
1534 /* just after name is now '\0'. */
1535 p
= input_line_pointer
;
1538 if (*input_line_pointer
!= ',')
1540 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1541 ignore_rest_of_line ();
1545 input_line_pointer
++; /* skip ',' */
1546 if ((size
= get_absolute_expression ()) < 0)
1548 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1549 ignore_rest_of_line ();
1553 /* The third argument to .lcomm is the alignment. */
1554 if (*input_line_pointer
!= ',')
1558 ++input_line_pointer
;
1559 align
= get_absolute_expression ();
1562 as_warn (_("ignoring bad alignment"));
1568 symbolP
= symbol_find_or_make (name
);
1571 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1573 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1574 S_GET_NAME (symbolP
));
1575 ignore_rest_of_line ();
1579 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1581 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1582 S_GET_NAME (symbolP
),
1583 (long) S_GET_VALUE (symbolP
),
1586 ignore_rest_of_line ();
1592 old_subsec
= now_subseg
;
1595 /* Convert to a power of 2 alignment. */
1596 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1599 as_bad (_("Common alignment not a power of 2"));
1600 ignore_rest_of_line ();
1607 record_alignment (bss_section
, align2
);
1608 subseg_set (bss_section
, 0);
1610 frag_align (align2
, 0, 0);
1611 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1612 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1613 symbol_set_frag (symbolP
, frag_now
);
1614 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1617 S_SET_SIZE (symbolP
, size
);
1618 S_SET_SEGMENT (symbolP
, bss_section
);
1619 subseg_set (old_sec
, old_subsec
);
1620 demand_empty_rest_of_line ();
1623 /* Validate any relocations emitted for -mrelocatable, possibly adding
1624 fixups for word relocations in writable segments, so we can adjust
1627 ppc_elf_validate_fix (fixp
, seg
)
1631 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1640 case SHLIB_MRELOCATABLE
:
1641 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1642 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1643 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1644 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1645 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1646 && fixp
->fx_r_type
!= BFD_RELOC_32_BASEREL
1647 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1648 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1649 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1650 && (seg
->flags
& SEC_LOAD
) != 0
1651 && strcmp (segment_name (seg
), ".got2") != 0
1652 && strcmp (segment_name (seg
), ".dtors") != 0
1653 && strcmp (segment_name (seg
), ".ctors") != 0
1654 && strcmp (segment_name (seg
), ".fixup") != 0
1655 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1656 && strcmp (segment_name (seg
), ".eh_frame") != 0
1657 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1659 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1660 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1662 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1663 _("Relocation cannot be done when using -mrelocatable"));
1670 #if BFD_DEFAULT_TARGET_SIZE == 64
1671 /* Don't emit .TOC. symbol. */
1673 ppc_elf_frob_symbol (sym
)
1678 name
= S_GET_NAME (sym
);
1679 if (name
!= NULL
&& strcmp (name
, ".TOC.") == 0)
1681 S_CLEAR_EXTERNAL (sym
);
1688 #endif /* OBJ_ELF */
1693 * Summary of parse_toc_entry.
1695 * in: Input_line_pointer points to the '[' in one of:
1697 * [toc] [tocv] [toc32] [toc64]
1699 * Anything else is an error of one kind or another.
1702 * return value: success or failure
1703 * toc_kind: kind of toc reference
1704 * input_line_pointer:
1705 * success: first char after the ']'
1706 * failure: unchanged
1710 * [toc] - rv == success, toc_kind = default_toc
1711 * [tocv] - rv == success, toc_kind = data_in_toc
1712 * [toc32] - rv == success, toc_kind = must_be_32
1713 * [toc64] - rv == success, toc_kind = must_be_64
1717 enum toc_size_qualifier
1719 default_toc
, /* The toc cell constructed should be the system default size */
1720 data_in_toc
, /* This is a direct reference to a toc cell */
1721 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1722 must_be_64
/* The toc cell constructed must be 64 bits wide */
1726 parse_toc_entry (toc_kind
)
1727 enum toc_size_qualifier
*toc_kind
;
1732 enum toc_size_qualifier t
;
1734 /* Save the input_line_pointer. */
1735 start
= input_line_pointer
;
1737 /* Skip over the '[' , and whitespace. */
1738 ++input_line_pointer
;
1741 /* Find the spelling of the operand. */
1742 toc_spec
= input_line_pointer
;
1743 c
= get_symbol_end ();
1745 if (strcmp (toc_spec
, "toc") == 0)
1749 else if (strcmp (toc_spec
, "tocv") == 0)
1753 else if (strcmp (toc_spec
, "toc32") == 0)
1757 else if (strcmp (toc_spec
, "toc64") == 0)
1763 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1764 *input_line_pointer
= c
;
1765 input_line_pointer
= start
;
1769 /* Now find the ']'. */
1770 *input_line_pointer
= c
;
1772 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1773 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1777 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1778 input_line_pointer
= start
;
1788 /* We need to keep a list of fixups. We can't simply generate them as
1789 we go, because that would require us to first create the frag, and
1790 that would screw up references to ``.''. */
1796 bfd_reloc_code_real_type reloc
;
1799 #define MAX_INSN_FIXUPS (5)
1801 /* This routine is called for each instruction to be assembled. */
1808 const struct powerpc_opcode
*opcode
;
1810 const unsigned char *opindex_ptr
;
1814 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
1819 bfd_reloc_code_real_type reloc
;
1822 /* Get the opcode. */
1823 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1828 /* Look up the opcode in the hash table. */
1829 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
1830 if (opcode
== (const struct powerpc_opcode
*) NULL
)
1832 const struct powerpc_macro
*macro
;
1834 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
1835 if (macro
== (const struct powerpc_macro
*) NULL
)
1836 as_bad (_("Unrecognized opcode: `%s'"), str
);
1838 ppc_macro (s
, macro
);
1843 insn
= opcode
->opcode
;
1846 while (ISSPACE (*str
))
1849 /* PowerPC operands are just expressions. The only real issue is
1850 that a few operand types are optional. All cases which might use
1851 an optional operand separate the operands only with commas (in
1852 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1853 cases never have optional operands). There is never more than
1854 one optional operand for an instruction. So, before we start
1855 seriously parsing the operands, we check to see if we have an
1856 optional operand, and, if we do, we count the number of commas to
1857 see whether the operand should be omitted. */
1859 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1861 const struct powerpc_operand
*operand
;
1863 operand
= &powerpc_operands
[*opindex_ptr
];
1864 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
1866 unsigned int opcount
;
1868 /* There is an optional operand. Count the number of
1869 commas in the input line. */
1876 while ((s
= strchr (s
, ',')) != (char *) NULL
)
1883 /* If there are fewer operands in the line then are called
1884 for by the instruction, we want to skip the optional
1886 if (opcount
< strlen (opcode
->operands
))
1893 /* Gather the operands. */
1897 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1899 const struct powerpc_operand
*operand
;
1905 if (next_opindex
== 0)
1906 operand
= &powerpc_operands
[*opindex_ptr
];
1909 operand
= &powerpc_operands
[next_opindex
];
1915 /* If this is a fake operand, then we do not expect anything
1917 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
1919 insn
= (*operand
->insert
) (insn
, 0L, &errmsg
);
1920 if (errmsg
!= (const char *) NULL
)
1925 /* If this is an optional operand, and we are skipping it, just
1927 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
1930 if (operand
->insert
)
1932 insn
= (*operand
->insert
) (insn
, 0L, &errmsg
);
1933 if (errmsg
!= (const char *) NULL
)
1936 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
1937 next_opindex
= *opindex_ptr
+ 1;
1941 /* Gather the operand. */
1942 hold
= input_line_pointer
;
1943 input_line_pointer
= str
;
1946 if (*input_line_pointer
== '[')
1948 /* We are expecting something like the second argument here:
1950 * lwz r4,[toc].GS.0.static_int(rtoc)
1951 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1952 * The argument following the `]' must be a symbol name, and the
1953 * register must be the toc register: 'rtoc' or '2'
1955 * The effect is to 0 as the displacement field
1956 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1957 * the appropriate variation) reloc against it based on the symbol.
1958 * The linker will build the toc, and insert the resolved toc offset.
1961 * o The size of the toc entry is currently assumed to be
1962 * 32 bits. This should not be assumed to be a hard coded
1964 * o In an effort to cope with a change from 32 to 64 bits,
1965 * there are also toc entries that are specified to be
1966 * either 32 or 64 bits:
1967 * lwz r4,[toc32].GS.0.static_int(rtoc)
1968 * lwz r4,[toc64].GS.0.static_int(rtoc)
1969 * These demand toc entries of the specified size, and the
1970 * instruction probably requires it.
1974 enum toc_size_qualifier toc_kind
;
1975 bfd_reloc_code_real_type toc_reloc
;
1977 /* Go parse off the [tocXX] part. */
1978 valid_toc
= parse_toc_entry (&toc_kind
);
1982 /* Note: message has already been issued.
1983 FIXME: what sort of recovery should we do?
1984 demand_rest_of_line (); return; ? */
1987 /* Now get the symbol following the ']'. */
1993 /* In this case, we may not have seen the symbol yet,
1994 since it is allowed to appear on a .extern or .globl
1995 or just be a label in the .data section. */
1996 toc_reloc
= BFD_RELOC_PPC_TOC16
;
1999 /* 1. The symbol must be defined and either in the toc
2000 section, or a global.
2001 2. The reloc generated must have the TOCDEFN flag set
2002 in upper bit mess of the reloc type.
2003 FIXME: It's a little confusing what the tocv
2004 qualifier can be used for. At the very least, I've
2005 seen three uses, only one of which I'm sure I can
2007 if (ex
.X_op
== O_symbol
)
2009 assert (ex
.X_add_symbol
!= NULL
);
2010 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
2013 as_bad (_("[tocv] symbol is not a toc symbol"));
2017 toc_reloc
= BFD_RELOC_PPC_TOC16
;
2020 /* FIXME: these next two specifically specify 32/64 bit
2021 toc entries. We don't support them today. Is this
2022 the right way to say that? */
2023 toc_reloc
= BFD_RELOC_UNUSED
;
2024 as_bad (_("Unimplemented toc32 expression modifier"));
2027 /* FIXME: see above. */
2028 toc_reloc
= BFD_RELOC_UNUSED
;
2029 as_bad (_("Unimplemented toc64 expression modifier"));
2033 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2039 /* We need to generate a fixup for this expression. */
2040 if (fc
>= MAX_INSN_FIXUPS
)
2041 as_fatal (_("too many fixups"));
2043 fixups
[fc
].reloc
= toc_reloc
;
2044 fixups
[fc
].exp
= ex
;
2045 fixups
[fc
].opindex
= *opindex_ptr
;
2048 /* Ok. We've set up the fixup for the instruction. Now make it
2049 look like the constant 0 was found here. */
2051 ex
.X_op
= O_constant
;
2052 ex
.X_add_number
= 0;
2053 ex
.X_add_symbol
= NULL
;
2054 ex
.X_op_symbol
= NULL
;
2060 if (! register_name (&ex
))
2062 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
2069 str
= input_line_pointer
;
2070 input_line_pointer
= hold
;
2072 if (ex
.X_op
== O_illegal
)
2073 as_bad (_("illegal operand"));
2074 else if (ex
.X_op
== O_absent
)
2075 as_bad (_("missing operand"));
2076 else if (ex
.X_op
== O_register
)
2078 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2081 else if (ex
.X_op
== O_constant
)
2084 /* Allow @HA, @L, @H on constants. */
2085 char *orig_str
= str
;
2087 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2094 case BFD_RELOC_LO16
:
2095 /* X_unsigned is the default, so if the user has done
2096 something which cleared it, we always produce a
2098 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2099 ex
.X_add_number
&= 0xffff;
2101 ex
.X_add_number
= SEX16 (ex
.X_add_number
);
2104 case BFD_RELOC_HI16
:
2105 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2106 ex
.X_add_number
= PPC_HI (ex
.X_add_number
);
2108 ex
.X_add_number
= SEX16 (PPC_HI (ex
.X_add_number
));
2111 case BFD_RELOC_HI16_S
:
2112 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2113 ex
.X_add_number
= PPC_HA (ex
.X_add_number
);
2115 ex
.X_add_number
= SEX16 (PPC_HA (ex
.X_add_number
));
2118 #if BFD_DEFAULT_TARGET_SIZE == 64
2119 case BFD_RELOC_PPC64_HIGHER
:
2120 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2121 ex
.X_add_number
= PPC_HIGHER (ex
.X_add_number
);
2123 ex
.X_add_number
= SEX16 (PPC_HIGHER (ex
.X_add_number
));
2126 case BFD_RELOC_PPC64_HIGHER_S
:
2127 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2128 ex
.X_add_number
= PPC_HIGHERA (ex
.X_add_number
);
2130 ex
.X_add_number
= SEX16 (PPC_HIGHERA (ex
.X_add_number
));
2133 case BFD_RELOC_PPC64_HIGHEST
:
2134 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2135 ex
.X_add_number
= PPC_HIGHEST (ex
.X_add_number
);
2137 ex
.X_add_number
= SEX16 (PPC_HIGHEST (ex
.X_add_number
));
2140 case BFD_RELOC_PPC64_HIGHEST_S
:
2141 if (ex
.X_unsigned
&& ! (operand
->flags
& PPC_OPERAND_SIGNED
))
2142 ex
.X_add_number
= PPC_HIGHESTA (ex
.X_add_number
);
2144 ex
.X_add_number
= SEX16 (PPC_HIGHESTA (ex
.X_add_number
));
2146 #endif /* BFD_DEFAULT_TARGET_SIZE == 64 */
2148 #endif /* OBJ_ELF */
2149 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
2153 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2155 /* For the absolute forms of branches, convert the PC
2156 relative form back into the absolute. */
2157 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
2161 case BFD_RELOC_PPC_B26
:
2162 reloc
= BFD_RELOC_PPC_BA26
;
2164 case BFD_RELOC_PPC_B16
:
2165 reloc
= BFD_RELOC_PPC_BA16
;
2167 case BFD_RELOC_PPC_B16_BRTAKEN
:
2168 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
2170 case BFD_RELOC_PPC_B16_BRNTAKEN
:
2171 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
2178 if (BFD_DEFAULT_TARGET_SIZE
== 64
2179 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
2184 reloc
= BFD_RELOC_PPC64_ADDR16_DS
;
2186 case BFD_RELOC_LO16
:
2187 reloc
= BFD_RELOC_PPC64_ADDR16_LO_DS
;
2189 case BFD_RELOC_16_GOTOFF
:
2190 reloc
= BFD_RELOC_PPC64_GOT16_DS
;
2192 case BFD_RELOC_LO16_GOTOFF
:
2193 reloc
= BFD_RELOC_PPC64_GOT16_LO_DS
;
2195 case BFD_RELOC_LO16_PLTOFF
:
2196 reloc
= BFD_RELOC_PPC64_PLT16_LO_DS
;
2198 case BFD_RELOC_32_BASEREL
:
2199 reloc
= BFD_RELOC_PPC64_SECTOFF_DS
;
2201 case BFD_RELOC_LO16_BASEREL
:
2202 reloc
= BFD_RELOC_PPC64_SECTOFF_LO_DS
;
2204 case BFD_RELOC_PPC_TOC16
:
2205 reloc
= BFD_RELOC_PPC64_TOC16_DS
;
2207 case BFD_RELOC_PPC64_TOC16_LO
:
2208 reloc
= BFD_RELOC_PPC64_TOC16_LO_DS
;
2210 case BFD_RELOC_PPC64_PLTGOT16
:
2211 reloc
= BFD_RELOC_PPC64_PLTGOT16_DS
;
2213 case BFD_RELOC_PPC64_PLTGOT16_LO
:
2214 reloc
= BFD_RELOC_PPC64_PLTGOT16_LO_DS
;
2217 as_bad (_("unsupported relocation for DS offset field"));
2222 /* We need to generate a fixup for this expression. */
2223 if (fc
>= MAX_INSN_FIXUPS
)
2224 as_fatal (_("too many fixups"));
2225 fixups
[fc
].exp
= ex
;
2226 fixups
[fc
].opindex
= 0;
2227 fixups
[fc
].reloc
= reloc
;
2230 #endif /* OBJ_ELF */
2234 /* We need to generate a fixup for this expression. */
2235 if (fc
>= MAX_INSN_FIXUPS
)
2236 as_fatal (_("too many fixups"));
2237 fixups
[fc
].exp
= ex
;
2238 fixups
[fc
].opindex
= *opindex_ptr
;
2239 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2248 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
2256 /* The call to expression should have advanced str past any
2259 && (endc
!= ',' || *str
!= '\0'))
2261 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
2269 while (ISSPACE (*str
))
2273 as_bad (_("junk at end of line: `%s'"), str
);
2275 /* Write out the instruction. */
2277 md_number_to_chars (f
, insn
, 4);
2280 dwarf2_emit_insn (4);
2283 /* Create any fixups. At this point we do not use a
2284 bfd_reloc_code_real_type, but instead just use the
2285 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2286 handle fixups for any operand type, although that is admittedly
2287 not a very exciting feature. We pick a BFD reloc type in
2289 for (i
= 0; i
< fc
; i
++)
2291 const struct powerpc_operand
*operand
;
2293 operand
= &powerpc_operands
[fixups
[i
].opindex
];
2294 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2296 reloc_howto_type
*reloc_howto
;
2301 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2305 size
= bfd_get_reloc_size (reloc_howto
);
2306 offset
= target_big_endian
? (4 - size
) : 0;
2308 if (size
< 1 || size
> 4)
2311 fixP
= fix_new_exp (frag_now
,
2312 f
- frag_now
->fr_literal
+ offset
,
2315 reloc_howto
->pc_relative
,
2318 /* Turn off complaints that the addend is too large for things like
2320 switch (fixups
[i
].reloc
)
2322 case BFD_RELOC_16_GOTOFF
:
2323 case BFD_RELOC_PPC_TOC16
:
2324 case BFD_RELOC_LO16
:
2325 case BFD_RELOC_HI16
:
2326 case BFD_RELOC_HI16_S
:
2328 #if BFD_DEFAULT_TARGET_SIZE == 64
2329 case BFD_RELOC_PPC64_HIGHER
:
2330 case BFD_RELOC_PPC64_HIGHER_S
:
2331 case BFD_RELOC_PPC64_HIGHEST
:
2332 case BFD_RELOC_PPC64_HIGHEST_S
:
2335 fixP
->fx_no_overflow
= 1;
2342 fix_new_exp (frag_now
,
2343 f
- frag_now
->fr_literal
,
2346 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2347 ((bfd_reloc_code_real_type
)
2348 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2352 /* Handle a macro. Gather all the operands, transform them as
2353 described by the macro, and call md_assemble recursively. All the
2354 operands are separated by commas; we don't accept parentheses
2355 around operands here. */
2358 ppc_macro (str
, macro
)
2360 const struct powerpc_macro
*macro
;
2371 /* Gather the users operands into the operands array. */
2376 if (count
>= sizeof operands
/ sizeof operands
[0])
2378 operands
[count
++] = s
;
2379 s
= strchr (s
, ',');
2380 if (s
== (char *) NULL
)
2385 if (count
!= macro
->operands
)
2387 as_bad (_("wrong number of operands"));
2391 /* Work out how large the string must be (the size is unbounded
2392 because it includes user input). */
2394 format
= macro
->format
;
2395 while (*format
!= '\0')
2404 arg
= strtol (format
+ 1, &send
, 10);
2405 know (send
!= format
&& arg
>= 0 && arg
< count
);
2406 len
+= strlen (operands
[arg
]);
2411 /* Put the string together. */
2412 complete
= s
= (char *) alloca (len
+ 1);
2413 format
= macro
->format
;
2414 while (*format
!= '\0')
2420 arg
= strtol (format
+ 1, &send
, 10);
2421 strcpy (s
, operands
[arg
]);
2428 /* Assemble the constructed instruction. */
2429 md_assemble (complete
);
2433 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2436 ppc_section_letter (letter
, ptr_msg
)
2443 *ptr_msg
= _("Bad .section directive: want a,e,w,x,M,S in string");
2448 ppc_section_word (str
, len
)
2452 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2459 ppc_section_type (str
, len
)
2463 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2470 ppc_section_flags (flags
, attr
, type
)
2475 if (type
== SHT_ORDERED
)
2476 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2478 if (attr
& SHF_EXCLUDE
)
2479 flags
|= SEC_EXCLUDE
;
2483 #endif /* OBJ_ELF */
2486 /* Pseudo-op handling. */
2488 /* The .byte pseudo-op. This is similar to the normal .byte
2489 pseudo-op, but it can also take a single ASCII string. */
2493 int ignore ATTRIBUTE_UNUSED
;
2495 if (*input_line_pointer
!= '\"')
2501 /* Gather characters. A real double quote is doubled. Unusual
2502 characters are not permitted. */
2503 ++input_line_pointer
;
2508 c
= *input_line_pointer
++;
2512 if (*input_line_pointer
!= '\"')
2514 ++input_line_pointer
;
2517 FRAG_APPEND_1_CHAR (c
);
2520 demand_empty_rest_of_line ();
2525 /* XCOFF specific pseudo-op handling. */
2527 /* This is set if we are creating a .stabx symbol, since we don't want
2528 to handle symbol suffixes for such symbols. */
2529 static boolean ppc_stab_symbol
;
2531 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2532 symbols in the .bss segment as though they were local common
2533 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2534 aligns .comm and .lcomm to 4 bytes. */
2540 asection
*current_seg
= now_seg
;
2541 subsegT current_subseg
= now_subseg
;
2547 symbolS
*lcomm_sym
= NULL
;
2551 name
= input_line_pointer
;
2552 endc
= get_symbol_end ();
2553 end_name
= input_line_pointer
;
2556 if (*input_line_pointer
!= ',')
2558 as_bad (_("missing size"));
2559 ignore_rest_of_line ();
2562 ++input_line_pointer
;
2564 size
= get_absolute_expression ();
2567 as_bad (_("negative size"));
2568 ignore_rest_of_line ();
2574 /* The third argument to .comm is the alignment. */
2575 if (*input_line_pointer
!= ',')
2579 ++input_line_pointer
;
2580 align
= get_absolute_expression ();
2583 as_warn (_("ignoring bad alignment"));
2598 /* The third argument to .lcomm appears to be the real local
2599 common symbol to create. References to the symbol named in
2600 the first argument are turned into references to the third
2602 if (*input_line_pointer
!= ',')
2604 as_bad (_("missing real symbol name"));
2605 ignore_rest_of_line ();
2608 ++input_line_pointer
;
2610 lcomm_name
= input_line_pointer
;
2611 lcomm_endc
= get_symbol_end ();
2613 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2615 *input_line_pointer
= lcomm_endc
;
2619 sym
= symbol_find_or_make (name
);
2622 if (S_IS_DEFINED (sym
)
2623 || S_GET_VALUE (sym
) != 0)
2625 as_bad (_("attempt to redefine symbol"));
2626 ignore_rest_of_line ();
2630 record_alignment (bss_section
, align
);
2633 || ! S_IS_DEFINED (lcomm_sym
))
2642 S_SET_EXTERNAL (sym
);
2646 symbol_get_tc (lcomm_sym
)->output
= 1;
2647 def_sym
= lcomm_sym
;
2651 subseg_set (bss_section
, 1);
2652 frag_align (align
, 0, 0);
2654 symbol_set_frag (def_sym
, frag_now
);
2655 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2656 def_size
, (char *) NULL
);
2658 S_SET_SEGMENT (def_sym
, bss_section
);
2659 symbol_get_tc (def_sym
)->align
= align
;
2663 /* Align the size of lcomm_sym. */
2664 symbol_get_frag (lcomm_sym
)->fr_offset
=
2665 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2666 &~ ((1 << align
) - 1));
2667 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2668 symbol_get_tc (lcomm_sym
)->align
= align
;
2673 /* Make sym an offset from lcomm_sym. */
2674 S_SET_SEGMENT (sym
, bss_section
);
2675 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2676 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2677 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2680 subseg_set (current_seg
, current_subseg
);
2682 demand_empty_rest_of_line ();
2685 /* The .csect pseudo-op. This switches us into a different
2686 subsegment. The first argument is a symbol whose value is the
2687 start of the .csect. In COFF, csect symbols get special aux
2688 entries defined by the x_csect field of union internal_auxent. The
2689 optional second argument is the alignment (the default is 2). */
2693 int ignore ATTRIBUTE_UNUSED
;
2699 name
= input_line_pointer
;
2700 endc
= get_symbol_end ();
2702 sym
= symbol_find_or_make (name
);
2704 *input_line_pointer
= endc
;
2706 if (S_GET_NAME (sym
)[0] == '\0')
2708 /* An unnamed csect is assumed to be [PR]. */
2709 symbol_get_tc (sym
)->class = XMC_PR
;
2712 ppc_change_csect (sym
);
2714 if (*input_line_pointer
== ',')
2716 ++input_line_pointer
;
2717 symbol_get_tc (sym
)->align
= get_absolute_expression ();
2720 demand_empty_rest_of_line ();
2723 /* Change to a different csect. */
2726 ppc_change_csect (sym
)
2729 if (S_IS_DEFINED (sym
))
2730 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
2738 /* This is a new csect. We need to look at the symbol class to
2739 figure out whether it should go in the text section or the
2742 switch (symbol_get_tc (sym
)->class)
2752 S_SET_SEGMENT (sym
, text_section
);
2753 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
2754 ++ppc_text_subsegment
;
2755 list_ptr
= &ppc_text_csects
;
2764 if (ppc_toc_csect
!= NULL
2765 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
2766 == ppc_data_subsegment
))
2768 S_SET_SEGMENT (sym
, data_section
);
2769 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
2770 ++ppc_data_subsegment
;
2771 list_ptr
= &ppc_data_csects
;
2777 /* We set the obstack chunk size to a small value before
2778 changing subsegments, so that we don't use a lot of memory
2779 space for what may be a small section. */
2780 hold_chunksize
= chunksize
;
2783 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
2784 symbol_get_tc (sym
)->subseg
);
2786 chunksize
= hold_chunksize
;
2789 ppc_after_toc_frag
= frag_now
;
2791 symbol_set_frag (sym
, frag_now
);
2792 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2794 symbol_get_tc (sym
)->align
= (ppc_xcoff64
) ? 3 : 2;
2795 symbol_get_tc (sym
)->output
= 1;
2796 symbol_get_tc (sym
)->within
= sym
;
2798 for (list
= *list_ptr
;
2799 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
2800 list
= symbol_get_tc (list
)->next
)
2802 symbol_get_tc (list
)->next
= sym
;
2804 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2805 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
2809 ppc_current_csect
= sym
;
2812 /* This function handles the .text and .data pseudo-ops. These
2813 pseudo-ops aren't really used by XCOFF; we implement them for the
2814 convenience of people who aren't used to XCOFF. */
2825 else if (type
== 'd')
2830 sym
= symbol_find_or_make (name
);
2832 ppc_change_csect (sym
);
2834 demand_empty_rest_of_line ();
2837 /* This function handles the .section pseudo-op. This is mostly to
2838 give an error, since XCOFF only supports .text, .data and .bss, but
2839 we do permit the user to name the text or data section. */
2842 ppc_named_section (ignore
)
2843 int ignore ATTRIBUTE_UNUSED
;
2846 const char *real_name
;
2850 user_name
= input_line_pointer
;
2851 c
= get_symbol_end ();
2853 if (strcmp (user_name
, ".text") == 0)
2854 real_name
= ".text[PR]";
2855 else if (strcmp (user_name
, ".data") == 0)
2856 real_name
= ".data[RW]";
2859 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2860 *input_line_pointer
= c
;
2861 ignore_rest_of_line ();
2865 *input_line_pointer
= c
;
2867 sym
= symbol_find_or_make (real_name
);
2869 ppc_change_csect (sym
);
2871 demand_empty_rest_of_line ();
2874 /* The .extern pseudo-op. We create an undefined symbol. */
2878 int ignore ATTRIBUTE_UNUSED
;
2883 name
= input_line_pointer
;
2884 endc
= get_symbol_end ();
2886 (void) symbol_find_or_make (name
);
2888 *input_line_pointer
= endc
;
2890 demand_empty_rest_of_line ();
2893 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2897 int ignore ATTRIBUTE_UNUSED
;
2903 name
= input_line_pointer
;
2904 endc
= get_symbol_end ();
2906 sym
= symbol_find_or_make (name
);
2908 *input_line_pointer
= endc
;
2910 symbol_get_tc (sym
)->output
= 1;
2912 demand_empty_rest_of_line ();
2915 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2916 although I don't know why it bothers. */
2920 int ignore ATTRIBUTE_UNUSED
;
2927 name
= input_line_pointer
;
2928 endc
= get_symbol_end ();
2930 sym
= symbol_find_or_make (name
);
2932 *input_line_pointer
= endc
;
2934 if (*input_line_pointer
!= ',')
2936 as_bad (_("missing rename string"));
2937 ignore_rest_of_line ();
2940 ++input_line_pointer
;
2942 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
2944 demand_empty_rest_of_line ();
2947 /* The .stabx pseudo-op. This is similar to a normal .stabs
2948 pseudo-op, but slightly different. A sample is
2949 .stabx "main:F-1",.main,142,0
2950 The first argument is the symbol name to create. The second is the
2951 value, and the third is the storage class. The fourth seems to be
2952 always zero, and I am assuming it is the type. */
2956 int ignore ATTRIBUTE_UNUSED
;
2963 name
= demand_copy_C_string (&len
);
2965 if (*input_line_pointer
!= ',')
2967 as_bad (_("missing value"));
2970 ++input_line_pointer
;
2972 ppc_stab_symbol
= true;
2973 sym
= symbol_make (name
);
2974 ppc_stab_symbol
= false;
2976 symbol_get_tc (sym
)->real_name
= name
;
2978 (void) expression (&exp
);
2985 as_bad (_("illegal .stabx expression; zero assumed"));
2986 exp
.X_add_number
= 0;
2989 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
2990 symbol_set_frag (sym
, &zero_address_frag
);
2994 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
2995 symbol_set_value_expression (sym
, &exp
);
2999 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
3000 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
3005 /* The value is some complex expression. This will probably
3006 fail at some later point, but this is probably the right
3007 thing to do here. */
3008 symbol_set_value_expression (sym
, &exp
);
3012 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3013 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3015 if (*input_line_pointer
!= ',')
3017 as_bad (_("missing class"));
3020 ++input_line_pointer
;
3022 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
3024 if (*input_line_pointer
!= ',')
3026 as_bad (_("missing type"));
3029 ++input_line_pointer
;
3031 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
3033 symbol_get_tc (sym
)->output
= 1;
3035 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
) {
3037 symbol_get_tc (sym
)->within
= ppc_current_block
;
3042 .stabx "z",arrays_,133,0
3045 .comm arrays_,13768,3
3047 resolve_symbol_value will copy the exp's "within" into sym's when the
3048 offset is 0. Since this seems to be corner case problem,
3049 only do the correction for storage class C_STSYM. A better solution
3050 would be to have the tc field updated in ppc_symbol_new_hook. */
3052 if (exp
.X_op
== O_symbol
)
3054 symbol_get_tc (exp
.X_add_symbol
)->within
= ppc_current_block
;
3058 if (exp
.X_op
!= O_symbol
3059 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
3060 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
3061 ppc_frob_label (sym
);
3064 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3065 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
3066 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
3067 symbol_get_tc (ppc_current_csect
)->within
= sym
;
3070 demand_empty_rest_of_line ();
3073 /* The .function pseudo-op. This takes several arguments. The first
3074 argument seems to be the external name of the symbol. The second
3075 argment seems to be the label for the start of the function. gcc
3076 uses the same name for both. I have no idea what the third and
3077 fourth arguments are meant to be. The optional fifth argument is
3078 an expression for the size of the function. In COFF this symbol
3079 gets an aux entry like that used for a csect. */
3082 ppc_function (ignore
)
3083 int ignore ATTRIBUTE_UNUSED
;
3091 name
= input_line_pointer
;
3092 endc
= get_symbol_end ();
3094 /* Ignore any [PR] suffix. */
3095 name
= ppc_canonicalize_symbol_name (name
);
3096 s
= strchr (name
, '[');
3097 if (s
!= (char *) NULL
3098 && strcmp (s
+ 1, "PR]") == 0)
3101 ext_sym
= symbol_find_or_make (name
);
3103 *input_line_pointer
= endc
;
3105 if (*input_line_pointer
!= ',')
3107 as_bad (_("missing symbol name"));
3108 ignore_rest_of_line ();
3111 ++input_line_pointer
;
3113 name
= input_line_pointer
;
3114 endc
= get_symbol_end ();
3116 lab_sym
= symbol_find_or_make (name
);
3118 *input_line_pointer
= endc
;
3120 if (ext_sym
!= lab_sym
)
3124 exp
.X_op
= O_symbol
;
3125 exp
.X_add_symbol
= lab_sym
;
3126 exp
.X_op_symbol
= NULL
;
3127 exp
.X_add_number
= 0;
3129 symbol_set_value_expression (ext_sym
, &exp
);
3132 if (symbol_get_tc (ext_sym
)->class == -1)
3133 symbol_get_tc (ext_sym
)->class = XMC_PR
;
3134 symbol_get_tc (ext_sym
)->output
= 1;
3136 if (*input_line_pointer
== ',')
3140 /* Ignore the third argument. */
3141 ++input_line_pointer
;
3142 expression (&ignore
);
3143 if (*input_line_pointer
== ',')
3145 /* Ignore the fourth argument. */
3146 ++input_line_pointer
;
3147 expression (&ignore
);
3148 if (*input_line_pointer
== ',')
3150 /* The fifth argument is the function size. */
3151 ++input_line_pointer
;
3152 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
3155 &zero_address_frag
);
3156 pseudo_set (symbol_get_tc (ext_sym
)->size
);
3161 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3162 SF_SET_FUNCTION (ext_sym
);
3163 SF_SET_PROCESS (ext_sym
);
3164 coff_add_linesym (ext_sym
);
3166 demand_empty_rest_of_line ();
3169 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3174 int ignore ATTRIBUTE_UNUSED
;
3178 sym
= symbol_make (".bf");
3179 S_SET_SEGMENT (sym
, text_section
);
3180 symbol_set_frag (sym
, frag_now
);
3181 S_SET_VALUE (sym
, frag_now_fix ());
3182 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3184 coff_line_base
= get_absolute_expression ();
3186 S_SET_NUMBER_AUXILIARY (sym
, 1);
3187 SA_SET_SYM_LNNO (sym
, coff_line_base
);
3189 symbol_get_tc (sym
)->output
= 1;
3191 ppc_frob_label (sym
);
3193 demand_empty_rest_of_line ();
3196 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3197 ".ef", except that the line number is absolute, not relative to the
3198 most recent ".bf" symbol. */
3202 int ignore ATTRIBUTE_UNUSED
;
3206 sym
= symbol_make (".ef");
3207 S_SET_SEGMENT (sym
, text_section
);
3208 symbol_set_frag (sym
, frag_now
);
3209 S_SET_VALUE (sym
, frag_now_fix ());
3210 S_SET_STORAGE_CLASS (sym
, C_FCN
);
3211 S_SET_NUMBER_AUXILIARY (sym
, 1);
3212 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3213 symbol_get_tc (sym
)->output
= 1;
3215 ppc_frob_label (sym
);
3217 demand_empty_rest_of_line ();
3220 /* The .bi and .ei pseudo-ops. These take a string argument and
3221 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3228 static symbolS
*last_biei
;
3235 name
= demand_copy_C_string (&len
);
3237 /* The value of these symbols is actually file offset. Here we set
3238 the value to the index into the line number entries. In
3239 ppc_frob_symbols we set the fix_line field, which will cause BFD
3240 to do the right thing. */
3242 sym
= symbol_make (name
);
3243 /* obj-coff.c currently only handles line numbers correctly in the
3245 S_SET_SEGMENT (sym
, text_section
);
3246 S_SET_VALUE (sym
, coff_n_line_nos
);
3247 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3249 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
3250 symbol_get_tc (sym
)->output
= 1;
3252 for (look
= last_biei
? last_biei
: symbol_rootP
;
3253 (look
!= (symbolS
*) NULL
3254 && (S_GET_STORAGE_CLASS (look
) == C_FILE
3255 || S_GET_STORAGE_CLASS (look
) == C_BINCL
3256 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
3257 look
= symbol_next (look
))
3259 if (look
!= (symbolS
*) NULL
)
3261 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3262 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
3266 demand_empty_rest_of_line ();
3269 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3270 There is one argument, which is a csect symbol. The value of the
3271 .bs symbol is the index of this csect symbol. */
3275 int ignore ATTRIBUTE_UNUSED
;
3282 if (ppc_current_block
!= NULL
)
3283 as_bad (_("nested .bs blocks"));
3285 name
= input_line_pointer
;
3286 endc
= get_symbol_end ();
3288 csect
= symbol_find_or_make (name
);
3290 *input_line_pointer
= endc
;
3292 sym
= symbol_make (".bs");
3293 S_SET_SEGMENT (sym
, now_seg
);
3294 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
3295 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3296 symbol_get_tc (sym
)->output
= 1;
3298 symbol_get_tc (sym
)->within
= csect
;
3300 ppc_frob_label (sym
);
3302 ppc_current_block
= sym
;
3304 demand_empty_rest_of_line ();
3307 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3311 int ignore ATTRIBUTE_UNUSED
;
3315 if (ppc_current_block
== NULL
)
3316 as_bad (_(".es without preceding .bs"));
3318 sym
= symbol_make (".es");
3319 S_SET_SEGMENT (sym
, now_seg
);
3320 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
3321 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3322 symbol_get_tc (sym
)->output
= 1;
3324 ppc_frob_label (sym
);
3326 ppc_current_block
= NULL
;
3328 demand_empty_rest_of_line ();
3331 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3336 int ignore ATTRIBUTE_UNUSED
;
3340 sym
= symbol_make (".bb");
3341 S_SET_SEGMENT (sym
, text_section
);
3342 symbol_set_frag (sym
, frag_now
);
3343 S_SET_VALUE (sym
, frag_now_fix ());
3344 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3346 S_SET_NUMBER_AUXILIARY (sym
, 1);
3347 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3349 symbol_get_tc (sym
)->output
= 1;
3351 SF_SET_PROCESS (sym
);
3353 ppc_frob_label (sym
);
3355 demand_empty_rest_of_line ();
3358 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3363 int ignore ATTRIBUTE_UNUSED
;
3367 sym
= symbol_make (".eb");
3368 S_SET_SEGMENT (sym
, text_section
);
3369 symbol_set_frag (sym
, frag_now
);
3370 S_SET_VALUE (sym
, frag_now_fix ());
3371 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3372 S_SET_NUMBER_AUXILIARY (sym
, 1);
3373 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3374 symbol_get_tc (sym
)->output
= 1;
3376 SF_SET_PROCESS (sym
);
3378 ppc_frob_label (sym
);
3380 demand_empty_rest_of_line ();
3383 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3388 int ignore ATTRIBUTE_UNUSED
;
3394 name
= demand_copy_C_string (&len
);
3395 sym
= symbol_make (name
);
3396 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3397 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3398 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3399 S_SET_VALUE (sym
, 0);
3400 symbol_get_tc (sym
)->output
= 1;
3402 ppc_frob_label (sym
);
3404 demand_empty_rest_of_line ();
3407 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3411 int ignore ATTRIBUTE_UNUSED
;
3415 sym
= symbol_make (".ec");
3416 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3417 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3418 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3419 S_SET_VALUE (sym
, 0);
3420 symbol_get_tc (sym
)->output
= 1;
3422 ppc_frob_label (sym
);
3424 demand_empty_rest_of_line ();
3427 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3431 int ignore ATTRIBUTE_UNUSED
;
3433 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3434 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3441 subseg
= ppc_data_subsegment
;
3442 ++ppc_data_subsegment
;
3444 subseg_new (segment_name (data_section
), subseg
);
3445 ppc_toc_frag
= frag_now
;
3447 sym
= symbol_find_or_make ("TOC[TC0]");
3448 symbol_set_frag (sym
, frag_now
);
3449 S_SET_SEGMENT (sym
, data_section
);
3450 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3451 symbol_get_tc (sym
)->subseg
= subseg
;
3452 symbol_get_tc (sym
)->output
= 1;
3453 symbol_get_tc (sym
)->within
= sym
;
3455 ppc_toc_csect
= sym
;
3457 for (list
= ppc_data_csects
;
3458 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3459 list
= symbol_get_tc (list
)->next
)
3461 symbol_get_tc (list
)->next
= sym
;
3463 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3464 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3468 ppc_current_csect
= ppc_toc_csect
;
3470 demand_empty_rest_of_line ();
3473 /* The AIX assembler automatically aligns the operands of a .long or
3474 .short pseudo-op, and we want to be compatible. */
3477 ppc_xcoff_cons (log_size
)
3480 frag_align (log_size
, 0, 0);
3481 record_alignment (now_seg
, log_size
);
3482 cons (1 << log_size
);
3487 int dummy ATTRIBUTE_UNUSED
;
3492 (void) expression (&exp
);
3494 if (exp
.X_op
!= O_constant
)
3496 as_bad (_("non-constant byte count"));
3500 byte_count
= exp
.X_add_number
;
3502 if (*input_line_pointer
!= ',')
3504 as_bad (_("missing value"));
3508 ++input_line_pointer
;
3512 #endif /* OBJ_XCOFF */
3513 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3515 /* The .tc pseudo-op. This is used when generating either XCOFF or
3516 ELF. This takes two or more arguments.
3518 When generating XCOFF output, the first argument is the name to
3519 give to this location in the toc; this will be a symbol with class
3520 TC. The rest of the arguments are N-byte values to actually put at
3521 this location in the TOC; often there is just one more argument, a
3522 relocateable symbol reference. The size of the value to store
3523 depends on target word size. A 32-bit target uses 4-byte values, a
3524 64-bit target uses 8-byte values.
3526 When not generating XCOFF output, the arguments are the same, but
3527 the first argument is simply ignored. */
3531 int ignore ATTRIBUTE_UNUSED
;
3535 /* Define the TOC symbol name. */
3541 if (ppc_toc_csect
== (symbolS
*) NULL
3542 || ppc_toc_csect
!= ppc_current_csect
)
3544 as_bad (_(".tc not in .toc section"));
3545 ignore_rest_of_line ();
3549 name
= input_line_pointer
;
3550 endc
= get_symbol_end ();
3552 sym
= symbol_find_or_make (name
);
3554 *input_line_pointer
= endc
;
3556 if (S_IS_DEFINED (sym
))
3560 label
= symbol_get_tc (ppc_current_csect
)->within
;
3561 if (symbol_get_tc (label
)->class != XMC_TC0
)
3563 as_bad (_(".tc with no label"));
3564 ignore_rest_of_line ();
3568 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3569 symbol_set_frag (label
, symbol_get_frag (sym
));
3570 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3572 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3573 ++input_line_pointer
;
3578 S_SET_SEGMENT (sym
, now_seg
);
3579 symbol_set_frag (sym
, frag_now
);
3580 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3581 symbol_get_tc (sym
)->class = XMC_TC
;
3582 symbol_get_tc (sym
)->output
= 1;
3584 ppc_frob_label (sym
);
3587 #endif /* OBJ_XCOFF */
3590 /* Skip the TOC symbol name. */
3591 while (is_part_of_name (*input_line_pointer
)
3592 || *input_line_pointer
== '['
3593 || *input_line_pointer
== ']'
3594 || *input_line_pointer
== '{'
3595 || *input_line_pointer
== '}')
3596 ++input_line_pointer
;
3598 /* Align to a four/eight byte boundary. */
3599 frag_align (BFD_DEFAULT_TARGET_SIZE
== 64 ? 3 : 2, 0, 0);
3600 record_alignment (now_seg
, BFD_DEFAULT_TARGET_SIZE
== 64 ? 3 : 2);
3601 #endif /* OBJ_ELF */
3603 if (*input_line_pointer
!= ',')
3604 demand_empty_rest_of_line ();
3607 ++input_line_pointer
;
3608 cons ((ppc_size
== PPC_OPCODE_64
) ? 8 : 4);
3612 /* Pseudo-op .machine. */
3613 /* FIXME: `.machine' is a nop for the moment. */
3616 ppc_machine (ignore
)
3617 int ignore ATTRIBUTE_UNUSED
;
3619 discard_rest_of_line ();
3622 /* See whether a symbol is in the TOC section. */
3625 ppc_is_toc_sym (sym
)
3629 return symbol_get_tc (sym
)->class == XMC_TC
;
3632 const char *sname
= segment_name (S_GET_SEGMENT (sym
));
3633 if (BFD_DEFAULT_TARGET_SIZE
== 64)
3634 return strcmp (sname
, ".toc") == 0;
3636 return strcmp (sname
, ".got") == 0;
3639 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3643 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3645 /* Set the current section. */
3647 ppc_set_current_section (new)
3650 ppc_previous_section
= ppc_current_section
;
3651 ppc_current_section
= new;
3654 /* pseudo-op: .previous
3655 behaviour: toggles the current section with the previous section.
3657 warnings: "No previous section" */
3660 ppc_previous (ignore
)
3661 int ignore ATTRIBUTE_UNUSED
;
3665 if (ppc_previous_section
== NULL
)
3667 as_warn (_("No previous section to return to. Directive ignored."));
3671 subseg_set (ppc_previous_section
, 0);
3673 ppc_set_current_section (ppc_previous_section
);
3676 /* pseudo-op: .pdata
3677 behaviour: predefined read only data section
3681 initial: .section .pdata "adr3"
3682 a - don't know -- maybe a misprint
3683 d - initialized data
3685 3 - double word aligned (that would be 4 byte boundary)
3688 Tag index tables (also known as the function table) for exception
3689 handling, debugging, etc. */
3693 int ignore ATTRIBUTE_UNUSED
;
3695 if (pdata_section
== 0)
3697 pdata_section
= subseg_new (".pdata", 0);
3699 bfd_set_section_flags (stdoutput
, pdata_section
,
3700 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3701 | SEC_READONLY
| SEC_DATA
));
3703 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
3707 pdata_section
= subseg_new (".pdata", 0);
3709 ppc_set_current_section (pdata_section
);
3712 /* pseudo-op: .ydata
3713 behaviour: predefined read only data section
3717 initial: .section .ydata "drw3"
3718 a - don't know -- maybe a misprint
3719 d - initialized data
3721 3 - double word aligned (that would be 4 byte boundary)
3723 Tag tables (also known as the scope table) for exception handling,
3728 int ignore ATTRIBUTE_UNUSED
;
3730 if (ydata_section
== 0)
3732 ydata_section
= subseg_new (".ydata", 0);
3733 bfd_set_section_flags (stdoutput
, ydata_section
,
3734 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3735 | SEC_READONLY
| SEC_DATA
));
3737 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
3741 ydata_section
= subseg_new (".ydata", 0);
3743 ppc_set_current_section (ydata_section
);
3746 /* pseudo-op: .reldata
3747 behaviour: predefined read write data section
3748 double word aligned (4-byte)
3749 FIXME: relocation is applied to it
3750 FIXME: what's the difference between this and .data?
3753 initial: .section .reldata "drw3"
3754 d - initialized data
3757 3 - double word aligned (that would be 8 byte boundary)
3760 Like .data, but intended to hold data subject to relocation, such as
3761 function descriptors, etc. */
3764 ppc_reldata (ignore
)
3765 int ignore ATTRIBUTE_UNUSED
;
3767 if (reldata_section
== 0)
3769 reldata_section
= subseg_new (".reldata", 0);
3771 bfd_set_section_flags (stdoutput
, reldata_section
,
3772 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3775 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
3779 reldata_section
= subseg_new (".reldata", 0);
3781 ppc_set_current_section (reldata_section
);
3784 /* pseudo-op: .rdata
3785 behaviour: predefined read only data section
3789 initial: .section .rdata "dr3"
3790 d - initialized data
3792 3 - double word aligned (that would be 4 byte boundary) */
3796 int ignore ATTRIBUTE_UNUSED
;
3798 if (rdata_section
== 0)
3800 rdata_section
= subseg_new (".rdata", 0);
3801 bfd_set_section_flags (stdoutput
, rdata_section
,
3802 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3803 | SEC_READONLY
| SEC_DATA
));
3805 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
3809 rdata_section
= subseg_new (".rdata", 0);
3811 ppc_set_current_section (rdata_section
);
3814 /* pseudo-op: .ualong
3815 behaviour: much like .int, with the exception that no alignment is
3817 FIXME: test the alignment statement
3823 int ignore ATTRIBUTE_UNUSED
;
3829 /* pseudo-op: .znop <symbol name>
3830 behaviour: Issue a nop instruction
3831 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3832 the supplied symbol name.
3834 warnings: Missing symbol name */
3838 int ignore ATTRIBUTE_UNUSED
;
3841 const struct powerpc_opcode
*opcode
;
3852 /* Strip out the symbol name. */
3853 symbol_name
= input_line_pointer
;
3854 c
= get_symbol_end ();
3856 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
3857 strcpy (name
, symbol_name
);
3859 sym
= symbol_find_or_make (name
);
3861 *input_line_pointer
= c
;
3865 /* Look up the opcode in the hash table. */
3866 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
3868 /* Stick in the nop. */
3869 insn
= opcode
->opcode
;
3871 /* Write out the instruction. */
3873 md_number_to_chars (f
, insn
, 4);
3875 f
- frag_now
->fr_literal
,
3880 BFD_RELOC_16_GOT_PCREL
);
3893 register char *name
;
3897 register symbolS
*symbolP
;
3900 name
= input_line_pointer
;
3901 c
= get_symbol_end ();
3903 /* just after name is now '\0'. */
3904 p
= input_line_pointer
;
3907 if (*input_line_pointer
!= ',')
3909 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3910 ignore_rest_of_line ();
3914 input_line_pointer
++; /* skip ',' */
3915 if ((temp
= get_absolute_expression ()) < 0)
3917 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
3918 ignore_rest_of_line ();
3924 /* The third argument to .comm is the alignment. */
3925 if (*input_line_pointer
!= ',')
3929 ++input_line_pointer
;
3930 align
= get_absolute_expression ();
3933 as_warn (_("ignoring bad alignment"));
3940 symbolP
= symbol_find_or_make (name
);
3943 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
3945 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
3946 S_GET_NAME (symbolP
));
3947 ignore_rest_of_line ();
3951 if (S_GET_VALUE (symbolP
))
3953 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
3954 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3955 S_GET_NAME (symbolP
),
3956 (long) S_GET_VALUE (symbolP
),
3961 S_SET_VALUE (symbolP
, (valueT
) temp
);
3962 S_SET_EXTERNAL (symbolP
);
3965 demand_empty_rest_of_line ();
3969 * implement the .section pseudo op:
3970 * .section name {, "flags"}
3972 * | +--- optional flags: 'b' for bss
3974 * +-- section name 'l' for lib
3978 * 'd' (apparently m88k for data)
3980 * But if the argument is not a quoted string, treat it as a
3981 * subsegment number.
3983 * FIXME: this is a copy of the section processing from obj-coff.c, with
3984 * additions/changes for the moto-pas assembler support. There are three
3987 * FIXME: I just noticed this. This doesn't work at all really. It it
3988 * setting bits that bfd probably neither understands or uses. The
3989 * correct approach (?) will have to incorporate extra fields attached
3990 * to the section to hold the system specific stuff. (krk)
3993 * 'a' - unknown - referred to in documentation, but no definition supplied
3994 * 'c' - section has code
3995 * 'd' - section has initialized data
3996 * 'u' - section has uninitialized data
3997 * 'i' - section contains directives (info)
3998 * 'n' - section can be discarded
3999 * 'R' - remove section at link time
4001 * Section Protection:
4002 * 'r' - section is readable
4003 * 'w' - section is writeable
4004 * 'x' - section is executable
4005 * 's' - section is sharable
4007 * Section Alignment:
4008 * '0' - align to byte boundary
4009 * '1' - align to halfword undary
4010 * '2' - align to word boundary
4011 * '3' - align to doubleword boundary
4012 * '4' - align to quadword boundary
4013 * '5' - align to 32 byte boundary
4014 * '6' - align to 64 byte boundary
4019 ppc_pe_section (ignore
)
4020 int ignore ATTRIBUTE_UNUSED
;
4022 /* Strip out the section name. */
4031 section_name
= input_line_pointer
;
4032 c
= get_symbol_end ();
4034 name
= xmalloc (input_line_pointer
- section_name
+ 1);
4035 strcpy (name
, section_name
);
4037 *input_line_pointer
= c
;
4042 flags
= SEC_NO_FLAGS
;
4044 if (strcmp (name
, ".idata$2") == 0)
4048 else if (strcmp (name
, ".idata$3") == 0)
4052 else if (strcmp (name
, ".idata$4") == 0)
4056 else if (strcmp (name
, ".idata$5") == 0)
4060 else if (strcmp (name
, ".idata$6") == 0)
4065 /* Default alignment to 16 byte boundary. */
4068 if (*input_line_pointer
== ',')
4070 ++input_line_pointer
;
4072 if (*input_line_pointer
!= '"')
4073 exp
= get_absolute_expression ();
4076 ++input_line_pointer
;
4077 while (*input_line_pointer
!= '"'
4078 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
4080 switch (*input_line_pointer
)
4082 /* Section Contents */
4083 case 'a': /* unknown */
4084 as_bad (_("Unsupported section attribute -- 'a'"));
4086 case 'c': /* code section */
4089 case 'd': /* section has initialized data */
4092 case 'u': /* section has uninitialized data */
4093 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4097 case 'i': /* section contains directives (info) */
4098 /* FIXME: This is IMAGE_SCN_LNK_INFO
4100 flags
|= SEC_HAS_CONTENTS
;
4102 case 'n': /* section can be discarded */
4105 case 'R': /* Remove section at link time */
4106 flags
|= SEC_NEVER_LOAD
;
4109 /* Section Protection */
4110 case 'r': /* section is readable */
4111 flags
|= IMAGE_SCN_MEM_READ
;
4113 case 'w': /* section is writeable */
4114 flags
|= IMAGE_SCN_MEM_WRITE
;
4116 case 'x': /* section is executable */
4117 flags
|= IMAGE_SCN_MEM_EXECUTE
;
4119 case 's': /* section is sharable */
4120 flags
|= IMAGE_SCN_MEM_SHARED
;
4123 /* Section Alignment */
4124 case '0': /* align to byte boundary */
4125 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
4128 case '1': /* align to halfword boundary */
4129 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
4132 case '2': /* align to word boundary */
4133 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
4136 case '3': /* align to doubleword boundary */
4137 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
4140 case '4': /* align to quadword boundary */
4141 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
4144 case '5': /* align to 32 byte boundary */
4145 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
4148 case '6': /* align to 64 byte boundary */
4149 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
4154 as_bad (_("unknown section attribute '%c'"),
4155 *input_line_pointer
);
4158 ++input_line_pointer
;
4160 if (*input_line_pointer
== '"')
4161 ++input_line_pointer
;
4165 sec
= subseg_new (name
, (subsegT
) exp
);
4167 ppc_set_current_section (sec
);
4169 if (flags
!= SEC_NO_FLAGS
)
4171 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
4172 as_bad (_("error setting flags for \"%s\": %s"),
4173 bfd_section_name (stdoutput
, sec
),
4174 bfd_errmsg (bfd_get_error ()));
4177 bfd_set_section_alignment (stdoutput
, sec
, align
);
4182 ppc_pe_function (ignore
)
4183 int ignore ATTRIBUTE_UNUSED
;
4189 name
= input_line_pointer
;
4190 endc
= get_symbol_end ();
4192 ext_sym
= symbol_find_or_make (name
);
4194 *input_line_pointer
= endc
;
4196 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
4197 SF_SET_FUNCTION (ext_sym
);
4198 SF_SET_PROCESS (ext_sym
);
4199 coff_add_linesym (ext_sym
);
4201 demand_empty_rest_of_line ();
4205 ppc_pe_tocd (ignore
)
4206 int ignore ATTRIBUTE_UNUSED
;
4208 if (tocdata_section
== 0)
4210 tocdata_section
= subseg_new (".tocd", 0);
4211 /* FIXME: section flags won't work. */
4212 bfd_set_section_flags (stdoutput
, tocdata_section
,
4213 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
4214 | SEC_READONLY
| SEC_DATA
));
4216 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
4220 rdata_section
= subseg_new (".tocd", 0);
4223 ppc_set_current_section (tocdata_section
);
4225 demand_empty_rest_of_line ();
4228 /* Don't adjust TOC relocs to use the section symbol. */
4231 ppc_pe_fix_adjustable (fix
)
4234 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
4241 /* XCOFF specific symbol and file handling. */
4243 /* Canonicalize the symbol name. We use the to force the suffix, if
4244 any, to use square brackets, and to be in upper case. */
4247 ppc_canonicalize_symbol_name (name
)
4252 if (ppc_stab_symbol
)
4255 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
4269 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
4272 if (*s
== '\0' || s
[1] != '\0')
4273 as_bad (_("bad symbol suffix"));
4281 /* Set the class of a symbol based on the suffix, if any. This is
4282 called whenever a new symbol is created. */
4285 ppc_symbol_new_hook (sym
)
4288 struct ppc_tc_sy
*tc
;
4291 tc
= symbol_get_tc (sym
);
4295 tc
->real_name
= NULL
;
4301 if (ppc_stab_symbol
)
4304 s
= strchr (S_GET_NAME (sym
), '[');
4305 if (s
== (const char *) NULL
)
4307 /* There is no suffix. */
4316 if (strcmp (s
, "BS]") == 0)
4320 if (strcmp (s
, "DB]") == 0)
4322 else if (strcmp (s
, "DS]") == 0)
4326 if (strcmp (s
, "GL]") == 0)
4330 if (strcmp (s
, "PR]") == 0)
4334 if (strcmp (s
, "RO]") == 0)
4336 else if (strcmp (s
, "RW]") == 0)
4340 if (strcmp (s
, "SV]") == 0)
4344 if (strcmp (s
, "TC]") == 0)
4346 else if (strcmp (s
, "TI]") == 0)
4348 else if (strcmp (s
, "TB]") == 0)
4350 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
4351 tc
->class = XMC_TC0
;
4354 if (strcmp (s
, "UA]") == 0)
4356 else if (strcmp (s
, "UC]") == 0)
4360 if (strcmp (s
, "XO]") == 0)
4365 if (tc
->class == -1)
4366 as_bad (_("Unrecognized symbol suffix"));
4369 /* Set the class of a label based on where it is defined. This
4370 handles symbols without suffixes. Also, move the symbol so that it
4371 follows the csect symbol. */
4374 ppc_frob_label (sym
)
4377 if (ppc_current_csect
!= (symbolS
*) NULL
)
4379 if (symbol_get_tc (sym
)->class == -1)
4380 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4382 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4383 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4384 &symbol_rootP
, &symbol_lastP
);
4385 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4389 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4390 seen. It tells ppc_adjust_symtab whether it needs to look through
4393 static boolean ppc_saw_abs
;
4395 /* Change the name of a symbol just before writing it out. Set the
4396 real name if the .rename pseudo-op was used. Otherwise, remove any
4397 class suffix. Return 1 if the symbol should not be included in the
4401 ppc_frob_symbol (sym
)
4404 static symbolS
*ppc_last_function
;
4405 static symbolS
*set_end
;
4407 /* Discard symbols that should not be included in the output symbol
4409 if (! symbol_used_in_reloc_p (sym
)
4410 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4411 || (! S_IS_EXTERNAL (sym
)
4412 && ! symbol_get_tc (sym
)->output
4413 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4416 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4417 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4423 name
= S_GET_NAME (sym
);
4424 s
= strchr (name
, '[');
4425 if (s
!= (char *) NULL
)
4431 snew
= xmalloc (len
+ 1);
4432 memcpy (snew
, name
, len
);
4435 S_SET_NAME (sym
, snew
);
4439 if (set_end
!= (symbolS
*) NULL
)
4441 SA_SET_SYM_ENDNDX (set_end
, sym
);
4445 if (SF_GET_FUNCTION (sym
))
4447 if (ppc_last_function
!= (symbolS
*) NULL
)
4448 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4449 ppc_last_function
= sym
;
4450 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4452 resolve_symbol_value (symbol_get_tc (sym
)->size
);
4453 SA_SET_SYM_FSIZE (sym
,
4454 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4457 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4458 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4460 if (ppc_last_function
== (symbolS
*) NULL
)
4461 as_bad (_(".ef with no preceding .function"));
4464 set_end
= ppc_last_function
;
4465 ppc_last_function
= NULL
;
4467 /* We don't have a C_EFCN symbol, but we need to force the
4468 COFF backend to believe that it has seen one. */
4469 coff_last_function
= NULL
;
4473 if (! S_IS_EXTERNAL (sym
)
4474 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4475 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4476 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4477 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4478 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4479 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4480 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4481 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4482 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4483 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4485 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4486 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4489 union internal_auxent
*a
;
4491 /* Create a csect aux. */
4492 i
= S_GET_NUMBER_AUXILIARY (sym
);
4493 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4494 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4495 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4497 /* This is the TOC table. */
4498 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4499 a
->x_csect
.x_scnlen
.l
= 0;
4500 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4502 else if (symbol_get_tc (sym
)->subseg
!= 0)
4504 /* This is a csect symbol. x_scnlen is the size of the
4506 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4507 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4508 S_GET_SEGMENT (sym
))
4509 - S_GET_VALUE (sym
));
4512 resolve_symbol_value (symbol_get_tc (sym
)->next
);
4513 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4514 - S_GET_VALUE (sym
));
4516 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4518 else if (S_GET_SEGMENT (sym
) == bss_section
)
4520 /* This is a common symbol. */
4521 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4522 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4523 if (S_IS_EXTERNAL (sym
))
4524 symbol_get_tc (sym
)->class = XMC_RW
;
4526 symbol_get_tc (sym
)->class = XMC_BS
;
4528 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4530 /* This is an absolute symbol. The csect will be created by
4531 ppc_adjust_symtab. */
4533 a
->x_csect
.x_smtyp
= XTY_LD
;
4534 if (symbol_get_tc (sym
)->class == -1)
4535 symbol_get_tc (sym
)->class = XMC_XO
;
4537 else if (! S_IS_DEFINED (sym
))
4539 /* This is an external symbol. */
4540 a
->x_csect
.x_scnlen
.l
= 0;
4541 a
->x_csect
.x_smtyp
= XTY_ER
;
4543 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4547 /* This is a TOC definition. x_scnlen is the size of the
4549 next
= symbol_next (sym
);
4550 while (symbol_get_tc (next
)->class == XMC_TC0
)
4551 next
= symbol_next (next
);
4552 if (next
== (symbolS
*) NULL
4553 || symbol_get_tc (next
)->class != XMC_TC
)
4555 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4556 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4558 - S_GET_VALUE (sym
));
4560 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4561 - S_GET_VALUE (sym
));
4565 resolve_symbol_value (next
);
4566 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4567 - S_GET_VALUE (sym
));
4569 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4575 /* This is a normal symbol definition. x_scnlen is the
4576 symbol index of the containing csect. */
4577 if (S_GET_SEGMENT (sym
) == text_section
)
4578 csect
= ppc_text_csects
;
4579 else if (S_GET_SEGMENT (sym
) == data_section
)
4580 csect
= ppc_data_csects
;
4584 /* Skip the initial dummy symbol. */
4585 csect
= symbol_get_tc (csect
)->next
;
4587 if (csect
== (symbolS
*) NULL
)
4589 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4590 a
->x_csect
.x_scnlen
.l
= 0;
4594 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4596 resolve_symbol_value (symbol_get_tc (csect
)->next
);
4597 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4598 > S_GET_VALUE (sym
))
4600 csect
= symbol_get_tc (csect
)->next
;
4603 a
->x_csect
.x_scnlen
.p
=
4604 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4605 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4608 a
->x_csect
.x_smtyp
= XTY_LD
;
4611 a
->x_csect
.x_parmhash
= 0;
4612 a
->x_csect
.x_snhash
= 0;
4613 if (symbol_get_tc (sym
)->class == -1)
4614 a
->x_csect
.x_smclas
= XMC_PR
;
4616 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4617 a
->x_csect
.x_stab
= 0;
4618 a
->x_csect
.x_snstab
= 0;
4620 /* Don't let the COFF backend resort these symbols. */
4621 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4623 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4625 /* We want the value to be the symbol index of the referenced
4626 csect symbol. BFD will do that for us if we set the right
4630 coffsymbol (symbol_get_bfdsym
4631 (symbol_get_tc (sym
)->within
))->native
));
4632 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4634 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4639 /* The value is the offset from the enclosing csect. */
4640 block
= symbol_get_tc (sym
)->within
;
4641 csect
= symbol_get_tc (block
)->within
;
4642 resolve_symbol_value (csect
);
4643 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4645 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4646 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4648 /* We want the value to be a file offset into the line numbers.
4649 BFD will do that for us if we set the right flags. We have
4650 already set the value correctly. */
4651 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4657 /* Adjust the symbol table. This creates csect symbols for all
4658 absolute symbols. */
4661 ppc_adjust_symtab ()
4668 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
4672 union internal_auxent
*a
;
4674 if (S_GET_SEGMENT (sym
) != absolute_section
)
4677 csect
= symbol_create (".abs[XO]", absolute_section
,
4678 S_GET_VALUE (sym
), &zero_address_frag
);
4679 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
4680 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
4681 i
= S_GET_NUMBER_AUXILIARY (csect
);
4682 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
4683 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
4684 a
->x_csect
.x_scnlen
.l
= 0;
4685 a
->x_csect
.x_smtyp
= XTY_SD
;
4686 a
->x_csect
.x_parmhash
= 0;
4687 a
->x_csect
.x_snhash
= 0;
4688 a
->x_csect
.x_smclas
= XMC_XO
;
4689 a
->x_csect
.x_stab
= 0;
4690 a
->x_csect
.x_snstab
= 0;
4692 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
4694 i
= S_GET_NUMBER_AUXILIARY (sym
);
4695 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
4696 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
4697 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
4700 ppc_saw_abs
= false;
4703 /* Set the VMA for a section. This is called on all the sections in
4707 ppc_frob_section (sec
)
4710 static bfd_size_type vma
= 0;
4712 bfd_set_section_vma (stdoutput
, sec
, vma
);
4713 vma
+= bfd_section_size (stdoutput
, sec
);
4716 #endif /* OBJ_XCOFF */
4718 /* Turn a string in input_line_pointer into a floating point constant
4719 of type TYPE, and store the appropriate bytes in *LITP. The number
4720 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4721 returned, or NULL on OK. */
4724 md_atof (type
, litp
, sizep
)
4730 LITTLENUM_TYPE words
[4];
4746 return _("bad call to md_atof");
4749 t
= atof_ieee (input_line_pointer
, type
, words
);
4751 input_line_pointer
= t
;
4755 if (target_big_endian
)
4757 for (i
= 0; i
< prec
; i
++)
4759 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4765 for (i
= prec
- 1; i
>= 0; i
--)
4767 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4775 /* Write a value out to the object file, using the appropriate
4779 md_number_to_chars (buf
, val
, n
)
4784 if (target_big_endian
)
4785 number_to_chars_bigendian (buf
, val
, n
);
4787 number_to_chars_littleendian (buf
, val
, n
);
4790 /* Align a section (I don't know why this is machine dependent). */
4793 md_section_align (seg
, addr
)
4797 int align
= bfd_get_section_alignment (stdoutput
, seg
);
4799 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
4802 /* We don't have any form of relaxing. */
4805 md_estimate_size_before_relax (fragp
, seg
)
4806 fragS
*fragp ATTRIBUTE_UNUSED
;
4807 asection
*seg ATTRIBUTE_UNUSED
;
4813 /* Convert a machine dependent frag. We never generate these. */
4816 md_convert_frag (abfd
, sec
, fragp
)
4817 bfd
*abfd ATTRIBUTE_UNUSED
;
4818 asection
*sec ATTRIBUTE_UNUSED
;
4819 fragS
*fragp ATTRIBUTE_UNUSED
;
4824 /* We have no need to default values of symbols. */
4827 md_undefined_symbol (name
)
4828 char *name ATTRIBUTE_UNUSED
;
4833 /* Functions concerning relocs. */
4835 /* The location from which a PC relative jump should be calculated,
4836 given a PC relative reloc. */
4839 md_pcrel_from_section (fixp
, sec
)
4841 segT sec ATTRIBUTE_UNUSED
;
4843 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4848 /* This is called to see whether a fixup should be adjusted to use a
4849 section symbol. We take the opportunity to change a fixup against
4850 a symbol in the TOC subsegment into a reloc against the
4851 corresponding .tc symbol. */
4854 ppc_fix_adjustable (fix
)
4859 resolve_symbol_value (fix
->fx_addsy
);
4860 val
= S_GET_VALUE (fix
->fx_addsy
);
4861 if (ppc_toc_csect
!= (symbolS
*) NULL
4862 && fix
->fx_addsy
!= (symbolS
*) NULL
4863 && fix
->fx_addsy
!= ppc_toc_csect
4864 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
4865 && val
>= ppc_toc_frag
->fr_address
4866 && (ppc_after_toc_frag
== (fragS
*) NULL
4867 || val
< ppc_after_toc_frag
->fr_address
))
4871 for (sy
= symbol_next (ppc_toc_csect
);
4872 sy
!= (symbolS
*) NULL
;
4873 sy
= symbol_next (sy
))
4875 if (symbol_get_tc (sy
)->class == XMC_TC0
)
4877 if (symbol_get_tc (sy
)->class != XMC_TC
)
4879 resolve_symbol_value (sy
);
4880 if (val
== S_GET_VALUE (sy
))
4883 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
4888 as_bad_where (fix
->fx_file
, fix
->fx_line
,
4889 _("symbol in .toc does not match any .tc"));
4892 /* Possibly adjust the reloc to be against the csect. */
4893 if (fix
->fx_addsy
!= (symbolS
*) NULL
4894 && symbol_get_tc (fix
->fx_addsy
)->subseg
== 0
4895 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC0
4896 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC
4897 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
4898 /* Don't adjust if this is a reloc in the toc section. */
4899 && (S_GET_SEGMENT (fix
->fx_addsy
) != data_section
4900 || ppc_toc_csect
== NULL
4901 || val
< ppc_toc_frag
->fr_address
4902 || (ppc_after_toc_frag
!= NULL
4903 && val
>= ppc_after_toc_frag
->fr_address
)))
4907 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
4908 csect
= ppc_text_csects
;
4909 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
4910 csect
= ppc_data_csects
;
4914 /* Skip the initial dummy symbol. */
4915 csect
= symbol_get_tc (csect
)->next
;
4917 if (csect
!= (symbolS
*) NULL
)
4919 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
4920 && (symbol_get_frag (symbol_get_tc (csect
)->next
)->fr_address
4923 /* If the csect address equals the symbol value, then we
4924 have to look through the full symbol table to see
4925 whether this is the csect we want. Note that we will
4926 only get here if the csect has zero length. */
4927 if ((symbol_get_frag (csect
)->fr_address
== val
)
4928 && S_GET_VALUE (csect
) == S_GET_VALUE (fix
->fx_addsy
))
4932 for (scan
= symbol_next (csect
);
4934 scan
= symbol_next (scan
))
4936 if (symbol_get_tc (scan
)->subseg
!= 0)
4938 if (scan
== fix
->fx_addsy
)
4942 /* If we found the symbol before the next csect
4943 symbol, then this is the csect we want. */
4944 if (scan
== fix
->fx_addsy
)
4948 csect
= symbol_get_tc (csect
)->next
;
4951 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
4952 - symbol_get_frag (csect
)->fr_address
);
4953 fix
->fx_addsy
= csect
;
4957 /* Adjust a reloc against a .lcomm symbol to be against the base
4959 if (fix
->fx_addsy
!= (symbolS
*) NULL
4960 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
4961 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
4963 resolve_symbol_value (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
);
4965 (S_GET_VALUE (fix
->fx_addsy
)
4966 - S_GET_VALUE (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
));
4967 fix
->fx_addsy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
4973 /* A reloc from one csect to another must be kept. The assembler
4974 will, of course, keep relocs between sections, and it will keep
4975 absolute relocs, but we need to force it to keep PC relative relocs
4976 between two csects in the same section. */
4979 ppc_force_relocation (fix
)
4982 /* At this point fix->fx_addsy should already have been converted to
4983 a csect symbol. If the csect does not include the fragment, then
4984 we need to force the relocation. */
4986 && fix
->fx_addsy
!= NULL
4987 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
4988 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
4989 > fix
->fx_frag
->fr_address
)
4990 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
4991 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
4992 <= fix
->fx_frag
->fr_address
))))
4998 #endif /* OBJ_XCOFF */
5002 ppc_fix_adjustable (fix
)
5005 return (fix
->fx_r_type
!= BFD_RELOC_16_GOTOFF
5006 && fix
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
5007 && fix
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
5008 && fix
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
5009 && fix
->fx_r_type
!= BFD_RELOC_GPREL16
5010 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
5011 && fix
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
5012 && ! S_IS_EXTERNAL (fix
->fx_addsy
)
5013 && ! S_IS_WEAK (fix
->fx_addsy
)
5015 || (fix
->fx_subsy
!= NULL
5016 && (S_GET_SEGMENT (fix
->fx_subsy
)
5017 == S_GET_SEGMENT (fix
->fx_addsy
)))
5018 || S_IS_LOCAL (fix
->fx_addsy
)));
5022 /* Apply a fixup to the object code. This is called for all the
5023 fixups we generated by the call to fix_new_exp, above. In the call
5024 above we used a reloc code which was the largest legal reloc code
5025 plus the operand index. Here we undo that to recover the operand
5026 index. At this point all symbol values should be fully resolved,
5027 and we attempt to completely resolve the reloc. If we can not do
5028 that, we determine the correct reloc code and put it back in the
5032 md_apply_fix3 (fixp
, valuep
, seg
)
5035 segT seg ATTRIBUTE_UNUSED
;
5041 if (fixp
->fx_addsy
!= NULL
)
5043 /* `*valuep' may contain the value of the symbol on which the reloc
5044 will be based; we have to remove it. */
5045 if (symbol_used_in_reloc_p (fixp
->fx_addsy
)
5046 && S_GET_SEGMENT (fixp
->fx_addsy
) != absolute_section
5047 && S_GET_SEGMENT (fixp
->fx_addsy
) != undefined_section
5048 && ! bfd_is_com_section (S_GET_SEGMENT (fixp
->fx_addsy
)))
5049 value
-= S_GET_VALUE (fixp
->fx_addsy
);
5051 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
5052 supposed to be? I think this is related to various similar
5053 FIXMEs in tc-i386.c and tc-sparc.c. */
5055 value
+= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5062 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
5063 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5064 doing this relocation the code in write.c is going to call
5065 bfd_install_relocation, which is also going to use the symbol
5066 value. That means that if the reloc is fully resolved we want to
5067 use *valuep since bfd_install_relocation is not being used.
5068 However, if the reloc is not fully resolved we do not want to use
5069 *valuep, and must use fx_offset instead. However, if the reloc
5070 is PC relative, we do want to use *valuep since it includes the
5071 result of md_pcrel_from. This is confusing. */
5072 if (fixp
->fx_addsy
== (symbolS
*) NULL
)
5077 else if (fixp
->fx_pcrel
)
5081 value
= fixp
->fx_offset
;
5082 if (fixp
->fx_subsy
!= (symbolS
*) NULL
)
5084 if (S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
5085 value
-= S_GET_VALUE (fixp
->fx_subsy
);
5088 /* We can't actually support subtracting a symbol. */
5089 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5090 _("expression too complex"));
5096 if ((int) fixp
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
5099 const struct powerpc_operand
*operand
;
5103 opindex
= (int) fixp
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
5105 operand
= &powerpc_operands
[opindex
];
5108 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5109 does not generate a reloc. It uses the offset of `sym' within its
5110 csect. Other usages, such as `.long sym', generate relocs. This
5111 is the documented behaviour of non-TOC symbols. */
5112 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5113 && operand
->bits
== 16
5114 && operand
->shift
== 0
5115 && operand
->insert
== NULL
5116 && fixp
->fx_addsy
!= NULL
5117 && symbol_get_tc (fixp
->fx_addsy
)->subseg
!= 0
5118 && symbol_get_tc (fixp
->fx_addsy
)->class != XMC_TC
5119 && symbol_get_tc (fixp
->fx_addsy
)->class != XMC_TC0
5120 && S_GET_SEGMENT (fixp
->fx_addsy
) != bss_section
)
5122 value
= fixp
->fx_offset
;
5127 /* Fetch the instruction, insert the fully resolved operand
5128 value, and stuff the instruction back again. */
5129 where
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
5130 if (target_big_endian
)
5131 insn
= bfd_getb32 ((unsigned char *) where
);
5133 insn
= bfd_getl32 ((unsigned char *) where
);
5134 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
5135 fixp
->fx_file
, fixp
->fx_line
);
5136 if (target_big_endian
)
5137 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5139 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5143 /* Nothing else to do here. */
5147 assert (fixp
->fx_addsy
!= NULL
);
5149 /* Determine a BFD reloc value based on the operand information.
5150 We are only prepared to turn a few of the operands into
5152 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5153 && operand
->bits
== 26
5154 && operand
->shift
== 0)
5155 fixp
->fx_r_type
= BFD_RELOC_PPC_B26
;
5156 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
5157 && operand
->bits
== 16
5158 && operand
->shift
== 0)
5159 fixp
->fx_r_type
= BFD_RELOC_PPC_B16
;
5160 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5161 && operand
->bits
== 26
5162 && operand
->shift
== 0)
5163 fixp
->fx_r_type
= BFD_RELOC_PPC_BA26
;
5164 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
5165 && operand
->bits
== 16
5166 && operand
->shift
== 0)
5167 fixp
->fx_r_type
= BFD_RELOC_PPC_BA16
;
5168 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5169 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
5170 && operand
->bits
== 16
5171 && operand
->shift
== 0
5172 && ppc_is_toc_sym (fixp
->fx_addsy
))
5174 fixp
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
5176 if (BFD_DEFAULT_TARGET_SIZE
== 64
5177 && (operand
->flags
& PPC_OPERAND_DS
) != 0)
5178 fixp
->fx_r_type
= BFD_RELOC_PPC64_TOC16_DS
;
5181 if (target_big_endian
)
5182 fixp
->fx_where
+= 2;
5184 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5190 /* Use expr_symbol_where to see if this is an expression
5192 if (expr_symbol_where (fixp
->fx_addsy
, &sfile
, &sline
))
5193 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5194 _("unresolved expression that must be resolved"));
5196 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5197 _("unsupported relocation against %s"),
5198 S_GET_NAME (fixp
->fx_addsy
));
5206 ppc_elf_validate_fix (fixp
, seg
);
5208 switch (fixp
->fx_r_type
)
5210 case BFD_RELOC_CTOR
:
5211 /* FIXME: 32 bits even for 64-bit targets? */
5214 fixp
->fx_r_type
= BFD_RELOC_32_PCREL
;
5218 case BFD_RELOC_32_PCREL
:
5219 case BFD_RELOC_32_BASEREL
:
5220 case BFD_RELOC_PPC_EMB_NADDR32
:
5221 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5227 fixp
->fx_r_type
= BFD_RELOC_64_PCREL
;
5230 case BFD_RELOC_64_PCREL
:
5231 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5235 case BFD_RELOC_LO16
:
5237 case BFD_RELOC_GPREL16
:
5238 case BFD_RELOC_16_GOT_PCREL
:
5239 case BFD_RELOC_16_GOTOFF
:
5240 case BFD_RELOC_LO16_GOTOFF
:
5241 case BFD_RELOC_HI16_GOTOFF
:
5242 case BFD_RELOC_HI16_S_GOTOFF
:
5243 case BFD_RELOC_LO16_BASEREL
:
5244 case BFD_RELOC_HI16_BASEREL
:
5245 case BFD_RELOC_HI16_S_BASEREL
:
5246 case BFD_RELOC_PPC_EMB_NADDR16
:
5247 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
5248 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
5249 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
5250 case BFD_RELOC_PPC_EMB_SDAI16
:
5251 case BFD_RELOC_PPC_EMB_SDA2REL
:
5252 case BFD_RELOC_PPC_EMB_SDA2I16
:
5253 case BFD_RELOC_PPC_EMB_RELSEC16
:
5254 case BFD_RELOC_PPC_EMB_RELST_LO
:
5255 case BFD_RELOC_PPC_EMB_RELST_HI
:
5256 case BFD_RELOC_PPC_EMB_RELST_HA
:
5257 case BFD_RELOC_PPC_EMB_RELSDA
:
5258 case BFD_RELOC_PPC_TOC16
:
5260 #if BFD_DEFAULT_TARGET_SIZE == 64
5261 case BFD_RELOC_PPC64_TOC16_LO
:
5262 case BFD_RELOC_PPC64_TOC16_HI
:
5263 case BFD_RELOC_PPC64_TOC16_HA
:
5268 if (fixp
->fx_addsy
!= NULL
)
5269 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5270 _("cannot emit PC relative %s relocation against %s"),
5271 bfd_get_reloc_code_name (fixp
->fx_r_type
),
5272 S_GET_NAME (fixp
->fx_addsy
));
5274 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5275 _("cannot emit PC relative %s relocation"),
5276 bfd_get_reloc_code_name (fixp
->fx_r_type
));
5279 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5283 /* This case happens when you write, for example,
5285 where L1 and L2 are defined later. */
5286 case BFD_RELOC_HI16
:
5289 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5293 case BFD_RELOC_HI16_S
:
5296 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5301 #if BFD_DEFAULT_TARGET_SIZE == 64
5302 case BFD_RELOC_PPC64_HIGHER
:
5305 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5306 PPC_HIGHER (value
), 2);
5309 case BFD_RELOC_PPC64_HIGHER_S
:
5312 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5313 PPC_HIGHERA (value
), 2);
5316 case BFD_RELOC_PPC64_HIGHEST
:
5319 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5320 PPC_HIGHEST (value
), 2);
5323 case BFD_RELOC_PPC64_HIGHEST_S
:
5326 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5327 PPC_HIGHESTA (value
), 2);
5330 case BFD_RELOC_PPC64_ADDR16_DS
:
5331 case BFD_RELOC_PPC64_ADDR16_LO_DS
:
5332 case BFD_RELOC_PPC64_GOT16_DS
:
5333 case BFD_RELOC_PPC64_GOT16_LO_DS
:
5334 case BFD_RELOC_PPC64_PLT16_LO_DS
:
5335 case BFD_RELOC_PPC64_SECTOFF_DS
:
5336 case BFD_RELOC_PPC64_SECTOFF_LO_DS
:
5337 case BFD_RELOC_PPC64_TOC16_DS
:
5338 case BFD_RELOC_PPC64_TOC16_LO_DS
:
5339 case BFD_RELOC_PPC64_PLTGOT16_DS
:
5340 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
:
5344 unsigned char *where
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
5347 if (target_big_endian
)
5348 val
= bfd_getb16 (where
);
5350 val
= bfd_getl16 (where
);
5351 val
|= (value
& 0xfffc);
5352 if (target_big_endian
)
5353 bfd_putb16 ((bfd_vma
) val
, where
);
5355 bfd_putl16 ((bfd_vma
) val
, where
);
5360 /* Because SDA21 modifies the register field, the size is set to 4
5361 bytes, rather than 2, so offset it here appropriately. */
5362 case BFD_RELOC_PPC_EMB_SDA21
:
5366 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
5367 + ((target_big_endian
) ? 2 : 0),
5375 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
5379 case BFD_RELOC_24_PLT_PCREL
:
5380 case BFD_RELOC_PPC_LOCAL24PC
:
5381 if (!fixp
->fx_pcrel
&& !fixp
->fx_done
)
5389 /* Fetch the instruction, insert the fully resolved operand
5390 value, and stuff the instruction back again. */
5391 where
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
5392 if (target_big_endian
)
5393 insn
= bfd_getb32 ((unsigned char *) where
);
5395 insn
= bfd_getl32 ((unsigned char *) where
);
5396 if ((value
& 3) != 0)
5397 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5398 _("must branch to an address a multiple of 4"));
5399 if ((offsetT
) value
< -0x40000000
5400 || (offsetT
) value
>= 0x40000000)
5401 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5402 _("@local or @plt branch destination is too far away, %ld bytes"),
5404 insn
= insn
| (value
& 0x03fffffc);
5405 if (target_big_endian
)
5406 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
5408 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
5412 case BFD_RELOC_VTABLE_INHERIT
:
5415 && !S_IS_DEFINED (fixp
->fx_addsy
)
5416 && !S_IS_WEAK (fixp
->fx_addsy
))
5417 S_SET_WEAK (fixp
->fx_addsy
);
5420 case BFD_RELOC_VTABLE_ENTRY
:
5425 #if BFD_DEFAULT_TARGET_SIZE == 64
5426 /* Generated by reference to `sym@tocbase'. The sym is
5427 ignored by the linker. */
5428 case BFD_RELOC_PPC64_TOC
:
5435 _("Gas failure, reloc value %d\n"), fixp
->fx_r_type
);
5442 fixp
->fx_addnumber
= value
;
5444 if (fixp
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
5445 fixp
->fx_addnumber
= 0;
5449 fixp
->fx_addnumber
= 0;
5451 /* We want to use the offset within the data segment of the
5452 symbol, not the actual VMA of the symbol. */
5453 fixp
->fx_addnumber
=
5454 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixp
->fx_addsy
));
5462 /* Generate a reloc for a fixup. */
5465 tc_gen_reloc (seg
, fixp
)
5466 asection
*seg ATTRIBUTE_UNUSED
;
5471 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5473 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5474 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5475 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5476 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5477 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5479 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5480 _("reloc %d not supported by object file format"),
5481 (int) fixp
->fx_r_type
);
5484 reloc
->addend
= fixp
->fx_addnumber
;