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) PPC_HI ((v) + 0x8000)
70 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
71 #define PPC_HIGHER(v) (((v) >> 32) & 0xffff)
73 /* #highera(value) denotes bits 32 through 47 of the indicated value,
74 compensating for #lo() being treated as a signed number. */
75 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
77 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
78 #define PPC_HIGHEST(v) (((v) >> 48) & 0xffff)
80 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
81 compensating for #lo being treated as a signed number. */
82 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
84 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
86 static boolean reg_names_p = TARGET_REG_NAMES_P;
88 static boolean register_name PARAMS ((expressionS *));
89 static void ppc_set_cpu PARAMS ((void));
90 static unsigned long ppc_insert_operand
91 PARAMS ((unsigned long insn, const struct powerpc_operand *operand,
92 offsetT val, char *file, unsigned int line));
93 static void ppc_macro PARAMS ((char *str, const struct powerpc_macro *macro));
94 static void ppc_byte PARAMS ((int));
96 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
97 static int ppc_is_toc_sym PARAMS ((symbolS *sym));
98 static void ppc_tc PARAMS ((int));
99 static void ppc_machine PARAMS ((int));
103 static void ppc_comm PARAMS ((int));
104 static void ppc_bb PARAMS ((int));
105 static void ppc_bc PARAMS ((int));
106 static void ppc_bf PARAMS ((int));
107 static void ppc_biei PARAMS ((int));
108 static void ppc_bs PARAMS ((int));
109 static void ppc_eb PARAMS ((int));
110 static void ppc_ec PARAMS ((int));
111 static void ppc_ef PARAMS ((int));
112 static void ppc_es PARAMS ((int));
113 static void ppc_csect PARAMS ((int));
114 static void ppc_change_csect PARAMS ((symbolS *));
115 static void ppc_function PARAMS ((int));
116 static void ppc_extern PARAMS ((int));
117 static void ppc_lglobl PARAMS ((int));
118 static void ppc_section PARAMS ((int));
119 static void ppc_named_section PARAMS ((int));
120 static void ppc_stabx PARAMS ((int));
121 static void ppc_rename PARAMS ((int));
122 static void ppc_toc PARAMS ((int));
123 static void ppc_xcoff_cons PARAMS ((int));
124 static void ppc_vbyte PARAMS ((int));
128 static bfd_reloc_code_real_type ppc_elf_suffix PARAMS ((char **, expressionS *));
129 static void ppc_elf_cons PARAMS ((int));
130 static void ppc_elf_rdata PARAMS ((int));
131 static void ppc_elf_lcomm PARAMS ((int));
132 static void ppc_elf_validate_fix PARAMS ((fixS *, segT));
136 static void ppc_set_current_section PARAMS ((segT));
137 static void ppc_previous PARAMS ((int));
138 static void ppc_pdata PARAMS ((int));
139 static void ppc_ydata PARAMS ((int));
140 static void ppc_reldata PARAMS ((int));
141 static void ppc_rdata PARAMS ((int));
142 static void ppc_ualong PARAMS ((int));
143 static void ppc_znop PARAMS ((int));
144 static void ppc_pe_comm PARAMS ((int));
145 static void ppc_pe_section PARAMS ((int));
146 static void ppc_pe_function PARAMS ((int));
147 static void ppc_pe_tocd PARAMS ((int));
150 /* Generic assembler global variables which must be defined by all
154 /* This string holds the chars that always start a comment. If the
155 pre-processor is disabled, these aren't very useful. The macro
156 tc_comment_chars points to this. We use this, rather than the
157 usual comment_chars, so that we can switch for Solaris conventions. */
158 static const char ppc_solaris_comment_chars[] = "#!";
159 static const char ppc_eabi_comment_chars[] = "#";
161 #ifdef TARGET_SOLARIS_COMMENT
162 const char *ppc_comment_chars = ppc_solaris_comment_chars;
164 const char *ppc_comment_chars = ppc_eabi_comment_chars;
167 const char comment_chars[] = "#";
170 /* Characters which start a comment at the beginning of a line. */
171 const char line_comment_chars[] = "#";
173 /* Characters which may be used to separate multiple commands on a
175 const char line_separator_chars[] = ";";
177 /* Characters which are used to indicate an exponent in a floating
179 const char EXP_CHARS[] = "eE";
181 /* Characters which mean that a number is a floating point constant,
183 const char FLT_CHARS[] = "dD";
185 /* The target specific pseudo-ops which we support. */
187 const pseudo_typeS md_pseudo_table[] =
189 /* Pseudo-ops which must be overridden. */
190 { "byte", ppc_byte, 0 },
193 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
194 legitimately belong in the obj-*.c file. However, XCOFF is based
195 on COFF, and is only implemented for the RS/6000. We just use
196 obj-coff.c, and add what we need here. */
197 { "comm", ppc_comm, 0 },
198 { "lcomm", ppc_comm, 1 },
202 { "bi", ppc_biei, 0 },
204 { "csect", ppc_csect, 0 },
205 { "data", ppc_section, 'd' },
209 { "ei", ppc_biei, 1 },
211 { "extern", ppc_extern, 0 },
212 { "function", ppc_function, 0 },
213 { "lglobl", ppc_lglobl, 0 },
214 { "rename", ppc_rename, 0 },
215 { "section", ppc_named_section, 0 },
216 { "stabx", ppc_stabx, 0 },
217 { "text", ppc_section, 't' },
218 { "toc", ppc_toc, 0 },
219 { "long", ppc_xcoff_cons, 2 },
220 { "llong", ppc_xcoff_cons, 3 },
221 { "word", ppc_xcoff_cons, 1 },
222 { "short", ppc_xcoff_cons, 1 },
223 { "vbyte", ppc_vbyte, 0 },
227 { "llong", ppc_elf_cons, 8 },
228 { "quad", ppc_elf_cons, 8 },
229 { "long", ppc_elf_cons, 4 },
230 { "word", ppc_elf_cons, 2 },
231 { "short", ppc_elf_cons, 2 },
232 { "rdata", ppc_elf_rdata, 0 },
233 { "rodata", ppc_elf_rdata, 0 },
234 { "lcomm", ppc_elf_lcomm, 0 },
235 { "file", dwarf2_directive_file, 0 },
236 { "loc", dwarf2_directive_loc, 0 },
240 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
241 { "previous", ppc_previous, 0 },
242 { "pdata", ppc_pdata, 0 },
243 { "ydata", ppc_ydata, 0 },
244 { "reldata", ppc_reldata, 0 },
245 { "rdata", ppc_rdata, 0 },
246 { "ualong", ppc_ualong, 0 },
247 { "znop", ppc_znop, 0 },
248 { "comm", ppc_pe_comm, 0 },
249 { "lcomm", ppc_pe_comm, 1 },
250 { "section", ppc_pe_section, 0 },
251 { "function", ppc_pe_function,0 },
252 { "tocd", ppc_pe_tocd, 0 },
255 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
257 { "machine", ppc_machine, 0 },
264 /* Predefined register names if -mregnames (or default for Windows NT).
265 In general, there are lots of them, in an attempt to be compatible
266 with a number of other Windows NT assemblers. */
268 /* Structure to hold information about predefined registers. */
275 /* List of registers that are pre-defined:
277 Each general register has predefined names of the form:
278 1. r<reg_num> which has the value <reg_num>.
279 2. r.<reg_num> which has the value <reg_num>.
281 Each floating point register has predefined names of the form:
282 1. f<reg_num> which has the value <reg_num>.
283 2. f.<reg_num> which has the value <reg_num>.
285 Each vector unit register has predefined names of the form:
286 1. v<reg_num> which has the value <reg_num>.
287 2. v.<reg_num> which has the value <reg_num>.
289 Each condition register has predefined names of the form:
290 1. cr<reg_num> which has the value <reg_num>.
291 2. cr.<reg_num> which has the value <reg_num>.
293 There are individual registers as well:
294 sp or r.sp has the value 1
295 rtoc or r.toc has the value 2
296 fpscr has the value 0
302 dsisr has the value 18
304 sdr1 has the value 25
305 srr0 has the value 26
306 srr1 has the value 27
308 The table is sorted. Suitable for searching by a binary search. */
310 static const struct pd_reg pre_defined_registers[] =
312 { "cr.0", 0 }, /* Condition Registers */
332 { "dar", 19 }, /* Data Access Register */
333 { "dec", 22 }, /* Decrementer */
334 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
336 { "f.0", 0 }, /* Floating point registers */
404 { "lr", 8 }, /* Link Register */
408 { "r.0", 0 }, /* General Purpose Registers */
441 { "r.sp", 1 }, /* Stack Pointer */
443 { "r.toc", 2 }, /* Pointer to the table of contents */
445 { "r0", 0 }, /* More general purpose registers */
478 { "rtoc", 2 }, /* Table of contents */
480 { "sdr1", 25 }, /* Storage Description Register 1 */
484 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
485 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
487 { "v.0", 0 }, /* Vector registers */
557 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
559 /* Given NAME, find the register number associated with that name, return
560 the integer value associated with the given name or -1 on failure. */
562 static int reg_name_search
563 PARAMS ((const struct pd_reg *, int, const char * name));
566 reg_name_search (regs, regcount, name)
567 const struct pd_reg *regs;
571 int middle, low, high;
579 middle = (low + high) / 2;
580 cmp = strcasecmp (name, regs[middle].name);
586 return regs[middle].value;
594 * Summary of register_name.
596 * in: Input_line_pointer points to 1st char of operand.
598 * out: A expressionS.
599 * The operand may have been a register: in this case, X_op == O_register,
600 * X_add_number is set to the register number, and truth is returned.
601 * Input_line_pointer->(next non-blank) char after operand, or is in its
606 register_name (expressionP)
607 expressionS *expressionP;
614 /* Find the spelling of the operand. */
615 start = name = input_line_pointer;
616 if (name[0] == '%' && ISALPHA (name[1]))
617 name = ++input_line_pointer;
619 else if (!reg_names_p || !ISALPHA (name[0]))
622 c = get_symbol_end ();
623 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
625 /* Put back the delimiting char. */
626 *input_line_pointer = c;
628 /* Look to see if it's in the register table. */
631 expressionP->X_op = O_register;
632 expressionP->X_add_number = reg_number;
634 /* Make the rest nice. */
635 expressionP->X_add_symbol = NULL;
636 expressionP->X_op_symbol = NULL;
640 /* Reset the line as if we had not done anything. */
641 input_line_pointer = start;
645 /* This function is called for each symbol seen in an expression. It
646 handles the special parsing which PowerPC assemblers are supposed
647 to use for condition codes. */
649 /* Whether to do the special parsing. */
650 static boolean cr_operand;
652 /* Names to recognize in a condition code. This table is sorted. */
653 static const struct pd_reg cr_names[] =
670 /* Parsing function. This returns non-zero if it recognized an
674 ppc_parse_name (name, expr)
683 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
688 expr->X_op = O_constant;
689 expr->X_add_number = val;
694 /* Local variables. */
696 /* The type of processor we are assembling for. This is one or more
697 of the PPC_OPCODE flags defined in opcode/ppc.h. */
698 static int ppc_cpu = 0;
700 /* The size of the processor we are assembling for. This is either
701 PPC_OPCODE_32 or PPC_OPCODE_64. */
702 static unsigned long ppc_size = (BFD_DEFAULT_TARGET_SIZE == 64
706 /* Whether to target xcoff64. */
707 static int ppc_xcoff64 = 0;
709 /* Opcode hash table. */
710 static struct hash_control *ppc_hash;
712 /* Macro hash table. */
713 static struct hash_control *ppc_macro_hash;
716 /* What type of shared library support to use. */
717 static enum { SHLIB_NONE, SHLIB_PIC, SHLIB_MRELOCATABLE } shlib = SHLIB_NONE;
719 /* Flags to set in the elf header. */
720 static flagword ppc_flags = 0;
722 /* Whether this is Solaris or not. */
723 #ifdef TARGET_SOLARIS_COMMENT
724 #define SOLARIS_P true
726 #define SOLARIS_P false
729 static boolean msolaris = SOLARIS_P;
734 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
735 using a bunch of different sections. These assembler sections,
736 however, are all encompassed within the .text or .data sections of
737 the final output file. We handle this by using different
738 subsegments within these main segments. */
740 /* Next subsegment to allocate within the .text segment. */
741 static subsegT ppc_text_subsegment = 2;
743 /* Linked list of csects in the text section. */
744 static symbolS *ppc_text_csects;
746 /* Next subsegment to allocate within the .data segment. */
747 static subsegT ppc_data_subsegment = 2;
749 /* Linked list of csects in the data section. */
750 static symbolS *ppc_data_csects;
752 /* The current csect. */
753 static symbolS *ppc_current_csect;
755 /* The RS/6000 assembler uses a TOC which holds addresses of functions
756 and variables. Symbols are put in the TOC with the .tc pseudo-op.
757 A special relocation is used when accessing TOC entries. We handle
758 the TOC as a subsegment within the .data segment. We set it up if
759 we see a .toc pseudo-op, and save the csect symbol here. */
760 static symbolS *ppc_toc_csect;
762 /* The first frag in the TOC subsegment. */
763 static fragS *ppc_toc_frag;
765 /* The first frag in the first subsegment after the TOC in the .data
766 segment. NULL if there are no subsegments after the TOC. */
767 static fragS *ppc_after_toc_frag;
769 /* The current static block. */
770 static symbolS *ppc_current_block;
772 /* The COFF debugging section; set by md_begin. This is not the
773 .debug section, but is instead the secret BFD section which will
774 cause BFD to set the section number of a symbol to N_DEBUG. */
775 static asection *ppc_coff_debug_section;
777 #endif /* OBJ_XCOFF */
781 /* Various sections that we need for PE coff support. */
782 static segT ydata_section;
783 static segT pdata_section;
784 static segT reldata_section;
785 static segT rdata_section;
786 static segT tocdata_section;
788 /* The current section and the previous section. See ppc_previous. */
789 static segT ppc_previous_section;
790 static segT ppc_current_section;
795 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
799 const char *const md_shortopts = "b:l:usm:K:VQ:";
801 const char *const md_shortopts = "um:";
803 const struct option md_longopts[] = {
804 {NULL, no_argument, NULL, 0}
806 const size_t md_longopts_size = sizeof (md_longopts);
809 md_parse_option (c, arg)
816 /* -u means that any undefined symbols should be treated as
817 external, which is the default for gas anyhow. */
822 /* Solaris as takes -le (presumably for little endian). For completeness
823 sake, recognize -be also. */
824 if (strcmp (arg, "e") == 0)
826 target_big_endian = 0;
827 set_target_endian = 1;
835 if (strcmp (arg, "e") == 0)
837 target_big_endian = 1;
838 set_target_endian = 1;
846 /* Recognize -K PIC. */
847 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
850 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
858 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
860 if (strcmp (arg, "64") == 0)
862 else if (strcmp (arg, "32") == 0)
869 /* Most CPU's are 32 bit. Exceptions are listed below. */
870 ppc_size = PPC_OPCODE_32;
872 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
874 if (strcmp (arg, "pwrx") == 0 || strcmp (arg, "pwr2") == 0)
875 ppc_cpu = PPC_OPCODE_POWER | PPC_OPCODE_POWER2;
876 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
877 else if (strcmp (arg, "pwr") == 0)
878 ppc_cpu = PPC_OPCODE_POWER;
879 /* -m601 means to assemble for the Motorola PowerPC 601, which includes
880 instructions that are holdovers from the Power. */
881 else if (strcmp (arg, "601") == 0)
882 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_601;
883 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
884 Motorola PowerPC 603/604. */
885 else if (strcmp (arg, "ppc") == 0
886 || strcmp (arg, "ppc32") == 0
887 || strcmp (arg, "603") == 0
888 || strcmp (arg, "604") == 0)
889 ppc_cpu = PPC_OPCODE_PPC;
890 /* -m403 and -m405 mean to assemble for the Motorola PowerPC 403/405. */
891 else if (strcmp (arg, "403") == 0
892 || strcmp (arg, "405") == 0)
893 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_403;
894 else if (strcmp (arg, "7400") == 0
895 || strcmp (arg, "7410") == 0
896 || strcmp (arg, "7450") == 0
897 || strcmp (arg, "7455") == 0)
898 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_ALTIVEC;
899 else if (strcmp (arg, "altivec") == 0)
902 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_ALTIVEC;
904 ppc_cpu |= PPC_OPCODE_ALTIVEC;
906 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
908 else if (strcmp (arg, "ppc64") == 0 || strcmp (arg, "620") == 0)
910 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_64;
911 ppc_size = PPC_OPCODE_64;
913 else if (strcmp (arg, "ppc64bridge") == 0)
915 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_64_BRIDGE | PPC_OPCODE_64;
916 ppc_size = PPC_OPCODE_64;
918 /* -mbooke/-mbooke32 mean enable 32-bit BookE support. */
919 else if (strcmp (arg, "booke") == 0 || strcmp (arg, "booke32") == 0)
920 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_BOOKE;
921 /* -mbooke64 means enable 64-bit BookE support. */
922 else if (strcmp (arg, "booke64") == 0)
924 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_BOOKE |
925 PPC_OPCODE_BOOKE64 | PPC_OPCODE_64;
926 ppc_size = PPC_OPCODE_64;
928 /* -mcom means assemble for the common intersection between Power
929 and PowerPC. At present, we just allow the union, rather
930 than the intersection. */
931 else if (strcmp (arg, "com") == 0)
932 ppc_cpu = PPC_OPCODE_COMMON;
933 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
934 else if (strcmp (arg, "any") == 0)
935 ppc_cpu = PPC_OPCODE_ANY;
937 else if (strcmp (arg, "regnames") == 0)
940 else if (strcmp (arg, "no-regnames") == 0)
944 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
945 that require relocation. */
946 else if (strcmp (arg, "relocatable") == 0)
948 shlib = SHLIB_MRELOCATABLE;
949 ppc_flags |= EF_PPC_RELOCATABLE;
952 else if (strcmp (arg, "relocatable-lib") == 0)
954 shlib = SHLIB_MRELOCATABLE;
955 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
958 /* -memb, set embedded bit. */
959 else if (strcmp (arg, "emb") == 0)
960 ppc_flags |= EF_PPC_EMB;
962 /* -mlittle/-mbig set the endianess. */
963 else if (strcmp (arg, "little") == 0
964 || strcmp (arg, "little-endian") == 0)
966 target_big_endian = 0;
967 set_target_endian = 1;
970 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
972 target_big_endian = 1;
973 set_target_endian = 1;
976 else if (strcmp (arg, "solaris") == 0)
979 ppc_comment_chars = ppc_solaris_comment_chars;
982 else if (strcmp (arg, "no-solaris") == 0)
985 ppc_comment_chars = ppc_eabi_comment_chars;
990 as_bad (_("invalid switch -m%s"), arg);
996 /* -V: SVR4 argument to print version ID. */
1001 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1002 should be emitted or not. FIXME: Not implemented. */
1006 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1007 rather than .stabs.excl, which is ignored by the linker.
1008 FIXME: Not implemented. */
1024 md_show_usage (stream)
1027 fprintf (stream, _("\
1030 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
1031 -mpwr generate code for IBM POWER (RIOS1)\n\
1032 -m601 generate code for Motorola PowerPC 601\n\
1033 -mppc, -mppc32, -m603, -m604\n\
1034 generate code for Motorola PowerPC 603/604\n\
1035 -m403, -m405 generate code for Motorola PowerPC 403/405\n\
1036 -m7400, -m7410, -m7450, -m7455\n\
1037 generate code For Motorola PowerPC 7400/7410/7450/7455\n\
1038 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
1039 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1040 -mbooke64 generate code for 64-bit Motorola BookE\n\
1041 -mbooke, mbooke32 generate code for 32-bit Motorola BookE\n\
1042 -maltivec generate code for AltiVec\n\
1043 -mcom generate code Power/PowerPC common instructions\n\
1044 -many generate code for any architecture (PWR/PWRX/PPC)\n\
1045 -mregnames Allow symbolic names for registers\n\
1046 -mno-regnames Do not allow symbolic names for registers\n"));
1048 fprintf (stream, _("\
1049 -mrelocatable support for GCC's -mrelocatble option\n\
1050 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1051 -memb set PPC_EMB bit in ELF flags\n\
1052 -mlittle, -mlittle-endian\n\
1053 generate code for a little endian machine\n\
1054 -mbig, -mbig-endian generate code for a big endian machine\n\
1055 -msolaris generate code for Solaris\n\
1056 -mno-solaris do not generate code for Solaris\n\
1057 -V print assembler version number\n\
1058 -Qy, -Qn ignored\n"));
1062 /* Set ppc_cpu if it is not already set. */
1067 const char *default_os = TARGET_OS;
1068 const char *default_cpu = TARGET_CPU;
1072 if (strncmp (default_os, "aix", 3) == 0
1073 && default_os[3] >= '4' && default_os[3] <= '9')
1074 ppc_cpu = PPC_OPCODE_COMMON;
1075 else if (strncmp (default_os, "aix3", 4) == 0)
1076 ppc_cpu = PPC_OPCODE_POWER;
1077 else if (strcmp (default_cpu, "rs6000") == 0)
1078 ppc_cpu = PPC_OPCODE_POWER;
1079 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1080 ppc_cpu = PPC_OPCODE_PPC;
1082 as_fatal (_("Unknown default cpu = %s, os = %s"),
1083 default_cpu, default_os);
1087 /* Figure out the BFD architecture to use. */
1089 enum bfd_architecture
1092 const char *default_cpu = TARGET_CPU;
1095 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
1096 return bfd_arch_powerpc;
1097 else if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
1098 return bfd_arch_rs6000;
1099 else if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
1101 if (strcmp (default_cpu, "rs6000") == 0)
1102 return bfd_arch_rs6000;
1103 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1104 return bfd_arch_powerpc;
1107 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
1108 return bfd_arch_unknown;
1114 return ppc_size == PPC_OPCODE_64 ? 620 : 0;
1121 return ppc_xcoff64 ? 3 : 2;
1126 ppc_target_format ()
1130 return target_big_endian ? "pe-powerpc" : "pe-powerpcle";
1132 return "xcoff-powermac";
1134 return ppc_xcoff64 ? "aixcoff64-rs6000" : "aixcoff-rs6000";
1138 boolean is64 = BFD_DEFAULT_TARGET_SIZE == 64 && ppc_size == PPC_OPCODE_64;
1140 return (target_big_endian
1141 ? (is64 ? "elf64-powerpc" : "elf32-powerpc")
1142 : (is64 ? "elf64-powerpcle" : "elf32-powerpcle"));
1146 /* This function is called when the assembler starts up. It is called
1147 after the options have been parsed and the output file has been
1153 register const struct powerpc_opcode *op;
1154 const struct powerpc_opcode *op_end;
1155 const struct powerpc_macro *macro;
1156 const struct powerpc_macro *macro_end;
1157 boolean dup_insn = false;
1162 /* Set the ELF flags if desired. */
1163 if (ppc_flags && !msolaris)
1164 bfd_set_private_flags (stdoutput, ppc_flags);
1167 /* Insert the opcodes into a hash table. */
1168 ppc_hash = hash_new ();
1170 op_end = powerpc_opcodes + powerpc_num_opcodes;
1171 for (op = powerpc_opcodes; op < op_end; op++)
1173 know ((op->opcode & op->mask) == op->opcode);
1175 if ((op->flags & ppc_cpu) != 0
1176 && ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == 0
1177 || (op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == ppc_size
1178 || (ppc_cpu & PPC_OPCODE_64_BRIDGE) != 0))
1182 retval = hash_insert (ppc_hash, op->name, (PTR) op);
1183 if (retval != (const char *) NULL)
1185 /* Ignore Power duplicates for -m601. */
1186 if ((ppc_cpu & PPC_OPCODE_601) != 0
1187 && (op->flags & PPC_OPCODE_POWER) != 0)
1190 as_bad (_("Internal assembler error for instruction %s"),
1197 /* Insert the macros into a hash table. */
1198 ppc_macro_hash = hash_new ();
1200 macro_end = powerpc_macros + powerpc_num_macros;
1201 for (macro = powerpc_macros; macro < macro_end; macro++)
1203 if ((macro->flags & ppc_cpu) != 0)
1207 retval = hash_insert (ppc_macro_hash, macro->name, (PTR) macro);
1208 if (retval != (const char *) NULL)
1210 as_bad (_("Internal assembler error for macro %s"), macro->name);
1219 /* Tell the main code what the endianness is if it is not overidden
1221 if (!set_target_endian)
1223 set_target_endian = 1;
1224 target_big_endian = PPC_BIG_ENDIAN;
1228 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1230 /* Create dummy symbols to serve as initial csects. This forces the
1231 text csects to precede the data csects. These symbols will not
1233 ppc_text_csects = symbol_make ("dummy\001");
1234 symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
1235 ppc_data_csects = symbol_make ("dummy\001");
1236 symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
1241 ppc_current_section = text_section;
1242 ppc_previous_section = 0;
1247 /* Insert an operand value into an instruction. */
1249 static unsigned long
1250 ppc_insert_operand (insn, operand, val, file, line)
1252 const struct powerpc_operand *operand;
1257 if (operand->bits != 32)
1262 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1264 if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0)
1265 max = (1 << operand->bits) - 1;
1267 max = (1 << (operand->bits - 1)) - 1;
1268 min = - (1 << (operand->bits - 1));
1270 if (ppc_size == PPC_OPCODE_32)
1272 /* Some people write 32 bit hex constants with the sign
1273 extension done by hand. This shouldn't really be
1274 valid, but, to permit this code to assemble on a 64
1275 bit host, we sign extend the 32 bit value. */
1277 && (val & (offsetT) 0x80000000) != 0
1278 && (val & (offsetT) 0xffffffff) == val)
1287 max = (1 << operand->bits) - 1;
1291 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1296 if (test < (offsetT) min || test > (offsetT) max)
1299 _("operand out of range (%s not between %ld and %ld)");
1302 sprint_value (buf, test);
1303 as_bad_where (file, line, err, buf, min, max);
1307 if (operand->insert)
1312 insn = (*operand->insert) (insn, (long) val, ppc_cpu | ppc_size, &errmsg);
1313 if (errmsg != (const char *) NULL)
1314 as_bad_where (file, line, errmsg);
1317 insn |= (((long) val & ((1 << operand->bits) - 1))
1325 /* Parse @got, etc. and return the desired relocation. */
1326 static bfd_reloc_code_real_type
1327 ppc_elf_suffix (str_p, exp_p)
1342 const struct map_bfd *ptr;
1344 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
1346 static const struct map_bfd mapping[] = {
1347 MAP ("l", (int) BFD_RELOC_LO16),
1348 MAP ("h", (int) BFD_RELOC_HI16),
1349 MAP ("ha", (int) BFD_RELOC_HI16_S),
1350 MAP ("brtaken", (int) BFD_RELOC_PPC_B16_BRTAKEN),
1351 MAP ("brntaken", (int) BFD_RELOC_PPC_B16_BRNTAKEN),
1352 MAP ("got", (int) BFD_RELOC_16_GOTOFF),
1353 MAP ("got@l", (int) BFD_RELOC_LO16_GOTOFF),
1354 MAP ("got@h", (int) BFD_RELOC_HI16_GOTOFF),
1355 MAP ("got@ha", (int) BFD_RELOC_HI16_S_GOTOFF),
1356 MAP ("fixup", (int) BFD_RELOC_CTOR), /* warning with -mrelocatable */
1357 MAP ("plt", (int) BFD_RELOC_24_PLT_PCREL),
1358 MAP ("pltrel24", (int) BFD_RELOC_24_PLT_PCREL),
1359 MAP ("copy", (int) BFD_RELOC_PPC_COPY),
1360 MAP ("globdat", (int) BFD_RELOC_PPC_GLOB_DAT),
1361 MAP ("local24pc", (int) BFD_RELOC_PPC_LOCAL24PC),
1362 MAP ("local", (int) BFD_RELOC_PPC_LOCAL24PC),
1363 MAP ("pltrel", (int) BFD_RELOC_32_PLT_PCREL),
1364 MAP ("plt@l", (int) BFD_RELOC_LO16_PLTOFF),
1365 MAP ("plt@h", (int) BFD_RELOC_HI16_PLTOFF),
1366 MAP ("plt@ha", (int) BFD_RELOC_HI16_S_PLTOFF),
1367 MAP ("sdarel", (int) BFD_RELOC_GPREL16),
1368 MAP ("sectoff", (int) BFD_RELOC_32_BASEREL),
1369 MAP ("sectoff@l", (int) BFD_RELOC_LO16_BASEREL),
1370 MAP ("sectoff@h", (int) BFD_RELOC_HI16_BASEREL),
1371 MAP ("sectoff@ha", (int) BFD_RELOC_HI16_S_BASEREL),
1372 MAP ("naddr", (int) BFD_RELOC_PPC_EMB_NADDR32),
1373 MAP ("naddr16", (int) BFD_RELOC_PPC_EMB_NADDR16),
1374 MAP ("naddr@l", (int) BFD_RELOC_PPC_EMB_NADDR16_LO),
1375 MAP ("naddr@h", (int) BFD_RELOC_PPC_EMB_NADDR16_HI),
1376 MAP ("naddr@ha", (int) BFD_RELOC_PPC_EMB_NADDR16_HA),
1377 MAP ("sdai16", (int) BFD_RELOC_PPC_EMB_SDAI16),
1378 MAP ("sda2rel", (int) BFD_RELOC_PPC_EMB_SDA2REL),
1379 MAP ("sda2i16", (int) BFD_RELOC_PPC_EMB_SDA2I16),
1380 MAP ("sda21", (int) BFD_RELOC_PPC_EMB_SDA21),
1381 MAP ("mrkref", (int) BFD_RELOC_PPC_EMB_MRKREF),
1382 MAP ("relsect", (int) BFD_RELOC_PPC_EMB_RELSEC16),
1383 MAP ("relsect@l", (int) BFD_RELOC_PPC_EMB_RELST_LO),
1384 MAP ("relsect@h", (int) BFD_RELOC_PPC_EMB_RELST_HI),
1385 MAP ("relsect@ha", (int) BFD_RELOC_PPC_EMB_RELST_HA),
1386 MAP ("bitfld", (int) BFD_RELOC_PPC_EMB_BIT_FLD),
1387 MAP ("relsda", (int) BFD_RELOC_PPC_EMB_RELSDA),
1388 MAP ("xgot", (int) BFD_RELOC_PPC_TOC16),
1389 #if BFD_DEFAULT_TARGET_SIZE == 64
1390 MAP ("higher", - (int) BFD_RELOC_PPC64_HIGHER),
1391 MAP ("highera", - (int) BFD_RELOC_PPC64_HIGHER_S),
1392 MAP ("highest", - (int) BFD_RELOC_PPC64_HIGHEST),
1393 MAP ("highesta", - (int) BFD_RELOC_PPC64_HIGHEST_S),
1394 MAP ("tocbase", - (int) BFD_RELOC_PPC64_TOC),
1395 MAP ("toc", - (int) BFD_RELOC_PPC_TOC16),
1396 MAP ("toc@l", - (int) BFD_RELOC_PPC64_TOC16_LO),
1397 MAP ("toc@h", - (int) BFD_RELOC_PPC64_TOC16_HI),
1398 MAP ("toc@ha", - (int) BFD_RELOC_PPC64_TOC16_HA),
1400 { (char *) 0, 0, (int) BFD_RELOC_UNUSED }
1404 return BFD_RELOC_UNUSED;
1406 for (ch = *str, str2 = ident;
1407 (str2 < ident + sizeof (ident) - 1
1408 && (ISALNUM (ch) || ch == '@'));
1411 *str2++ = TOLOWER (ch);
1418 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1419 if (ch == ptr->string[0]
1420 && len == ptr->length
1421 && memcmp (ident, ptr->string, ptr->length) == 0)
1423 int reloc = ptr->reloc;
1425 if (BFD_DEFAULT_TARGET_SIZE == 64 && reloc < 0)
1427 if (ppc_size != PPC_OPCODE_64)
1428 return BFD_RELOC_UNUSED;
1432 if (exp_p->X_add_number != 0
1433 && (reloc == (int) BFD_RELOC_16_GOTOFF
1434 || reloc == (int) BFD_RELOC_LO16_GOTOFF
1435 || reloc == (int) BFD_RELOC_HI16_GOTOFF
1436 || reloc == (int) BFD_RELOC_HI16_S_GOTOFF))
1437 as_warn (_("identifier+constant@got means identifier@got+constant"));
1439 /* Now check for identifier@suffix+constant. */
1440 if (*str == '-' || *str == '+')
1442 char *orig_line = input_line_pointer;
1443 expressionS new_exp;
1445 input_line_pointer = str;
1446 expression (&new_exp);
1447 if (new_exp.X_op == O_constant)
1449 exp_p->X_add_number += new_exp.X_add_number;
1450 str = input_line_pointer;
1453 if (&input_line_pointer != str_p)
1454 input_line_pointer = orig_line;
1458 if (BFD_DEFAULT_TARGET_SIZE == 64
1459 && reloc == (int) BFD_RELOC_PPC64_TOC
1460 && exp_p->X_op == O_symbol)
1462 /* This reloc type ignores the symbol. Change the symbol
1463 so that the dummy .TOC. symbol can be omitted from the
1465 exp_p->X_add_symbol = &abs_symbol;
1468 return (bfd_reloc_code_real_type) reloc;
1471 return BFD_RELOC_UNUSED;
1474 /* Like normal .long/.short/.word, except support @got, etc.
1475 Clobbers input_line_pointer, checks end-of-line. */
1477 ppc_elf_cons (nbytes)
1478 register int nbytes; /* 1=.byte, 2=.word, 4=.long, 8=.llong. */
1481 bfd_reloc_code_real_type reloc;
1483 if (is_it_end_of_statement ())
1485 demand_empty_rest_of_line ();
1492 if (exp.X_op == O_symbol
1493 && *input_line_pointer == '@'
1494 && (reloc = ppc_elf_suffix (&input_line_pointer,
1495 &exp)) != BFD_RELOC_UNUSED)
1497 reloc_howto_type *reloc_howto;
1500 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
1501 size = bfd_get_reloc_size (reloc_howto);
1505 as_bad (_("%s relocations do not fit in %d bytes\n"),
1506 reloc_howto->name, nbytes);
1513 p = frag_more (nbytes);
1515 if (target_big_endian)
1516 offset = nbytes - size;
1517 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
1522 emit_expr (&exp, (unsigned int) nbytes);
1524 while (*input_line_pointer++ == ',');
1526 /* Put terminator back into stream. */
1527 input_line_pointer--;
1528 demand_empty_rest_of_line ();
1531 /* Solaris pseduo op to change to the .rodata section. */
1536 char *save_line = input_line_pointer;
1537 static char section[] = ".rodata\n";
1539 /* Just pretend this is .section .rodata */
1540 input_line_pointer = section;
1541 obj_elf_section (xxx);
1543 input_line_pointer = save_line;
1546 /* Pseudo op to make file scope bss items. */
1549 int xxx ATTRIBUTE_UNUSED;
1551 register char *name;
1555 register symbolS *symbolP;
1562 name = input_line_pointer;
1563 c = get_symbol_end ();
1565 /* just after name is now '\0'. */
1566 p = input_line_pointer;
1569 if (*input_line_pointer != ',')
1571 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1572 ignore_rest_of_line ();
1576 input_line_pointer++; /* skip ',' */
1577 if ((size = get_absolute_expression ()) < 0)
1579 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
1580 ignore_rest_of_line ();
1584 /* The third argument to .lcomm is the alignment. */
1585 if (*input_line_pointer != ',')
1589 ++input_line_pointer;
1590 align = get_absolute_expression ();
1593 as_warn (_("ignoring bad alignment"));
1599 symbolP = symbol_find_or_make (name);
1602 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1604 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1605 S_GET_NAME (symbolP));
1606 ignore_rest_of_line ();
1610 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1612 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1613 S_GET_NAME (symbolP),
1614 (long) S_GET_VALUE (symbolP),
1617 ignore_rest_of_line ();
1623 old_subsec = now_subseg;
1626 /* Convert to a power of 2 alignment. */
1627 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
1630 as_bad (_("Common alignment not a power of 2"));
1631 ignore_rest_of_line ();
1638 record_alignment (bss_section, align2);
1639 subseg_set (bss_section, 0);
1641 frag_align (align2, 0, 0);
1642 if (S_GET_SEGMENT (symbolP) == bss_section)
1643 symbol_get_frag (symbolP)->fr_symbol = 0;
1644 symbol_set_frag (symbolP, frag_now);
1645 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1648 S_SET_SIZE (symbolP, size);
1649 S_SET_SEGMENT (symbolP, bss_section);
1650 subseg_set (old_sec, old_subsec);
1651 demand_empty_rest_of_line ();
1654 /* Validate any relocations emitted for -mrelocatable, possibly adding
1655 fixups for word relocations in writable segments, so we can adjust
1658 ppc_elf_validate_fix (fixp, seg)
1662 if (fixp->fx_done || fixp->fx_pcrel)
1671 case SHLIB_MRELOCATABLE:
1672 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1673 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1674 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1675 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1676 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1677 && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1678 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1679 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1680 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1681 && (seg->flags & SEC_LOAD) != 0
1682 && strcmp (segment_name (seg), ".got2") != 0
1683 && strcmp (segment_name (seg), ".dtors") != 0
1684 && strcmp (segment_name (seg), ".ctors") != 0
1685 && strcmp (segment_name (seg), ".fixup") != 0
1686 && strcmp (segment_name (seg), ".gcc_except_table") != 0
1687 && strcmp (segment_name (seg), ".eh_frame") != 0
1688 && strcmp (segment_name (seg), ".ex_shared") != 0)
1690 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1691 || fixp->fx_r_type != BFD_RELOC_CTOR)
1693 as_bad_where (fixp->fx_file, fixp->fx_line,
1694 _("Relocation cannot be done when using -mrelocatable"));
1701 #if BFD_DEFAULT_TARGET_SIZE == 64
1702 /* Don't emit .TOC. symbol. */
1704 ppc_elf_frob_symbol (sym)
1709 name = S_GET_NAME (sym);
1710 if (name != NULL && strcmp (name, ".TOC.") == 0)
1712 S_CLEAR_EXTERNAL (sym);
1719 #endif /* OBJ_ELF */
1724 * Summary of parse_toc_entry.
1726 * in: Input_line_pointer points to the '[' in one of:
1728 * [toc] [tocv] [toc32] [toc64]
1730 * Anything else is an error of one kind or another.
1733 * return value: success or failure
1734 * toc_kind: kind of toc reference
1735 * input_line_pointer:
1736 * success: first char after the ']'
1737 * failure: unchanged
1741 * [toc] - rv == success, toc_kind = default_toc
1742 * [tocv] - rv == success, toc_kind = data_in_toc
1743 * [toc32] - rv == success, toc_kind = must_be_32
1744 * [toc64] - rv == success, toc_kind = must_be_64
1748 enum toc_size_qualifier
1750 default_toc, /* The toc cell constructed should be the system default size */
1751 data_in_toc, /* This is a direct reference to a toc cell */
1752 must_be_32, /* The toc cell constructed must be 32 bits wide */
1753 must_be_64 /* The toc cell constructed must be 64 bits wide */
1757 parse_toc_entry (toc_kind)
1758 enum toc_size_qualifier *toc_kind;
1763 enum toc_size_qualifier t;
1765 /* Save the input_line_pointer. */
1766 start = input_line_pointer;
1768 /* Skip over the '[' , and whitespace. */
1769 ++input_line_pointer;
1772 /* Find the spelling of the operand. */
1773 toc_spec = input_line_pointer;
1774 c = get_symbol_end ();
1776 if (strcmp (toc_spec, "toc") == 0)
1780 else if (strcmp (toc_spec, "tocv") == 0)
1784 else if (strcmp (toc_spec, "toc32") == 0)
1788 else if (strcmp (toc_spec, "toc64") == 0)
1794 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
1795 *input_line_pointer = c;
1796 input_line_pointer = start;
1800 /* Now find the ']'. */
1801 *input_line_pointer = c;
1803 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1804 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
1808 as_bad (_("syntax error: expected `]', found `%c'"), c);
1809 input_line_pointer = start;
1819 /* We need to keep a list of fixups. We can't simply generate them as
1820 we go, because that would require us to first create the frag, and
1821 that would screw up references to ``.''. */
1827 bfd_reloc_code_real_type reloc;
1830 #define MAX_INSN_FIXUPS (5)
1832 /* This routine is called for each instruction to be assembled. */
1839 const struct powerpc_opcode *opcode;
1841 const unsigned char *opindex_ptr;
1845 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
1850 bfd_reloc_code_real_type reloc;
1853 /* Get the opcode. */
1854 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1859 /* Look up the opcode in the hash table. */
1860 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
1861 if (opcode == (const struct powerpc_opcode *) NULL)
1863 const struct powerpc_macro *macro;
1865 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
1866 if (macro == (const struct powerpc_macro *) NULL)
1867 as_bad (_("Unrecognized opcode: `%s'"), str);
1869 ppc_macro (s, macro);
1874 insn = opcode->opcode;
1877 while (ISSPACE (*str))
1880 /* PowerPC operands are just expressions. The only real issue is
1881 that a few operand types are optional. All cases which might use
1882 an optional operand separate the operands only with commas (in
1883 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1884 cases never have optional operands). There is never more than
1885 one optional operand for an instruction. So, before we start
1886 seriously parsing the operands, we check to see if we have an
1887 optional operand, and, if we do, we count the number of commas to
1888 see whether the operand should be omitted. */
1890 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1892 const struct powerpc_operand *operand;
1894 operand = &powerpc_operands[*opindex_ptr];
1895 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
1897 unsigned int opcount;
1899 /* There is an optional operand. Count the number of
1900 commas in the input line. */
1907 while ((s = strchr (s, ',')) != (char *) NULL)
1914 /* If there are fewer operands in the line then are called
1915 for by the instruction, we want to skip the optional
1917 if (opcount < strlen (opcode->operands))
1924 /* Gather the operands. */
1928 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1930 const struct powerpc_operand *operand;
1936 if (next_opindex == 0)
1937 operand = &powerpc_operands[*opindex_ptr];
1940 operand = &powerpc_operands[next_opindex];
1946 /* If this is a fake operand, then we do not expect anything
1948 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
1950 insn = (*operand->insert) (insn, 0L, ppc_cpu | ppc_size, &errmsg);
1951 if (errmsg != (const char *) NULL)
1956 /* If this is an optional operand, and we are skipping it, just
1958 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
1961 if (operand->insert)
1963 insn = (*operand->insert) (insn, 0L, ppc_cpu | ppc_size, &errmsg);
1964 if (errmsg != (const char *) NULL)
1967 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
1968 next_opindex = *opindex_ptr + 1;
1972 /* Gather the operand. */
1973 hold = input_line_pointer;
1974 input_line_pointer = str;
1977 if (*input_line_pointer == '[')
1979 /* We are expecting something like the second argument here:
1981 * lwz r4,[toc].GS.0.static_int(rtoc)
1982 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1983 * The argument following the `]' must be a symbol name, and the
1984 * register must be the toc register: 'rtoc' or '2'
1986 * The effect is to 0 as the displacement field
1987 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1988 * the appropriate variation) reloc against it based on the symbol.
1989 * The linker will build the toc, and insert the resolved toc offset.
1992 * o The size of the toc entry is currently assumed to be
1993 * 32 bits. This should not be assumed to be a hard coded
1995 * o In an effort to cope with a change from 32 to 64 bits,
1996 * there are also toc entries that are specified to be
1997 * either 32 or 64 bits:
1998 * lwz r4,[toc32].GS.0.static_int(rtoc)
1999 * lwz r4,[toc64].GS.0.static_int(rtoc)
2000 * These demand toc entries of the specified size, and the
2001 * instruction probably requires it.
2005 enum toc_size_qualifier toc_kind;
2006 bfd_reloc_code_real_type toc_reloc;
2008 /* Go parse off the [tocXX] part. */
2009 valid_toc = parse_toc_entry (&toc_kind);
2013 /* Note: message has already been issued.
2014 FIXME: what sort of recovery should we do?
2015 demand_rest_of_line (); return; ? */
2018 /* Now get the symbol following the ']'. */
2024 /* In this case, we may not have seen the symbol yet,
2025 since it is allowed to appear on a .extern or .globl
2026 or just be a label in the .data section. */
2027 toc_reloc = BFD_RELOC_PPC_TOC16;
2030 /* 1. The symbol must be defined and either in the toc
2031 section, or a global.
2032 2. The reloc generated must have the TOCDEFN flag set
2033 in upper bit mess of the reloc type.
2034 FIXME: It's a little confusing what the tocv
2035 qualifier can be used for. At the very least, I've
2036 seen three uses, only one of which I'm sure I can
2038 if (ex.X_op == O_symbol)
2040 assert (ex.X_add_symbol != NULL);
2041 if (symbol_get_bfdsym (ex.X_add_symbol)->section
2044 as_bad (_("[tocv] symbol is not a toc symbol"));
2048 toc_reloc = BFD_RELOC_PPC_TOC16;
2051 /* FIXME: these next two specifically specify 32/64 bit
2052 toc entries. We don't support them today. Is this
2053 the right way to say that? */
2054 toc_reloc = BFD_RELOC_UNUSED;
2055 as_bad (_("Unimplemented toc32 expression modifier"));
2058 /* FIXME: see above. */
2059 toc_reloc = BFD_RELOC_UNUSED;
2060 as_bad (_("Unimplemented toc64 expression modifier"));
2064 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2070 /* We need to generate a fixup for this expression. */
2071 if (fc >= MAX_INSN_FIXUPS)
2072 as_fatal (_("too many fixups"));
2074 fixups[fc].reloc = toc_reloc;
2075 fixups[fc].exp = ex;
2076 fixups[fc].opindex = *opindex_ptr;
2079 /* Ok. We've set up the fixup for the instruction. Now make it
2080 look like the constant 0 was found here. */
2082 ex.X_op = O_constant;
2083 ex.X_add_number = 0;
2084 ex.X_add_symbol = NULL;
2085 ex.X_op_symbol = NULL;
2091 if (! register_name (&ex))
2093 if ((operand->flags & PPC_OPERAND_CR) != 0)
2100 str = input_line_pointer;
2101 input_line_pointer = hold;
2103 if (ex.X_op == O_illegal)
2104 as_bad (_("illegal operand"));
2105 else if (ex.X_op == O_absent)
2106 as_bad (_("missing operand"));
2107 else if (ex.X_op == O_register)
2109 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2112 else if (ex.X_op == O_constant)
2115 /* Allow @HA, @L, @H on constants. */
2116 char *orig_str = str;
2118 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2125 case BFD_RELOC_LO16:
2126 /* X_unsigned is the default, so if the user has done
2127 something which cleared it, we always produce a
2129 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2130 ex.X_add_number &= 0xffff;
2132 ex.X_add_number = SEX16 (ex.X_add_number);
2135 case BFD_RELOC_HI16:
2136 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2137 ex.X_add_number = PPC_HI (ex.X_add_number);
2139 ex.X_add_number = SEX16 (PPC_HI (ex.X_add_number));
2142 case BFD_RELOC_HI16_S:
2143 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2144 ex.X_add_number = PPC_HA (ex.X_add_number);
2146 ex.X_add_number = SEX16 (PPC_HA (ex.X_add_number));
2149 #if BFD_DEFAULT_TARGET_SIZE == 64
2150 case BFD_RELOC_PPC64_HIGHER:
2151 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2152 ex.X_add_number = PPC_HIGHER (ex.X_add_number);
2154 ex.X_add_number = SEX16 (PPC_HIGHER (ex.X_add_number));
2157 case BFD_RELOC_PPC64_HIGHER_S:
2158 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2159 ex.X_add_number = PPC_HIGHERA (ex.X_add_number);
2161 ex.X_add_number = SEX16 (PPC_HIGHERA (ex.X_add_number));
2164 case BFD_RELOC_PPC64_HIGHEST:
2165 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2166 ex.X_add_number = PPC_HIGHEST (ex.X_add_number);
2168 ex.X_add_number = SEX16 (PPC_HIGHEST (ex.X_add_number));
2171 case BFD_RELOC_PPC64_HIGHEST_S:
2172 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2173 ex.X_add_number = PPC_HIGHESTA (ex.X_add_number);
2175 ex.X_add_number = SEX16 (PPC_HIGHESTA (ex.X_add_number));
2177 #endif /* BFD_DEFAULT_TARGET_SIZE == 64 */
2179 #endif /* OBJ_ELF */
2180 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2184 else if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2186 /* For the absolute forms of branches, convert the PC
2187 relative form back into the absolute. */
2188 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
2192 case BFD_RELOC_PPC_B26:
2193 reloc = BFD_RELOC_PPC_BA26;
2195 case BFD_RELOC_PPC_B16:
2196 reloc = BFD_RELOC_PPC_BA16;
2198 case BFD_RELOC_PPC_B16_BRTAKEN:
2199 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
2201 case BFD_RELOC_PPC_B16_BRNTAKEN:
2202 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
2209 if (BFD_DEFAULT_TARGET_SIZE == 64
2210 && ppc_size == PPC_OPCODE_64
2211 && (operand->flags & PPC_OPERAND_DS) != 0)
2216 reloc = BFD_RELOC_PPC64_ADDR16_DS;
2218 case BFD_RELOC_LO16:
2219 reloc = BFD_RELOC_PPC64_ADDR16_LO_DS;
2221 case BFD_RELOC_16_GOTOFF:
2222 reloc = BFD_RELOC_PPC64_GOT16_DS;
2224 case BFD_RELOC_LO16_GOTOFF:
2225 reloc = BFD_RELOC_PPC64_GOT16_LO_DS;
2227 case BFD_RELOC_LO16_PLTOFF:
2228 reloc = BFD_RELOC_PPC64_PLT16_LO_DS;
2230 case BFD_RELOC_32_BASEREL:
2231 reloc = BFD_RELOC_PPC64_SECTOFF_DS;
2233 case BFD_RELOC_LO16_BASEREL:
2234 reloc = BFD_RELOC_PPC64_SECTOFF_LO_DS;
2236 case BFD_RELOC_PPC_TOC16:
2237 reloc = BFD_RELOC_PPC64_TOC16_DS;
2239 case BFD_RELOC_PPC64_TOC16_LO:
2240 reloc = BFD_RELOC_PPC64_TOC16_LO_DS;
2242 case BFD_RELOC_PPC64_PLTGOT16:
2243 reloc = BFD_RELOC_PPC64_PLTGOT16_DS;
2245 case BFD_RELOC_PPC64_PLTGOT16_LO:
2246 reloc = BFD_RELOC_PPC64_PLTGOT16_LO_DS;
2249 as_bad (_("unsupported relocation for DS offset field"));
2254 /* We need to generate a fixup for this expression. */
2255 if (fc >= MAX_INSN_FIXUPS)
2256 as_fatal (_("too many fixups"));
2257 fixups[fc].exp = ex;
2258 fixups[fc].opindex = 0;
2259 fixups[fc].reloc = reloc;
2262 #endif /* OBJ_ELF */
2266 /* We need to generate a fixup for this expression. */
2267 if (fc >= MAX_INSN_FIXUPS)
2268 as_fatal (_("too many fixups"));
2269 fixups[fc].exp = ex;
2270 fixups[fc].opindex = *opindex_ptr;
2271 fixups[fc].reloc = BFD_RELOC_UNUSED;
2280 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
2288 /* The call to expression should have advanced str past any
2291 && (endc != ',' || *str != '\0'))
2293 as_bad (_("syntax error; found `%c' but expected `%c'"), *str, endc);
2301 while (ISSPACE (*str))
2305 as_bad (_("junk at end of line: `%s'"), str);
2307 /* Write out the instruction. */
2309 md_number_to_chars (f, insn, 4);
2312 dwarf2_emit_insn (4);
2315 /* Create any fixups. At this point we do not use a
2316 bfd_reloc_code_real_type, but instead just use the
2317 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2318 handle fixups for any operand type, although that is admittedly
2319 not a very exciting feature. We pick a BFD reloc type in
2321 for (i = 0; i < fc; i++)
2323 const struct powerpc_operand *operand;
2325 operand = &powerpc_operands[fixups[i].opindex];
2326 if (fixups[i].reloc != BFD_RELOC_UNUSED)
2328 reloc_howto_type *reloc_howto;
2333 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
2337 size = bfd_get_reloc_size (reloc_howto);
2338 offset = target_big_endian ? (4 - size) : 0;
2340 if (size < 1 || size > 4)
2343 fixP = fix_new_exp (frag_now,
2344 f - frag_now->fr_literal + offset,
2347 reloc_howto->pc_relative,
2350 /* Turn off complaints that the addend is too large for things like
2352 switch (fixups[i].reloc)
2354 case BFD_RELOC_16_GOTOFF:
2355 case BFD_RELOC_PPC_TOC16:
2356 case BFD_RELOC_LO16:
2357 case BFD_RELOC_HI16:
2358 case BFD_RELOC_HI16_S:
2360 #if BFD_DEFAULT_TARGET_SIZE == 64
2361 case BFD_RELOC_PPC64_HIGHER:
2362 case BFD_RELOC_PPC64_HIGHER_S:
2363 case BFD_RELOC_PPC64_HIGHEST:
2364 case BFD_RELOC_PPC64_HIGHEST_S:
2367 fixP->fx_no_overflow = 1;
2374 fix_new_exp (frag_now,
2375 f - frag_now->fr_literal,
2378 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
2379 ((bfd_reloc_code_real_type)
2380 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2384 /* Handle a macro. Gather all the operands, transform them as
2385 described by the macro, and call md_assemble recursively. All the
2386 operands are separated by commas; we don't accept parentheses
2387 around operands here. */
2390 ppc_macro (str, macro)
2392 const struct powerpc_macro *macro;
2403 /* Gather the users operands into the operands array. */
2408 if (count >= sizeof operands / sizeof operands[0])
2410 operands[count++] = s;
2411 s = strchr (s, ',');
2412 if (s == (char *) NULL)
2417 if (count != macro->operands)
2419 as_bad (_("wrong number of operands"));
2423 /* Work out how large the string must be (the size is unbounded
2424 because it includes user input). */
2426 format = macro->format;
2427 while (*format != '\0')
2436 arg = strtol (format + 1, &send, 10);
2437 know (send != format && arg >= 0 && arg < count);
2438 len += strlen (operands[arg]);
2443 /* Put the string together. */
2444 complete = s = (char *) alloca (len + 1);
2445 format = macro->format;
2446 while (*format != '\0')
2452 arg = strtol (format + 1, &send, 10);
2453 strcpy (s, operands[arg]);
2460 /* Assemble the constructed instruction. */
2461 md_assemble (complete);
2465 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED. */
2468 ppc_section_letter (letter, ptr_msg)
2475 *ptr_msg = _("Bad .section directive: want a,e,w,x,M,S in string");
2480 ppc_section_word (str, len)
2484 if (len == 7 && strncmp (str, "exclude", 7) == 0)
2491 ppc_section_type (str, len)
2495 if (len == 7 && strncmp (str, "ordered", 7) == 0)
2502 ppc_section_flags (flags, attr, type)
2507 if (type == SHT_ORDERED)
2508 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
2510 if (attr & SHF_EXCLUDE)
2511 flags |= SEC_EXCLUDE;
2515 #endif /* OBJ_ELF */
2518 /* Pseudo-op handling. */
2520 /* The .byte pseudo-op. This is similar to the normal .byte
2521 pseudo-op, but it can also take a single ASCII string. */
2525 int ignore ATTRIBUTE_UNUSED;
2527 if (*input_line_pointer != '\"')
2533 /* Gather characters. A real double quote is doubled. Unusual
2534 characters are not permitted. */
2535 ++input_line_pointer;
2540 c = *input_line_pointer++;
2544 if (*input_line_pointer != '\"')
2546 ++input_line_pointer;
2549 FRAG_APPEND_1_CHAR (c);
2552 demand_empty_rest_of_line ();
2557 /* XCOFF specific pseudo-op handling. */
2559 /* This is set if we are creating a .stabx symbol, since we don't want
2560 to handle symbol suffixes for such symbols. */
2561 static boolean ppc_stab_symbol;
2563 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2564 symbols in the .bss segment as though they were local common
2565 symbols, and uses a different smclas. The native Aix 4.3.3 assember
2566 aligns .comm and .lcomm to 4 bytes. */
2572 asection *current_seg = now_seg;
2573 subsegT current_subseg = now_subseg;
2579 symbolS *lcomm_sym = NULL;
2583 name = input_line_pointer;
2584 endc = get_symbol_end ();
2585 end_name = input_line_pointer;
2588 if (*input_line_pointer != ',')
2590 as_bad (_("missing size"));
2591 ignore_rest_of_line ();
2594 ++input_line_pointer;
2596 size = get_absolute_expression ();
2599 as_bad (_("negative size"));
2600 ignore_rest_of_line ();
2606 /* The third argument to .comm is the alignment. */
2607 if (*input_line_pointer != ',')
2611 ++input_line_pointer;
2612 align = get_absolute_expression ();
2615 as_warn (_("ignoring bad alignment"));
2630 /* The third argument to .lcomm appears to be the real local
2631 common symbol to create. References to the symbol named in
2632 the first argument are turned into references to the third
2634 if (*input_line_pointer != ',')
2636 as_bad (_("missing real symbol name"));
2637 ignore_rest_of_line ();
2640 ++input_line_pointer;
2642 lcomm_name = input_line_pointer;
2643 lcomm_endc = get_symbol_end ();
2645 lcomm_sym = symbol_find_or_make (lcomm_name);
2647 *input_line_pointer = lcomm_endc;
2651 sym = symbol_find_or_make (name);
2654 if (S_IS_DEFINED (sym)
2655 || S_GET_VALUE (sym) != 0)
2657 as_bad (_("attempt to redefine symbol"));
2658 ignore_rest_of_line ();
2662 record_alignment (bss_section, align);
2665 || ! S_IS_DEFINED (lcomm_sym))
2674 S_SET_EXTERNAL (sym);
2678 symbol_get_tc (lcomm_sym)->output = 1;
2679 def_sym = lcomm_sym;
2683 subseg_set (bss_section, 1);
2684 frag_align (align, 0, 0);
2686 symbol_set_frag (def_sym, frag_now);
2687 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
2688 def_size, (char *) NULL);
2690 S_SET_SEGMENT (def_sym, bss_section);
2691 symbol_get_tc (def_sym)->align = align;
2695 /* Align the size of lcomm_sym. */
2696 symbol_get_frag (lcomm_sym)->fr_offset =
2697 ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
2698 &~ ((1 << align) - 1));
2699 if (align > symbol_get_tc (lcomm_sym)->align)
2700 symbol_get_tc (lcomm_sym)->align = align;
2705 /* Make sym an offset from lcomm_sym. */
2706 S_SET_SEGMENT (sym, bss_section);
2707 symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
2708 S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
2709 symbol_get_frag (lcomm_sym)->fr_offset += size;
2712 subseg_set (current_seg, current_subseg);
2714 demand_empty_rest_of_line ();
2717 /* The .csect pseudo-op. This switches us into a different
2718 subsegment. The first argument is a symbol whose value is the
2719 start of the .csect. In COFF, csect symbols get special aux
2720 entries defined by the x_csect field of union internal_auxent. The
2721 optional second argument is the alignment (the default is 2). */
2725 int ignore ATTRIBUTE_UNUSED;
2731 name = input_line_pointer;
2732 endc = get_symbol_end ();
2734 sym = symbol_find_or_make (name);
2736 *input_line_pointer = endc;
2738 if (S_GET_NAME (sym)[0] == '\0')
2740 /* An unnamed csect is assumed to be [PR]. */
2741 symbol_get_tc (sym)->class = XMC_PR;
2744 ppc_change_csect (sym);
2746 if (*input_line_pointer == ',')
2748 ++input_line_pointer;
2749 symbol_get_tc (sym)->align = get_absolute_expression ();
2752 demand_empty_rest_of_line ();
2755 /* Change to a different csect. */
2758 ppc_change_csect (sym)
2761 if (S_IS_DEFINED (sym))
2762 subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
2770 /* This is a new csect. We need to look at the symbol class to
2771 figure out whether it should go in the text section or the
2774 switch (symbol_get_tc (sym)->class)
2784 S_SET_SEGMENT (sym, text_section);
2785 symbol_get_tc (sym)->subseg = ppc_text_subsegment;
2786 ++ppc_text_subsegment;
2787 list_ptr = &ppc_text_csects;
2796 if (ppc_toc_csect != NULL
2797 && (symbol_get_tc (ppc_toc_csect)->subseg + 1
2798 == ppc_data_subsegment))
2800 S_SET_SEGMENT (sym, data_section);
2801 symbol_get_tc (sym)->subseg = ppc_data_subsegment;
2802 ++ppc_data_subsegment;
2803 list_ptr = &ppc_data_csects;
2809 /* We set the obstack chunk size to a small value before
2810 changing subsegments, so that we don't use a lot of memory
2811 space for what may be a small section. */
2812 hold_chunksize = chunksize;
2815 subseg_new (segment_name (S_GET_SEGMENT (sym)),
2816 symbol_get_tc (sym)->subseg);
2818 chunksize = hold_chunksize;
2821 ppc_after_toc_frag = frag_now;
2823 symbol_set_frag (sym, frag_now);
2824 S_SET_VALUE (sym, (valueT) frag_now_fix ());
2826 symbol_get_tc (sym)->align = (ppc_xcoff64) ? 3 : 2;
2827 symbol_get_tc (sym)->output = 1;
2828 symbol_get_tc (sym)->within = sym;
2830 for (list = *list_ptr;
2831 symbol_get_tc (list)->next != (symbolS *) NULL;
2832 list = symbol_get_tc (list)->next)
2834 symbol_get_tc (list)->next = sym;
2836 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2837 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
2841 ppc_current_csect = sym;
2844 /* This function handles the .text and .data pseudo-ops. These
2845 pseudo-ops aren't really used by XCOFF; we implement them for the
2846 convenience of people who aren't used to XCOFF. */
2857 else if (type == 'd')
2862 sym = symbol_find_or_make (name);
2864 ppc_change_csect (sym);
2866 demand_empty_rest_of_line ();
2869 /* This function handles the .section pseudo-op. This is mostly to
2870 give an error, since XCOFF only supports .text, .data and .bss, but
2871 we do permit the user to name the text or data section. */
2874 ppc_named_section (ignore)
2875 int ignore ATTRIBUTE_UNUSED;
2878 const char *real_name;
2882 user_name = input_line_pointer;
2883 c = get_symbol_end ();
2885 if (strcmp (user_name, ".text") == 0)
2886 real_name = ".text[PR]";
2887 else if (strcmp (user_name, ".data") == 0)
2888 real_name = ".data[RW]";
2891 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2892 *input_line_pointer = c;
2893 ignore_rest_of_line ();
2897 *input_line_pointer = c;
2899 sym = symbol_find_or_make (real_name);
2901 ppc_change_csect (sym);
2903 demand_empty_rest_of_line ();
2906 /* The .extern pseudo-op. We create an undefined symbol. */
2910 int ignore ATTRIBUTE_UNUSED;
2915 name = input_line_pointer;
2916 endc = get_symbol_end ();
2918 (void) symbol_find_or_make (name);
2920 *input_line_pointer = endc;
2922 demand_empty_rest_of_line ();
2925 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2929 int ignore ATTRIBUTE_UNUSED;
2935 name = input_line_pointer;
2936 endc = get_symbol_end ();
2938 sym = symbol_find_or_make (name);
2940 *input_line_pointer = endc;
2942 symbol_get_tc (sym)->output = 1;
2944 demand_empty_rest_of_line ();
2947 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2948 although I don't know why it bothers. */
2952 int ignore ATTRIBUTE_UNUSED;
2959 name = input_line_pointer;
2960 endc = get_symbol_end ();
2962 sym = symbol_find_or_make (name);
2964 *input_line_pointer = endc;
2966 if (*input_line_pointer != ',')
2968 as_bad (_("missing rename string"));
2969 ignore_rest_of_line ();
2972 ++input_line_pointer;
2974 symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
2976 demand_empty_rest_of_line ();
2979 /* The .stabx pseudo-op. This is similar to a normal .stabs
2980 pseudo-op, but slightly different. A sample is
2981 .stabx "main:F-1",.main,142,0
2982 The first argument is the symbol name to create. The second is the
2983 value, and the third is the storage class. The fourth seems to be
2984 always zero, and I am assuming it is the type. */
2988 int ignore ATTRIBUTE_UNUSED;
2995 name = demand_copy_C_string (&len);
2997 if (*input_line_pointer != ',')
2999 as_bad (_("missing value"));
3002 ++input_line_pointer;
3004 ppc_stab_symbol = true;
3005 sym = symbol_make (name);
3006 ppc_stab_symbol = false;
3008 symbol_get_tc (sym)->real_name = name;
3010 (void) expression (&exp);
3017 as_bad (_("illegal .stabx expression; zero assumed"));
3018 exp.X_add_number = 0;
3021 S_SET_VALUE (sym, (valueT) exp.X_add_number);
3022 symbol_set_frag (sym, &zero_address_frag);
3026 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
3027 symbol_set_value_expression (sym, &exp);
3031 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
3032 symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
3037 /* The value is some complex expression. This will probably
3038 fail at some later point, but this is probably the right
3039 thing to do here. */
3040 symbol_set_value_expression (sym, &exp);
3044 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3045 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3047 if (*input_line_pointer != ',')
3049 as_bad (_("missing class"));
3052 ++input_line_pointer;
3054 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
3056 if (*input_line_pointer != ',')
3058 as_bad (_("missing type"));
3061 ++input_line_pointer;
3063 S_SET_DATA_TYPE (sym, get_absolute_expression ());
3065 symbol_get_tc (sym)->output = 1;
3067 if (S_GET_STORAGE_CLASS (sym) == C_STSYM) {
3069 symbol_get_tc (sym)->within = ppc_current_block;
3074 .stabx "z",arrays_,133,0
3077 .comm arrays_,13768,3
3079 resolve_symbol_value will copy the exp's "within" into sym's when the
3080 offset is 0. Since this seems to be corner case problem,
3081 only do the correction for storage class C_STSYM. A better solution
3082 would be to have the tc field updated in ppc_symbol_new_hook. */
3084 if (exp.X_op == O_symbol)
3086 symbol_get_tc (exp.X_add_symbol)->within = ppc_current_block;
3090 if (exp.X_op != O_symbol
3091 || ! S_IS_EXTERNAL (exp.X_add_symbol)
3092 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
3093 ppc_frob_label (sym);
3096 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3097 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
3098 if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
3099 symbol_get_tc (ppc_current_csect)->within = sym;
3102 demand_empty_rest_of_line ();
3105 /* The .function pseudo-op. This takes several arguments. The first
3106 argument seems to be the external name of the symbol. The second
3107 argment seems to be the label for the start of the function. gcc
3108 uses the same name for both. I have no idea what the third and
3109 fourth arguments are meant to be. The optional fifth argument is
3110 an expression for the size of the function. In COFF this symbol
3111 gets an aux entry like that used for a csect. */
3114 ppc_function (ignore)
3115 int ignore ATTRIBUTE_UNUSED;
3123 name = input_line_pointer;
3124 endc = get_symbol_end ();
3126 /* Ignore any [PR] suffix. */
3127 name = ppc_canonicalize_symbol_name (name);
3128 s = strchr (name, '[');
3129 if (s != (char *) NULL
3130 && strcmp (s + 1, "PR]") == 0)
3133 ext_sym = symbol_find_or_make (name);
3135 *input_line_pointer = endc;
3137 if (*input_line_pointer != ',')
3139 as_bad (_("missing symbol name"));
3140 ignore_rest_of_line ();
3143 ++input_line_pointer;
3145 name = input_line_pointer;
3146 endc = get_symbol_end ();
3148 lab_sym = symbol_find_or_make (name);
3150 *input_line_pointer = endc;
3152 if (ext_sym != lab_sym)
3156 exp.X_op = O_symbol;
3157 exp.X_add_symbol = lab_sym;
3158 exp.X_op_symbol = NULL;
3159 exp.X_add_number = 0;
3161 symbol_set_value_expression (ext_sym, &exp);
3164 if (symbol_get_tc (ext_sym)->class == -1)
3165 symbol_get_tc (ext_sym)->class = XMC_PR;
3166 symbol_get_tc (ext_sym)->output = 1;
3168 if (*input_line_pointer == ',')
3172 /* Ignore the third argument. */
3173 ++input_line_pointer;
3174 expression (&ignore);
3175 if (*input_line_pointer == ',')
3177 /* Ignore the fourth argument. */
3178 ++input_line_pointer;
3179 expression (&ignore);
3180 if (*input_line_pointer == ',')
3182 /* The fifth argument is the function size. */
3183 ++input_line_pointer;
3184 symbol_get_tc (ext_sym)->size = symbol_new ("L0\001",
3187 &zero_address_frag);
3188 pseudo_set (symbol_get_tc (ext_sym)->size);
3193 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3194 SF_SET_FUNCTION (ext_sym);
3195 SF_SET_PROCESS (ext_sym);
3196 coff_add_linesym (ext_sym);
3198 demand_empty_rest_of_line ();
3201 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
3202 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
3203 with the correct line number */
3205 static symbolS *saved_bi_sym = 0;
3209 int ignore ATTRIBUTE_UNUSED;
3213 sym = symbol_make (".bf");
3214 S_SET_SEGMENT (sym, text_section);
3215 symbol_set_frag (sym, frag_now);
3216 S_SET_VALUE (sym, frag_now_fix ());
3217 S_SET_STORAGE_CLASS (sym, C_FCN);
3219 coff_line_base = get_absolute_expression ();
3221 S_SET_NUMBER_AUXILIARY (sym, 1);
3222 SA_SET_SYM_LNNO (sym, coff_line_base);
3224 /* Line number for bi. */
3227 S_SET_VALUE (saved_bi_sym, coff_n_line_nos);
3232 symbol_get_tc (sym)->output = 1;
3234 ppc_frob_label (sym);
3236 demand_empty_rest_of_line ();
3239 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
3240 ".ef", except that the line number is absolute, not relative to the
3241 most recent ".bf" symbol. */
3245 int ignore ATTRIBUTE_UNUSED;
3249 sym = symbol_make (".ef");
3250 S_SET_SEGMENT (sym, text_section);
3251 symbol_set_frag (sym, frag_now);
3252 S_SET_VALUE (sym, frag_now_fix ());
3253 S_SET_STORAGE_CLASS (sym, C_FCN);
3254 S_SET_NUMBER_AUXILIARY (sym, 1);
3255 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3256 symbol_get_tc (sym)->output = 1;
3258 ppc_frob_label (sym);
3260 demand_empty_rest_of_line ();
3263 /* The .bi and .ei pseudo-ops. These take a string argument and
3264 generates a C_BINCL or C_EINCL symbol, which goes at the start of
3265 the symbol list. The value of .bi will be know when the next .bf
3272 static symbolS *last_biei;
3279 name = demand_copy_C_string (&len);
3281 /* The value of these symbols is actually file offset. Here we set
3282 the value to the index into the line number entries. In
3283 ppc_frob_symbols we set the fix_line field, which will cause BFD
3284 to do the right thing. */
3286 sym = symbol_make (name);
3287 /* obj-coff.c currently only handles line numbers correctly in the
3289 S_SET_SEGMENT (sym, text_section);
3290 S_SET_VALUE (sym, coff_n_line_nos);
3291 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3293 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
3294 symbol_get_tc (sym)->output = 1;
3302 for (look = last_biei ? last_biei : symbol_rootP;
3303 (look != (symbolS *) NULL
3304 && (S_GET_STORAGE_CLASS (look) == C_FILE
3305 || S_GET_STORAGE_CLASS (look) == C_BINCL
3306 || S_GET_STORAGE_CLASS (look) == C_EINCL));
3307 look = symbol_next (look))
3309 if (look != (symbolS *) NULL)
3311 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3312 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
3316 demand_empty_rest_of_line ();
3319 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
3320 There is one argument, which is a csect symbol. The value of the
3321 .bs symbol is the index of this csect symbol. */
3325 int ignore ATTRIBUTE_UNUSED;
3332 if (ppc_current_block != NULL)
3333 as_bad (_("nested .bs blocks"));
3335 name = input_line_pointer;
3336 endc = get_symbol_end ();
3338 csect = symbol_find_or_make (name);
3340 *input_line_pointer = endc;
3342 sym = symbol_make (".bs");
3343 S_SET_SEGMENT (sym, now_seg);
3344 S_SET_STORAGE_CLASS (sym, C_BSTAT);
3345 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3346 symbol_get_tc (sym)->output = 1;
3348 symbol_get_tc (sym)->within = csect;
3350 ppc_frob_label (sym);
3352 ppc_current_block = sym;
3354 demand_empty_rest_of_line ();
3357 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
3361 int ignore ATTRIBUTE_UNUSED;
3365 if (ppc_current_block == NULL)
3366 as_bad (_(".es without preceding .bs"));
3368 sym = symbol_make (".es");
3369 S_SET_SEGMENT (sym, now_seg);
3370 S_SET_STORAGE_CLASS (sym, C_ESTAT);
3371 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3372 symbol_get_tc (sym)->output = 1;
3374 ppc_frob_label (sym);
3376 ppc_current_block = NULL;
3378 demand_empty_rest_of_line ();
3381 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3386 int ignore ATTRIBUTE_UNUSED;
3390 sym = symbol_make (".bb");
3391 S_SET_SEGMENT (sym, text_section);
3392 symbol_set_frag (sym, frag_now);
3393 S_SET_VALUE (sym, frag_now_fix ());
3394 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3396 S_SET_NUMBER_AUXILIARY (sym, 1);
3397 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3399 symbol_get_tc (sym)->output = 1;
3401 SF_SET_PROCESS (sym);
3403 ppc_frob_label (sym);
3405 demand_empty_rest_of_line ();
3408 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3413 int ignore ATTRIBUTE_UNUSED;
3417 sym = symbol_make (".eb");
3418 S_SET_SEGMENT (sym, text_section);
3419 symbol_set_frag (sym, frag_now);
3420 S_SET_VALUE (sym, frag_now_fix ());
3421 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3422 S_SET_NUMBER_AUXILIARY (sym, 1);
3423 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3424 symbol_get_tc (sym)->output = 1;
3426 SF_SET_PROCESS (sym);
3428 ppc_frob_label (sym);
3430 demand_empty_rest_of_line ();
3433 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3438 int ignore ATTRIBUTE_UNUSED;
3444 name = demand_copy_C_string (&len);
3445 sym = symbol_make (name);
3446 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3447 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3448 S_SET_STORAGE_CLASS (sym, C_BCOMM);
3449 S_SET_VALUE (sym, 0);
3450 symbol_get_tc (sym)->output = 1;
3452 ppc_frob_label (sym);
3454 demand_empty_rest_of_line ();
3457 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3461 int ignore ATTRIBUTE_UNUSED;
3465 sym = symbol_make (".ec");
3466 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3467 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3468 S_SET_STORAGE_CLASS (sym, C_ECOMM);
3469 S_SET_VALUE (sym, 0);
3470 symbol_get_tc (sym)->output = 1;
3472 ppc_frob_label (sym);
3474 demand_empty_rest_of_line ();
3477 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3481 int ignore ATTRIBUTE_UNUSED;
3483 if (ppc_toc_csect != (symbolS *) NULL)
3484 subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
3491 subseg = ppc_data_subsegment;
3492 ++ppc_data_subsegment;
3494 subseg_new (segment_name (data_section), subseg);
3495 ppc_toc_frag = frag_now;
3497 sym = symbol_find_or_make ("TOC[TC0]");
3498 symbol_set_frag (sym, frag_now);
3499 S_SET_SEGMENT (sym, data_section);
3500 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3501 symbol_get_tc (sym)->subseg = subseg;
3502 symbol_get_tc (sym)->output = 1;
3503 symbol_get_tc (sym)->within = sym;
3505 ppc_toc_csect = sym;
3507 for (list = ppc_data_csects;
3508 symbol_get_tc (list)->next != (symbolS *) NULL;
3509 list = symbol_get_tc (list)->next)
3511 symbol_get_tc (list)->next = sym;
3513 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3514 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3518 ppc_current_csect = ppc_toc_csect;
3520 demand_empty_rest_of_line ();
3523 /* The AIX assembler automatically aligns the operands of a .long or
3524 .short pseudo-op, and we want to be compatible. */
3527 ppc_xcoff_cons (log_size)
3530 frag_align (log_size, 0, 0);
3531 record_alignment (now_seg, log_size);
3532 cons (1 << log_size);
3537 int dummy ATTRIBUTE_UNUSED;
3542 (void) expression (&exp);
3544 if (exp.X_op != O_constant)
3546 as_bad (_("non-constant byte count"));
3550 byte_count = exp.X_add_number;
3552 if (*input_line_pointer != ',')
3554 as_bad (_("missing value"));
3558 ++input_line_pointer;
3562 #endif /* OBJ_XCOFF */
3563 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3565 /* The .tc pseudo-op. This is used when generating either XCOFF or
3566 ELF. This takes two or more arguments.
3568 When generating XCOFF output, the first argument is the name to
3569 give to this location in the toc; this will be a symbol with class
3570 TC. The rest of the arguments are N-byte values to actually put at
3571 this location in the TOC; often there is just one more argument, a
3572 relocateable symbol reference. The size of the value to store
3573 depends on target word size. A 32-bit target uses 4-byte values, a
3574 64-bit target uses 8-byte values.
3576 When not generating XCOFF output, the arguments are the same, but
3577 the first argument is simply ignored. */
3581 int ignore ATTRIBUTE_UNUSED;
3585 /* Define the TOC symbol name. */
3591 if (ppc_toc_csect == (symbolS *) NULL
3592 || ppc_toc_csect != ppc_current_csect)
3594 as_bad (_(".tc not in .toc section"));
3595 ignore_rest_of_line ();
3599 name = input_line_pointer;
3600 endc = get_symbol_end ();
3602 sym = symbol_find_or_make (name);
3604 *input_line_pointer = endc;
3606 if (S_IS_DEFINED (sym))
3610 label = symbol_get_tc (ppc_current_csect)->within;
3611 if (symbol_get_tc (label)->class != XMC_TC0)
3613 as_bad (_(".tc with no label"));
3614 ignore_rest_of_line ();
3618 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
3619 symbol_set_frag (label, symbol_get_frag (sym));
3620 S_SET_VALUE (label, S_GET_VALUE (sym));
3622 while (! is_end_of_line[(unsigned char) *input_line_pointer])
3623 ++input_line_pointer;
3628 S_SET_SEGMENT (sym, now_seg);
3629 symbol_set_frag (sym, frag_now);
3630 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3631 symbol_get_tc (sym)->class = XMC_TC;
3632 symbol_get_tc (sym)->output = 1;
3634 ppc_frob_label (sym);
3637 #endif /* OBJ_XCOFF */
3641 /* Skip the TOC symbol name. */
3642 while (is_part_of_name (*input_line_pointer)
3643 || *input_line_pointer == '['
3644 || *input_line_pointer == ']'
3645 || *input_line_pointer == '{'
3646 || *input_line_pointer == '}')
3647 ++input_line_pointer;
3649 /* Align to a four/eight byte boundary. */
3650 align = BFD_DEFAULT_TARGET_SIZE == 64 && ppc_size == PPC_OPCODE_64 ? 3 : 2;
3651 frag_align (align, 0, 0);
3652 record_alignment (now_seg, align);
3653 #endif /* OBJ_ELF */
3655 if (*input_line_pointer != ',')
3656 demand_empty_rest_of_line ();
3659 ++input_line_pointer;
3660 cons ((ppc_size == PPC_OPCODE_64) ? 8 : 4);
3664 /* Pseudo-op .machine. */
3665 /* FIXME: `.machine' is a nop for the moment. It would be nice to
3666 accept this directive on the first line of input and set ppc_size
3667 and the target format accordingly. Unfortunately, the target
3668 format is selected in output-file.c:output_file_create before we
3669 even get to md_begin, so it's not possible without changing
3673 ppc_machine (ignore)
3674 int ignore ATTRIBUTE_UNUSED;
3676 discard_rest_of_line ();
3679 /* See whether a symbol is in the TOC section. */
3682 ppc_is_toc_sym (sym)
3686 return symbol_get_tc (sym)->class == XMC_TC;
3689 const char *sname = segment_name (S_GET_SEGMENT (sym));
3690 if (BFD_DEFAULT_TARGET_SIZE == 64 && ppc_size == PPC_OPCODE_64)
3691 return strcmp (sname, ".toc") == 0;
3693 return strcmp (sname, ".got") == 0;
3696 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3700 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
3702 /* Set the current section. */
3704 ppc_set_current_section (new)
3707 ppc_previous_section = ppc_current_section;
3708 ppc_current_section = new;
3711 /* pseudo-op: .previous
3712 behaviour: toggles the current section with the previous section.
3714 warnings: "No previous section" */
3717 ppc_previous (ignore)
3718 int ignore ATTRIBUTE_UNUSED;
3722 if (ppc_previous_section == NULL)
3724 as_warn (_("No previous section to return to. Directive ignored."));
3728 subseg_set (ppc_previous_section, 0);
3730 ppc_set_current_section (ppc_previous_section);
3733 /* pseudo-op: .pdata
3734 behaviour: predefined read only data section
3738 initial: .section .pdata "adr3"
3739 a - don't know -- maybe a misprint
3740 d - initialized data
3742 3 - double word aligned (that would be 4 byte boundary)
3745 Tag index tables (also known as the function table) for exception
3746 handling, debugging, etc. */
3750 int ignore ATTRIBUTE_UNUSED;
3752 if (pdata_section == 0)
3754 pdata_section = subseg_new (".pdata", 0);
3756 bfd_set_section_flags (stdoutput, pdata_section,
3757 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3758 | SEC_READONLY | SEC_DATA ));
3760 bfd_set_section_alignment (stdoutput, pdata_section, 2);
3764 pdata_section = subseg_new (".pdata", 0);
3766 ppc_set_current_section (pdata_section);
3769 /* pseudo-op: .ydata
3770 behaviour: predefined read only data section
3774 initial: .section .ydata "drw3"
3775 a - don't know -- maybe a misprint
3776 d - initialized data
3778 3 - double word aligned (that would be 4 byte boundary)
3780 Tag tables (also known as the scope table) for exception handling,
3785 int ignore ATTRIBUTE_UNUSED;
3787 if (ydata_section == 0)
3789 ydata_section = subseg_new (".ydata", 0);
3790 bfd_set_section_flags (stdoutput, ydata_section,
3791 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3792 | SEC_READONLY | SEC_DATA ));
3794 bfd_set_section_alignment (stdoutput, ydata_section, 3);
3798 ydata_section = subseg_new (".ydata", 0);
3800 ppc_set_current_section (ydata_section);
3803 /* pseudo-op: .reldata
3804 behaviour: predefined read write data section
3805 double word aligned (4-byte)
3806 FIXME: relocation is applied to it
3807 FIXME: what's the difference between this and .data?
3810 initial: .section .reldata "drw3"
3811 d - initialized data
3814 3 - double word aligned (that would be 8 byte boundary)
3817 Like .data, but intended to hold data subject to relocation, such as
3818 function descriptors, etc. */
3821 ppc_reldata (ignore)
3822 int ignore ATTRIBUTE_UNUSED;
3824 if (reldata_section == 0)
3826 reldata_section = subseg_new (".reldata", 0);
3828 bfd_set_section_flags (stdoutput, reldata_section,
3829 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3832 bfd_set_section_alignment (stdoutput, reldata_section, 2);
3836 reldata_section = subseg_new (".reldata", 0);
3838 ppc_set_current_section (reldata_section);
3841 /* pseudo-op: .rdata
3842 behaviour: predefined read only data section
3846 initial: .section .rdata "dr3"
3847 d - initialized data
3849 3 - double word aligned (that would be 4 byte boundary) */
3853 int ignore ATTRIBUTE_UNUSED;
3855 if (rdata_section == 0)
3857 rdata_section = subseg_new (".rdata", 0);
3858 bfd_set_section_flags (stdoutput, rdata_section,
3859 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3860 | SEC_READONLY | SEC_DATA ));
3862 bfd_set_section_alignment (stdoutput, rdata_section, 2);
3866 rdata_section = subseg_new (".rdata", 0);
3868 ppc_set_current_section (rdata_section);
3871 /* pseudo-op: .ualong
3872 behaviour: much like .int, with the exception that no alignment is
3874 FIXME: test the alignment statement
3880 int ignore ATTRIBUTE_UNUSED;
3886 /* pseudo-op: .znop <symbol name>
3887 behaviour: Issue a nop instruction
3888 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3889 the supplied symbol name.
3891 warnings: Missing symbol name */
3895 int ignore ATTRIBUTE_UNUSED;
3898 const struct powerpc_opcode *opcode;
3909 /* Strip out the symbol name. */
3910 symbol_name = input_line_pointer;
3911 c = get_symbol_end ();
3913 name = xmalloc (input_line_pointer - symbol_name + 1);
3914 strcpy (name, symbol_name);
3916 sym = symbol_find_or_make (name);
3918 *input_line_pointer = c;
3922 /* Look up the opcode in the hash table. */
3923 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
3925 /* Stick in the nop. */
3926 insn = opcode->opcode;
3928 /* Write out the instruction. */
3930 md_number_to_chars (f, insn, 4);
3932 f - frag_now->fr_literal,
3937 BFD_RELOC_16_GOT_PCREL);
3950 register char *name;
3954 register symbolS *symbolP;
3957 name = input_line_pointer;
3958 c = get_symbol_end ();
3960 /* just after name is now '\0'. */
3961 p = input_line_pointer;
3964 if (*input_line_pointer != ',')
3966 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3967 ignore_rest_of_line ();
3971 input_line_pointer++; /* skip ',' */
3972 if ((temp = get_absolute_expression ()) < 0)
3974 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
3975 ignore_rest_of_line ();
3981 /* The third argument to .comm is the alignment. */
3982 if (*input_line_pointer != ',')
3986 ++input_line_pointer;
3987 align = get_absolute_expression ();
3990 as_warn (_("ignoring bad alignment"));
3997 symbolP = symbol_find_or_make (name);
4000 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
4002 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4003 S_GET_NAME (symbolP));
4004 ignore_rest_of_line ();
4008 if (S_GET_VALUE (symbolP))
4010 if (S_GET_VALUE (symbolP) != (valueT) temp)
4011 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4012 S_GET_NAME (symbolP),
4013 (long) S_GET_VALUE (symbolP),
4018 S_SET_VALUE (symbolP, (valueT) temp);
4019 S_SET_EXTERNAL (symbolP);
4022 demand_empty_rest_of_line ();
4026 * implement the .section pseudo op:
4027 * .section name {, "flags"}
4029 * | +--- optional flags: 'b' for bss
4031 * +-- section name 'l' for lib
4035 * 'd' (apparently m88k for data)
4037 * But if the argument is not a quoted string, treat it as a
4038 * subsegment number.
4040 * FIXME: this is a copy of the section processing from obj-coff.c, with
4041 * additions/changes for the moto-pas assembler support. There are three
4044 * FIXME: I just noticed this. This doesn't work at all really. It it
4045 * setting bits that bfd probably neither understands or uses. The
4046 * correct approach (?) will have to incorporate extra fields attached
4047 * to the section to hold the system specific stuff. (krk)
4050 * 'a' - unknown - referred to in documentation, but no definition supplied
4051 * 'c' - section has code
4052 * 'd' - section has initialized data
4053 * 'u' - section has uninitialized data
4054 * 'i' - section contains directives (info)
4055 * 'n' - section can be discarded
4056 * 'R' - remove section at link time
4058 * Section Protection:
4059 * 'r' - section is readable
4060 * 'w' - section is writeable
4061 * 'x' - section is executable
4062 * 's' - section is sharable
4064 * Section Alignment:
4065 * '0' - align to byte boundary
4066 * '1' - align to halfword undary
4067 * '2' - align to word boundary
4068 * '3' - align to doubleword boundary
4069 * '4' - align to quadword boundary
4070 * '5' - align to 32 byte boundary
4071 * '6' - align to 64 byte boundary
4076 ppc_pe_section (ignore)
4077 int ignore ATTRIBUTE_UNUSED;
4079 /* Strip out the section name. */
4088 section_name = input_line_pointer;
4089 c = get_symbol_end ();
4091 name = xmalloc (input_line_pointer - section_name + 1);
4092 strcpy (name, section_name);
4094 *input_line_pointer = c;
4099 flags = SEC_NO_FLAGS;
4101 if (strcmp (name, ".idata$2") == 0)
4105 else if (strcmp (name, ".idata$3") == 0)
4109 else if (strcmp (name, ".idata$4") == 0)
4113 else if (strcmp (name, ".idata$5") == 0)
4117 else if (strcmp (name, ".idata$6") == 0)
4122 /* Default alignment to 16 byte boundary. */
4125 if (*input_line_pointer == ',')
4127 ++input_line_pointer;
4129 if (*input_line_pointer != '"')
4130 exp = get_absolute_expression ();
4133 ++input_line_pointer;
4134 while (*input_line_pointer != '"'
4135 && ! is_end_of_line[(unsigned char) *input_line_pointer])
4137 switch (*input_line_pointer)
4139 /* Section Contents */
4140 case 'a': /* unknown */
4141 as_bad (_("Unsupported section attribute -- 'a'"));
4143 case 'c': /* code section */
4146 case 'd': /* section has initialized data */
4149 case 'u': /* section has uninitialized data */
4150 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4154 case 'i': /* section contains directives (info) */
4155 /* FIXME: This is IMAGE_SCN_LNK_INFO
4157 flags |= SEC_HAS_CONTENTS;
4159 case 'n': /* section can be discarded */
4162 case 'R': /* Remove section at link time */
4163 flags |= SEC_NEVER_LOAD;
4166 /* Section Protection */
4167 case 'r': /* section is readable */
4168 flags |= IMAGE_SCN_MEM_READ;
4170 case 'w': /* section is writeable */
4171 flags |= IMAGE_SCN_MEM_WRITE;
4173 case 'x': /* section is executable */
4174 flags |= IMAGE_SCN_MEM_EXECUTE;
4176 case 's': /* section is sharable */
4177 flags |= IMAGE_SCN_MEM_SHARED;
4180 /* Section Alignment */
4181 case '0': /* align to byte boundary */
4182 flags |= IMAGE_SCN_ALIGN_1BYTES;
4185 case '1': /* align to halfword boundary */
4186 flags |= IMAGE_SCN_ALIGN_2BYTES;
4189 case '2': /* align to word boundary */
4190 flags |= IMAGE_SCN_ALIGN_4BYTES;
4193 case '3': /* align to doubleword boundary */
4194 flags |= IMAGE_SCN_ALIGN_8BYTES;
4197 case '4': /* align to quadword boundary */
4198 flags |= IMAGE_SCN_ALIGN_16BYTES;
4201 case '5': /* align to 32 byte boundary */
4202 flags |= IMAGE_SCN_ALIGN_32BYTES;
4205 case '6': /* align to 64 byte boundary */
4206 flags |= IMAGE_SCN_ALIGN_64BYTES;
4211 as_bad (_("unknown section attribute '%c'"),
4212 *input_line_pointer);
4215 ++input_line_pointer;
4217 if (*input_line_pointer == '"')
4218 ++input_line_pointer;
4222 sec = subseg_new (name, (subsegT) exp);
4224 ppc_set_current_section (sec);
4226 if (flags != SEC_NO_FLAGS)
4228 if (! bfd_set_section_flags (stdoutput, sec, flags))
4229 as_bad (_("error setting flags for \"%s\": %s"),
4230 bfd_section_name (stdoutput, sec),
4231 bfd_errmsg (bfd_get_error ()));
4234 bfd_set_section_alignment (stdoutput, sec, align);
4239 ppc_pe_function (ignore)
4240 int ignore ATTRIBUTE_UNUSED;
4246 name = input_line_pointer;
4247 endc = get_symbol_end ();
4249 ext_sym = symbol_find_or_make (name);
4251 *input_line_pointer = endc;
4253 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
4254 SF_SET_FUNCTION (ext_sym);
4255 SF_SET_PROCESS (ext_sym);
4256 coff_add_linesym (ext_sym);
4258 demand_empty_rest_of_line ();
4262 ppc_pe_tocd (ignore)
4263 int ignore ATTRIBUTE_UNUSED;
4265 if (tocdata_section == 0)
4267 tocdata_section = subseg_new (".tocd", 0);
4268 /* FIXME: section flags won't work. */
4269 bfd_set_section_flags (stdoutput, tocdata_section,
4270 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4271 | SEC_READONLY | SEC_DATA));
4273 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
4277 rdata_section = subseg_new (".tocd", 0);
4280 ppc_set_current_section (tocdata_section);
4282 demand_empty_rest_of_line ();
4285 /* Don't adjust TOC relocs to use the section symbol. */
4288 ppc_pe_fix_adjustable (fix)
4291 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
4298 /* XCOFF specific symbol and file handling. */
4300 /* Canonicalize the symbol name. We use the to force the suffix, if
4301 any, to use square brackets, and to be in upper case. */
4304 ppc_canonicalize_symbol_name (name)
4309 if (ppc_stab_symbol)
4312 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
4326 for (s++; *s != '\0' && *s != brac; s++)
4329 if (*s == '\0' || s[1] != '\0')
4330 as_bad (_("bad symbol suffix"));
4338 /* Set the class of a symbol based on the suffix, if any. This is
4339 called whenever a new symbol is created. */
4342 ppc_symbol_new_hook (sym)
4345 struct ppc_tc_sy *tc;
4348 tc = symbol_get_tc (sym);
4352 tc->real_name = NULL;
4358 if (ppc_stab_symbol)
4361 s = strchr (S_GET_NAME (sym), '[');
4362 if (s == (const char *) NULL)
4364 /* There is no suffix. */
4373 if (strcmp (s, "BS]") == 0)
4377 if (strcmp (s, "DB]") == 0)
4379 else if (strcmp (s, "DS]") == 0)
4383 if (strcmp (s, "GL]") == 0)
4387 if (strcmp (s, "PR]") == 0)
4391 if (strcmp (s, "RO]") == 0)
4393 else if (strcmp (s, "RW]") == 0)
4397 if (strcmp (s, "SV]") == 0)
4401 if (strcmp (s, "TC]") == 0)
4403 else if (strcmp (s, "TI]") == 0)
4405 else if (strcmp (s, "TB]") == 0)
4407 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
4408 tc->class = XMC_TC0;
4411 if (strcmp (s, "UA]") == 0)
4413 else if (strcmp (s, "UC]") == 0)
4417 if (strcmp (s, "XO]") == 0)
4422 if (tc->class == -1)
4423 as_bad (_("Unrecognized symbol suffix"));
4426 /* Set the class of a label based on where it is defined. This
4427 handles symbols without suffixes. Also, move the symbol so that it
4428 follows the csect symbol. */
4431 ppc_frob_label (sym)
4434 if (ppc_current_csect != (symbolS *) NULL)
4436 if (symbol_get_tc (sym)->class == -1)
4437 symbol_get_tc (sym)->class = symbol_get_tc (ppc_current_csect)->class;
4439 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4440 symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
4441 &symbol_rootP, &symbol_lastP);
4442 symbol_get_tc (ppc_current_csect)->within = sym;
4446 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4447 seen. It tells ppc_adjust_symtab whether it needs to look through
4450 static boolean ppc_saw_abs;
4452 /* Change the name of a symbol just before writing it out. Set the
4453 real name if the .rename pseudo-op was used. Otherwise, remove any
4454 class suffix. Return 1 if the symbol should not be included in the
4458 ppc_frob_symbol (sym)
4461 static symbolS *ppc_last_function;
4462 static symbolS *set_end;
4464 /* Discard symbols that should not be included in the output symbol
4466 if (! symbol_used_in_reloc_p (sym)
4467 && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
4468 || (! S_IS_EXTERNAL (sym)
4469 && ! symbol_get_tc (sym)->output
4470 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
4473 if (symbol_get_tc (sym)->real_name != (char *) NULL)
4474 S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
4480 name = S_GET_NAME (sym);
4481 s = strchr (name, '[');
4482 if (s != (char *) NULL)
4488 snew = xmalloc (len + 1);
4489 memcpy (snew, name, len);
4492 S_SET_NAME (sym, snew);
4496 if (set_end != (symbolS *) NULL)
4498 SA_SET_SYM_ENDNDX (set_end, sym);
4502 if (SF_GET_FUNCTION (sym))
4504 if (ppc_last_function != (symbolS *) NULL)
4505 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4506 ppc_last_function = sym;
4507 if (symbol_get_tc (sym)->size != (symbolS *) NULL)
4509 resolve_symbol_value (symbol_get_tc (sym)->size);
4510 SA_SET_SYM_FSIZE (sym,
4511 (long) S_GET_VALUE (symbol_get_tc (sym)->size));
4514 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4515 && strcmp (S_GET_NAME (sym), ".ef") == 0)
4517 if (ppc_last_function == (symbolS *) NULL)
4518 as_bad (_(".ef with no preceding .function"));
4521 set_end = ppc_last_function;
4522 ppc_last_function = NULL;
4524 /* We don't have a C_EFCN symbol, but we need to force the
4525 COFF backend to believe that it has seen one. */
4526 coff_last_function = NULL;
4530 if (! S_IS_EXTERNAL (sym)
4531 && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
4532 && S_GET_STORAGE_CLASS (sym) != C_FILE
4533 && S_GET_STORAGE_CLASS (sym) != C_FCN
4534 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4535 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4536 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
4537 && S_GET_STORAGE_CLASS (sym) != C_BINCL
4538 && S_GET_STORAGE_CLASS (sym) != C_EINCL
4539 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
4540 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
4542 if (S_GET_STORAGE_CLASS (sym) == C_EXT
4543 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
4546 union internal_auxent *a;
4548 /* Create a csect aux. */
4549 i = S_GET_NUMBER_AUXILIARY (sym);
4550 S_SET_NUMBER_AUXILIARY (sym, i + 1);
4551 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
4552 if (symbol_get_tc (sym)->class == XMC_TC0)
4554 /* This is the TOC table. */
4555 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
4556 a->x_csect.x_scnlen.l = 0;
4557 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4559 else if (symbol_get_tc (sym)->subseg != 0)
4561 /* This is a csect symbol. x_scnlen is the size of the
4563 if (symbol_get_tc (sym)->next == (symbolS *) NULL)
4564 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4565 S_GET_SEGMENT (sym))
4566 - S_GET_VALUE (sym));
4569 resolve_symbol_value (symbol_get_tc (sym)->next);
4570 a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
4571 - S_GET_VALUE (sym));
4573 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
4575 else if (S_GET_SEGMENT (sym) == bss_section)
4577 /* This is a common symbol. */
4578 a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
4579 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
4580 if (S_IS_EXTERNAL (sym))
4581 symbol_get_tc (sym)->class = XMC_RW;
4583 symbol_get_tc (sym)->class = XMC_BS;
4585 else if (S_GET_SEGMENT (sym) == absolute_section)
4587 /* This is an absolute symbol. The csect will be created by
4588 ppc_adjust_symtab. */
4590 a->x_csect.x_smtyp = XTY_LD;
4591 if (symbol_get_tc (sym)->class == -1)
4592 symbol_get_tc (sym)->class = XMC_XO;
4594 else if (! S_IS_DEFINED (sym))
4596 /* This is an external symbol. */
4597 a->x_csect.x_scnlen.l = 0;
4598 a->x_csect.x_smtyp = XTY_ER;
4600 else if (symbol_get_tc (sym)->class == XMC_TC)
4604 /* This is a TOC definition. x_scnlen is the size of the
4606 next = symbol_next (sym);
4607 while (symbol_get_tc (next)->class == XMC_TC0)
4608 next = symbol_next (next);
4609 if (next == (symbolS *) NULL
4610 || symbol_get_tc (next)->class != XMC_TC)
4612 if (ppc_after_toc_frag == (fragS *) NULL)
4613 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4615 - S_GET_VALUE (sym));
4617 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
4618 - S_GET_VALUE (sym));
4622 resolve_symbol_value (next);
4623 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
4624 - S_GET_VALUE (sym));
4626 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4632 /* This is a normal symbol definition. x_scnlen is the
4633 symbol index of the containing csect. */
4634 if (S_GET_SEGMENT (sym) == text_section)
4635 csect = ppc_text_csects;
4636 else if (S_GET_SEGMENT (sym) == data_section)
4637 csect = ppc_data_csects;
4641 /* Skip the initial dummy symbol. */
4642 csect = symbol_get_tc (csect)->next;
4644 if (csect == (symbolS *) NULL)
4646 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
4647 a->x_csect.x_scnlen.l = 0;
4651 while (symbol_get_tc (csect)->next != (symbolS *) NULL)
4653 resolve_symbol_value (symbol_get_tc (csect)->next);
4654 if (S_GET_VALUE (symbol_get_tc (csect)->next)
4655 > S_GET_VALUE (sym))
4657 csect = symbol_get_tc (csect)->next;
4660 a->x_csect.x_scnlen.p =
4661 coffsymbol (symbol_get_bfdsym (csect))->native;
4662 coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
4665 a->x_csect.x_smtyp = XTY_LD;
4668 a->x_csect.x_parmhash = 0;
4669 a->x_csect.x_snhash = 0;
4670 if (symbol_get_tc (sym)->class == -1)
4671 a->x_csect.x_smclas = XMC_PR;
4673 a->x_csect.x_smclas = symbol_get_tc (sym)->class;
4674 a->x_csect.x_stab = 0;
4675 a->x_csect.x_snstab = 0;
4677 /* Don't let the COFF backend resort these symbols. */
4678 symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
4680 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
4682 /* We want the value to be the symbol index of the referenced
4683 csect symbol. BFD will do that for us if we set the right
4687 coffsymbol (symbol_get_bfdsym
4688 (symbol_get_tc (sym)->within))->native));
4689 coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
4691 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4696 /* The value is the offset from the enclosing csect. */
4697 block = symbol_get_tc (sym)->within;
4698 csect = symbol_get_tc (block)->within;
4699 resolve_symbol_value (csect);
4700 S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
4702 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
4703 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
4705 /* We want the value to be a file offset into the line numbers.
4706 BFD will do that for us if we set the right flags. We have
4707 already set the value correctly. */
4708 coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
4714 /* Adjust the symbol table. This creates csect symbols for all
4715 absolute symbols. */
4718 ppc_adjust_symtab ()
4725 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4729 union internal_auxent *a;
4731 if (S_GET_SEGMENT (sym) != absolute_section)
4734 csect = symbol_create (".abs[XO]", absolute_section,
4735 S_GET_VALUE (sym), &zero_address_frag);
4736 symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
4737 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
4738 i = S_GET_NUMBER_AUXILIARY (csect);
4739 S_SET_NUMBER_AUXILIARY (csect, i + 1);
4740 a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
4741 a->x_csect.x_scnlen.l = 0;
4742 a->x_csect.x_smtyp = XTY_SD;
4743 a->x_csect.x_parmhash = 0;
4744 a->x_csect.x_snhash = 0;
4745 a->x_csect.x_smclas = XMC_XO;
4746 a->x_csect.x_stab = 0;
4747 a->x_csect.x_snstab = 0;
4749 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
4751 i = S_GET_NUMBER_AUXILIARY (sym);
4752 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
4753 a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
4754 coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
4757 ppc_saw_abs = false;
4760 /* Set the VMA for a section. This is called on all the sections in
4764 ppc_frob_section (sec)
4767 static bfd_size_type vma = 0;
4769 bfd_set_section_vma (stdoutput, sec, vma);
4770 vma += bfd_section_size (stdoutput, sec);
4773 #endif /* OBJ_XCOFF */
4775 /* Turn a string in input_line_pointer into a floating point constant
4776 of type TYPE, and store the appropriate bytes in *LITP. The number
4777 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4778 returned, or NULL on OK. */
4781 md_atof (type, litp, sizep)
4787 LITTLENUM_TYPE words[4];
4803 return _("bad call to md_atof");
4806 t = atof_ieee (input_line_pointer, type, words);
4808 input_line_pointer = t;
4812 if (target_big_endian)
4814 for (i = 0; i < prec; i++)
4816 md_number_to_chars (litp, (valueT) words[i], 2);
4822 for (i = prec - 1; i >= 0; i--)
4824 md_number_to_chars (litp, (valueT) words[i], 2);
4832 /* Write a value out to the object file, using the appropriate
4836 md_number_to_chars (buf, val, n)
4841 if (target_big_endian)
4842 number_to_chars_bigendian (buf, val, n);
4844 number_to_chars_littleendian (buf, val, n);
4847 /* Align a section (I don't know why this is machine dependent). */
4850 md_section_align (seg, addr)
4854 int align = bfd_get_section_alignment (stdoutput, seg);
4856 return ((addr + (1 << align) - 1) & (-1 << align));
4859 /* We don't have any form of relaxing. */
4862 md_estimate_size_before_relax (fragp, seg)
4863 fragS *fragp ATTRIBUTE_UNUSED;
4864 asection *seg ATTRIBUTE_UNUSED;
4870 /* Convert a machine dependent frag. We never generate these. */
4873 md_convert_frag (abfd, sec, fragp)
4874 bfd *abfd ATTRIBUTE_UNUSED;
4875 asection *sec ATTRIBUTE_UNUSED;
4876 fragS *fragp ATTRIBUTE_UNUSED;
4881 /* We have no need to default values of symbols. */
4884 md_undefined_symbol (name)
4885 char *name ATTRIBUTE_UNUSED;
4890 /* Functions concerning relocs. */
4892 /* The location from which a PC relative jump should be calculated,
4893 given a PC relative reloc. */
4896 md_pcrel_from_section (fixp, sec)
4898 segT sec ATTRIBUTE_UNUSED;
4900 return fixp->fx_frag->fr_address + fixp->fx_where;
4905 /* This is called to see whether a fixup should be adjusted to use a
4906 section symbol. We take the opportunity to change a fixup against
4907 a symbol in the TOC subsegment into a reloc against the
4908 corresponding .tc symbol. */
4911 ppc_fix_adjustable (fix)
4916 resolve_symbol_value (fix->fx_addsy);
4917 val = S_GET_VALUE (fix->fx_addsy);
4918 if (ppc_toc_csect != (symbolS *) NULL
4919 && fix->fx_addsy != (symbolS *) NULL
4920 && fix->fx_addsy != ppc_toc_csect
4921 && S_GET_SEGMENT (fix->fx_addsy) == data_section
4922 && val >= ppc_toc_frag->fr_address
4923 && (ppc_after_toc_frag == (fragS *) NULL
4924 || val < ppc_after_toc_frag->fr_address))
4928 for (sy = symbol_next (ppc_toc_csect);
4929 sy != (symbolS *) NULL;
4930 sy = symbol_next (sy))
4932 if (symbol_get_tc (sy)->class == XMC_TC0)
4934 if (symbol_get_tc (sy)->class != XMC_TC)
4936 resolve_symbol_value (sy);
4937 if (val == S_GET_VALUE (sy))
4940 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
4945 as_bad_where (fix->fx_file, fix->fx_line,
4946 _("symbol in .toc does not match any .tc"));
4949 /* Possibly adjust the reloc to be against the csect. */
4950 if (fix->fx_addsy != (symbolS *) NULL
4951 && symbol_get_tc (fix->fx_addsy)->subseg == 0
4952 && symbol_get_tc (fix->fx_addsy)->class != XMC_TC0
4953 && symbol_get_tc (fix->fx_addsy)->class != XMC_TC
4954 && S_GET_SEGMENT (fix->fx_addsy) != bss_section
4955 /* Don't adjust if this is a reloc in the toc section. */
4956 && (S_GET_SEGMENT (fix->fx_addsy) != data_section
4957 || ppc_toc_csect == NULL
4958 || val < ppc_toc_frag->fr_address
4959 || (ppc_after_toc_frag != NULL
4960 && val >= ppc_after_toc_frag->fr_address)))
4964 if (S_GET_SEGMENT (fix->fx_addsy) == text_section)
4965 csect = ppc_text_csects;
4966 else if (S_GET_SEGMENT (fix->fx_addsy) == data_section)
4967 csect = ppc_data_csects;
4971 /* Skip the initial dummy symbol. */
4972 csect = symbol_get_tc (csect)->next;
4974 if (csect != (symbolS *) NULL)
4976 while (symbol_get_tc (csect)->next != (symbolS *) NULL
4977 && (symbol_get_frag (symbol_get_tc (csect)->next)->fr_address
4980 /* If the csect address equals the symbol value, then we
4981 have to look through the full symbol table to see
4982 whether this is the csect we want. Note that we will
4983 only get here if the csect has zero length. */
4984 if ((symbol_get_frag (csect)->fr_address == val)
4985 && S_GET_VALUE (csect) == S_GET_VALUE (fix->fx_addsy))
4989 for (scan = symbol_next (csect);
4991 scan = symbol_next (scan))
4993 if (symbol_get_tc (scan)->subseg != 0)
4995 if (scan == fix->fx_addsy)
4999 /* If we found the symbol before the next csect
5000 symbol, then this is the csect we want. */
5001 if (scan == fix->fx_addsy)
5005 csect = symbol_get_tc (csect)->next;
5008 fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
5009 - symbol_get_frag (csect)->fr_address);
5010 fix->fx_addsy = csect;
5014 /* Adjust a reloc against a .lcomm symbol to be against the base
5016 if (fix->fx_addsy != (symbolS *) NULL
5017 && S_GET_SEGMENT (fix->fx_addsy) == bss_section
5018 && ! S_IS_EXTERNAL (fix->fx_addsy))
5020 resolve_symbol_value (symbol_get_frag (fix->fx_addsy)->fr_symbol);
5022 (S_GET_VALUE (fix->fx_addsy)
5023 - S_GET_VALUE (symbol_get_frag (fix->fx_addsy)->fr_symbol));
5024 fix->fx_addsy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
5030 /* A reloc from one csect to another must be kept. The assembler
5031 will, of course, keep relocs between sections, and it will keep
5032 absolute relocs, but we need to force it to keep PC relative relocs
5033 between two csects in the same section. */
5036 ppc_force_relocation (fix)
5039 /* At this point fix->fx_addsy should already have been converted to
5040 a csect symbol. If the csect does not include the fragment, then
5041 we need to force the relocation. */
5043 && fix->fx_addsy != NULL
5044 && symbol_get_tc (fix->fx_addsy)->subseg != 0
5045 && ((symbol_get_frag (fix->fx_addsy)->fr_address
5046 > fix->fx_frag->fr_address)
5047 || (symbol_get_tc (fix->fx_addsy)->next != NULL
5048 && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
5049 <= fix->fx_frag->fr_address))))
5055 #endif /* OBJ_XCOFF */
5059 ppc_fix_adjustable (fix)
5062 return (fix->fx_r_type != BFD_RELOC_16_GOTOFF
5063 && fix->fx_r_type != BFD_RELOC_LO16_GOTOFF
5064 && fix->fx_r_type != BFD_RELOC_HI16_GOTOFF
5065 && fix->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
5066 && fix->fx_r_type != BFD_RELOC_GPREL16
5067 && fix->fx_r_type != BFD_RELOC_VTABLE_INHERIT
5068 && fix->fx_r_type != BFD_RELOC_VTABLE_ENTRY
5069 && ! S_IS_EXTERNAL (fix->fx_addsy)
5070 && ! S_IS_WEAK (fix->fx_addsy)
5072 || (fix->fx_subsy != NULL
5073 && (S_GET_SEGMENT (fix->fx_subsy)
5074 == S_GET_SEGMENT (fix->fx_addsy)))
5075 || S_IS_LOCAL (fix->fx_addsy)));
5079 /* Apply a fixup to the object code. This is called for all the
5080 fixups we generated by the call to fix_new_exp, above. In the call
5081 above we used a reloc code which was the largest legal reloc code
5082 plus the operand index. Here we undo that to recover the operand
5083 index. At this point all symbol values should be fully resolved,
5084 and we attempt to completely resolve the reloc. If we can not do
5085 that, we determine the correct reloc code and put it back in the
5089 md_apply_fix3 (fixP, valP, seg)
5092 segT seg ATTRIBUTE_UNUSED;
5094 valueT value = * valP;
5097 if (fixP->fx_addsy != NULL)
5099 /* `*valuep' may contain the value of the symbol on which the reloc
5100 will be based; we have to remove it. */
5101 if (symbol_used_in_reloc_p (fixP->fx_addsy)
5102 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section
5103 && S_GET_SEGMENT (fixP->fx_addsy) != undefined_section
5104 && ! bfd_is_com_section (S_GET_SEGMENT (fixP->fx_addsy)))
5105 value -= S_GET_VALUE (fixP->fx_addsy);
5107 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
5108 supposed to be? I think this is related to various similar
5109 FIXMEs in tc-i386.c and tc-sparc.c. */
5111 value += fixP->fx_frag->fr_address + fixP->fx_where;
5116 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
5117 the symbol values. Since we are using BFD_ASSEMBLER, if we are
5118 doing this relocation the code in write.c is going to call
5119 bfd_install_relocation, which is also going to use the symbol
5120 value. That means that if the reloc is fully resolved we want to
5121 use *valuep since bfd_install_relocation is not being used.
5122 However, if the reloc is not fully resolved we do not want to use
5123 *valuep, and must use fx_offset instead. However, if the reloc
5124 is PC relative, we do want to use *valuep since it includes the
5125 result of md_pcrel_from. This is confusing. */
5126 if (fixP->fx_addsy == (symbolS *) NULL)
5129 else if (fixP->fx_pcrel)
5134 value = fixP->fx_offset;
5135 if (fixP->fx_subsy != (symbolS *) NULL)
5137 if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
5138 value -= S_GET_VALUE (fixP->fx_subsy);
5141 /* We can't actually support subtracting a symbol. */
5142 as_bad_where (fixP->fx_file, fixP->fx_line,
5143 _("expression too complex"));
5149 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
5152 const struct powerpc_operand *operand;
5156 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
5158 operand = &powerpc_operands[opindex];
5161 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5162 does not generate a reloc. It uses the offset of `sym' within its
5163 csect. Other usages, such as `.long sym', generate relocs. This
5164 is the documented behaviour of non-TOC symbols. */
5165 if ((operand->flags & PPC_OPERAND_PARENS) != 0
5166 && operand->bits == 16
5167 && operand->shift == 0
5168 && operand->insert == NULL
5169 && fixP->fx_addsy != NULL
5170 && symbol_get_tc (fixP->fx_addsy)->subseg != 0
5171 && symbol_get_tc (fixP->fx_addsy)->class != XMC_TC
5172 && symbol_get_tc (fixP->fx_addsy)->class != XMC_TC0
5173 && S_GET_SEGMENT (fixP->fx_addsy) != bss_section)
5175 value = fixP->fx_offset;
5180 /* Fetch the instruction, insert the fully resolved operand
5181 value, and stuff the instruction back again. */
5182 where = fixP->fx_frag->fr_literal + fixP->fx_where;
5183 if (target_big_endian)
5184 insn = bfd_getb32 ((unsigned char *) where);
5186 insn = bfd_getl32 ((unsigned char *) where);
5187 insn = ppc_insert_operand (insn, operand, (offsetT) value,
5188 fixP->fx_file, fixP->fx_line);
5189 if (target_big_endian)
5190 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
5192 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
5195 /* Nothing else to do here. */
5198 assert (fixP->fx_addsy != NULL);
5200 /* Determine a BFD reloc value based on the operand information.
5201 We are only prepared to turn a few of the operands into
5203 if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
5204 && operand->bits == 26
5205 && operand->shift == 0)
5206 fixP->fx_r_type = BFD_RELOC_PPC_B26;
5207 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
5208 && operand->bits == 16
5209 && operand->shift == 0)
5210 fixP->fx_r_type = BFD_RELOC_PPC_B16;
5211 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
5212 && operand->bits == 26
5213 && operand->shift == 0)
5214 fixP->fx_r_type = BFD_RELOC_PPC_BA26;
5215 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
5216 && operand->bits == 16
5217 && operand->shift == 0)
5218 fixP->fx_r_type = BFD_RELOC_PPC_BA16;
5219 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5220 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
5221 && operand->bits == 16
5222 && operand->shift == 0
5223 && ppc_is_toc_sym (fixP->fx_addsy))
5225 fixP->fx_r_type = BFD_RELOC_PPC_TOC16;
5227 if (BFD_DEFAULT_TARGET_SIZE == 64
5228 && ppc_size == PPC_OPCODE_64
5229 && (operand->flags & PPC_OPERAND_DS) != 0)
5230 fixP->fx_r_type = BFD_RELOC_PPC64_TOC16_DS;
5233 if (target_big_endian)
5234 fixP->fx_where += 2;
5236 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5242 /* Use expr_symbol_where to see if this is an expression
5244 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
5245 as_bad_where (fixP->fx_file, fixP->fx_line,
5246 _("unresolved expression that must be resolved"));
5248 as_bad_where (fixP->fx_file, fixP->fx_line,
5249 _("unsupported relocation against %s"),
5250 S_GET_NAME (fixP->fx_addsy));
5258 ppc_elf_validate_fix (fixP, seg);
5260 switch (fixP->fx_r_type)
5262 case BFD_RELOC_CTOR:
5263 if (BFD_DEFAULT_TARGET_SIZE == 64 && ppc_size == PPC_OPCODE_64)
5269 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5273 case BFD_RELOC_32_PCREL:
5274 case BFD_RELOC_32_BASEREL:
5275 case BFD_RELOC_PPC_EMB_NADDR32:
5276 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5283 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5286 case BFD_RELOC_64_PCREL:
5287 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5291 case BFD_RELOC_LO16:
5293 case BFD_RELOC_GPREL16:
5294 case BFD_RELOC_16_GOT_PCREL:
5295 case BFD_RELOC_16_GOTOFF:
5296 case BFD_RELOC_LO16_GOTOFF:
5297 case BFD_RELOC_HI16_GOTOFF:
5298 case BFD_RELOC_HI16_S_GOTOFF:
5299 case BFD_RELOC_LO16_BASEREL:
5300 case BFD_RELOC_HI16_BASEREL:
5301 case BFD_RELOC_HI16_S_BASEREL:
5302 case BFD_RELOC_PPC_EMB_NADDR16:
5303 case BFD_RELOC_PPC_EMB_NADDR16_LO:
5304 case BFD_RELOC_PPC_EMB_NADDR16_HI:
5305 case BFD_RELOC_PPC_EMB_NADDR16_HA:
5306 case BFD_RELOC_PPC_EMB_SDAI16:
5307 case BFD_RELOC_PPC_EMB_SDA2REL:
5308 case BFD_RELOC_PPC_EMB_SDA2I16:
5309 case BFD_RELOC_PPC_EMB_RELSEC16:
5310 case BFD_RELOC_PPC_EMB_RELST_LO:
5311 case BFD_RELOC_PPC_EMB_RELST_HI:
5312 case BFD_RELOC_PPC_EMB_RELST_HA:
5313 case BFD_RELOC_PPC_EMB_RELSDA:
5314 case BFD_RELOC_PPC_TOC16:
5316 #if BFD_DEFAULT_TARGET_SIZE == 64
5317 case BFD_RELOC_PPC64_TOC16_LO:
5318 case BFD_RELOC_PPC64_TOC16_HI:
5319 case BFD_RELOC_PPC64_TOC16_HA:
5324 if (fixP->fx_addsy != NULL)
5325 as_bad_where (fixP->fx_file, fixP->fx_line,
5326 _("cannot emit PC relative %s relocation against %s"),
5327 bfd_get_reloc_code_name (fixP->fx_r_type),
5328 S_GET_NAME (fixP->fx_addsy));
5330 as_bad_where (fixP->fx_file, fixP->fx_line,
5331 _("cannot emit PC relative %s relocation"),
5332 bfd_get_reloc_code_name (fixP->fx_r_type));
5335 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5339 /* This case happens when you write, for example,
5341 where L1 and L2 are defined later. */
5342 case BFD_RELOC_HI16:
5345 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5349 case BFD_RELOC_HI16_S:
5352 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5357 #if BFD_DEFAULT_TARGET_SIZE == 64
5358 case BFD_RELOC_PPC64_HIGHER:
5361 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5362 PPC_HIGHER (value), 2);
5365 case BFD_RELOC_PPC64_HIGHER_S:
5368 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5369 PPC_HIGHERA (value), 2);
5372 case BFD_RELOC_PPC64_HIGHEST:
5375 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5376 PPC_HIGHEST (value), 2);
5379 case BFD_RELOC_PPC64_HIGHEST_S:
5382 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5383 PPC_HIGHESTA (value), 2);
5386 case BFD_RELOC_PPC64_ADDR16_DS:
5387 case BFD_RELOC_PPC64_ADDR16_LO_DS:
5388 case BFD_RELOC_PPC64_GOT16_DS:
5389 case BFD_RELOC_PPC64_GOT16_LO_DS:
5390 case BFD_RELOC_PPC64_PLT16_LO_DS:
5391 case BFD_RELOC_PPC64_SECTOFF_DS:
5392 case BFD_RELOC_PPC64_SECTOFF_LO_DS:
5393 case BFD_RELOC_PPC64_TOC16_DS:
5394 case BFD_RELOC_PPC64_TOC16_LO_DS:
5395 case BFD_RELOC_PPC64_PLTGOT16_DS:
5396 case BFD_RELOC_PPC64_PLTGOT16_LO_DS:
5400 unsigned char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
5403 if (target_big_endian)
5404 val = bfd_getb16 (where);
5406 val = bfd_getl16 (where);
5407 val |= (value & 0xfffc);
5408 if (target_big_endian)
5409 bfd_putb16 ((bfd_vma) val, where);
5411 bfd_putl16 ((bfd_vma) val, where);
5416 /* Because SDA21 modifies the register field, the size is set to 4
5417 bytes, rather than 2, so offset it here appropriately. */
5418 case BFD_RELOC_PPC_EMB_SDA21:
5422 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where
5423 + ((target_big_endian) ? 2 : 0),
5431 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5435 case BFD_RELOC_24_PLT_PCREL:
5436 case BFD_RELOC_PPC_LOCAL24PC:
5437 if (!fixP->fx_pcrel && !fixP->fx_done)
5445 /* Fetch the instruction, insert the fully resolved operand
5446 value, and stuff the instruction back again. */
5447 where = fixP->fx_frag->fr_literal + fixP->fx_where;
5448 if (target_big_endian)
5449 insn = bfd_getb32 ((unsigned char *) where);
5451 insn = bfd_getl32 ((unsigned char *) where);
5452 if ((value & 3) != 0)
5453 as_bad_where (fixP->fx_file, fixP->fx_line,
5454 _("must branch to an address a multiple of 4"));
5455 if ((offsetT) value < -0x40000000
5456 || (offsetT) value >= 0x40000000)
5457 as_bad_where (fixP->fx_file, fixP->fx_line,
5458 _("@local or @plt branch destination is too far away, %ld bytes"),
5460 insn = insn | (value & 0x03fffffc);
5461 if (target_big_endian)
5462 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
5464 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
5468 case BFD_RELOC_VTABLE_INHERIT:
5471 && !S_IS_DEFINED (fixP->fx_addsy)
5472 && !S_IS_WEAK (fixP->fx_addsy))
5473 S_SET_WEAK (fixP->fx_addsy);
5476 case BFD_RELOC_VTABLE_ENTRY:
5481 #if BFD_DEFAULT_TARGET_SIZE == 64
5482 /* Generated by reference to `sym@tocbase'. The sym is
5483 ignored by the linker. */
5484 case BFD_RELOC_PPC64_TOC:
5491 _("Gas failure, reloc value %d\n"), fixP->fx_r_type);
5498 fixP->fx_addnumber = value;
5500 if (fixP->fx_r_type != BFD_RELOC_PPC_TOC16)
5501 fixP->fx_addnumber = 0;
5505 fixP->fx_addnumber = 0;
5507 /* We want to use the offset within the data segment of the
5508 symbol, not the actual VMA of the symbol. */
5509 fixP->fx_addnumber =
5510 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixP->fx_addsy));
5516 /* Generate a reloc for a fixup. */
5519 tc_gen_reloc (seg, fixp)
5520 asection *seg ATTRIBUTE_UNUSED;
5525 reloc = (arelent *) xmalloc (sizeof (arelent));
5527 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5528 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5529 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5530 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
5531 if (reloc->howto == (reloc_howto_type *) NULL)
5533 as_bad_where (fixp->fx_file, fixp->fx_line,
5534 _("reloc %d not supported by object file format"),
5535 (int) fixp->fx_r_type);
5538 reloc->addend = fixp->fx_addnumber;