1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 #include "opcode/ppc.h"
37 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
39 /* Tell the main code what the endianness is. */
40 extern int target_big_endian;
42 /* Whether or not, we've set target_big_endian. */
43 static int set_target_endian = 0;
45 /* Whether to use user friendly register names. */
46 #ifndef TARGET_REG_NAMES_P
48 #define TARGET_REG_NAMES_P true
50 #define TARGET_REG_NAMES_P false
54 static boolean reg_names_p = TARGET_REG_NAMES_P;
56 static boolean register_name PARAMS ((expressionS *));
57 static void ppc_set_cpu PARAMS ((void));
58 static unsigned long ppc_insert_operand
59 PARAMS ((unsigned long insn, const struct powerpc_operand *operand,
60 offsetT val, char *file, unsigned int line));
61 static void ppc_macro PARAMS ((char *str, const struct powerpc_macro *macro));
62 static void ppc_byte PARAMS ((int));
63 static int ppc_is_toc_sym PARAMS ((symbolS *sym));
64 static void ppc_tc PARAMS ((int));
67 static void ppc_comm PARAMS ((int));
68 static void ppc_bb PARAMS ((int));
69 static void ppc_bc PARAMS ((int));
70 static void ppc_bf PARAMS ((int));
71 static void ppc_biei PARAMS ((int));
72 static void ppc_bs PARAMS ((int));
73 static void ppc_eb PARAMS ((int));
74 static void ppc_ec PARAMS ((int));
75 static void ppc_ef PARAMS ((int));
76 static void ppc_es PARAMS ((int));
77 static void ppc_csect PARAMS ((int));
78 static void ppc_change_csect PARAMS ((symbolS *));
79 static void ppc_function PARAMS ((int));
80 static void ppc_extern PARAMS ((int));
81 static void ppc_lglobl PARAMS ((int));
82 static void ppc_section PARAMS ((int));
83 static void ppc_named_section PARAMS ((int));
84 static void ppc_stabx PARAMS ((int));
85 static void ppc_rename PARAMS ((int));
86 static void ppc_toc PARAMS ((int));
87 static void ppc_xcoff_cons PARAMS ((int));
88 static void ppc_vbyte PARAMS ((int));
92 static bfd_reloc_code_real_type ppc_elf_suffix PARAMS ((char **, expressionS *));
93 static void ppc_elf_cons PARAMS ((int));
94 static void ppc_elf_rdata PARAMS ((int));
95 static void ppc_elf_lcomm PARAMS ((int));
96 static void ppc_elf_validate_fix PARAMS ((fixS *, segT));
100 static void ppc_set_current_section PARAMS ((segT));
101 static void ppc_previous PARAMS ((int));
102 static void ppc_pdata PARAMS ((int));
103 static void ppc_ydata PARAMS ((int));
104 static void ppc_reldata PARAMS ((int));
105 static void ppc_rdata PARAMS ((int));
106 static void ppc_ualong PARAMS ((int));
107 static void ppc_znop PARAMS ((int));
108 static void ppc_pe_comm PARAMS ((int));
109 static void ppc_pe_section PARAMS ((int));
110 static void ppc_pe_function PARAMS ((int));
111 static void ppc_pe_tocd PARAMS ((int));
114 /* Generic assembler global variables which must be defined by all
118 /* This string holds the chars that always start a comment. If the
119 pre-processor is disabled, these aren't very useful. The macro
120 tc_comment_chars points to this. We use this, rather than the
121 usual comment_chars, so that we can switch for Solaris conventions. */
122 static const char ppc_solaris_comment_chars[] = "#!";
123 static const char ppc_eabi_comment_chars[] = "#";
125 #ifdef TARGET_SOLARIS_COMMENT
126 const char *ppc_comment_chars = ppc_solaris_comment_chars;
128 const char *ppc_comment_chars = ppc_eabi_comment_chars;
131 const char comment_chars[] = "#";
134 /* Characters which start a comment at the beginning of a line. */
135 const char line_comment_chars[] = "#";
137 /* Characters which may be used to separate multiple commands on a
139 const char line_separator_chars[] = ";";
141 /* Characters which are used to indicate an exponent in a floating
143 const char EXP_CHARS[] = "eE";
145 /* Characters which mean that a number is a floating point constant,
147 const char FLT_CHARS[] = "dD";
149 /* The target specific pseudo-ops which we support. */
151 const pseudo_typeS md_pseudo_table[] =
153 /* Pseudo-ops which must be overridden. */
154 { "byte", ppc_byte, 0 },
157 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
158 legitimately belong in the obj-*.c file. However, XCOFF is based
159 on COFF, and is only implemented for the RS/6000. We just use
160 obj-coff.c, and add what we need here. */
161 { "comm", ppc_comm, 0 },
162 { "lcomm", ppc_comm, 1 },
166 { "bi", ppc_biei, 0 },
168 { "csect", ppc_csect, 0 },
169 { "data", ppc_section, 'd' },
173 { "ei", ppc_biei, 1 },
175 { "extern", ppc_extern, 0 },
176 { "function", ppc_function, 0 },
177 { "lglobl", ppc_lglobl, 0 },
178 { "rename", ppc_rename, 0 },
179 { "section", ppc_named_section, 0 },
180 { "stabx", ppc_stabx, 0 },
181 { "text", ppc_section, 't' },
182 { "toc", ppc_toc, 0 },
183 { "long", ppc_xcoff_cons, 2 },
184 { "word", ppc_xcoff_cons, 1 },
185 { "short", ppc_xcoff_cons, 1 },
186 { "vbyte", ppc_vbyte, 0 },
190 { "long", ppc_elf_cons, 4 },
191 { "word", ppc_elf_cons, 2 },
192 { "short", ppc_elf_cons, 2 },
193 { "rdata", ppc_elf_rdata, 0 },
194 { "rodata", ppc_elf_rdata, 0 },
195 { "lcomm", ppc_elf_lcomm, 0 },
199 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
200 { "previous", ppc_previous, 0 },
201 { "pdata", ppc_pdata, 0 },
202 { "ydata", ppc_ydata, 0 },
203 { "reldata", ppc_reldata, 0 },
204 { "rdata", ppc_rdata, 0 },
205 { "ualong", ppc_ualong, 0 },
206 { "znop", ppc_znop, 0 },
207 { "comm", ppc_pe_comm, 0 },
208 { "lcomm", ppc_pe_comm, 1 },
209 { "section", ppc_pe_section, 0 },
210 { "function", ppc_pe_function,0 },
211 { "tocd", ppc_pe_tocd, 0 },
214 /* This pseudo-op is used even when not generating XCOFF output. */
221 /* Predefined register names if -mregnames (or default for Windows NT). */
222 /* In general, there are lots of them, in an attempt to be compatible */
223 /* with a number of other Windows NT assemblers. */
225 /* Structure to hold information about predefined registers. */
232 /* List of registers that are pre-defined:
234 Each general register has predefined names of the form:
235 1. r<reg_num> which has the value <reg_num>.
236 2. r.<reg_num> which has the value <reg_num>.
239 Each floating point register has predefined names of the form:
240 1. f<reg_num> which has the value <reg_num>.
241 2. f.<reg_num> which has the value <reg_num>.
243 Each condition register has predefined names of the form:
244 1. cr<reg_num> which has the value <reg_num>.
245 2. cr.<reg_num> which has the value <reg_num>.
247 There are individual registers as well:
248 sp or r.sp has the value 1
249 rtoc or r.toc has the value 2
250 fpscr has the value 0
256 dsisr has the value 18
258 sdr1 has the value 25
259 srr0 has the value 26
260 srr1 has the value 27
262 The table is sorted. Suitable for searching by a binary search. */
264 static const struct pd_reg pre_defined_registers[] =
266 { "cr.0", 0 }, /* Condition Registers */
286 { "dar", 19 }, /* Data Access Register */
287 { "dec", 22 }, /* Decrementer */
288 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
290 { "f.0", 0 }, /* Floating point registers */
358 { "lr", 8 }, /* Link Register */
362 { "r.0", 0 }, /* General Purpose Registers */
395 { "r.sp", 1 }, /* Stack Pointer */
397 { "r.toc", 2 }, /* Pointer to the table of contents */
399 { "r0", 0 }, /* More general purpose registers */
432 { "rtoc", 2 }, /* Table of contents */
434 { "sdr1", 25 }, /* Storage Description Register 1 */
438 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
439 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
445 #define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
447 /* Given NAME, find the register number associated with that name, return
448 the integer value associated with the given name or -1 on failure. */
450 static int reg_name_search
451 PARAMS ((const struct pd_reg *, int, const char * name));
454 reg_name_search (regs, regcount, name)
455 const struct pd_reg *regs;
459 int middle, low, high;
467 middle = (low + high) / 2;
468 cmp = strcasecmp (name, regs[middle].name);
474 return regs[middle].value;
482 * Summary of register_name().
484 * in: Input_line_pointer points to 1st char of operand.
486 * out: A expressionS.
487 * The operand may have been a register: in this case, X_op == O_register,
488 * X_add_number is set to the register number, and truth is returned.
489 * Input_line_pointer->(next non-blank) char after operand, or is in its
494 register_name (expressionP)
495 expressionS *expressionP;
502 /* Find the spelling of the operand */
503 start = name = input_line_pointer;
504 if (name[0] == '%' && isalpha (name[1]))
505 name = ++input_line_pointer;
507 else if (!reg_names_p || !isalpha (name[0]))
510 c = get_symbol_end ();
511 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
513 /* look to see if it's in the register table */
516 expressionP->X_op = O_register;
517 expressionP->X_add_number = reg_number;
519 /* make the rest nice */
520 expressionP->X_add_symbol = NULL;
521 expressionP->X_op_symbol = NULL;
522 *input_line_pointer = c; /* put back the delimiting char */
527 /* reset the line as if we had not done anything */
528 *input_line_pointer = c; /* put back the delimiting char */
529 input_line_pointer = start; /* reset input_line pointer */
534 /* This function is called for each symbol seen in an expression. It
535 handles the special parsing which PowerPC assemblers are supposed
536 to use for condition codes. */
538 /* Whether to do the special parsing. */
539 static boolean cr_operand;
541 /* Names to recognize in a condition code. This table is sorted. */
542 static const struct pd_reg cr_names[] =
559 /* Parsing function. This returns non-zero if it recognized an
563 ppc_parse_name (name, expr)
572 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
577 expr->X_op = O_constant;
578 expr->X_add_number = val;
583 /* Local variables. */
585 /* The type of processor we are assembling for. This is one or more
586 of the PPC_OPCODE flags defined in opcode/ppc.h. */
587 static int ppc_cpu = 0;
589 /* The size of the processor we are assembling for. This is either
590 PPC_OPCODE_32 or PPC_OPCODE_64. */
591 static int ppc_size = PPC_OPCODE_32;
593 /* Opcode hash table. */
594 static struct hash_control *ppc_hash;
596 /* Macro hash table. */
597 static struct hash_control *ppc_macro_hash;
600 /* What type of shared library support to use */
601 static enum { SHLIB_NONE, SHLIB_PIC, SHILB_MRELOCATABLE } shlib = SHLIB_NONE;
603 /* Flags to set in the elf header */
604 static flagword ppc_flags = 0;
606 /* Whether this is Solaris or not. */
607 #ifdef TARGET_SOLARIS_COMMENT
608 #define SOLARIS_P true
610 #define SOLARIS_P false
613 static boolean msolaris = SOLARIS_P;
618 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
619 using a bunch of different sections. These assembler sections,
620 however, are all encompassed within the .text or .data sections of
621 the final output file. We handle this by using different
622 subsegments within these main segments. */
624 /* Next subsegment to allocate within the .text segment. */
625 static subsegT ppc_text_subsegment = 2;
627 /* Linked list of csects in the text section. */
628 static symbolS *ppc_text_csects;
630 /* Next subsegment to allocate within the .data segment. */
631 static subsegT ppc_data_subsegment = 2;
633 /* Linked list of csects in the data section. */
634 static symbolS *ppc_data_csects;
636 /* The current csect. */
637 static symbolS *ppc_current_csect;
639 /* The RS/6000 assembler uses a TOC which holds addresses of functions
640 and variables. Symbols are put in the TOC with the .tc pseudo-op.
641 A special relocation is used when accessing TOC entries. We handle
642 the TOC as a subsegment within the .data segment. We set it up if
643 we see a .toc pseudo-op, and save the csect symbol here. */
644 static symbolS *ppc_toc_csect;
646 /* The first frag in the TOC subsegment. */
647 static fragS *ppc_toc_frag;
649 /* The first frag in the first subsegment after the TOC in the .data
650 segment. NULL if there are no subsegments after the TOC. */
651 static fragS *ppc_after_toc_frag;
653 /* The current static block. */
654 static symbolS *ppc_current_block;
656 /* The COFF debugging section; set by md_begin. This is not the
657 .debug section, but is instead the secret BFD section which will
658 cause BFD to set the section number of a symbol to N_DEBUG. */
659 static asection *ppc_coff_debug_section;
661 #endif /* OBJ_XCOFF */
665 /* Various sections that we need for PE coff support. */
666 static segT ydata_section;
667 static segT pdata_section;
668 static segT reldata_section;
669 static segT rdata_section;
670 static segT tocdata_section;
672 /* The current section and the previous section. See ppc_previous. */
673 static segT ppc_previous_section;
674 static segT ppc_current_section;
679 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
683 CONST char *md_shortopts = "b:l:usm:K:VQ:";
685 CONST char *md_shortopts = "um:";
687 struct option md_longopts[] = {
688 {NULL, no_argument, NULL, 0}
690 size_t md_longopts_size = sizeof(md_longopts);
693 md_parse_option (c, arg)
700 /* -u means that any undefined symbols should be treated as
701 external, which is the default for gas anyhow. */
706 /* Solaris as takes -le (presumably for little endian). For completeness
707 sake, recognize -be also. */
708 if (strcmp (arg, "e") == 0)
710 target_big_endian = 0;
711 set_target_endian = 1;
719 if (strcmp (arg, "e") == 0)
721 target_big_endian = 1;
722 set_target_endian = 1;
730 /* Recognize -K PIC */
731 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
734 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
743 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
745 if (strcmp (arg, "pwrx") == 0 || strcmp (arg, "pwr2") == 0)
746 ppc_cpu = PPC_OPCODE_POWER | PPC_OPCODE_POWER2;
747 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
748 else if (strcmp (arg, "pwr") == 0)
749 ppc_cpu = PPC_OPCODE_POWER;
750 /* -m601 means to assemble for the Motorola PowerPC 601, which includes
751 instructions that are holdovers from the Power. */
752 else if (strcmp (arg, "601") == 0)
753 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_601;
754 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
755 Motorola PowerPC 603/604. */
756 else if (strcmp (arg, "ppc") == 0
757 || strcmp (arg, "ppc32") == 0
758 || strcmp (arg, "403") == 0
759 || strcmp (arg, "603") == 0
760 || strcmp (arg, "604") == 0)
761 ppc_cpu = PPC_OPCODE_PPC;
762 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
764 else if (strcmp (arg, "ppc64") == 0 || strcmp (arg, "620") == 0)
766 ppc_cpu = PPC_OPCODE_PPC;
767 ppc_size = PPC_OPCODE_64;
769 /* -mcom means assemble for the common intersection between Power
770 and PowerPC. At present, we just allow the union, rather
771 than the intersection. */
772 else if (strcmp (arg, "com") == 0)
773 ppc_cpu = PPC_OPCODE_COMMON;
774 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
775 else if (strcmp (arg, "any") == 0)
776 ppc_cpu = PPC_OPCODE_ANY;
778 else if (strcmp (arg, "regnames") == 0)
781 else if (strcmp (arg, "no-regnames") == 0)
785 /* -mrelocatable/-mrelocatable-lib -- warn about initializations that require relocation */
786 else if (strcmp (arg, "relocatable") == 0)
788 shlib = SHILB_MRELOCATABLE;
789 ppc_flags |= EF_PPC_RELOCATABLE;
792 else if (strcmp (arg, "relocatable-lib") == 0)
794 shlib = SHILB_MRELOCATABLE;
795 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
798 /* -memb, set embedded bit */
799 else if (strcmp (arg, "emb") == 0)
800 ppc_flags |= EF_PPC_EMB;
802 /* -mlittle/-mbig set the endianess */
803 else if (strcmp (arg, "little") == 0 || strcmp (arg, "little-endian") == 0)
805 target_big_endian = 0;
806 set_target_endian = 1;
809 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
811 target_big_endian = 1;
812 set_target_endian = 1;
815 else if (strcmp (arg, "solaris") == 0)
818 ppc_comment_chars = ppc_solaris_comment_chars;
821 else if (strcmp (arg, "no-solaris") == 0)
824 ppc_comment_chars = ppc_eabi_comment_chars;
829 as_bad (_("invalid switch -m%s"), arg);
835 /* -V: SVR4 argument to print version ID. */
840 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
841 should be emitted or not. FIXME: Not implemented. */
845 /* Solaris takes -s to specify that .stabs go in a .stabs section,
846 rather than .stabs.excl, which is ignored by the linker.
847 FIXME: Not implemented. */
863 md_show_usage (stream)
869 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
870 -mpwr generate code for IBM POWER (RIOS1)\n\
871 -m601 generate code for Motorola PowerPC 601\n\
872 -mppc, -mppc32, -m403, -m603, -m604\n\
873 generate code for Motorola PowerPC 603/604\n\
874 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
875 -mcom generate code Power/PowerPC common instructions\n\
876 -many generate code for any architecture (PWR/PWRX/PPC)\n\
877 -mregnames Allow symbolic names for registers\n\
878 -mno-regnames Do not allow symbolic names for registers\n"));
881 -mrelocatable support for GCC's -mrelocatble option\n\
882 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
883 -memb set PPC_EMB bit in ELF flags\n\
884 -mlittle, -mlittle-endian\n\
885 generate code for a little endian machine\n\
886 -mbig, -mbig-endian generate code for a big endian machine\n\
887 -msolaris generate code for Solaris\n\
888 -mno-solaris do not generate code for Solaris\n\
889 -V print assembler version number\n\
890 -Qy, -Qn ignored\n"));
894 /* Set ppc_cpu if it is not already set. */
899 const char *default_os = TARGET_OS;
900 const char *default_cpu = TARGET_CPU;
904 if (strncmp (default_os, "aix", 3) == 0
905 && default_os[3] >= '4' && default_os[3] <= '9')
906 ppc_cpu = PPC_OPCODE_COMMON;
907 else if (strncmp (default_os, "aix3", 4) == 0)
908 ppc_cpu = PPC_OPCODE_POWER;
909 else if (strcmp (default_cpu, "rs6000") == 0)
910 ppc_cpu = PPC_OPCODE_POWER;
911 else if (strcmp (default_cpu, "powerpc") == 0
912 || strcmp (default_cpu, "powerpcle") == 0)
913 ppc_cpu = PPC_OPCODE_PPC;
915 as_fatal (_("Unknown default cpu = %s, os = %s"), default_cpu, default_os);
919 /* Figure out the BFD architecture to use. */
921 enum bfd_architecture
924 const char *default_cpu = TARGET_CPU;
927 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
928 return bfd_arch_powerpc;
929 else if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
930 return bfd_arch_rs6000;
931 else if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
933 if (strcmp (default_cpu, "rs6000") == 0)
934 return bfd_arch_rs6000;
935 else if (strcmp (default_cpu, "powerpc") == 0
936 || strcmp (default_cpu, "powerpcle") == 0)
937 return bfd_arch_powerpc;
940 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
941 return bfd_arch_unknown;
944 /* This function is called when the assembler starts up. It is called
945 after the options have been parsed and the output file has been
951 register const struct powerpc_opcode *op;
952 const struct powerpc_opcode *op_end;
953 const struct powerpc_macro *macro;
954 const struct powerpc_macro *macro_end;
955 boolean dup_insn = false;
960 /* Set the ELF flags if desired. */
961 if (ppc_flags && !msolaris)
962 bfd_set_private_flags (stdoutput, ppc_flags);
965 /* Insert the opcodes into a hash table. */
966 ppc_hash = hash_new ();
968 op_end = powerpc_opcodes + powerpc_num_opcodes;
969 for (op = powerpc_opcodes; op < op_end; op++)
971 know ((op->opcode & op->mask) == op->opcode);
973 if ((op->flags & ppc_cpu) != 0
974 && ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == 0
975 || (op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == ppc_size))
979 retval = hash_insert (ppc_hash, op->name, (PTR) op);
980 if (retval != (const char *) NULL)
982 /* Ignore Power duplicates for -m601 */
983 if ((ppc_cpu & PPC_OPCODE_601) != 0
984 && (op->flags & PPC_OPCODE_POWER) != 0)
987 as_bad (_("Internal assembler error for instruction %s"), op->name);
993 /* Insert the macros into a hash table. */
994 ppc_macro_hash = hash_new ();
996 macro_end = powerpc_macros + powerpc_num_macros;
997 for (macro = powerpc_macros; macro < macro_end; macro++)
999 if ((macro->flags & ppc_cpu) != 0)
1003 retval = hash_insert (ppc_macro_hash, macro->name, (PTR) macro);
1004 if (retval != (const char *) NULL)
1006 as_bad (_("Internal assembler error for macro %s"), macro->name);
1015 /* Tell the main code what the endianness is if it is not overidden by the user. */
1016 if (!set_target_endian)
1018 set_target_endian = 1;
1019 target_big_endian = PPC_BIG_ENDIAN;
1023 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1025 /* Create dummy symbols to serve as initial csects. This forces the
1026 text csects to precede the data csects. These symbols will not
1028 ppc_text_csects = symbol_make ("dummy\001");
1029 ppc_text_csects->sy_tc.within = ppc_text_csects;
1030 ppc_data_csects = symbol_make ("dummy\001");
1031 ppc_data_csects->sy_tc.within = ppc_data_csects;
1036 ppc_current_section = text_section;
1037 ppc_previous_section = 0;
1042 /* Insert an operand value into an instruction. */
1044 static unsigned long
1045 ppc_insert_operand (insn, operand, val, file, line)
1047 const struct powerpc_operand *operand;
1052 if (operand->bits != 32)
1057 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1059 if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0
1060 && ppc_size == PPC_OPCODE_32)
1061 max = (1 << operand->bits) - 1;
1063 max = (1 << (operand->bits - 1)) - 1;
1064 min = - (1 << (operand->bits - 1));
1066 if (ppc_size == PPC_OPCODE_32)
1068 /* Some people write 32 bit hex constants with the sign
1069 extension done by hand. This shouldn't really be
1070 valid, but, to permit this code to assemble on a 64
1071 bit host, we sign extend the 32 bit value. */
1073 && (val & 0x80000000) != 0
1074 && (val & 0xffffffff) == val)
1083 max = (1 << operand->bits) - 1;
1087 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1092 if (test < (offsetT) min || test > (offsetT) max)
1095 _("operand out of range (%s not between %ld and %ld)");
1098 sprint_value (buf, test);
1099 if (file == (char *) NULL)
1100 as_bad (err, buf, min, max);
1102 as_bad_where (file, line, err, buf, min, max);
1106 if (operand->insert)
1111 insn = (*operand->insert) (insn, (long) val, &errmsg);
1112 if (errmsg != (const char *) NULL)
1116 insn |= (((long) val & ((1 << operand->bits) - 1))
1124 /* Parse @got, etc. and return the desired relocation. */
1125 static bfd_reloc_code_real_type
1126 ppc_elf_suffix (str_p, exp_p)
1133 bfd_reloc_code_real_type reloc;
1141 struct map_bfd *ptr;
1143 #define MAP(str,reloc) { str, sizeof(str)-1, reloc }
1145 static struct map_bfd mapping[] = {
1146 MAP ("l", BFD_RELOC_LO16),
1147 MAP ("h", BFD_RELOC_HI16),
1148 MAP ("ha", BFD_RELOC_HI16_S),
1149 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1150 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1151 MAP ("got", BFD_RELOC_16_GOTOFF),
1152 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1153 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1154 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1155 MAP ("fixup", BFD_RELOC_CTOR), /* warnings with -mrelocatable */
1156 MAP ("plt", BFD_RELOC_24_PLT_PCREL),
1157 MAP ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1158 MAP ("copy", BFD_RELOC_PPC_COPY),
1159 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1160 MAP ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1161 MAP ("local", BFD_RELOC_PPC_LOCAL24PC),
1162 MAP ("pltrel", BFD_RELOC_32_PLT_PCREL),
1163 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1164 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1165 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1166 MAP ("sdarel", BFD_RELOC_GPREL16),
1167 MAP ("sectoff", BFD_RELOC_32_BASEREL),
1168 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1169 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1170 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1171 MAP ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1172 MAP ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1173 MAP ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1174 MAP ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1175 MAP ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1176 MAP ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1177 MAP ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1178 MAP ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1179 MAP ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1180 MAP ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1181 MAP ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1182 MAP ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1183 MAP ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1184 MAP ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1185 MAP ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1186 MAP ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1187 MAP ("xgot", BFD_RELOC_PPC_TOC16),
1189 { (char *)0, 0, BFD_RELOC_UNUSED }
1193 return BFD_RELOC_UNUSED;
1195 for (ch = *str, str2 = ident;
1196 (str2 < ident + sizeof (ident) - 1
1197 && (isalnum (ch) || ch == '@'));
1200 *str2++ = (islower (ch)) ? ch : tolower (ch);
1207 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1208 if (ch == ptr->string[0]
1209 && len == ptr->length
1210 && memcmp (ident, ptr->string, ptr->length) == 0)
1212 if (exp_p->X_add_number != 0
1213 && (ptr->reloc == BFD_RELOC_16_GOTOFF
1214 || ptr->reloc == BFD_RELOC_LO16_GOTOFF
1215 || ptr->reloc == BFD_RELOC_HI16_GOTOFF
1216 || ptr->reloc == BFD_RELOC_HI16_S_GOTOFF))
1217 as_warn (_("identifier+constant@got means identifier@got+constant"));
1219 /* Now check for identifier@suffix+constant */
1220 if (*str == '-' || *str == '+')
1222 char *orig_line = input_line_pointer;
1223 expressionS new_exp;
1225 input_line_pointer = str;
1226 expression (&new_exp);
1227 if (new_exp.X_op == O_constant)
1229 exp_p->X_add_number += new_exp.X_add_number;
1230 str = input_line_pointer;
1233 if (&input_line_pointer != str_p)
1234 input_line_pointer = orig_line;
1241 return BFD_RELOC_UNUSED;
1244 /* Like normal .long/.short/.word, except support @got, etc. */
1245 /* clobbers input_line_pointer, checks */
1248 ppc_elf_cons (nbytes)
1249 register int nbytes; /* 1=.byte, 2=.word, 4=.long */
1252 bfd_reloc_code_real_type reloc;
1254 if (is_it_end_of_statement ())
1256 demand_empty_rest_of_line ();
1263 if (exp.X_op == O_symbol
1264 && *input_line_pointer == '@'
1265 && (reloc = ppc_elf_suffix (&input_line_pointer, &exp)) != BFD_RELOC_UNUSED)
1267 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
1268 int size = bfd_get_reloc_size (reloc_howto);
1271 as_bad (_("%s relocations do not fit in %d bytes\n"), reloc_howto->name, nbytes);
1275 register char *p = frag_more ((int) nbytes);
1276 int offset = nbytes - size;
1278 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc);
1282 emit_expr (&exp, (unsigned int) nbytes);
1284 while (*input_line_pointer++ == ',');
1286 input_line_pointer--; /* Put terminator back into stream. */
1287 demand_empty_rest_of_line ();
1290 /* Solaris pseduo op to change to the .rodata section. */
1295 char *save_line = input_line_pointer;
1296 static char section[] = ".rodata\n";
1298 /* Just pretend this is .section .rodata */
1299 input_line_pointer = section;
1300 obj_elf_section (xxx);
1302 input_line_pointer = save_line;
1305 /* Pseudo op to make file scope bss items */
1310 register char *name;
1314 register symbolS *symbolP;
1321 name = input_line_pointer;
1322 c = get_symbol_end ();
1324 /* just after name is now '\0' */
1325 p = input_line_pointer;
1328 if (*input_line_pointer != ',')
1330 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1331 ignore_rest_of_line ();
1335 input_line_pointer++; /* skip ',' */
1336 if ((size = get_absolute_expression ()) < 0)
1338 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
1339 ignore_rest_of_line ();
1343 /* The third argument to .lcomm is the alignment. */
1344 if (*input_line_pointer != ',')
1348 ++input_line_pointer;
1349 align = get_absolute_expression ();
1352 as_warn (_("ignoring bad alignment"));
1358 symbolP = symbol_find_or_make (name);
1361 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1363 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1364 S_GET_NAME (symbolP));
1365 ignore_rest_of_line ();
1369 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1371 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1372 S_GET_NAME (symbolP),
1373 (long) S_GET_VALUE (symbolP),
1376 ignore_rest_of_line ();
1382 old_subsec = now_subseg;
1385 /* convert to a power of 2 alignment */
1386 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
1389 as_bad (_("Common alignment not a power of 2"));
1390 ignore_rest_of_line ();
1397 record_alignment (bss_section, align2);
1398 subseg_set (bss_section, 0);
1400 frag_align (align2, 0, 0);
1401 if (S_GET_SEGMENT (symbolP) == bss_section)
1402 symbolP->sy_frag->fr_symbol = 0;
1403 symbolP->sy_frag = frag_now;
1404 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1407 S_SET_SIZE (symbolP, size);
1408 S_SET_SEGMENT (symbolP, bss_section);
1409 subseg_set (old_sec, old_subsec);
1410 demand_empty_rest_of_line ();
1413 /* Validate any relocations emitted for -mrelocatable, possibly adding
1414 fixups for word relocations in writable segments, so we can adjust
1417 ppc_elf_validate_fix (fixp, seg)
1421 if (fixp->fx_done || fixp->fx_pcrel)
1430 case SHILB_MRELOCATABLE:
1431 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1432 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1433 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1434 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1435 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1436 && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1437 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1438 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1439 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1440 && strcmp (segment_name (seg), ".got2") != 0
1441 && strcmp (segment_name (seg), ".dtors") != 0
1442 && strcmp (segment_name (seg), ".ctors") != 0
1443 && strcmp (segment_name (seg), ".fixup") != 0
1444 && strcmp (segment_name (seg), ".stab") != 0
1445 && strcmp (segment_name (seg), ".gcc_except_table") != 0
1446 && strcmp (segment_name (seg), ".eh_frame") != 0
1447 && strcmp (segment_name (seg), ".ex_shared") != 0)
1449 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1450 || fixp->fx_r_type != BFD_RELOC_CTOR)
1452 as_bad_where (fixp->fx_file, fixp->fx_line,
1453 _("Relocation cannot be done when using -mrelocatable"));
1459 #endif /* OBJ_ELF */
1464 * Summary of parse_toc_entry().
1466 * in: Input_line_pointer points to the '[' in one of:
1468 * [toc] [tocv] [toc32] [toc64]
1470 * Anything else is an error of one kind or another.
1473 * return value: success or failure
1474 * toc_kind: kind of toc reference
1475 * input_line_pointer:
1476 * success: first char after the ']'
1477 * failure: unchanged
1481 * [toc] - rv == success, toc_kind = default_toc
1482 * [tocv] - rv == success, toc_kind = data_in_toc
1483 * [toc32] - rv == success, toc_kind = must_be_32
1484 * [toc64] - rv == success, toc_kind = must_be_64
1488 enum toc_size_qualifier
1490 default_toc, /* The toc cell constructed should be the system default size */
1491 data_in_toc, /* This is a direct reference to a toc cell */
1492 must_be_32, /* The toc cell constructed must be 32 bits wide */
1493 must_be_64 /* The toc cell constructed must be 64 bits wide */
1497 parse_toc_entry(toc_kind)
1498 enum toc_size_qualifier *toc_kind;
1503 enum toc_size_qualifier t;
1505 /* save the input_line_pointer */
1506 start = input_line_pointer;
1508 /* skip over the '[' , and whitespace */
1509 ++input_line_pointer;
1512 /* find the spelling of the operand */
1513 toc_spec = input_line_pointer;
1514 c = get_symbol_end ();
1516 if (strcmp(toc_spec, "toc") == 0)
1520 else if (strcmp(toc_spec, "tocv") == 0)
1524 else if (strcmp(toc_spec, "toc32") == 0)
1528 else if (strcmp(toc_spec, "toc64") == 0)
1534 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
1535 *input_line_pointer = c; /* put back the delimiting char */
1536 input_line_pointer = start; /* reset input_line pointer */
1540 /* now find the ']' */
1541 *input_line_pointer = c; /* put back the delimiting char */
1543 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1544 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
1548 as_bad (_("syntax error: expected `]', found `%c'"), c);
1549 input_line_pointer = start; /* reset input_line pointer */
1553 *toc_kind = t; /* set return value */
1559 /* We need to keep a list of fixups. We can't simply generate them as
1560 we go, because that would require us to first create the frag, and
1561 that would screw up references to ``.''. */
1567 bfd_reloc_code_real_type reloc;
1570 #define MAX_INSN_FIXUPS (5)
1572 /* This routine is called for each instruction to be assembled. */
1579 const struct powerpc_opcode *opcode;
1581 const unsigned char *opindex_ptr;
1585 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
1590 bfd_reloc_code_real_type reloc;
1593 /* Get the opcode. */
1594 for (s = str; *s != '\0' && ! isspace (*s); s++)
1599 /* Look up the opcode in the hash table. */
1600 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
1601 if (opcode == (const struct powerpc_opcode *) NULL)
1603 const struct powerpc_macro *macro;
1605 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
1606 if (macro == (const struct powerpc_macro *) NULL)
1607 as_bad (_("Unrecognized opcode: `%s'"), str);
1609 ppc_macro (s, macro);
1614 insn = opcode->opcode;
1617 while (isspace (*str))
1620 /* PowerPC operands are just expressions. The only real issue is
1621 that a few operand types are optional. All cases which might use
1622 an optional operand separate the operands only with commas (in
1623 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1624 cases never have optional operands). There is never more than
1625 one optional operand for an instruction. So, before we start
1626 seriously parsing the operands, we check to see if we have an
1627 optional operand, and, if we do, we count the number of commas to
1628 see whether the operand should be omitted. */
1630 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1632 const struct powerpc_operand *operand;
1634 operand = &powerpc_operands[*opindex_ptr];
1635 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
1637 unsigned int opcount;
1639 /* There is an optional operand. Count the number of
1640 commas in the input line. */
1647 while ((s = strchr (s, ',')) != (char *) NULL)
1654 /* If there are fewer operands in the line then are called
1655 for by the instruction, we want to skip the optional
1657 if (opcount < strlen (opcode->operands))
1664 /* Gather the operands. */
1668 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1670 const struct powerpc_operand *operand;
1676 if (next_opindex == 0)
1677 operand = &powerpc_operands[*opindex_ptr];
1680 operand = &powerpc_operands[next_opindex];
1686 /* If this is a fake operand, then we do not expect anything
1688 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
1690 insn = (*operand->insert) (insn, 0L, &errmsg);
1691 if (errmsg != (const char *) NULL)
1696 /* If this is an optional operand, and we are skipping it, just
1698 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
1701 if (operand->insert)
1703 insn = (*operand->insert) (insn, 0L, &errmsg);
1704 if (errmsg != (const char *) NULL)
1707 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
1708 next_opindex = *opindex_ptr + 1;
1712 /* Gather the operand. */
1713 hold = input_line_pointer;
1714 input_line_pointer = str;
1717 if (*input_line_pointer == '[')
1719 /* We are expecting something like the second argument here:
1721 lwz r4,[toc].GS.0.static_int(rtoc)
1722 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1723 The argument following the `]' must be a symbol name, and the
1724 register must be the toc register: 'rtoc' or '2'
1726 The effect is to 0 as the displacement field
1727 in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1728 the appropriate variation) reloc against it based on the symbol.
1729 The linker will build the toc, and insert the resolved toc offset.
1732 o The size of the toc entry is currently assumed to be
1733 32 bits. This should not be assumed to be a hard coded
1735 o In an effort to cope with a change from 32 to 64 bits,
1736 there are also toc entries that are specified to be
1737 either 32 or 64 bits:
1738 lwz r4,[toc32].GS.0.static_int(rtoc)
1739 lwz r4,[toc64].GS.0.static_int(rtoc)
1740 These demand toc entries of the specified size, and the
1741 instruction probably requires it.
1745 enum toc_size_qualifier toc_kind;
1746 bfd_reloc_code_real_type toc_reloc;
1748 /* go parse off the [tocXX] part */
1749 valid_toc = parse_toc_entry(&toc_kind);
1753 /* Note: message has already been issued. */
1754 /* FIXME: what sort of recovery should we do? */
1755 /* demand_rest_of_line(); return; ? */
1758 /* Now get the symbol following the ']' */
1764 /* In this case, we may not have seen the symbol yet, since */
1765 /* it is allowed to appear on a .extern or .globl or just be */
1766 /* a label in the .data section. */
1767 toc_reloc = BFD_RELOC_PPC_TOC16;
1770 /* 1. The symbol must be defined and either in the toc */
1771 /* section, or a global. */
1772 /* 2. The reloc generated must have the TOCDEFN flag set in */
1773 /* upper bit mess of the reloc type. */
1774 /* FIXME: It's a little confusing what the tocv qualifier can */
1775 /* be used for. At the very least, I've seen three */
1776 /* uses, only one of which I'm sure I can explain. */
1777 if (ex.X_op == O_symbol)
1779 assert (ex.X_add_symbol != NULL);
1780 if (ex.X_add_symbol->bsym->section != tocdata_section)
1782 as_bad(_("[tocv] symbol is not a toc symbol"));
1786 toc_reloc = BFD_RELOC_PPC_TOC16;
1789 /* FIXME: these next two specifically specify 32/64 bit toc */
1790 /* entries. We don't support them today. Is this the */
1791 /* right way to say that? */
1792 toc_reloc = BFD_RELOC_UNUSED;
1793 as_bad (_("Unimplemented toc32 expression modifier"));
1796 /* FIXME: see above */
1797 toc_reloc = BFD_RELOC_UNUSED;
1798 as_bad (_("Unimplemented toc64 expression modifier"));
1802 _("Unexpected return value [%d] from parse_toc_entry!\n"),
1808 /* We need to generate a fixup for this expression. */
1809 if (fc >= MAX_INSN_FIXUPS)
1810 as_fatal (_("too many fixups"));
1812 fixups[fc].reloc = toc_reloc;
1813 fixups[fc].exp = ex;
1814 fixups[fc].opindex = *opindex_ptr;
1817 /* Ok. We've set up the fixup for the instruction. Now make it
1818 look like the constant 0 was found here */
1820 ex.X_op = O_constant;
1821 ex.X_add_number = 0;
1822 ex.X_add_symbol = NULL;
1823 ex.X_op_symbol = NULL;
1829 if (! register_name (&ex))
1831 if ((operand->flags & PPC_OPERAND_CR) != 0)
1838 str = input_line_pointer;
1839 input_line_pointer = hold;
1841 if (ex.X_op == O_illegal)
1842 as_bad (_("illegal operand"));
1843 else if (ex.X_op == O_absent)
1844 as_bad (_("missing operand"));
1845 else if (ex.X_op == O_register)
1847 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
1850 else if (ex.X_op == O_constant)
1853 /* Allow @HA, @L, @H on constants. */
1854 char *orig_str = str;
1856 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
1863 case BFD_RELOC_LO16:
1864 /* X_unsigned is the default, so if the user has done
1865 something which cleared it, we always produce a
1868 && (operand->flags & PPC_OPERAND_SIGNED) == 0)
1869 ex.X_add_number &= 0xffff;
1871 ex.X_add_number = (((ex.X_add_number & 0xffff)
1876 case BFD_RELOC_HI16:
1877 ex.X_add_number = (ex.X_add_number >> 16) & 0xffff;
1880 case BFD_RELOC_HI16_S:
1881 ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
1882 + ((ex.X_add_number >> 15) & 1));
1886 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
1890 else if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
1892 /* For the absoulte forms of branchs, convert the PC relative form back into
1894 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
1898 case BFD_RELOC_PPC_B26:
1899 reloc = BFD_RELOC_PPC_BA26;
1901 case BFD_RELOC_PPC_B16:
1902 reloc = BFD_RELOC_PPC_BA16;
1904 case BFD_RELOC_PPC_B16_BRTAKEN:
1905 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
1907 case BFD_RELOC_PPC_B16_BRNTAKEN:
1908 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
1915 /* We need to generate a fixup for this expression. */
1916 if (fc >= MAX_INSN_FIXUPS)
1917 as_fatal (_("too many fixups"));
1918 fixups[fc].exp = ex;
1919 fixups[fc].opindex = 0;
1920 fixups[fc].reloc = reloc;
1923 #endif /* OBJ_ELF */
1927 /* We need to generate a fixup for this expression. */
1928 if (fc >= MAX_INSN_FIXUPS)
1929 as_fatal (_("too many fixups"));
1930 fixups[fc].exp = ex;
1931 fixups[fc].opindex = *opindex_ptr;
1932 fixups[fc].reloc = BFD_RELOC_UNUSED;
1941 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
1949 /* The call to expression should have advanced str past any
1952 && (endc != ',' || *str != '\0'))
1954 as_bad (_("syntax error; found `%c' but expected `%c'"), *str, endc);
1962 while (isspace (*str))
1966 as_bad (_("junk at end of line: `%s'"), str);
1968 /* Write out the instruction. */
1970 md_number_to_chars (f, insn, 4);
1972 /* Create any fixups. At this point we do not use a
1973 bfd_reloc_code_real_type, but instead just use the
1974 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1975 handle fixups for any operand type, although that is admittedly
1976 not a very exciting feature. We pick a BFD reloc type in
1978 for (i = 0; i < fc; i++)
1980 const struct powerpc_operand *operand;
1982 operand = &powerpc_operands[fixups[i].opindex];
1983 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1985 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1993 size = bfd_get_reloc_size (reloc_howto);
1994 offset = target_big_endian ? (4 - size) : 0;
1996 if (size < 1 || size > 4)
1999 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, size,
2000 &fixups[i].exp, reloc_howto->pc_relative,
2003 /* Turn off complaints that the addend is too large for things like
2005 switch (fixups[i].reloc)
2007 case BFD_RELOC_16_GOTOFF:
2008 case BFD_RELOC_PPC_TOC16:
2009 case BFD_RELOC_LO16:
2010 case BFD_RELOC_HI16:
2011 case BFD_RELOC_HI16_S:
2012 fixP->fx_no_overflow = 1;
2019 fix_new_exp (frag_now, f - frag_now->fr_literal, 4,
2021 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
2022 ((bfd_reloc_code_real_type)
2023 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2027 /* Handle a macro. Gather all the operands, transform them as
2028 described by the macro, and call md_assemble recursively. All the
2029 operands are separated by commas; we don't accept parentheses
2030 around operands here. */
2033 ppc_macro (str, macro)
2035 const struct powerpc_macro *macro;
2046 /* Gather the users operands into the operands array. */
2051 if (count >= sizeof operands / sizeof operands[0])
2053 operands[count++] = s;
2054 s = strchr (s, ',');
2055 if (s == (char *) NULL)
2060 if (count != macro->operands)
2062 as_bad (_("wrong number of operands"));
2066 /* Work out how large the string must be (the size is unbounded
2067 because it includes user input). */
2069 format = macro->format;
2070 while (*format != '\0')
2079 arg = strtol (format + 1, &send, 10);
2080 know (send != format && arg >= 0 && arg < count);
2081 len += strlen (operands[arg]);
2086 /* Put the string together. */
2087 complete = s = (char *) alloca (len + 1);
2088 format = macro->format;
2089 while (*format != '\0')
2095 arg = strtol (format + 1, &send, 10);
2096 strcpy (s, operands[arg]);
2103 /* Assemble the constructed instruction. */
2104 md_assemble (complete);
2108 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED */
2111 ppc_section_letter (letter, ptr_msg)
2118 *ptr_msg = _("Bad .section directive: want a,w,x,e in string");
2123 ppc_section_word (ptr_str)
2126 if (strncmp (*ptr_str, "exclude", sizeof ("exclude")-1) == 0)
2128 *ptr_str += sizeof ("exclude")-1;
2136 ppc_section_type (ptr_str)
2139 if (strncmp (*ptr_str, "ordered", sizeof ("ordered")-1) == 0)
2141 *ptr_str += sizeof ("ordered")-1;
2149 ppc_section_flags (flags, attr, type)
2154 if (type == SHT_ORDERED)
2155 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
2157 if (attr & SHF_EXCLUDE)
2158 flags |= SEC_EXCLUDE;
2162 #endif /* OBJ_ELF */
2165 /* Pseudo-op handling. */
2167 /* The .byte pseudo-op. This is similar to the normal .byte
2168 pseudo-op, but it can also take a single ASCII string. */
2174 if (*input_line_pointer != '\"')
2180 /* Gather characters. A real double quote is doubled. Unusual
2181 characters are not permitted. */
2182 ++input_line_pointer;
2187 c = *input_line_pointer++;
2191 if (*input_line_pointer != '\"')
2193 ++input_line_pointer;
2196 FRAG_APPEND_1_CHAR (c);
2199 demand_empty_rest_of_line ();
2204 /* XCOFF specific pseudo-op handling. */
2206 /* This is set if we are creating a .stabx symbol, since we don't want
2207 to handle symbol suffixes for such symbols. */
2208 static boolean ppc_stab_symbol;
2210 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2211 symbols in the .bss segment as though they were local common
2212 symbols, and uses a different smclas. */
2218 asection *current_seg = now_seg;
2219 subsegT current_subseg = now_subseg;
2225 symbolS *lcomm_sym = NULL;
2229 name = input_line_pointer;
2230 endc = get_symbol_end ();
2231 end_name = input_line_pointer;
2234 if (*input_line_pointer != ',')
2236 as_bad (_("missing size"));
2237 ignore_rest_of_line ();
2240 ++input_line_pointer;
2242 size = get_absolute_expression ();
2245 as_bad (_("negative size"));
2246 ignore_rest_of_line ();
2252 /* The third argument to .comm is the alignment. */
2253 if (*input_line_pointer != ',')
2257 ++input_line_pointer;
2258 align = get_absolute_expression ();
2261 as_warn (_("ignoring bad alignment"));
2280 /* The third argument to .lcomm appears to be the real local
2281 common symbol to create. References to the symbol named in
2282 the first argument are turned into references to the third
2284 if (*input_line_pointer != ',')
2286 as_bad (_("missing real symbol name"));
2287 ignore_rest_of_line ();
2290 ++input_line_pointer;
2292 lcomm_name = input_line_pointer;
2293 lcomm_endc = get_symbol_end ();
2295 lcomm_sym = symbol_find_or_make (lcomm_name);
2297 *input_line_pointer = lcomm_endc;
2301 sym = symbol_find_or_make (name);
2304 if (S_IS_DEFINED (sym)
2305 || S_GET_VALUE (sym) != 0)
2307 as_bad (_("attempt to redefine symbol"));
2308 ignore_rest_of_line ();
2312 record_alignment (bss_section, align);
2315 || ! S_IS_DEFINED (lcomm_sym))
2324 S_SET_EXTERNAL (sym);
2328 lcomm_sym->sy_tc.output = 1;
2329 def_sym = lcomm_sym;
2333 subseg_set (bss_section, 1);
2334 frag_align (align, 0, 0);
2336 def_sym->sy_frag = frag_now;
2337 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
2338 def_size, (char *) NULL);
2340 S_SET_SEGMENT (def_sym, bss_section);
2341 def_sym->sy_tc.align = align;
2345 /* Align the size of lcomm_sym. */
2346 lcomm_sym->sy_frag->fr_offset =
2347 ((lcomm_sym->sy_frag->fr_offset + (1 << align) - 1)
2348 &~ ((1 << align) - 1));
2349 if (align > lcomm_sym->sy_tc.align)
2350 lcomm_sym->sy_tc.align = align;
2355 /* Make sym an offset from lcomm_sym. */
2356 S_SET_SEGMENT (sym, bss_section);
2357 sym->sy_frag = lcomm_sym->sy_frag;
2358 S_SET_VALUE (sym, lcomm_sym->sy_frag->fr_offset);
2359 lcomm_sym->sy_frag->fr_offset += size;
2362 subseg_set (current_seg, current_subseg);
2364 demand_empty_rest_of_line ();
2367 /* The .csect pseudo-op. This switches us into a different
2368 subsegment. The first argument is a symbol whose value is the
2369 start of the .csect. In COFF, csect symbols get special aux
2370 entries defined by the x_csect field of union internal_auxent. The
2371 optional second argument is the alignment (the default is 2). */
2381 name = input_line_pointer;
2382 endc = get_symbol_end ();
2384 sym = symbol_find_or_make (name);
2386 *input_line_pointer = endc;
2388 if (S_GET_NAME (sym)[0] == '\0')
2390 /* An unnamed csect is assumed to be [PR]. */
2391 sym->sy_tc.class = XMC_PR;
2394 ppc_change_csect (sym);
2396 if (*input_line_pointer == ',')
2398 ++input_line_pointer;
2399 sym->sy_tc.align = get_absolute_expression ();
2402 demand_empty_rest_of_line ();
2405 /* Change to a different csect. */
2408 ppc_change_csect (sym)
2411 if (S_IS_DEFINED (sym))
2412 subseg_set (S_GET_SEGMENT (sym), sym->sy_tc.subseg);
2420 /* This is a new csect. We need to look at the symbol class to
2421 figure out whether it should go in the text section or the
2424 switch (sym->sy_tc.class)
2434 S_SET_SEGMENT (sym, text_section);
2435 sym->sy_tc.subseg = ppc_text_subsegment;
2436 ++ppc_text_subsegment;
2437 list_ptr = &ppc_text_csects;
2446 if (ppc_toc_csect != NULL
2447 && ppc_toc_csect->sy_tc.subseg + 1 == ppc_data_subsegment)
2449 S_SET_SEGMENT (sym, data_section);
2450 sym->sy_tc.subseg = ppc_data_subsegment;
2451 ++ppc_data_subsegment;
2452 list_ptr = &ppc_data_csects;
2458 /* We set the obstack chunk size to a small value before
2459 changing subsegments, so that we don't use a lot of memory
2460 space for what may be a small section. */
2461 hold_chunksize = chunksize;
2464 subseg_new (segment_name (S_GET_SEGMENT (sym)), sym->sy_tc.subseg);
2466 chunksize = hold_chunksize;
2469 ppc_after_toc_frag = frag_now;
2471 sym->sy_frag = frag_now;
2472 S_SET_VALUE (sym, (valueT) frag_now_fix ());
2474 sym->sy_tc.align = 2;
2475 sym->sy_tc.output = 1;
2476 sym->sy_tc.within = sym;
2478 for (list = *list_ptr;
2479 list->sy_tc.next != (symbolS *) NULL;
2480 list = list->sy_tc.next)
2482 list->sy_tc.next = sym;
2484 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2485 symbol_append (sym, list->sy_tc.within, &symbol_rootP, &symbol_lastP);
2488 ppc_current_csect = sym;
2491 /* This function handles the .text and .data pseudo-ops. These
2492 pseudo-ops aren't really used by XCOFF; we implement them for the
2493 convenience of people who aren't used to XCOFF. */
2504 else if (type == 'd')
2509 sym = symbol_find_or_make (name);
2511 ppc_change_csect (sym);
2513 demand_empty_rest_of_line ();
2516 /* This function handles the .section pseudo-op. This is mostly to
2517 give an error, since XCOFF only supports .text, .data and .bss, but
2518 we do permit the user to name the text or data section. */
2521 ppc_named_section (ignore)
2525 const char *real_name;
2529 user_name = input_line_pointer;
2530 c = get_symbol_end ();
2532 if (strcmp (user_name, ".text") == 0)
2533 real_name = ".text[PR]";
2534 else if (strcmp (user_name, ".data") == 0)
2535 real_name = ".data[RW]";
2538 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2539 *input_line_pointer = c;
2540 ignore_rest_of_line ();
2544 *input_line_pointer = c;
2546 sym = symbol_find_or_make (real_name);
2548 ppc_change_csect (sym);
2550 demand_empty_rest_of_line ();
2553 /* The .extern pseudo-op. We create an undefined symbol. */
2562 name = input_line_pointer;
2563 endc = get_symbol_end ();
2565 (void) symbol_find_or_make (name);
2567 *input_line_pointer = endc;
2569 demand_empty_rest_of_line ();
2572 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2582 name = input_line_pointer;
2583 endc = get_symbol_end ();
2585 sym = symbol_find_or_make (name);
2587 *input_line_pointer = endc;
2589 sym->sy_tc.output = 1;
2591 demand_empty_rest_of_line ();
2594 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2595 although I don't know why it bothers. */
2606 name = input_line_pointer;
2607 endc = get_symbol_end ();
2609 sym = symbol_find_or_make (name);
2611 *input_line_pointer = endc;
2613 if (*input_line_pointer != ',')
2615 as_bad (_("missing rename string"));
2616 ignore_rest_of_line ();
2619 ++input_line_pointer;
2621 sym->sy_tc.real_name = demand_copy_C_string (&len);
2623 demand_empty_rest_of_line ();
2626 /* The .stabx pseudo-op. This is similar to a normal .stabs
2627 pseudo-op, but slightly different. A sample is
2628 .stabx "main:F-1",.main,142,0
2629 The first argument is the symbol name to create. The second is the
2630 value, and the third is the storage class. The fourth seems to be
2631 always zero, and I am assuming it is the type. */
2642 name = demand_copy_C_string (&len);
2644 if (*input_line_pointer != ',')
2646 as_bad (_("missing value"));
2649 ++input_line_pointer;
2651 ppc_stab_symbol = true;
2652 sym = symbol_make (name);
2653 ppc_stab_symbol = false;
2655 sym->sy_tc.real_name = name;
2657 (void) expression (&exp);
2664 as_bad (_("illegal .stabx expression; zero assumed"));
2665 exp.X_add_number = 0;
2668 S_SET_VALUE (sym, (valueT) exp.X_add_number);
2669 sym->sy_frag = &zero_address_frag;
2673 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
2674 sym->sy_value = exp;
2678 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
2679 sym->sy_frag = exp.X_add_symbol->sy_frag;
2684 /* The value is some complex expression. This will probably
2685 fail at some later point, but this is probably the right
2686 thing to do here. */
2687 sym->sy_value = exp;
2691 S_SET_SEGMENT (sym, ppc_coff_debug_section);
2692 sym->bsym->flags |= BSF_DEBUGGING;
2694 if (*input_line_pointer != ',')
2696 as_bad (_("missing class"));
2699 ++input_line_pointer;
2701 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
2703 if (*input_line_pointer != ',')
2705 as_bad (_("missing type"));
2708 ++input_line_pointer;
2710 S_SET_DATA_TYPE (sym, get_absolute_expression ());
2712 sym->sy_tc.output = 1;
2714 if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
2715 sym->sy_tc.within = ppc_current_block;
2717 if (exp.X_op != O_symbol
2718 || ! S_IS_EXTERNAL (exp.X_add_symbol)
2719 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
2720 ppc_frob_label (sym);
2723 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2724 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
2725 if (ppc_current_csect->sy_tc.within == exp.X_add_symbol)
2726 ppc_current_csect->sy_tc.within = sym;
2729 demand_empty_rest_of_line ();
2732 /* The .function pseudo-op. This takes several arguments. The first
2733 argument seems to be the external name of the symbol. The second
2734 argment seems to be the label for the start of the function. gcc
2735 uses the same name for both. I have no idea what the third and
2736 fourth arguments are meant to be. The optional fifth argument is
2737 an expression for the size of the function. In COFF this symbol
2738 gets an aux entry like that used for a csect. */
2741 ppc_function (ignore)
2750 name = input_line_pointer;
2751 endc = get_symbol_end ();
2753 /* Ignore any [PR] suffix. */
2754 name = ppc_canonicalize_symbol_name (name);
2755 s = strchr (name, '[');
2756 if (s != (char *) NULL
2757 && strcmp (s + 1, "PR]") == 0)
2760 ext_sym = symbol_find_or_make (name);
2762 *input_line_pointer = endc;
2764 if (*input_line_pointer != ',')
2766 as_bad (_("missing symbol name"));
2767 ignore_rest_of_line ();
2770 ++input_line_pointer;
2772 name = input_line_pointer;
2773 endc = get_symbol_end ();
2775 lab_sym = symbol_find_or_make (name);
2777 *input_line_pointer = endc;
2779 if (ext_sym != lab_sym)
2781 ext_sym->sy_value.X_op = O_symbol;
2782 ext_sym->sy_value.X_add_symbol = lab_sym;
2783 ext_sym->sy_value.X_op_symbol = NULL;
2784 ext_sym->sy_value.X_add_number = 0;
2787 if (ext_sym->sy_tc.class == -1)
2788 ext_sym->sy_tc.class = XMC_PR;
2789 ext_sym->sy_tc.output = 1;
2791 if (*input_line_pointer == ',')
2795 /* Ignore the third argument. */
2796 ++input_line_pointer;
2797 expression (&ignore);
2798 if (*input_line_pointer == ',')
2800 /* Ignore the fourth argument. */
2801 ++input_line_pointer;
2802 expression (&ignore);
2803 if (*input_line_pointer == ',')
2805 /* The fifth argument is the function size. */
2806 ++input_line_pointer;
2807 ext_sym->sy_tc.size = symbol_new ("L0\001",
2810 &zero_address_frag);
2811 pseudo_set (ext_sym->sy_tc.size);
2816 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
2817 SF_SET_FUNCTION (ext_sym);
2818 SF_SET_PROCESS (ext_sym);
2819 coff_add_linesym (ext_sym);
2821 demand_empty_rest_of_line ();
2824 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
2833 sym = symbol_make (".bf");
2834 S_SET_SEGMENT (sym, text_section);
2835 sym->sy_frag = frag_now;
2836 S_SET_VALUE (sym, frag_now_fix ());
2837 S_SET_STORAGE_CLASS (sym, C_FCN);
2839 coff_line_base = get_absolute_expression ();
2841 S_SET_NUMBER_AUXILIARY (sym, 1);
2842 SA_SET_SYM_LNNO (sym, coff_line_base);
2844 sym->sy_tc.output = 1;
2846 ppc_frob_label (sym);
2848 demand_empty_rest_of_line ();
2851 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
2852 ".ef", except that the line number is absolute, not relative to the
2853 most recent ".bf" symbol. */
2861 sym = symbol_make (".ef");
2862 S_SET_SEGMENT (sym, text_section);
2863 sym->sy_frag = frag_now;
2864 S_SET_VALUE (sym, frag_now_fix ());
2865 S_SET_STORAGE_CLASS (sym, C_FCN);
2866 S_SET_NUMBER_AUXILIARY (sym, 1);
2867 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
2868 sym->sy_tc.output = 1;
2870 ppc_frob_label (sym);
2872 demand_empty_rest_of_line ();
2875 /* The .bi and .ei pseudo-ops. These take a string argument and
2876 generates a C_BINCL or C_EINCL symbol, which goes at the start of
2883 static symbolS *last_biei;
2890 name = demand_copy_C_string (&len);
2892 /* The value of these symbols is actually file offset. Here we set
2893 the value to the index into the line number entries. In
2894 ppc_frob_symbols we set the fix_line field, which will cause BFD
2895 to do the right thing. */
2897 sym = symbol_make (name);
2898 /* obj-coff.c currently only handles line numbers correctly in the
2900 S_SET_SEGMENT (sym, text_section);
2901 S_SET_VALUE (sym, coff_n_line_nos);
2902 sym->bsym->flags |= BSF_DEBUGGING;
2904 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
2905 sym->sy_tc.output = 1;
2907 for (look = last_biei ? last_biei : symbol_rootP;
2908 (look != (symbolS *) NULL
2909 && (S_GET_STORAGE_CLASS (look) == C_FILE
2910 || S_GET_STORAGE_CLASS (look) == C_BINCL
2911 || S_GET_STORAGE_CLASS (look) == C_EINCL));
2912 look = symbol_next (look))
2914 if (look != (symbolS *) NULL)
2916 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2917 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
2921 demand_empty_rest_of_line ();
2924 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
2925 There is one argument, which is a csect symbol. The value of the
2926 .bs symbol is the index of this csect symbol. */
2937 if (ppc_current_block != NULL)
2938 as_bad (_("nested .bs blocks"));
2940 name = input_line_pointer;
2941 endc = get_symbol_end ();
2943 csect = symbol_find_or_make (name);
2945 *input_line_pointer = endc;
2947 sym = symbol_make (".bs");
2948 S_SET_SEGMENT (sym, now_seg);
2949 S_SET_STORAGE_CLASS (sym, C_BSTAT);
2950 sym->bsym->flags |= BSF_DEBUGGING;
2951 sym->sy_tc.output = 1;
2953 sym->sy_tc.within = csect;
2955 ppc_frob_label (sym);
2957 ppc_current_block = sym;
2959 demand_empty_rest_of_line ();
2962 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
2970 if (ppc_current_block == NULL)
2971 as_bad (_(".es without preceding .bs"));
2973 sym = symbol_make (".es");
2974 S_SET_SEGMENT (sym, now_seg);
2975 S_SET_STORAGE_CLASS (sym, C_ESTAT);
2976 sym->bsym->flags |= BSF_DEBUGGING;
2977 sym->sy_tc.output = 1;
2979 ppc_frob_label (sym);
2981 ppc_current_block = NULL;
2983 demand_empty_rest_of_line ();
2986 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
2995 sym = symbol_make (".bb");
2996 S_SET_SEGMENT (sym, text_section);
2997 sym->sy_frag = frag_now;
2998 S_SET_VALUE (sym, frag_now_fix ());
2999 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3001 S_SET_NUMBER_AUXILIARY (sym, 1);
3002 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3004 sym->sy_tc.output = 1;
3006 SF_SET_PROCESS (sym);
3008 ppc_frob_label (sym);
3010 demand_empty_rest_of_line ();
3013 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3022 sym = symbol_make (".eb");
3023 S_SET_SEGMENT (sym, text_section);
3024 sym->sy_frag = frag_now;
3025 S_SET_VALUE (sym, frag_now_fix ());
3026 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3027 S_SET_NUMBER_AUXILIARY (sym, 1);
3028 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3029 sym->sy_tc.output = 1;
3031 SF_SET_PROCESS (sym);
3033 ppc_frob_label (sym);
3035 demand_empty_rest_of_line ();
3038 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3049 name = demand_copy_C_string (&len);
3050 sym = symbol_make (name);
3051 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3052 sym->bsym->flags |= BSF_DEBUGGING;
3053 S_SET_STORAGE_CLASS (sym, C_BCOMM);
3054 S_SET_VALUE (sym, 0);
3055 sym->sy_tc.output = 1;
3057 ppc_frob_label (sym);
3059 demand_empty_rest_of_line ();
3062 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3070 sym = symbol_make (".ec");
3071 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3072 sym->bsym->flags |= BSF_DEBUGGING;
3073 S_SET_STORAGE_CLASS (sym, C_ECOMM);
3074 S_SET_VALUE (sym, 0);
3075 sym->sy_tc.output = 1;
3077 ppc_frob_label (sym);
3079 demand_empty_rest_of_line ();
3082 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3088 if (ppc_toc_csect != (symbolS *) NULL)
3089 subseg_set (data_section, ppc_toc_csect->sy_tc.subseg);
3096 subseg = ppc_data_subsegment;
3097 ++ppc_data_subsegment;
3099 subseg_new (segment_name (data_section), subseg);
3100 ppc_toc_frag = frag_now;
3102 sym = symbol_find_or_make ("TOC[TC0]");
3103 sym->sy_frag = frag_now;
3104 S_SET_SEGMENT (sym, data_section);
3105 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3106 sym->sy_tc.subseg = subseg;
3107 sym->sy_tc.output = 1;
3108 sym->sy_tc.within = sym;
3110 ppc_toc_csect = sym;
3112 for (list = ppc_data_csects;
3113 list->sy_tc.next != (symbolS *) NULL;
3114 list = list->sy_tc.next)
3116 list->sy_tc.next = sym;
3118 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3119 symbol_append (sym, list->sy_tc.within, &symbol_rootP, &symbol_lastP);
3122 ppc_current_csect = ppc_toc_csect;
3124 demand_empty_rest_of_line ();
3127 /* The AIX assembler automatically aligns the operands of a .long or
3128 .short pseudo-op, and we want to be compatible. */
3131 ppc_xcoff_cons (log_size)
3134 frag_align (log_size, 0, 0);
3135 record_alignment (now_seg, log_size);
3136 cons (1 << log_size);
3146 (void) expression (&exp);
3148 if (exp.X_op != O_constant)
3150 as_bad (_("non-constant byte count"));
3154 byte_count = exp.X_add_number;
3156 if (*input_line_pointer != ',')
3158 as_bad (_("missing value"));
3162 ++input_line_pointer;
3166 #endif /* OBJ_XCOFF */
3168 /* The .tc pseudo-op. This is used when generating either XCOFF or
3169 ELF. This takes two or more arguments.
3171 When generating XCOFF output, the first argument is the name to
3172 give to this location in the toc; this will be a symbol with class
3173 TC. The rest of the arguments are 4 byte values to actually put at
3174 this location in the TOC; often there is just one more argument, a
3175 relocateable symbol reference.
3177 When not generating XCOFF output, the arguments are the same, but
3178 the first argument is simply ignored. */
3186 /* Define the TOC symbol name. */
3192 if (ppc_toc_csect == (symbolS *) NULL
3193 || ppc_toc_csect != ppc_current_csect)
3195 as_bad (_(".tc not in .toc section"));
3196 ignore_rest_of_line ();
3200 name = input_line_pointer;
3201 endc = get_symbol_end ();
3203 sym = symbol_find_or_make (name);
3205 *input_line_pointer = endc;
3207 if (S_IS_DEFINED (sym))
3211 label = ppc_current_csect->sy_tc.within;
3212 if (label->sy_tc.class != XMC_TC0)
3214 as_bad (_(".tc with no label"));
3215 ignore_rest_of_line ();
3219 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
3220 label->sy_frag = sym->sy_frag;
3221 S_SET_VALUE (label, S_GET_VALUE (sym));
3223 while (! is_end_of_line[(unsigned char) *input_line_pointer])
3224 ++input_line_pointer;
3229 S_SET_SEGMENT (sym, now_seg);
3230 sym->sy_frag = frag_now;
3231 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3232 sym->sy_tc.class = XMC_TC;
3233 sym->sy_tc.output = 1;
3235 ppc_frob_label (sym);
3238 #else /* ! defined (OBJ_XCOFF) */
3240 /* Skip the TOC symbol name. */
3241 while (is_part_of_name (*input_line_pointer)
3242 || *input_line_pointer == '['
3243 || *input_line_pointer == ']'
3244 || *input_line_pointer == '{'
3245 || *input_line_pointer == '}')
3246 ++input_line_pointer;
3248 /* Align to a four byte boundary. */
3249 frag_align (2, 0, 0);
3250 record_alignment (now_seg, 2);
3252 #endif /* ! defined (OBJ_XCOFF) */
3254 if (*input_line_pointer != ',')
3255 demand_empty_rest_of_line ();
3258 ++input_line_pointer;
3265 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
3267 /* Set the current section. */
3269 ppc_set_current_section (new)
3272 ppc_previous_section = ppc_current_section;
3273 ppc_current_section = new;
3276 /* pseudo-op: .previous
3277 behaviour: toggles the current section with the previous section.
3279 warnings: "No previous section"
3282 ppc_previous(ignore)
3287 if (ppc_previous_section == NULL)
3289 as_warn(_("No previous section to return to. Directive ignored."));
3293 subseg_set(ppc_previous_section, 0);
3295 ppc_set_current_section(ppc_previous_section);
3298 /* pseudo-op: .pdata
3299 behaviour: predefined read only data section
3303 initial: .section .pdata "adr3"
3304 a - don't know -- maybe a misprint
3305 d - initialized data
3307 3 - double word aligned (that would be 4 byte boundary)
3310 Tag index tables (also known as the function table) for exception
3311 handling, debugging, etc.
3318 if (pdata_section == 0)
3320 pdata_section = subseg_new (".pdata", 0);
3322 bfd_set_section_flags (stdoutput, pdata_section,
3323 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3324 | SEC_READONLY | SEC_DATA ));
3326 bfd_set_section_alignment (stdoutput, pdata_section, 2);
3330 pdata_section = subseg_new(".pdata", 0);
3332 ppc_set_current_section(pdata_section);
3335 /* pseudo-op: .ydata
3336 behaviour: predefined read only data section
3340 initial: .section .ydata "drw3"
3341 a - don't know -- maybe a misprint
3342 d - initialized data
3344 3 - double word aligned (that would be 4 byte boundary)
3346 Tag tables (also known as the scope table) for exception handling,
3353 if (ydata_section == 0)
3355 ydata_section = subseg_new (".ydata", 0);
3356 bfd_set_section_flags (stdoutput, ydata_section,
3357 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3358 | SEC_READONLY | SEC_DATA ));
3360 bfd_set_section_alignment (stdoutput, ydata_section, 3);
3364 ydata_section = subseg_new (".ydata", 0);
3366 ppc_set_current_section(ydata_section);
3369 /* pseudo-op: .reldata
3370 behaviour: predefined read write data section
3371 double word aligned (4-byte)
3372 FIXME: relocation is applied to it
3373 FIXME: what's the difference between this and .data?
3376 initial: .section .reldata "drw3"
3377 d - initialized data
3380 3 - double word aligned (that would be 8 byte boundary)
3383 Like .data, but intended to hold data subject to relocation, such as
3384 function descriptors, etc.
3390 if (reldata_section == 0)
3392 reldata_section = subseg_new (".reldata", 0);
3394 bfd_set_section_flags (stdoutput, reldata_section,
3395 ( SEC_ALLOC | SEC_LOAD | SEC_RELOC
3398 bfd_set_section_alignment (stdoutput, reldata_section, 2);
3402 reldata_section = subseg_new (".reldata", 0);
3404 ppc_set_current_section(reldata_section);
3407 /* pseudo-op: .rdata
3408 behaviour: predefined read only data section
3412 initial: .section .rdata "dr3"
3413 d - initialized data
3415 3 - double word aligned (that would be 4 byte boundary)
3421 if (rdata_section == 0)
3423 rdata_section = subseg_new (".rdata", 0);
3424 bfd_set_section_flags (stdoutput, rdata_section,
3425 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3426 | SEC_READONLY | SEC_DATA ));
3428 bfd_set_section_alignment (stdoutput, rdata_section, 2);
3432 rdata_section = subseg_new (".rdata", 0);
3434 ppc_set_current_section(rdata_section);
3437 /* pseudo-op: .ualong
3438 behaviour: much like .int, with the exception that no alignment is
3440 FIXME: test the alignment statement
3452 /* pseudo-op: .znop <symbol name>
3453 behaviour: Issue a nop instruction
3454 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3455 the supplied symbol name.
3457 warnings: Missing symbol name
3464 const struct powerpc_opcode *opcode;
3470 /* Strip out the symbol name */
3478 symbol_name = input_line_pointer;
3479 c = get_symbol_end ();
3481 name = xmalloc (input_line_pointer - symbol_name + 1);
3482 strcpy (name, symbol_name);
3484 sym = symbol_find_or_make (name);
3486 *input_line_pointer = c;
3490 /* Look up the opcode in the hash table. */
3491 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
3493 /* stick in the nop */
3494 insn = opcode->opcode;
3496 /* Write out the instruction. */
3498 md_number_to_chars (f, insn, 4);
3500 f - frag_now->fr_literal,
3505 BFD_RELOC_16_GOT_PCREL);
3518 register char *name;
3522 register symbolS *symbolP;
3525 name = input_line_pointer;
3526 c = get_symbol_end ();
3528 /* just after name is now '\0' */
3529 p = input_line_pointer;
3532 if (*input_line_pointer != ',')
3534 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3535 ignore_rest_of_line ();
3539 input_line_pointer++; /* skip ',' */
3540 if ((temp = get_absolute_expression ()) < 0)
3542 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
3543 ignore_rest_of_line ();
3549 /* The third argument to .comm is the alignment. */
3550 if (*input_line_pointer != ',')
3554 ++input_line_pointer;
3555 align = get_absolute_expression ();
3558 as_warn (_("ignoring bad alignment"));
3565 symbolP = symbol_find_or_make (name);
3568 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3570 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
3571 S_GET_NAME (symbolP));
3572 ignore_rest_of_line ();
3576 if (S_GET_VALUE (symbolP))
3578 if (S_GET_VALUE (symbolP) != (valueT) temp)
3579 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3580 S_GET_NAME (symbolP),
3581 (long) S_GET_VALUE (symbolP),
3586 S_SET_VALUE (symbolP, (valueT) temp);
3587 S_SET_EXTERNAL (symbolP);
3590 demand_empty_rest_of_line ();
3594 * implement the .section pseudo op:
3595 * .section name {, "flags"}
3597 * | +--- optional flags: 'b' for bss
3599 * +-- section name 'l' for lib
3603 * 'd' (apparently m88k for data)
3605 * But if the argument is not a quoted string, treat it as a
3606 * subsegment number.
3608 * FIXME: this is a copy of the section processing from obj-coff.c, with
3609 * additions/changes for the moto-pas assembler support. There are three
3612 * FIXME: I just noticed this. This doesn't work at all really. It it
3613 * setting bits that bfd probably neither understands or uses. The
3614 * correct approach (?) will have to incorporate extra fields attached
3615 * to the section to hold the system specific stuff. (krk)
3618 * 'a' - unknown - referred to in documentation, but no definition supplied
3619 * 'c' - section has code
3620 * 'd' - section has initialized data
3621 * 'u' - section has uninitialized data
3622 * 'i' - section contains directives (info)
3623 * 'n' - section can be discarded
3624 * 'R' - remove section at link time
3626 * Section Protection:
3627 * 'r' - section is readable
3628 * 'w' - section is writeable
3629 * 'x' - section is executable
3630 * 's' - section is sharable
3632 * Section Alignment:
3633 * '0' - align to byte boundary
3634 * '1' - align to halfword undary
3635 * '2' - align to word boundary
3636 * '3' - align to doubleword boundary
3637 * '4' - align to quadword boundary
3638 * '5' - align to 32 byte boundary
3639 * '6' - align to 64 byte boundary
3644 ppc_pe_section (ignore)
3647 /* Strip out the section name */
3656 section_name = input_line_pointer;
3657 c = get_symbol_end ();
3659 name = xmalloc (input_line_pointer - section_name + 1);
3660 strcpy (name, section_name);
3662 *input_line_pointer = c;
3667 flags = SEC_NO_FLAGS;
3669 if (strcmp (name, ".idata$2") == 0)
3673 else if (strcmp (name, ".idata$3") == 0)
3677 else if (strcmp (name, ".idata$4") == 0)
3681 else if (strcmp (name, ".idata$5") == 0)
3685 else if (strcmp (name, ".idata$6") == 0)
3690 align = 4; /* default alignment to 16 byte boundary */
3692 if (*input_line_pointer == ',')
3694 ++input_line_pointer;
3696 if (*input_line_pointer != '"')
3697 exp = get_absolute_expression ();
3700 ++input_line_pointer;
3701 while (*input_line_pointer != '"'
3702 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3704 switch (*input_line_pointer)
3706 /* Section Contents */
3707 case 'a': /* unknown */
3708 as_bad (_("Unsupported section attribute -- 'a'"));
3710 case 'c': /* code section */
3713 case 'd': /* section has initialized data */
3716 case 'u': /* section has uninitialized data */
3717 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
3721 case 'i': /* section contains directives (info) */
3722 /* FIXME: This is IMAGE_SCN_LNK_INFO
3724 flags |= SEC_HAS_CONTENTS;
3726 case 'n': /* section can be discarded */
3729 case 'R': /* Remove section at link time */
3730 flags |= SEC_NEVER_LOAD;
3733 /* Section Protection */
3734 case 'r': /* section is readable */
3735 flags |= IMAGE_SCN_MEM_READ;
3737 case 'w': /* section is writeable */
3738 flags |= IMAGE_SCN_MEM_WRITE;
3740 case 'x': /* section is executable */
3741 flags |= IMAGE_SCN_MEM_EXECUTE;
3743 case 's': /* section is sharable */
3744 flags |= IMAGE_SCN_MEM_SHARED;
3747 /* Section Alignment */
3748 case '0': /* align to byte boundary */
3749 flags |= IMAGE_SCN_ALIGN_1BYTES;
3752 case '1': /* align to halfword boundary */
3753 flags |= IMAGE_SCN_ALIGN_2BYTES;
3756 case '2': /* align to word boundary */
3757 flags |= IMAGE_SCN_ALIGN_4BYTES;
3760 case '3': /* align to doubleword boundary */
3761 flags |= IMAGE_SCN_ALIGN_8BYTES;
3764 case '4': /* align to quadword boundary */
3765 flags |= IMAGE_SCN_ALIGN_16BYTES;
3768 case '5': /* align to 32 byte boundary */
3769 flags |= IMAGE_SCN_ALIGN_32BYTES;
3772 case '6': /* align to 64 byte boundary */
3773 flags |= IMAGE_SCN_ALIGN_64BYTES;
3778 as_bad(_("unknown section attribute '%c'"),
3779 *input_line_pointer);
3782 ++input_line_pointer;
3784 if (*input_line_pointer == '"')
3785 ++input_line_pointer;
3789 sec = subseg_new (name, (subsegT) exp);
3791 ppc_set_current_section(sec);
3793 if (flags != SEC_NO_FLAGS)
3795 if (! bfd_set_section_flags (stdoutput, sec, flags))
3796 as_bad (_("error setting flags for \"%s\": %s"),
3797 bfd_section_name (stdoutput, sec),
3798 bfd_errmsg (bfd_get_error ()));
3801 bfd_set_section_alignment(stdoutput, sec, align);
3806 ppc_pe_function (ignore)
3813 name = input_line_pointer;
3814 endc = get_symbol_end ();
3816 ext_sym = symbol_find_or_make (name);
3818 *input_line_pointer = endc;
3820 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3821 SF_SET_FUNCTION (ext_sym);
3822 SF_SET_PROCESS (ext_sym);
3823 coff_add_linesym (ext_sym);
3825 demand_empty_rest_of_line ();
3829 ppc_pe_tocd (ignore)
3832 if (tocdata_section == 0)
3834 tocdata_section = subseg_new (".tocd", 0);
3835 /* FIXME: section flags won't work */
3836 bfd_set_section_flags (stdoutput, tocdata_section,
3837 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3838 | SEC_READONLY | SEC_DATA ));
3840 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
3844 rdata_section = subseg_new (".tocd", 0);
3847 ppc_set_current_section(tocdata_section);
3849 demand_empty_rest_of_line ();
3852 /* Don't adjust TOC relocs to use the section symbol. */
3855 ppc_pe_fix_adjustable (fix)
3858 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
3865 /* XCOFF specific symbol and file handling. */
3867 /* Canonicalize the symbol name. We use the to force the suffix, if
3868 any, to use square brackets, and to be in upper case. */
3871 ppc_canonicalize_symbol_name (name)
3876 if (ppc_stab_symbol)
3879 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
3893 for (s++; *s != '\0' && *s != brac; s++)
3897 if (*s == '\0' || s[1] != '\0')
3898 as_bad (_("bad symbol suffix"));
3906 /* Set the class of a symbol based on the suffix, if any. This is
3907 called whenever a new symbol is created. */
3910 ppc_symbol_new_hook (sym)
3915 sym->sy_tc.next = NULL;
3916 sym->sy_tc.output = 0;
3917 sym->sy_tc.class = -1;
3918 sym->sy_tc.real_name = NULL;
3919 sym->sy_tc.subseg = 0;
3920 sym->sy_tc.align = 0;
3921 sym->sy_tc.size = NULL;
3922 sym->sy_tc.within = NULL;
3924 if (ppc_stab_symbol)
3927 s = strchr (S_GET_NAME (sym), '[');
3928 if (s == (const char *) NULL)
3930 /* There is no suffix. */
3939 if (strcmp (s, "BS]") == 0)
3940 sym->sy_tc.class = XMC_BS;
3943 if (strcmp (s, "DB]") == 0)
3944 sym->sy_tc.class = XMC_DB;
3945 else if (strcmp (s, "DS]") == 0)
3946 sym->sy_tc.class = XMC_DS;
3949 if (strcmp (s, "GL]") == 0)
3950 sym->sy_tc.class = XMC_GL;
3953 if (strcmp (s, "PR]") == 0)
3954 sym->sy_tc.class = XMC_PR;
3957 if (strcmp (s, "RO]") == 0)
3958 sym->sy_tc.class = XMC_RO;
3959 else if (strcmp (s, "RW]") == 0)
3960 sym->sy_tc.class = XMC_RW;
3963 if (strcmp (s, "SV]") == 0)
3964 sym->sy_tc.class = XMC_SV;
3967 if (strcmp (s, "TC]") == 0)
3968 sym->sy_tc.class = XMC_TC;
3969 else if (strcmp (s, "TI]") == 0)
3970 sym->sy_tc.class = XMC_TI;
3971 else if (strcmp (s, "TB]") == 0)
3972 sym->sy_tc.class = XMC_TB;
3973 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
3974 sym->sy_tc.class = XMC_TC0;
3977 if (strcmp (s, "UA]") == 0)
3978 sym->sy_tc.class = XMC_UA;
3979 else if (strcmp (s, "UC]") == 0)
3980 sym->sy_tc.class = XMC_UC;
3983 if (strcmp (s, "XO]") == 0)
3984 sym->sy_tc.class = XMC_XO;
3988 if (sym->sy_tc.class == -1)
3989 as_bad (_("Unrecognized symbol suffix"));
3992 /* Set the class of a label based on where it is defined. This
3993 handles symbols without suffixes. Also, move the symbol so that it
3994 follows the csect symbol. */
3997 ppc_frob_label (sym)
4000 if (ppc_current_csect != (symbolS *) NULL)
4002 if (sym->sy_tc.class == -1)
4003 sym->sy_tc.class = ppc_current_csect->sy_tc.class;
4005 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4006 symbol_append (sym, ppc_current_csect->sy_tc.within, &symbol_rootP,
4008 ppc_current_csect->sy_tc.within = sym;
4012 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4013 seen. It tells ppc_adjust_symtab whether it needs to look through
4016 static boolean ppc_saw_abs;
4018 /* Change the name of a symbol just before writing it out. Set the
4019 real name if the .rename pseudo-op was used. Otherwise, remove any
4020 class suffix. Return 1 if the symbol should not be included in the
4024 ppc_frob_symbol (sym)
4027 static symbolS *ppc_last_function;
4028 static symbolS *set_end;
4030 /* Discard symbols that should not be included in the output symbol
4032 if (! sym->sy_used_in_reloc
4033 && ((sym->bsym->flags & BSF_SECTION_SYM) != 0
4034 || (! S_IS_EXTERNAL (sym)
4035 && ! sym->sy_tc.output
4036 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
4039 if (sym->sy_tc.real_name != (char *) NULL)
4040 S_SET_NAME (sym, sym->sy_tc.real_name);
4046 name = S_GET_NAME (sym);
4047 s = strchr (name, '[');
4048 if (s != (char *) NULL)
4054 snew = xmalloc (len + 1);
4055 memcpy (snew, name, len);
4058 S_SET_NAME (sym, snew);
4062 if (set_end != (symbolS *) NULL)
4064 SA_SET_SYM_ENDNDX (set_end, sym);
4068 if (SF_GET_FUNCTION (sym))
4070 if (ppc_last_function != (symbolS *) NULL)
4071 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4072 ppc_last_function = sym;
4073 if (sym->sy_tc.size != (symbolS *) NULL)
4075 resolve_symbol_value (sym->sy_tc.size, 1);
4076 SA_SET_SYM_FSIZE (sym, (long) S_GET_VALUE (sym->sy_tc.size));
4079 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4080 && strcmp (S_GET_NAME (sym), ".ef") == 0)
4082 if (ppc_last_function == (symbolS *) NULL)
4083 as_bad (_(".ef with no preceding .function"));
4086 set_end = ppc_last_function;
4087 ppc_last_function = NULL;
4089 /* We don't have a C_EFCN symbol, but we need to force the
4090 COFF backend to believe that it has seen one. */
4091 coff_last_function = NULL;
4095 if (! S_IS_EXTERNAL (sym)
4096 && (sym->bsym->flags & BSF_SECTION_SYM) == 0
4097 && S_GET_STORAGE_CLASS (sym) != C_FILE
4098 && S_GET_STORAGE_CLASS (sym) != C_FCN
4099 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4100 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4101 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
4102 && S_GET_STORAGE_CLASS (sym) != C_BINCL
4103 && S_GET_STORAGE_CLASS (sym) != C_EINCL
4104 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
4105 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
4107 if (S_GET_STORAGE_CLASS (sym) == C_EXT
4108 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
4111 union internal_auxent *a;
4113 /* Create a csect aux. */
4114 i = S_GET_NUMBER_AUXILIARY (sym);
4115 S_SET_NUMBER_AUXILIARY (sym, i + 1);
4116 a = &coffsymbol (sym->bsym)->native[i + 1].u.auxent;
4117 if (sym->sy_tc.class == XMC_TC0)
4119 /* This is the TOC table. */
4120 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
4121 a->x_csect.x_scnlen.l = 0;
4122 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4124 else if (sym->sy_tc.subseg != 0)
4126 /* This is a csect symbol. x_scnlen is the size of the
4128 if (sym->sy_tc.next == (symbolS *) NULL)
4129 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4130 S_GET_SEGMENT (sym))
4131 - S_GET_VALUE (sym));
4134 resolve_symbol_value (sym->sy_tc.next, 1);
4135 a->x_csect.x_scnlen.l = (S_GET_VALUE (sym->sy_tc.next)
4136 - S_GET_VALUE (sym));
4138 a->x_csect.x_smtyp = (sym->sy_tc.align << 3) | XTY_SD;
4140 else if (S_GET_SEGMENT (sym) == bss_section)
4142 /* This is a common symbol. */
4143 a->x_csect.x_scnlen.l = sym->sy_frag->fr_offset;
4144 a->x_csect.x_smtyp = (sym->sy_tc.align << 3) | XTY_CM;
4145 if (S_IS_EXTERNAL (sym))
4146 sym->sy_tc.class = XMC_RW;
4148 sym->sy_tc.class = XMC_BS;
4150 else if (S_GET_SEGMENT (sym) == absolute_section)
4152 /* This is an absolute symbol. The csect will be created by
4153 ppc_adjust_symtab. */
4155 a->x_csect.x_smtyp = XTY_LD;
4156 if (sym->sy_tc.class == -1)
4157 sym->sy_tc.class = XMC_XO;
4159 else if (! S_IS_DEFINED (sym))
4161 /* This is an external symbol. */
4162 a->x_csect.x_scnlen.l = 0;
4163 a->x_csect.x_smtyp = XTY_ER;
4165 else if (sym->sy_tc.class == XMC_TC)
4169 /* This is a TOC definition. x_scnlen is the size of the
4171 next = symbol_next (sym);
4172 while (next->sy_tc.class == XMC_TC0)
4173 next = symbol_next (next);
4174 if (next == (symbolS *) NULL
4175 || next->sy_tc.class != XMC_TC)
4177 if (ppc_after_toc_frag == (fragS *) NULL)
4178 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4180 - S_GET_VALUE (sym));
4182 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
4183 - S_GET_VALUE (sym));
4187 resolve_symbol_value (next, 1);
4188 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
4189 - S_GET_VALUE (sym));
4191 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4197 /* This is a normal symbol definition. x_scnlen is the
4198 symbol index of the containing csect. */
4199 if (S_GET_SEGMENT (sym) == text_section)
4200 csect = ppc_text_csects;
4201 else if (S_GET_SEGMENT (sym) == data_section)
4202 csect = ppc_data_csects;
4206 /* Skip the initial dummy symbol. */
4207 csect = csect->sy_tc.next;
4209 if (csect == (symbolS *) NULL)
4211 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
4212 a->x_csect.x_scnlen.l = 0;
4216 while (csect->sy_tc.next != (symbolS *) NULL)
4218 resolve_symbol_value (csect->sy_tc.next, 1);
4219 if (S_GET_VALUE (csect->sy_tc.next) > S_GET_VALUE (sym))
4221 csect = csect->sy_tc.next;
4224 a->x_csect.x_scnlen.p = coffsymbol (csect->bsym)->native;
4225 coffsymbol (sym->bsym)->native[i + 1].fix_scnlen = 1;
4227 a->x_csect.x_smtyp = XTY_LD;
4230 a->x_csect.x_parmhash = 0;
4231 a->x_csect.x_snhash = 0;
4232 if (sym->sy_tc.class == -1)
4233 a->x_csect.x_smclas = XMC_PR;
4235 a->x_csect.x_smclas = sym->sy_tc.class;
4236 a->x_csect.x_stab = 0;
4237 a->x_csect.x_snstab = 0;
4239 /* Don't let the COFF backend resort these symbols. */
4240 sym->bsym->flags |= BSF_NOT_AT_END;
4242 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
4244 /* We want the value to be the symbol index of the referenced
4245 csect symbol. BFD will do that for us if we set the right
4248 (valueT) coffsymbol (sym->sy_tc.within->bsym)->native);
4249 coffsymbol (sym->bsym)->native->fix_value = 1;
4251 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4256 /* The value is the offset from the enclosing csect. */
4257 block = sym->sy_tc.within;
4258 csect = block->sy_tc.within;
4259 resolve_symbol_value (csect, 1);
4260 S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
4262 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
4263 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
4265 /* We want the value to be a file offset into the line numbers.
4266 BFD will do that for us if we set the right flags. We have
4267 already set the value correctly. */
4268 coffsymbol (sym->bsym)->native->fix_line = 1;
4274 /* Adjust the symbol table. This creates csect symbols for all
4275 absolute symbols. */
4278 ppc_adjust_symtab ()
4285 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4289 union internal_auxent *a;
4291 if (S_GET_SEGMENT (sym) != absolute_section)
4294 csect = symbol_create (".abs[XO]", absolute_section,
4295 S_GET_VALUE (sym), &zero_address_frag);
4296 csect->bsym->value = S_GET_VALUE (sym);
4297 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
4298 i = S_GET_NUMBER_AUXILIARY (csect);
4299 S_SET_NUMBER_AUXILIARY (csect, i + 1);
4300 a = &coffsymbol (csect->bsym)->native[i + 1].u.auxent;
4301 a->x_csect.x_scnlen.l = 0;
4302 a->x_csect.x_smtyp = XTY_SD;
4303 a->x_csect.x_parmhash = 0;
4304 a->x_csect.x_snhash = 0;
4305 a->x_csect.x_smclas = XMC_XO;
4306 a->x_csect.x_stab = 0;
4307 a->x_csect.x_snstab = 0;
4309 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
4311 i = S_GET_NUMBER_AUXILIARY (sym);
4312 a = &coffsymbol (sym->bsym)->native[i].u.auxent;
4313 a->x_csect.x_scnlen.p = coffsymbol (csect->bsym)->native;
4314 coffsymbol (sym->bsym)->native[i].fix_scnlen = 1;
4317 ppc_saw_abs = false;
4320 /* Set the VMA for a section. This is called on all the sections in
4324 ppc_frob_section (sec)
4327 static bfd_size_type vma = 0;
4329 bfd_set_section_vma (stdoutput, sec, vma);
4330 vma += bfd_section_size (stdoutput, sec);
4333 #endif /* OBJ_XCOFF */
4335 /* Turn a string in input_line_pointer into a floating point constant
4336 of type type, and store the appropriate bytes in *litp. The number
4337 of LITTLENUMS emitted is stored in *sizep . An error message is
4338 returned, or NULL on OK. */
4341 md_atof (type, litp, sizep)
4347 LITTLENUM_TYPE words[4];
4363 return _("bad call to md_atof");
4366 t = atof_ieee (input_line_pointer, type, words);
4368 input_line_pointer = t;
4372 if (target_big_endian)
4374 for (i = 0; i < prec; i++)
4376 md_number_to_chars (litp, (valueT) words[i], 2);
4382 for (i = prec - 1; i >= 0; i--)
4384 md_number_to_chars (litp, (valueT) words[i], 2);
4392 /* Write a value out to the object file, using the appropriate
4396 md_number_to_chars (buf, val, n)
4401 if (target_big_endian)
4402 number_to_chars_bigendian (buf, val, n);
4404 number_to_chars_littleendian (buf, val, n);
4407 /* Align a section (I don't know why this is machine dependent). */
4410 md_section_align (seg, addr)
4414 int align = bfd_get_section_alignment (stdoutput, seg);
4416 return ((addr + (1 << align) - 1) & (-1 << align));
4419 /* We don't have any form of relaxing. */
4422 md_estimate_size_before_relax (fragp, seg)
4430 /* Convert a machine dependent frag. We never generate these. */
4433 md_convert_frag (abfd, sec, fragp)
4441 /* We have no need to default values of symbols. */
4445 md_undefined_symbol (name)
4451 /* Functions concerning relocs. */
4453 /* The location from which a PC relative jump should be calculated,
4454 given a PC relative reloc. */
4457 md_pcrel_from_section (fixp, sec)
4461 return fixp->fx_frag->fr_address + fixp->fx_where;
4466 /* This is called to see whether a fixup should be adjusted to use a
4467 section symbol. We take the opportunity to change a fixup against
4468 a symbol in the TOC subsegment into a reloc against the
4469 corresponding .tc symbol. */
4472 ppc_fix_adjustable (fix)
4477 resolve_symbol_value (fix->fx_addsy, 1);
4478 val = S_GET_VALUE (fix->fx_addsy);
4479 if (ppc_toc_csect != (symbolS *) NULL
4480 && fix->fx_addsy != (symbolS *) NULL
4481 && fix->fx_addsy != ppc_toc_csect
4482 && S_GET_SEGMENT (fix->fx_addsy) == data_section
4483 && val >= ppc_toc_frag->fr_address
4484 && (ppc_after_toc_frag == (fragS *) NULL
4485 || val < ppc_after_toc_frag->fr_address))
4489 for (sy = symbol_next (ppc_toc_csect);
4490 sy != (symbolS *) NULL;
4491 sy = symbol_next (sy))
4493 if (sy->sy_tc.class == XMC_TC0)
4495 if (sy->sy_tc.class != XMC_TC)
4497 resolve_symbol_value (sy, 1);
4498 if (val == S_GET_VALUE (sy))
4501 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
4506 as_bad_where (fix->fx_file, fix->fx_line,
4507 _("symbol in .toc does not match any .tc"));
4510 /* Possibly adjust the reloc to be against the csect. */
4511 if (fix->fx_addsy != (symbolS *) NULL
4512 && fix->fx_addsy->sy_tc.subseg == 0
4513 && fix->fx_addsy->sy_tc.class != XMC_TC0
4514 && fix->fx_addsy->sy_tc.class != XMC_TC
4515 && S_GET_SEGMENT (fix->fx_addsy) != bss_section
4516 /* Don't adjust if this is a reloc in the toc section. */
4517 && (S_GET_SEGMENT (fix->fx_addsy) != data_section
4518 || ppc_toc_csect == NULL
4519 || val < ppc_toc_frag->fr_address
4520 || (ppc_after_toc_frag != NULL
4521 && val >= ppc_after_toc_frag->fr_address)))
4525 if (S_GET_SEGMENT (fix->fx_addsy) == text_section)
4526 csect = ppc_text_csects;
4527 else if (S_GET_SEGMENT (fix->fx_addsy) == data_section)
4528 csect = ppc_data_csects;
4532 /* Skip the initial dummy symbol. */
4533 csect = csect->sy_tc.next;
4535 if (csect != (symbolS *) NULL)
4537 while (csect->sy_tc.next != (symbolS *) NULL
4538 && (csect->sy_tc.next->sy_frag->fr_address
4539 <= fix->fx_addsy->sy_frag->fr_address))
4541 /* If the csect address equals the symbol value, then we
4542 have to look through the full symbol table to see
4543 whether this is the csect we want. Note that we will
4544 only get here if the csect has zero length. */
4545 if ((csect->sy_frag->fr_address
4546 == fix->fx_addsy->sy_frag->fr_address)
4547 && S_GET_VALUE (csect) == S_GET_VALUE (fix->fx_addsy))
4551 for (scan = csect->sy_next;
4553 scan = scan->sy_next)
4555 if (scan->sy_tc.subseg != 0)
4557 if (scan == fix->fx_addsy)
4561 /* If we found the symbol before the next csect
4562 symbol, then this is the csect we want. */
4563 if (scan == fix->fx_addsy)
4567 csect = csect->sy_tc.next;
4570 fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
4571 - csect->sy_frag->fr_address);
4572 fix->fx_addsy = csect;
4576 /* Adjust a reloc against a .lcomm symbol to be against the base
4578 if (fix->fx_addsy != (symbolS *) NULL
4579 && S_GET_SEGMENT (fix->fx_addsy) == bss_section
4580 && ! S_IS_EXTERNAL (fix->fx_addsy))
4582 resolve_symbol_value (fix->fx_addsy->sy_frag->fr_symbol, 1);
4583 fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
4584 - S_GET_VALUE (fix->fx_addsy->sy_frag->fr_symbol));
4585 fix->fx_addsy = fix->fx_addsy->sy_frag->fr_symbol;
4591 /* A reloc from one csect to another must be kept. The assembler
4592 will, of course, keep relocs between sections, and it will keep
4593 absolute relocs, but we need to force it to keep PC relative relocs
4594 between two csects in the same section. */
4597 ppc_force_relocation (fix)
4600 /* At this point fix->fx_addsy should already have been converted to
4601 a csect symbol. If the csect does not include the fragment, then
4602 we need to force the relocation. */
4604 && fix->fx_addsy != NULL
4605 && fix->fx_addsy->sy_tc.subseg != 0
4606 && (fix->fx_addsy->sy_frag->fr_address > fix->fx_frag->fr_address
4607 || (fix->fx_addsy->sy_tc.next != NULL
4608 && (fix->fx_addsy->sy_tc.next->sy_frag->fr_address
4609 <= fix->fx_frag->fr_address))))
4615 #endif /* OBJ_XCOFF */
4617 /* See whether a symbol is in the TOC section. */
4620 ppc_is_toc_sym (sym)
4624 return sym->sy_tc.class == XMC_TC;
4626 return strcmp (segment_name (S_GET_SEGMENT (sym)), ".got") == 0;
4630 /* Apply a fixup to the object code. This is called for all the
4631 fixups we generated by the call to fix_new_exp, above. In the call
4632 above we used a reloc code which was the largest legal reloc code
4633 plus the operand index. Here we undo that to recover the operand
4634 index. At this point all symbol values should be fully resolved,
4635 and we attempt to completely resolve the reloc. If we can not do
4636 that, we determine the correct reloc code and put it back in the
4640 md_apply_fix3 (fixp, valuep, seg)
4649 if (fixp->fx_addsy != NULL)
4651 /* `*valuep' may contain the value of the symbol on which the reloc
4652 will be based; we have to remove it. */
4653 if (fixp->fx_addsy->sy_used_in_reloc
4654 && S_GET_SEGMENT (fixp->fx_addsy) != absolute_section
4655 && S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
4656 && ! bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy)))
4657 value -= S_GET_VALUE (fixp->fx_addsy);
4659 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
4660 supposed to be? I think this is related to various similar
4661 FIXMEs in tc-i386.c and tc-sparc.c. */
4663 value += fixp->fx_frag->fr_address + fixp->fx_where;
4670 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
4671 the symbol values. Since we are using BFD_ASSEMBLER, if we are
4672 doing this relocation the code in write.c is going to call
4673 bfd_install_relocation, which is also going to use the symbol
4674 value. That means that if the reloc is fully resolved we want to
4675 use *valuep since bfd_install_relocation is not being used.
4676 However, if the reloc is not fully resolved we do not want to use
4677 *valuep, and must use fx_offset instead. However, if the reloc
4678 is PC relative, we do want to use *valuep since it includes the
4679 result of md_pcrel_from. This is confusing. */
4680 if (fixp->fx_addsy == (symbolS *) NULL)
4685 else if (fixp->fx_pcrel)
4689 value = fixp->fx_offset;
4690 if (fixp->fx_subsy != (symbolS *) NULL)
4692 if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
4693 value -= S_GET_VALUE (fixp->fx_subsy);
4696 /* We can't actually support subtracting a symbol. */
4697 as_bad_where (fixp->fx_file, fixp->fx_line,
4698 _("expression too complex"));
4704 if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
4707 const struct powerpc_operand *operand;
4711 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
4713 operand = &powerpc_operands[opindex];
4716 /* It appears that an instruction like
4718 when LC..1 is not a TOC symbol does not generate a reloc. It
4719 uses the offset of LC..1 within its csect. However, .long
4720 LC..1 will generate a reloc. I can't find any documentation
4721 on how these cases are to be distinguished, so this is a wild
4722 guess. These cases are generated by gcc -mminimal-toc. */
4723 if ((operand->flags & PPC_OPERAND_PARENS) != 0
4724 && operand->bits == 16
4725 && operand->shift == 0
4726 && operand->insert == NULL
4727 && fixp->fx_addsy != NULL
4728 && fixp->fx_addsy->sy_tc.subseg != 0
4729 && fixp->fx_addsy->sy_tc.class != XMC_TC
4730 && fixp->fx_addsy->sy_tc.class != XMC_TC0
4731 && S_GET_SEGMENT (fixp->fx_addsy) != bss_section)
4733 value = fixp->fx_offset;
4738 /* Fetch the instruction, insert the fully resolved operand
4739 value, and stuff the instruction back again. */
4740 where = fixp->fx_frag->fr_literal + fixp->fx_where;
4741 if (target_big_endian)
4742 insn = bfd_getb32 ((unsigned char *) where);
4744 insn = bfd_getl32 ((unsigned char *) where);
4745 insn = ppc_insert_operand (insn, operand, (offsetT) value,
4746 fixp->fx_file, fixp->fx_line);
4747 if (target_big_endian)
4748 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4750 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4754 /* Nothing else to do here. */
4758 /* Determine a BFD reloc value based on the operand information.
4759 We are only prepared to turn a few of the operands into
4761 FIXME: We need to handle the DS field at the very least.
4762 FIXME: Selecting the reloc type is a bit haphazard; perhaps
4763 there should be a new field in the operand table. */
4764 if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4765 && operand->bits == 26
4766 && operand->shift == 0)
4767 fixp->fx_r_type = BFD_RELOC_PPC_B26;
4768 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4769 && operand->bits == 16
4770 && operand->shift == 0)
4771 fixp->fx_r_type = BFD_RELOC_PPC_B16;
4772 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4773 && operand->bits == 26
4774 && operand->shift == 0)
4775 fixp->fx_r_type = BFD_RELOC_PPC_BA26;
4776 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4777 && operand->bits == 16
4778 && operand->shift == 0)
4779 fixp->fx_r_type = BFD_RELOC_PPC_BA16;
4780 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
4781 && operand->bits == 16
4782 && operand->shift == 0
4783 && operand->insert == NULL
4784 && fixp->fx_addsy != NULL
4785 && ppc_is_toc_sym (fixp->fx_addsy))
4788 if (target_big_endian)
4789 fixp->fx_where += 2;
4790 fixp->fx_r_type = BFD_RELOC_PPC_TOC16;
4797 /* Use expr_symbol_where to see if this is an expression
4799 if (expr_symbol_where (fixp->fx_addsy, &sfile, &sline))
4800 as_bad_where (fixp->fx_file, fixp->fx_line,
4801 _("unresolved expression that must be resolved"));
4803 as_bad_where (fixp->fx_file, fixp->fx_line,
4804 _("unsupported relocation type"));
4812 ppc_elf_validate_fix (fixp, seg);
4814 switch (fixp->fx_r_type)
4817 case BFD_RELOC_CTOR:
4819 fixp->fx_r_type = BFD_RELOC_32_PCREL;
4823 case BFD_RELOC_32_PCREL:
4824 case BFD_RELOC_32_BASEREL:
4825 case BFD_RELOC_PPC_EMB_NADDR32:
4826 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4830 case BFD_RELOC_LO16:
4832 case BFD_RELOC_GPREL16:
4833 case BFD_RELOC_16_GOT_PCREL:
4834 case BFD_RELOC_16_GOTOFF:
4835 case BFD_RELOC_LO16_GOTOFF:
4836 case BFD_RELOC_HI16_GOTOFF:
4837 case BFD_RELOC_HI16_S_GOTOFF:
4838 case BFD_RELOC_LO16_BASEREL:
4839 case BFD_RELOC_HI16_BASEREL:
4840 case BFD_RELOC_HI16_S_BASEREL:
4841 case BFD_RELOC_PPC_EMB_NADDR16:
4842 case BFD_RELOC_PPC_EMB_NADDR16_LO:
4843 case BFD_RELOC_PPC_EMB_NADDR16_HI:
4844 case BFD_RELOC_PPC_EMB_NADDR16_HA:
4845 case BFD_RELOC_PPC_EMB_SDAI16:
4846 case BFD_RELOC_PPC_EMB_SDA2REL:
4847 case BFD_RELOC_PPC_EMB_SDA2I16:
4848 case BFD_RELOC_PPC_EMB_RELSEC16:
4849 case BFD_RELOC_PPC_EMB_RELST_LO:
4850 case BFD_RELOC_PPC_EMB_RELST_HI:
4851 case BFD_RELOC_PPC_EMB_RELST_HA:
4852 case BFD_RELOC_PPC_EMB_RELSDA:
4853 case BFD_RELOC_PPC_TOC16:
4856 if (fixp->fx_addsy != NULL)
4857 as_bad_where (fixp->fx_file, fixp->fx_line,
4858 _("cannot emit PC relative %s relocation against %s"),
4859 bfd_get_reloc_code_name (fixp->fx_r_type),
4860 S_GET_NAME (fixp->fx_addsy));
4862 as_bad_where (fixp->fx_file, fixp->fx_line,
4863 _("cannot emit PC relative %s relocation"),
4864 bfd_get_reloc_code_name (fixp->fx_r_type));
4867 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4871 /* This case happens when you write, for example,
4873 where L1 and L2 are defined later. */
4874 case BFD_RELOC_HI16:
4877 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4880 case BFD_RELOC_HI16_S:
4883 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4884 value + 0x8000 >> 16, 2);
4887 /* Because SDA21 modifies the register field, the size is set to 4
4888 bytes, rather than 2, so offset it here appropriately */
4889 case BFD_RELOC_PPC_EMB_SDA21:
4893 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where
4894 + ((target_big_endian) ? 2 : 0),
4902 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4906 case BFD_RELOC_24_PLT_PCREL:
4907 case BFD_RELOC_PPC_LOCAL24PC:
4908 if (!fixp->fx_pcrel && !fixp->fx_done)
4916 /* Fetch the instruction, insert the fully resolved operand
4917 value, and stuff the instruction back again. */
4918 where = fixp->fx_frag->fr_literal + fixp->fx_where;
4919 if (target_big_endian)
4920 insn = bfd_getb32 ((unsigned char *) where);
4922 insn = bfd_getl32 ((unsigned char *) where);
4923 if ((value & 3) != 0)
4924 as_bad_where (fixp->fx_file, fixp->fx_line,
4925 _("must branch to an address a multiple of 4"));
4926 if ((offsetT) value < -0x40000000
4927 || (offsetT) value >= 0x40000000)
4928 as_bad_where (fixp->fx_file, fixp->fx_line,
4929 _("@local or @plt branch destination is too far away, %ld bytes"),
4931 insn = insn | (value & 0x03fffffc);
4932 if (target_big_endian)
4933 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4935 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4939 case BFD_RELOC_VTABLE_INHERIT:
4942 && !S_IS_DEFINED (fixp->fx_addsy)
4943 && !S_IS_WEAK (fixp->fx_addsy))
4944 S_SET_WEAK (fixp->fx_addsy);
4947 case BFD_RELOC_VTABLE_ENTRY:
4953 _("Gas failure, reloc value %d\n"), fixp->fx_r_type);
4960 fixp->fx_addnumber = value;
4962 if (fixp->fx_r_type != BFD_RELOC_PPC_TOC16)
4963 fixp->fx_addnumber = 0;
4967 fixp->fx_addnumber = 0;
4969 /* We want to use the offset within the data segment of the
4970 symbol, not the actual VMA of the symbol. */
4971 fixp->fx_addnumber =
4972 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixp->fx_addsy));
4980 /* Generate a reloc for a fixup. */
4983 tc_gen_reloc (seg, fixp)
4989 reloc = (arelent *) xmalloc (sizeof (arelent));
4991 reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
4992 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
4993 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
4994 if (reloc->howto == (reloc_howto_type *) NULL)
4996 as_bad_where (fixp->fx_file, fixp->fx_line,
4997 _("reloc %d not supported by object file format"), (int)fixp->fx_r_type);
5000 reloc->addend = fixp->fx_addnumber;