1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994, 95, 96, 97, 98, 1999 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 else if (strcmp (arg
, "ppc64bridge") == 0)
771 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_64_BRIDGE
;
772 ppc_size
= PPC_OPCODE_64
;
774 /* -mcom means assemble for the common intersection between Power
775 and PowerPC. At present, we just allow the union, rather
776 than the intersection. */
777 else if (strcmp (arg
, "com") == 0)
778 ppc_cpu
= PPC_OPCODE_COMMON
;
779 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
780 else if (strcmp (arg
, "any") == 0)
781 ppc_cpu
= PPC_OPCODE_ANY
;
783 else if (strcmp (arg
, "regnames") == 0)
786 else if (strcmp (arg
, "no-regnames") == 0)
790 /* -mrelocatable/-mrelocatable-lib -- warn about initializations that require relocation */
791 else if (strcmp (arg
, "relocatable") == 0)
793 shlib
= SHILB_MRELOCATABLE
;
794 ppc_flags
|= EF_PPC_RELOCATABLE
;
797 else if (strcmp (arg
, "relocatable-lib") == 0)
799 shlib
= SHILB_MRELOCATABLE
;
800 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
803 /* -memb, set embedded bit */
804 else if (strcmp (arg
, "emb") == 0)
805 ppc_flags
|= EF_PPC_EMB
;
807 /* -mlittle/-mbig set the endianess */
808 else if (strcmp (arg
, "little") == 0 || strcmp (arg
, "little-endian") == 0)
810 target_big_endian
= 0;
811 set_target_endian
= 1;
814 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
816 target_big_endian
= 1;
817 set_target_endian
= 1;
820 else if (strcmp (arg
, "solaris") == 0)
823 ppc_comment_chars
= ppc_solaris_comment_chars
;
826 else if (strcmp (arg
, "no-solaris") == 0)
829 ppc_comment_chars
= ppc_eabi_comment_chars
;
834 as_bad (_("invalid switch -m%s"), arg
);
840 /* -V: SVR4 argument to print version ID. */
845 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
846 should be emitted or not. FIXME: Not implemented. */
850 /* Solaris takes -s to specify that .stabs go in a .stabs section,
851 rather than .stabs.excl, which is ignored by the linker.
852 FIXME: Not implemented. */
868 md_show_usage (stream
)
874 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
875 -mpwr generate code for IBM POWER (RIOS1)\n\
876 -m601 generate code for Motorola PowerPC 601\n\
877 -mppc, -mppc32, -m403, -m603, -m604\n\
878 generate code for Motorola PowerPC 603/604\n\
879 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
880 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
881 -mcom generate code Power/PowerPC common instructions\n\
882 -many generate code for any architecture (PWR/PWRX/PPC)\n\
883 -mregnames Allow symbolic names for registers\n\
884 -mno-regnames Do not allow symbolic names for registers\n"));
887 -mrelocatable support for GCC's -mrelocatble option\n\
888 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
889 -memb set PPC_EMB bit in ELF flags\n\
890 -mlittle, -mlittle-endian\n\
891 generate code for a little endian machine\n\
892 -mbig, -mbig-endian generate code for a big endian machine\n\
893 -msolaris generate code for Solaris\n\
894 -mno-solaris do not generate code for Solaris\n\
895 -V print assembler version number\n\
896 -Qy, -Qn ignored\n"));
900 /* Set ppc_cpu if it is not already set. */
905 const char *default_os
= TARGET_OS
;
906 const char *default_cpu
= TARGET_CPU
;
910 if (strncmp (default_os
, "aix", 3) == 0
911 && default_os
[3] >= '4' && default_os
[3] <= '9')
912 ppc_cpu
= PPC_OPCODE_COMMON
;
913 else if (strncmp (default_os
, "aix3", 4) == 0)
914 ppc_cpu
= PPC_OPCODE_POWER
;
915 else if (strcmp (default_cpu
, "rs6000") == 0)
916 ppc_cpu
= PPC_OPCODE_POWER
;
917 else if (strcmp (default_cpu
, "powerpc") == 0
918 || strcmp (default_cpu
, "powerpcle") == 0)
919 ppc_cpu
= PPC_OPCODE_PPC
;
921 as_fatal (_("Unknown default cpu = %s, os = %s"), default_cpu
, default_os
);
925 /* Figure out the BFD architecture to use. */
927 enum bfd_architecture
930 const char *default_cpu
= TARGET_CPU
;
933 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
934 return bfd_arch_powerpc
;
935 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
936 return bfd_arch_rs6000
;
937 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
939 if (strcmp (default_cpu
, "rs6000") == 0)
940 return bfd_arch_rs6000
;
941 else if (strcmp (default_cpu
, "powerpc") == 0
942 || strcmp (default_cpu
, "powerpcle") == 0)
943 return bfd_arch_powerpc
;
946 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
947 return bfd_arch_unknown
;
950 /* This function is called when the assembler starts up. It is called
951 after the options have been parsed and the output file has been
957 register const struct powerpc_opcode
*op
;
958 const struct powerpc_opcode
*op_end
;
959 const struct powerpc_macro
*macro
;
960 const struct powerpc_macro
*macro_end
;
961 boolean dup_insn
= false;
966 /* Set the ELF flags if desired. */
967 if (ppc_flags
&& !msolaris
)
968 bfd_set_private_flags (stdoutput
, ppc_flags
);
971 /* Insert the opcodes into a hash table. */
972 ppc_hash
= hash_new ();
974 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
975 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
977 know ((op
->opcode
& op
->mask
) == op
->opcode
);
979 if ((op
->flags
& ppc_cpu
) != 0
980 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
981 || (op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == ppc_size
982 || (ppc_cpu
& PPC_OPCODE_64_BRIDGE
) != 0))
986 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
987 if (retval
!= (const char *) NULL
)
989 /* Ignore Power duplicates for -m601 */
990 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
991 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
994 as_bad (_("Internal assembler error for instruction %s"), op
->name
);
1000 /* Insert the macros into a hash table. */
1001 ppc_macro_hash
= hash_new ();
1003 macro_end
= powerpc_macros
+ powerpc_num_macros
;
1004 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
1006 if ((macro
->flags
& ppc_cpu
) != 0)
1010 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
1011 if (retval
!= (const char *) NULL
)
1013 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
1022 /* Tell the main code what the endianness is if it is not overidden by the user. */
1023 if (!set_target_endian
)
1025 set_target_endian
= 1;
1026 target_big_endian
= PPC_BIG_ENDIAN
;
1030 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
1032 /* Create dummy symbols to serve as initial csects. This forces the
1033 text csects to precede the data csects. These symbols will not
1035 ppc_text_csects
= symbol_make ("dummy\001");
1036 symbol_get_tc (ppc_text_csects
)->within
= ppc_text_csects
;
1037 ppc_data_csects
= symbol_make ("dummy\001");
1038 symbol_get_tc (ppc_data_csects
)->within
= ppc_data_csects
;
1043 ppc_current_section
= text_section
;
1044 ppc_previous_section
= 0;
1049 /* Insert an operand value into an instruction. */
1051 static unsigned long
1052 ppc_insert_operand (insn
, operand
, val
, file
, line
)
1054 const struct powerpc_operand
*operand
;
1059 if (operand
->bits
!= 32)
1064 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
1066 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0)
1067 max
= (1 << operand
->bits
) - 1;
1069 max
= (1 << (operand
->bits
- 1)) - 1;
1070 min
= - (1 << (operand
->bits
- 1));
1072 if (ppc_size
== PPC_OPCODE_32
)
1074 /* Some people write 32 bit hex constants with the sign
1075 extension done by hand. This shouldn't really be
1076 valid, but, to permit this code to assemble on a 64
1077 bit host, we sign extend the 32 bit value. */
1079 && (val
& 0x80000000) != 0
1080 && (val
& 0xffffffff) == val
)
1089 max
= (1 << operand
->bits
) - 1;
1093 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
1098 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
1101 _("operand out of range (%s not between %ld and %ld)");
1104 sprint_value (buf
, test
);
1105 if (file
== (char *) NULL
)
1106 as_bad (err
, buf
, min
, max
);
1108 as_bad_where (file
, line
, err
, buf
, min
, max
);
1112 if (operand
->insert
)
1117 insn
= (*operand
->insert
) (insn
, (long) val
, &errmsg
);
1118 if (errmsg
!= (const char *) NULL
)
1122 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
1130 /* Parse @got, etc. and return the desired relocation. */
1131 static bfd_reloc_code_real_type
1132 ppc_elf_suffix (str_p
, exp_p
)
1139 bfd_reloc_code_real_type reloc
;
1147 struct map_bfd
*ptr
;
1149 #define MAP(str,reloc) { str, sizeof(str)-1, reloc }
1151 static struct map_bfd mapping
[] = {
1152 MAP ("l", BFD_RELOC_LO16
),
1153 MAP ("h", BFD_RELOC_HI16
),
1154 MAP ("ha", BFD_RELOC_HI16_S
),
1155 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
1156 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
1157 MAP ("got", BFD_RELOC_16_GOTOFF
),
1158 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
1159 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
1160 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
1161 MAP ("fixup", BFD_RELOC_CTOR
), /* warnings with -mrelocatable */
1162 MAP ("plt", BFD_RELOC_24_PLT_PCREL
),
1163 MAP ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
1164 MAP ("copy", BFD_RELOC_PPC_COPY
),
1165 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
1166 MAP ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
1167 MAP ("local", BFD_RELOC_PPC_LOCAL24PC
),
1168 MAP ("pltrel", BFD_RELOC_32_PLT_PCREL
),
1169 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
1170 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
1171 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
1172 MAP ("sdarel", BFD_RELOC_GPREL16
),
1173 MAP ("sectoff", BFD_RELOC_32_BASEREL
),
1174 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
1175 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
1176 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
1177 MAP ("naddr", BFD_RELOC_PPC_EMB_NADDR32
),
1178 MAP ("naddr16", BFD_RELOC_PPC_EMB_NADDR16
),
1179 MAP ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO
),
1180 MAP ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI
),
1181 MAP ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA
),
1182 MAP ("sdai16", BFD_RELOC_PPC_EMB_SDAI16
),
1183 MAP ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL
),
1184 MAP ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16
),
1185 MAP ("sda21", BFD_RELOC_PPC_EMB_SDA21
),
1186 MAP ("mrkref", BFD_RELOC_PPC_EMB_MRKREF
),
1187 MAP ("relsect", BFD_RELOC_PPC_EMB_RELSEC16
),
1188 MAP ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO
),
1189 MAP ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI
),
1190 MAP ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA
),
1191 MAP ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD
),
1192 MAP ("relsda", BFD_RELOC_PPC_EMB_RELSDA
),
1193 MAP ("xgot", BFD_RELOC_PPC_TOC16
),
1195 { (char *)0, 0, BFD_RELOC_UNUSED
}
1199 return BFD_RELOC_UNUSED
;
1201 for (ch
= *str
, str2
= ident
;
1202 (str2
< ident
+ sizeof (ident
) - 1
1203 && (isalnum (ch
) || ch
== '@'));
1206 *str2
++ = (islower (ch
)) ? ch
: tolower (ch
);
1213 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
1214 if (ch
== ptr
->string
[0]
1215 && len
== ptr
->length
1216 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
1218 if (exp_p
->X_add_number
!= 0
1219 && (ptr
->reloc
== BFD_RELOC_16_GOTOFF
1220 || ptr
->reloc
== BFD_RELOC_LO16_GOTOFF
1221 || ptr
->reloc
== BFD_RELOC_HI16_GOTOFF
1222 || ptr
->reloc
== BFD_RELOC_HI16_S_GOTOFF
))
1223 as_warn (_("identifier+constant@got means identifier@got+constant"));
1225 /* Now check for identifier@suffix+constant */
1226 if (*str
== '-' || *str
== '+')
1228 char *orig_line
= input_line_pointer
;
1229 expressionS new_exp
;
1231 input_line_pointer
= str
;
1232 expression (&new_exp
);
1233 if (new_exp
.X_op
== O_constant
)
1235 exp_p
->X_add_number
+= new_exp
.X_add_number
;
1236 str
= input_line_pointer
;
1239 if (&input_line_pointer
!= str_p
)
1240 input_line_pointer
= orig_line
;
1247 return BFD_RELOC_UNUSED
;
1250 /* Like normal .long/.short/.word, except support @got, etc. */
1251 /* clobbers input_line_pointer, checks */
1254 ppc_elf_cons (nbytes
)
1255 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1258 bfd_reloc_code_real_type reloc
;
1260 if (is_it_end_of_statement ())
1262 demand_empty_rest_of_line ();
1269 if (exp
.X_op
== O_symbol
1270 && *input_line_pointer
== '@'
1271 && (reloc
= ppc_elf_suffix (&input_line_pointer
, &exp
)) != BFD_RELOC_UNUSED
)
1273 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1274 int size
= bfd_get_reloc_size (reloc_howto
);
1277 as_bad (_("%s relocations do not fit in %d bytes\n"), reloc_howto
->name
, nbytes
);
1281 register char *p
= frag_more ((int) nbytes
);
1282 int offset
= nbytes
- size
;
1284 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
, &exp
, 0, reloc
);
1288 emit_expr (&exp
, (unsigned int) nbytes
);
1290 while (*input_line_pointer
++ == ',');
1292 input_line_pointer
--; /* Put terminator back into stream. */
1293 demand_empty_rest_of_line ();
1296 /* Solaris pseduo op to change to the .rodata section. */
1301 char *save_line
= input_line_pointer
;
1302 static char section
[] = ".rodata\n";
1304 /* Just pretend this is .section .rodata */
1305 input_line_pointer
= section
;
1306 obj_elf_section (xxx
);
1308 input_line_pointer
= save_line
;
1311 /* Pseudo op to make file scope bss items */
1316 register char *name
;
1320 register symbolS
*symbolP
;
1327 name
= input_line_pointer
;
1328 c
= get_symbol_end ();
1330 /* just after name is now '\0' */
1331 p
= input_line_pointer
;
1334 if (*input_line_pointer
!= ',')
1336 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1337 ignore_rest_of_line ();
1341 input_line_pointer
++; /* skip ',' */
1342 if ((size
= get_absolute_expression ()) < 0)
1344 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1345 ignore_rest_of_line ();
1349 /* The third argument to .lcomm is the alignment. */
1350 if (*input_line_pointer
!= ',')
1354 ++input_line_pointer
;
1355 align
= get_absolute_expression ();
1358 as_warn (_("ignoring bad alignment"));
1364 symbolP
= symbol_find_or_make (name
);
1367 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1369 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1370 S_GET_NAME (symbolP
));
1371 ignore_rest_of_line ();
1375 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1377 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1378 S_GET_NAME (symbolP
),
1379 (long) S_GET_VALUE (symbolP
),
1382 ignore_rest_of_line ();
1388 old_subsec
= now_subseg
;
1391 /* convert to a power of 2 alignment */
1392 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
);
1395 as_bad (_("Common alignment not a power of 2"));
1396 ignore_rest_of_line ();
1403 record_alignment (bss_section
, align2
);
1404 subseg_set (bss_section
, 0);
1406 frag_align (align2
, 0, 0);
1407 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1408 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1409 symbol_set_frag (symbolP
, frag_now
);
1410 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1413 S_SET_SIZE (symbolP
, size
);
1414 S_SET_SEGMENT (symbolP
, bss_section
);
1415 subseg_set (old_sec
, old_subsec
);
1416 demand_empty_rest_of_line ();
1419 /* Validate any relocations emitted for -mrelocatable, possibly adding
1420 fixups for word relocations in writable segments, so we can adjust
1423 ppc_elf_validate_fix (fixp
, seg
)
1427 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1436 case SHILB_MRELOCATABLE
:
1437 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1438 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1439 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1440 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1441 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1442 && fixp
->fx_r_type
!= BFD_RELOC_32_BASEREL
1443 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1444 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1445 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1446 && strcmp (segment_name (seg
), ".got2") != 0
1447 && strcmp (segment_name (seg
), ".dtors") != 0
1448 && strcmp (segment_name (seg
), ".ctors") != 0
1449 && strcmp (segment_name (seg
), ".fixup") != 0
1450 && strcmp (segment_name (seg
), ".stab") != 0
1451 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1452 && strcmp (segment_name (seg
), ".eh_frame") != 0
1453 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1455 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1456 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1458 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1459 _("Relocation cannot be done when using -mrelocatable"));
1465 #endif /* OBJ_ELF */
1470 * Summary of parse_toc_entry().
1472 * in: Input_line_pointer points to the '[' in one of:
1474 * [toc] [tocv] [toc32] [toc64]
1476 * Anything else is an error of one kind or another.
1479 * return value: success or failure
1480 * toc_kind: kind of toc reference
1481 * input_line_pointer:
1482 * success: first char after the ']'
1483 * failure: unchanged
1487 * [toc] - rv == success, toc_kind = default_toc
1488 * [tocv] - rv == success, toc_kind = data_in_toc
1489 * [toc32] - rv == success, toc_kind = must_be_32
1490 * [toc64] - rv == success, toc_kind = must_be_64
1494 enum toc_size_qualifier
1496 default_toc
, /* The toc cell constructed should be the system default size */
1497 data_in_toc
, /* This is a direct reference to a toc cell */
1498 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1499 must_be_64
/* The toc cell constructed must be 64 bits wide */
1503 parse_toc_entry(toc_kind
)
1504 enum toc_size_qualifier
*toc_kind
;
1509 enum toc_size_qualifier t
;
1511 /* save the input_line_pointer */
1512 start
= input_line_pointer
;
1514 /* skip over the '[' , and whitespace */
1515 ++input_line_pointer
;
1518 /* find the spelling of the operand */
1519 toc_spec
= input_line_pointer
;
1520 c
= get_symbol_end ();
1522 if (strcmp(toc_spec
, "toc") == 0)
1526 else if (strcmp(toc_spec
, "tocv") == 0)
1530 else if (strcmp(toc_spec
, "toc32") == 0)
1534 else if (strcmp(toc_spec
, "toc64") == 0)
1540 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec
);
1541 *input_line_pointer
= c
; /* put back the delimiting char */
1542 input_line_pointer
= start
; /* reset input_line pointer */
1546 /* now find the ']' */
1547 *input_line_pointer
= c
; /* put back the delimiting char */
1549 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1550 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1554 as_bad (_("syntax error: expected `]', found `%c'"), c
);
1555 input_line_pointer
= start
; /* reset input_line pointer */
1559 *toc_kind
= t
; /* set return value */
1565 /* We need to keep a list of fixups. We can't simply generate them as
1566 we go, because that would require us to first create the frag, and
1567 that would screw up references to ``.''. */
1573 bfd_reloc_code_real_type reloc
;
1576 #define MAX_INSN_FIXUPS (5)
1578 /* This routine is called for each instruction to be assembled. */
1585 const struct powerpc_opcode
*opcode
;
1587 const unsigned char *opindex_ptr
;
1591 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
1596 bfd_reloc_code_real_type reloc
;
1599 /* Get the opcode. */
1600 for (s
= str
; *s
!= '\0' && ! isspace (*s
); s
++)
1605 /* Look up the opcode in the hash table. */
1606 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
1607 if (opcode
== (const struct powerpc_opcode
*) NULL
)
1609 const struct powerpc_macro
*macro
;
1611 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
1612 if (macro
== (const struct powerpc_macro
*) NULL
)
1613 as_bad (_("Unrecognized opcode: `%s'"), str
);
1615 ppc_macro (s
, macro
);
1620 insn
= opcode
->opcode
;
1623 while (isspace (*str
))
1626 /* PowerPC operands are just expressions. The only real issue is
1627 that a few operand types are optional. All cases which might use
1628 an optional operand separate the operands only with commas (in
1629 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1630 cases never have optional operands). There is never more than
1631 one optional operand for an instruction. So, before we start
1632 seriously parsing the operands, we check to see if we have an
1633 optional operand, and, if we do, we count the number of commas to
1634 see whether the operand should be omitted. */
1636 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1638 const struct powerpc_operand
*operand
;
1640 operand
= &powerpc_operands
[*opindex_ptr
];
1641 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
1643 unsigned int opcount
;
1645 /* There is an optional operand. Count the number of
1646 commas in the input line. */
1653 while ((s
= strchr (s
, ',')) != (char *) NULL
)
1660 /* If there are fewer operands in the line then are called
1661 for by the instruction, we want to skip the optional
1663 if (opcount
< strlen (opcode
->operands
))
1670 /* Gather the operands. */
1674 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1676 const struct powerpc_operand
*operand
;
1682 if (next_opindex
== 0)
1683 operand
= &powerpc_operands
[*opindex_ptr
];
1686 operand
= &powerpc_operands
[next_opindex
];
1692 /* If this is a fake operand, then we do not expect anything
1694 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
1696 insn
= (*operand
->insert
) (insn
, 0L, &errmsg
);
1697 if (errmsg
!= (const char *) NULL
)
1702 /* If this is an optional operand, and we are skipping it, just
1704 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
1707 if (operand
->insert
)
1709 insn
= (*operand
->insert
) (insn
, 0L, &errmsg
);
1710 if (errmsg
!= (const char *) NULL
)
1713 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
1714 next_opindex
= *opindex_ptr
+ 1;
1718 /* Gather the operand. */
1719 hold
= input_line_pointer
;
1720 input_line_pointer
= str
;
1723 if (*input_line_pointer
== '[')
1725 /* We are expecting something like the second argument here:
1727 lwz r4,[toc].GS.0.static_int(rtoc)
1728 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1729 The argument following the `]' must be a symbol name, and the
1730 register must be the toc register: 'rtoc' or '2'
1732 The effect is to 0 as the displacement field
1733 in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1734 the appropriate variation) reloc against it based on the symbol.
1735 The linker will build the toc, and insert the resolved toc offset.
1738 o The size of the toc entry is currently assumed to be
1739 32 bits. This should not be assumed to be a hard coded
1741 o In an effort to cope with a change from 32 to 64 bits,
1742 there are also toc entries that are specified to be
1743 either 32 or 64 bits:
1744 lwz r4,[toc32].GS.0.static_int(rtoc)
1745 lwz r4,[toc64].GS.0.static_int(rtoc)
1746 These demand toc entries of the specified size, and the
1747 instruction probably requires it.
1751 enum toc_size_qualifier toc_kind
;
1752 bfd_reloc_code_real_type toc_reloc
;
1754 /* go parse off the [tocXX] part */
1755 valid_toc
= parse_toc_entry(&toc_kind
);
1759 /* Note: message has already been issued. */
1760 /* FIXME: what sort of recovery should we do? */
1761 /* demand_rest_of_line(); return; ? */
1764 /* Now get the symbol following the ']' */
1770 /* In this case, we may not have seen the symbol yet, since */
1771 /* it is allowed to appear on a .extern or .globl or just be */
1772 /* a label in the .data section. */
1773 toc_reloc
= BFD_RELOC_PPC_TOC16
;
1776 /* 1. The symbol must be defined and either in the toc */
1777 /* section, or a global. */
1778 /* 2. The reloc generated must have the TOCDEFN flag set in */
1779 /* upper bit mess of the reloc type. */
1780 /* FIXME: It's a little confusing what the tocv qualifier can */
1781 /* be used for. At the very least, I've seen three */
1782 /* uses, only one of which I'm sure I can explain. */
1783 if (ex
.X_op
== O_symbol
)
1785 assert (ex
.X_add_symbol
!= NULL
);
1786 if (symbol_get_bfdsym (ex
.X_add_symbol
)->section
1789 as_bad(_("[tocv] symbol is not a toc symbol"));
1793 toc_reloc
= BFD_RELOC_PPC_TOC16
;
1796 /* FIXME: these next two specifically specify 32/64 bit toc */
1797 /* entries. We don't support them today. Is this the */
1798 /* right way to say that? */
1799 toc_reloc
= BFD_RELOC_UNUSED
;
1800 as_bad (_("Unimplemented toc32 expression modifier"));
1803 /* FIXME: see above */
1804 toc_reloc
= BFD_RELOC_UNUSED
;
1805 as_bad (_("Unimplemented toc64 expression modifier"));
1809 _("Unexpected return value [%d] from parse_toc_entry!\n"),
1815 /* We need to generate a fixup for this expression. */
1816 if (fc
>= MAX_INSN_FIXUPS
)
1817 as_fatal (_("too many fixups"));
1819 fixups
[fc
].reloc
= toc_reloc
;
1820 fixups
[fc
].exp
= ex
;
1821 fixups
[fc
].opindex
= *opindex_ptr
;
1824 /* Ok. We've set up the fixup for the instruction. Now make it
1825 look like the constant 0 was found here */
1827 ex
.X_op
= O_constant
;
1828 ex
.X_add_number
= 0;
1829 ex
.X_add_symbol
= NULL
;
1830 ex
.X_op_symbol
= NULL
;
1836 if (! register_name (&ex
))
1838 if ((operand
->flags
& PPC_OPERAND_CR
) != 0)
1845 str
= input_line_pointer
;
1846 input_line_pointer
= hold
;
1848 if (ex
.X_op
== O_illegal
)
1849 as_bad (_("illegal operand"));
1850 else if (ex
.X_op
== O_absent
)
1851 as_bad (_("missing operand"));
1852 else if (ex
.X_op
== O_register
)
1854 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
1857 else if (ex
.X_op
== O_constant
)
1860 /* Allow @HA, @L, @H on constants. */
1861 char *orig_str
= str
;
1863 if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
1870 case BFD_RELOC_LO16
:
1871 /* X_unsigned is the default, so if the user has done
1872 something which cleared it, we always produce a
1875 && (operand
->flags
& PPC_OPERAND_SIGNED
) == 0)
1876 ex
.X_add_number
&= 0xffff;
1878 ex
.X_add_number
= (((ex
.X_add_number
& 0xffff)
1883 case BFD_RELOC_HI16
:
1884 ex
.X_add_number
= (ex
.X_add_number
>> 16) & 0xffff;
1887 case BFD_RELOC_HI16_S
:
1888 ex
.X_add_number
= ((((ex
.X_add_number
>> 16) & 0xffff)
1889 + ((ex
.X_add_number
>> 15) & 1))
1894 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
1898 else if ((reloc
= ppc_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
1900 /* For the absoulte forms of branchs, convert the PC relative form back into
1902 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
1906 case BFD_RELOC_PPC_B26
:
1907 reloc
= BFD_RELOC_PPC_BA26
;
1909 case BFD_RELOC_PPC_B16
:
1910 reloc
= BFD_RELOC_PPC_BA16
;
1912 case BFD_RELOC_PPC_B16_BRTAKEN
:
1913 reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
;
1915 case BFD_RELOC_PPC_B16_BRNTAKEN
:
1916 reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
;
1923 /* We need to generate a fixup for this expression. */
1924 if (fc
>= MAX_INSN_FIXUPS
)
1925 as_fatal (_("too many fixups"));
1926 fixups
[fc
].exp
= ex
;
1927 fixups
[fc
].opindex
= 0;
1928 fixups
[fc
].reloc
= reloc
;
1931 #endif /* OBJ_ELF */
1935 /* We need to generate a fixup for this expression. */
1936 if (fc
>= MAX_INSN_FIXUPS
)
1937 as_fatal (_("too many fixups"));
1938 fixups
[fc
].exp
= ex
;
1939 fixups
[fc
].opindex
= *opindex_ptr
;
1940 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1949 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
1957 /* The call to expression should have advanced str past any
1960 && (endc
!= ',' || *str
!= '\0'))
1962 as_bad (_("syntax error; found `%c' but expected `%c'"), *str
, endc
);
1970 while (isspace (*str
))
1974 as_bad (_("junk at end of line: `%s'"), str
);
1976 /* Write out the instruction. */
1978 md_number_to_chars (f
, insn
, 4);
1980 /* Create any fixups. At this point we do not use a
1981 bfd_reloc_code_real_type, but instead just use the
1982 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1983 handle fixups for any operand type, although that is admittedly
1984 not a very exciting feature. We pick a BFD reloc type in
1986 for (i
= 0; i
< fc
; i
++)
1988 const struct powerpc_operand
*operand
;
1990 operand
= &powerpc_operands
[fixups
[i
].opindex
];
1991 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1993 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2001 size
= bfd_get_reloc_size (reloc_howto
);
2002 offset
= target_big_endian
? (4 - size
) : 0;
2004 if (size
< 1 || size
> 4)
2007 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
+ offset
, size
,
2008 &fixups
[i
].exp
, reloc_howto
->pc_relative
,
2011 /* Turn off complaints that the addend is too large for things like
2013 switch (fixups
[i
].reloc
)
2015 case BFD_RELOC_16_GOTOFF
:
2016 case BFD_RELOC_PPC_TOC16
:
2017 case BFD_RELOC_LO16
:
2018 case BFD_RELOC_HI16
:
2019 case BFD_RELOC_HI16_S
:
2020 fixP
->fx_no_overflow
= 1;
2027 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4,
2029 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
2030 ((bfd_reloc_code_real_type
)
2031 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2035 /* Handle a macro. Gather all the operands, transform them as
2036 described by the macro, and call md_assemble recursively. All the
2037 operands are separated by commas; we don't accept parentheses
2038 around operands here. */
2041 ppc_macro (str
, macro
)
2043 const struct powerpc_macro
*macro
;
2054 /* Gather the users operands into the operands array. */
2059 if (count
>= sizeof operands
/ sizeof operands
[0])
2061 operands
[count
++] = s
;
2062 s
= strchr (s
, ',');
2063 if (s
== (char *) NULL
)
2068 if (count
!= macro
->operands
)
2070 as_bad (_("wrong number of operands"));
2074 /* Work out how large the string must be (the size is unbounded
2075 because it includes user input). */
2077 format
= macro
->format
;
2078 while (*format
!= '\0')
2087 arg
= strtol (format
+ 1, &send
, 10);
2088 know (send
!= format
&& arg
>= 0 && arg
< count
);
2089 len
+= strlen (operands
[arg
]);
2094 /* Put the string together. */
2095 complete
= s
= (char *) alloca (len
+ 1);
2096 format
= macro
->format
;
2097 while (*format
!= '\0')
2103 arg
= strtol (format
+ 1, &send
, 10);
2104 strcpy (s
, operands
[arg
]);
2111 /* Assemble the constructed instruction. */
2112 md_assemble (complete
);
2116 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED */
2119 ppc_section_letter (letter
, ptr_msg
)
2126 *ptr_msg
= _("Bad .section directive: want a,w,x,e in string");
2131 ppc_section_word (str
, len
)
2135 if (len
== 7 && strncmp (str
, "exclude", 7) == 0)
2142 ppc_section_type (str
, len
)
2146 if (len
== 7 && strncmp (str
, "ordered", 7) == 0)
2153 ppc_section_flags (flags
, attr
, type
)
2158 if (type
== SHT_ORDERED
)
2159 flags
|= SEC_ALLOC
| SEC_LOAD
| SEC_SORT_ENTRIES
;
2161 if (attr
& SHF_EXCLUDE
)
2162 flags
|= SEC_EXCLUDE
;
2166 #endif /* OBJ_ELF */
2169 /* Pseudo-op handling. */
2171 /* The .byte pseudo-op. This is similar to the normal .byte
2172 pseudo-op, but it can also take a single ASCII string. */
2178 if (*input_line_pointer
!= '\"')
2184 /* Gather characters. A real double quote is doubled. Unusual
2185 characters are not permitted. */
2186 ++input_line_pointer
;
2191 c
= *input_line_pointer
++;
2195 if (*input_line_pointer
!= '\"')
2197 ++input_line_pointer
;
2200 FRAG_APPEND_1_CHAR (c
);
2203 demand_empty_rest_of_line ();
2208 /* XCOFF specific pseudo-op handling. */
2210 /* This is set if we are creating a .stabx symbol, since we don't want
2211 to handle symbol suffixes for such symbols. */
2212 static boolean ppc_stab_symbol
;
2214 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2215 symbols in the .bss segment as though they were local common
2216 symbols, and uses a different smclas. */
2222 asection
*current_seg
= now_seg
;
2223 subsegT current_subseg
= now_subseg
;
2229 symbolS
*lcomm_sym
= NULL
;
2233 name
= input_line_pointer
;
2234 endc
= get_symbol_end ();
2235 end_name
= input_line_pointer
;
2238 if (*input_line_pointer
!= ',')
2240 as_bad (_("missing size"));
2241 ignore_rest_of_line ();
2244 ++input_line_pointer
;
2246 size
= get_absolute_expression ();
2249 as_bad (_("negative size"));
2250 ignore_rest_of_line ();
2256 /* The third argument to .comm is the alignment. */
2257 if (*input_line_pointer
!= ',')
2261 ++input_line_pointer
;
2262 align
= get_absolute_expression ();
2265 as_warn (_("ignoring bad alignment"));
2284 /* The third argument to .lcomm appears to be the real local
2285 common symbol to create. References to the symbol named in
2286 the first argument are turned into references to the third
2288 if (*input_line_pointer
!= ',')
2290 as_bad (_("missing real symbol name"));
2291 ignore_rest_of_line ();
2294 ++input_line_pointer
;
2296 lcomm_name
= input_line_pointer
;
2297 lcomm_endc
= get_symbol_end ();
2299 lcomm_sym
= symbol_find_or_make (lcomm_name
);
2301 *input_line_pointer
= lcomm_endc
;
2305 sym
= symbol_find_or_make (name
);
2308 if (S_IS_DEFINED (sym
)
2309 || S_GET_VALUE (sym
) != 0)
2311 as_bad (_("attempt to redefine symbol"));
2312 ignore_rest_of_line ();
2316 record_alignment (bss_section
, align
);
2319 || ! S_IS_DEFINED (lcomm_sym
))
2328 S_SET_EXTERNAL (sym
);
2332 symbol_get_tc (lcomm_sym
)->output
= 1;
2333 def_sym
= lcomm_sym
;
2337 subseg_set (bss_section
, 1);
2338 frag_align (align
, 0, 0);
2340 symbol_set_frag (def_sym
, frag_now
);
2341 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
2342 def_size
, (char *) NULL
);
2344 S_SET_SEGMENT (def_sym
, bss_section
);
2345 symbol_get_tc (def_sym
)->align
= align
;
2349 /* Align the size of lcomm_sym. */
2350 symbol_get_frag (lcomm_sym
)->fr_offset
=
2351 ((symbol_get_frag (lcomm_sym
)->fr_offset
+ (1 << align
) - 1)
2352 &~ ((1 << align
) - 1));
2353 if (align
> symbol_get_tc (lcomm_sym
)->align
)
2354 symbol_get_tc (lcomm_sym
)->align
= align
;
2359 /* Make sym an offset from lcomm_sym. */
2360 S_SET_SEGMENT (sym
, bss_section
);
2361 symbol_set_frag (sym
, symbol_get_frag (lcomm_sym
));
2362 S_SET_VALUE (sym
, symbol_get_frag (lcomm_sym
)->fr_offset
);
2363 symbol_get_frag (lcomm_sym
)->fr_offset
+= size
;
2366 subseg_set (current_seg
, current_subseg
);
2368 demand_empty_rest_of_line ();
2371 /* The .csect pseudo-op. This switches us into a different
2372 subsegment. The first argument is a symbol whose value is the
2373 start of the .csect. In COFF, csect symbols get special aux
2374 entries defined by the x_csect field of union internal_auxent. The
2375 optional second argument is the alignment (the default is 2). */
2385 name
= input_line_pointer
;
2386 endc
= get_symbol_end ();
2388 sym
= symbol_find_or_make (name
);
2390 *input_line_pointer
= endc
;
2392 if (S_GET_NAME (sym
)[0] == '\0')
2394 /* An unnamed csect is assumed to be [PR]. */
2395 symbol_get_tc (sym
)->class = XMC_PR
;
2398 ppc_change_csect (sym
);
2400 if (*input_line_pointer
== ',')
2402 ++input_line_pointer
;
2403 symbol_get_tc (sym
)->align
= get_absolute_expression ();
2406 demand_empty_rest_of_line ();
2409 /* Change to a different csect. */
2412 ppc_change_csect (sym
)
2415 if (S_IS_DEFINED (sym
))
2416 subseg_set (S_GET_SEGMENT (sym
), symbol_get_tc (sym
)->subseg
);
2424 /* This is a new csect. We need to look at the symbol class to
2425 figure out whether it should go in the text section or the
2428 switch (symbol_get_tc (sym
)->class)
2438 S_SET_SEGMENT (sym
, text_section
);
2439 symbol_get_tc (sym
)->subseg
= ppc_text_subsegment
;
2440 ++ppc_text_subsegment
;
2441 list_ptr
= &ppc_text_csects
;
2450 if (ppc_toc_csect
!= NULL
2451 && (symbol_get_tc (ppc_toc_csect
)->subseg
+ 1
2452 == ppc_data_subsegment
))
2454 S_SET_SEGMENT (sym
, data_section
);
2455 symbol_get_tc (sym
)->subseg
= ppc_data_subsegment
;
2456 ++ppc_data_subsegment
;
2457 list_ptr
= &ppc_data_csects
;
2463 /* We set the obstack chunk size to a small value before
2464 changing subsegments, so that we don't use a lot of memory
2465 space for what may be a small section. */
2466 hold_chunksize
= chunksize
;
2469 subseg_new (segment_name (S_GET_SEGMENT (sym
)),
2470 symbol_get_tc (sym
)->subseg
);
2472 chunksize
= hold_chunksize
;
2475 ppc_after_toc_frag
= frag_now
;
2477 symbol_set_frag (sym
, frag_now
);
2478 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2480 symbol_get_tc (sym
)->align
= 2;
2481 symbol_get_tc (sym
)->output
= 1;
2482 symbol_get_tc (sym
)->within
= sym
;
2484 for (list
= *list_ptr
;
2485 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
2486 list
= symbol_get_tc (list
)->next
)
2488 symbol_get_tc (list
)->next
= sym
;
2490 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2491 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
2495 ppc_current_csect
= sym
;
2498 /* This function handles the .text and .data pseudo-ops. These
2499 pseudo-ops aren't really used by XCOFF; we implement them for the
2500 convenience of people who aren't used to XCOFF. */
2511 else if (type
== 'd')
2516 sym
= symbol_find_or_make (name
);
2518 ppc_change_csect (sym
);
2520 demand_empty_rest_of_line ();
2523 /* This function handles the .section pseudo-op. This is mostly to
2524 give an error, since XCOFF only supports .text, .data and .bss, but
2525 we do permit the user to name the text or data section. */
2528 ppc_named_section (ignore
)
2532 const char *real_name
;
2536 user_name
= input_line_pointer
;
2537 c
= get_symbol_end ();
2539 if (strcmp (user_name
, ".text") == 0)
2540 real_name
= ".text[PR]";
2541 else if (strcmp (user_name
, ".data") == 0)
2542 real_name
= ".data[RW]";
2545 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2546 *input_line_pointer
= c
;
2547 ignore_rest_of_line ();
2551 *input_line_pointer
= c
;
2553 sym
= symbol_find_or_make (real_name
);
2555 ppc_change_csect (sym
);
2557 demand_empty_rest_of_line ();
2560 /* The .extern pseudo-op. We create an undefined symbol. */
2569 name
= input_line_pointer
;
2570 endc
= get_symbol_end ();
2572 (void) symbol_find_or_make (name
);
2574 *input_line_pointer
= endc
;
2576 demand_empty_rest_of_line ();
2579 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2589 name
= input_line_pointer
;
2590 endc
= get_symbol_end ();
2592 sym
= symbol_find_or_make (name
);
2594 *input_line_pointer
= endc
;
2596 symbol_get_tc (sym
)->output
= 1;
2598 demand_empty_rest_of_line ();
2601 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2602 although I don't know why it bothers. */
2613 name
= input_line_pointer
;
2614 endc
= get_symbol_end ();
2616 sym
= symbol_find_or_make (name
);
2618 *input_line_pointer
= endc
;
2620 if (*input_line_pointer
!= ',')
2622 as_bad (_("missing rename string"));
2623 ignore_rest_of_line ();
2626 ++input_line_pointer
;
2628 symbol_get_tc (sym
)->real_name
= demand_copy_C_string (&len
);
2630 demand_empty_rest_of_line ();
2633 /* The .stabx pseudo-op. This is similar to a normal .stabs
2634 pseudo-op, but slightly different. A sample is
2635 .stabx "main:F-1",.main,142,0
2636 The first argument is the symbol name to create. The second is the
2637 value, and the third is the storage class. The fourth seems to be
2638 always zero, and I am assuming it is the type. */
2649 name
= demand_copy_C_string (&len
);
2651 if (*input_line_pointer
!= ',')
2653 as_bad (_("missing value"));
2656 ++input_line_pointer
;
2658 ppc_stab_symbol
= true;
2659 sym
= symbol_make (name
);
2660 ppc_stab_symbol
= false;
2662 symbol_get_tc (sym
)->real_name
= name
;
2664 (void) expression (&exp
);
2671 as_bad (_("illegal .stabx expression; zero assumed"));
2672 exp
.X_add_number
= 0;
2675 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
2676 symbol_set_frag (sym
, &zero_address_frag
);
2680 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
2681 symbol_set_value_expression (sym
, &exp
);
2685 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
2686 symbol_set_frag (sym
, symbol_get_frag (exp
.X_add_symbol
));
2691 /* The value is some complex expression. This will probably
2692 fail at some later point, but this is probably the right
2693 thing to do here. */
2694 symbol_set_value_expression (sym
, &exp
);
2698 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
2699 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
2701 if (*input_line_pointer
!= ',')
2703 as_bad (_("missing class"));
2706 ++input_line_pointer
;
2708 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
2710 if (*input_line_pointer
!= ',')
2712 as_bad (_("missing type"));
2715 ++input_line_pointer
;
2717 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
2719 symbol_get_tc (sym
)->output
= 1;
2721 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
2722 symbol_get_tc (sym
)->within
= ppc_current_block
;
2724 if (exp
.X_op
!= O_symbol
2725 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
2726 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
2727 ppc_frob_label (sym
);
2730 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2731 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
2732 if (symbol_get_tc (ppc_current_csect
)->within
== exp
.X_add_symbol
)
2733 symbol_get_tc (ppc_current_csect
)->within
= sym
;
2736 demand_empty_rest_of_line ();
2739 /* The .function pseudo-op. This takes several arguments. The first
2740 argument seems to be the external name of the symbol. The second
2741 argment seems to be the label for the start of the function. gcc
2742 uses the same name for both. I have no idea what the third and
2743 fourth arguments are meant to be. The optional fifth argument is
2744 an expression for the size of the function. In COFF this symbol
2745 gets an aux entry like that used for a csect. */
2748 ppc_function (ignore
)
2757 name
= input_line_pointer
;
2758 endc
= get_symbol_end ();
2760 /* Ignore any [PR] suffix. */
2761 name
= ppc_canonicalize_symbol_name (name
);
2762 s
= strchr (name
, '[');
2763 if (s
!= (char *) NULL
2764 && strcmp (s
+ 1, "PR]") == 0)
2767 ext_sym
= symbol_find_or_make (name
);
2769 *input_line_pointer
= endc
;
2771 if (*input_line_pointer
!= ',')
2773 as_bad (_("missing symbol name"));
2774 ignore_rest_of_line ();
2777 ++input_line_pointer
;
2779 name
= input_line_pointer
;
2780 endc
= get_symbol_end ();
2782 lab_sym
= symbol_find_or_make (name
);
2784 *input_line_pointer
= endc
;
2786 if (ext_sym
!= lab_sym
)
2790 exp
.X_op
= O_symbol
;
2791 exp
.X_add_symbol
= lab_sym
;
2792 exp
.X_op_symbol
= NULL
;
2793 exp
.X_add_number
= 0;
2795 symbol_set_value_expression (ext_sym
, &exp
);
2798 if (symbol_get_tc (ext_sym
)->class == -1)
2799 symbol_get_tc (ext_sym
)->class = XMC_PR
;
2800 symbol_get_tc (ext_sym
)->output
= 1;
2802 if (*input_line_pointer
== ',')
2806 /* Ignore the third argument. */
2807 ++input_line_pointer
;
2808 expression (&ignore
);
2809 if (*input_line_pointer
== ',')
2811 /* Ignore the fourth argument. */
2812 ++input_line_pointer
;
2813 expression (&ignore
);
2814 if (*input_line_pointer
== ',')
2816 /* The fifth argument is the function size. */
2817 ++input_line_pointer
;
2818 symbol_get_tc (ext_sym
)->size
= symbol_new ("L0\001",
2821 &zero_address_frag
);
2822 pseudo_set (symbol_get_tc (ext_sym
)->size
);
2827 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
2828 SF_SET_FUNCTION (ext_sym
);
2829 SF_SET_PROCESS (ext_sym
);
2830 coff_add_linesym (ext_sym
);
2832 demand_empty_rest_of_line ();
2835 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
2844 sym
= symbol_make (".bf");
2845 S_SET_SEGMENT (sym
, text_section
);
2846 symbol_set_frag (sym
, frag_now
);
2847 S_SET_VALUE (sym
, frag_now_fix ());
2848 S_SET_STORAGE_CLASS (sym
, C_FCN
);
2850 coff_line_base
= get_absolute_expression ();
2852 S_SET_NUMBER_AUXILIARY (sym
, 1);
2853 SA_SET_SYM_LNNO (sym
, coff_line_base
);
2855 symbol_get_tc (sym
)->output
= 1;
2857 ppc_frob_label (sym
);
2859 demand_empty_rest_of_line ();
2862 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
2863 ".ef", except that the line number is absolute, not relative to the
2864 most recent ".bf" symbol. */
2872 sym
= symbol_make (".ef");
2873 S_SET_SEGMENT (sym
, text_section
);
2874 symbol_set_frag (sym
, frag_now
);
2875 S_SET_VALUE (sym
, frag_now_fix ());
2876 S_SET_STORAGE_CLASS (sym
, C_FCN
);
2877 S_SET_NUMBER_AUXILIARY (sym
, 1);
2878 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
2879 symbol_get_tc (sym
)->output
= 1;
2881 ppc_frob_label (sym
);
2883 demand_empty_rest_of_line ();
2886 /* The .bi and .ei pseudo-ops. These take a string argument and
2887 generates a C_BINCL or C_EINCL symbol, which goes at the start of
2894 static symbolS
*last_biei
;
2901 name
= demand_copy_C_string (&len
);
2903 /* The value of these symbols is actually file offset. Here we set
2904 the value to the index into the line number entries. In
2905 ppc_frob_symbols we set the fix_line field, which will cause BFD
2906 to do the right thing. */
2908 sym
= symbol_make (name
);
2909 /* obj-coff.c currently only handles line numbers correctly in the
2911 S_SET_SEGMENT (sym
, text_section
);
2912 S_SET_VALUE (sym
, coff_n_line_nos
);
2913 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
2915 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
2916 symbol_get_tc (sym
)->output
= 1;
2918 for (look
= last_biei
? last_biei
: symbol_rootP
;
2919 (look
!= (symbolS
*) NULL
2920 && (S_GET_STORAGE_CLASS (look
) == C_FILE
2921 || S_GET_STORAGE_CLASS (look
) == C_BINCL
2922 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
2923 look
= symbol_next (look
))
2925 if (look
!= (symbolS
*) NULL
)
2927 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2928 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
2932 demand_empty_rest_of_line ();
2935 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
2936 There is one argument, which is a csect symbol. The value of the
2937 .bs symbol is the index of this csect symbol. */
2948 if (ppc_current_block
!= NULL
)
2949 as_bad (_("nested .bs blocks"));
2951 name
= input_line_pointer
;
2952 endc
= get_symbol_end ();
2954 csect
= symbol_find_or_make (name
);
2956 *input_line_pointer
= endc
;
2958 sym
= symbol_make (".bs");
2959 S_SET_SEGMENT (sym
, now_seg
);
2960 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
2961 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
2962 symbol_get_tc (sym
)->output
= 1;
2964 symbol_get_tc (sym
)->within
= csect
;
2966 ppc_frob_label (sym
);
2968 ppc_current_block
= sym
;
2970 demand_empty_rest_of_line ();
2973 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
2981 if (ppc_current_block
== NULL
)
2982 as_bad (_(".es without preceding .bs"));
2984 sym
= symbol_make (".es");
2985 S_SET_SEGMENT (sym
, now_seg
);
2986 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
2987 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
2988 symbol_get_tc (sym
)->output
= 1;
2990 ppc_frob_label (sym
);
2992 ppc_current_block
= NULL
;
2994 demand_empty_rest_of_line ();
2997 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
3006 sym
= symbol_make (".bb");
3007 S_SET_SEGMENT (sym
, text_section
);
3008 symbol_set_frag (sym
, frag_now
);
3009 S_SET_VALUE (sym
, frag_now_fix ());
3010 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3012 S_SET_NUMBER_AUXILIARY (sym
, 1);
3013 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3015 symbol_get_tc (sym
)->output
= 1;
3017 SF_SET_PROCESS (sym
);
3019 ppc_frob_label (sym
);
3021 demand_empty_rest_of_line ();
3024 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3033 sym
= symbol_make (".eb");
3034 S_SET_SEGMENT (sym
, text_section
);
3035 symbol_set_frag (sym
, frag_now
);
3036 S_SET_VALUE (sym
, frag_now_fix ());
3037 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
3038 S_SET_NUMBER_AUXILIARY (sym
, 1);
3039 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
3040 symbol_get_tc (sym
)->output
= 1;
3042 SF_SET_PROCESS (sym
);
3044 ppc_frob_label (sym
);
3046 demand_empty_rest_of_line ();
3049 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3060 name
= demand_copy_C_string (&len
);
3061 sym
= symbol_make (name
);
3062 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3063 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3064 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
3065 S_SET_VALUE (sym
, 0);
3066 symbol_get_tc (sym
)->output
= 1;
3068 ppc_frob_label (sym
);
3070 demand_empty_rest_of_line ();
3073 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3081 sym
= symbol_make (".ec");
3082 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
3083 symbol_get_bfdsym (sym
)->flags
|= BSF_DEBUGGING
;
3084 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
3085 S_SET_VALUE (sym
, 0);
3086 symbol_get_tc (sym
)->output
= 1;
3088 ppc_frob_label (sym
);
3090 demand_empty_rest_of_line ();
3093 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3099 if (ppc_toc_csect
!= (symbolS
*) NULL
)
3100 subseg_set (data_section
, symbol_get_tc (ppc_toc_csect
)->subseg
);
3107 subseg
= ppc_data_subsegment
;
3108 ++ppc_data_subsegment
;
3110 subseg_new (segment_name (data_section
), subseg
);
3111 ppc_toc_frag
= frag_now
;
3113 sym
= symbol_find_or_make ("TOC[TC0]");
3114 symbol_set_frag (sym
, frag_now
);
3115 S_SET_SEGMENT (sym
, data_section
);
3116 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3117 symbol_get_tc (sym
)->subseg
= subseg
;
3118 symbol_get_tc (sym
)->output
= 1;
3119 symbol_get_tc (sym
)->within
= sym
;
3121 ppc_toc_csect
= sym
;
3123 for (list
= ppc_data_csects
;
3124 symbol_get_tc (list
)->next
!= (symbolS
*) NULL
;
3125 list
= symbol_get_tc (list
)->next
)
3127 symbol_get_tc (list
)->next
= sym
;
3129 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3130 symbol_append (sym
, symbol_get_tc (list
)->within
, &symbol_rootP
,
3134 ppc_current_csect
= ppc_toc_csect
;
3136 demand_empty_rest_of_line ();
3139 /* The AIX assembler automatically aligns the operands of a .long or
3140 .short pseudo-op, and we want to be compatible. */
3143 ppc_xcoff_cons (log_size
)
3146 frag_align (log_size
, 0, 0);
3147 record_alignment (now_seg
, log_size
);
3148 cons (1 << log_size
);
3158 (void) expression (&exp
);
3160 if (exp
.X_op
!= O_constant
)
3162 as_bad (_("non-constant byte count"));
3166 byte_count
= exp
.X_add_number
;
3168 if (*input_line_pointer
!= ',')
3170 as_bad (_("missing value"));
3174 ++input_line_pointer
;
3178 #endif /* OBJ_XCOFF */
3180 /* The .tc pseudo-op. This is used when generating either XCOFF or
3181 ELF. This takes two or more arguments.
3183 When generating XCOFF output, the first argument is the name to
3184 give to this location in the toc; this will be a symbol with class
3185 TC. The rest of the arguments are 4 byte values to actually put at
3186 this location in the TOC; often there is just one more argument, a
3187 relocateable symbol reference.
3189 When not generating XCOFF output, the arguments are the same, but
3190 the first argument is simply ignored. */
3198 /* Define the TOC symbol name. */
3204 if (ppc_toc_csect
== (symbolS
*) NULL
3205 || ppc_toc_csect
!= ppc_current_csect
)
3207 as_bad (_(".tc not in .toc section"));
3208 ignore_rest_of_line ();
3212 name
= input_line_pointer
;
3213 endc
= get_symbol_end ();
3215 sym
= symbol_find_or_make (name
);
3217 *input_line_pointer
= endc
;
3219 if (S_IS_DEFINED (sym
))
3223 label
= symbol_get_tc (ppc_current_csect
)->within
;
3224 if (symbol_get_tc (label
)->class != XMC_TC0
)
3226 as_bad (_(".tc with no label"));
3227 ignore_rest_of_line ();
3231 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
3232 symbol_set_frag (label
, symbol_get_frag (sym
));
3233 S_SET_VALUE (label
, S_GET_VALUE (sym
));
3235 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3236 ++input_line_pointer
;
3241 S_SET_SEGMENT (sym
, now_seg
);
3242 symbol_set_frag (sym
, frag_now
);
3243 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
3244 symbol_get_tc (sym
)->class = XMC_TC
;
3245 symbol_get_tc (sym
)->output
= 1;
3247 ppc_frob_label (sym
);
3250 #else /* ! defined (OBJ_XCOFF) */
3252 /* Skip the TOC symbol name. */
3253 while (is_part_of_name (*input_line_pointer
)
3254 || *input_line_pointer
== '['
3255 || *input_line_pointer
== ']'
3256 || *input_line_pointer
== '{'
3257 || *input_line_pointer
== '}')
3258 ++input_line_pointer
;
3260 /* Align to a four byte boundary. */
3261 frag_align (2, 0, 0);
3262 record_alignment (now_seg
, 2);
3264 #endif /* ! defined (OBJ_XCOFF) */
3266 if (*input_line_pointer
!= ',')
3267 demand_empty_rest_of_line ();
3270 ++input_line_pointer
;
3277 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
3279 /* Set the current section. */
3281 ppc_set_current_section (new)
3284 ppc_previous_section
= ppc_current_section
;
3285 ppc_current_section
= new;
3288 /* pseudo-op: .previous
3289 behaviour: toggles the current section with the previous section.
3291 warnings: "No previous section"
3294 ppc_previous(ignore
)
3299 if (ppc_previous_section
== NULL
)
3301 as_warn(_("No previous section to return to. Directive ignored."));
3305 subseg_set(ppc_previous_section
, 0);
3307 ppc_set_current_section(ppc_previous_section
);
3310 /* pseudo-op: .pdata
3311 behaviour: predefined read only data section
3315 initial: .section .pdata "adr3"
3316 a - don't know -- maybe a misprint
3317 d - initialized data
3319 3 - double word aligned (that would be 4 byte boundary)
3322 Tag index tables (also known as the function table) for exception
3323 handling, debugging, etc.
3330 if (pdata_section
== 0)
3332 pdata_section
= subseg_new (".pdata", 0);
3334 bfd_set_section_flags (stdoutput
, pdata_section
,
3335 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3336 | SEC_READONLY
| SEC_DATA
));
3338 bfd_set_section_alignment (stdoutput
, pdata_section
, 2);
3342 pdata_section
= subseg_new(".pdata", 0);
3344 ppc_set_current_section(pdata_section
);
3347 /* pseudo-op: .ydata
3348 behaviour: predefined read only data section
3352 initial: .section .ydata "drw3"
3353 a - don't know -- maybe a misprint
3354 d - initialized data
3356 3 - double word aligned (that would be 4 byte boundary)
3358 Tag tables (also known as the scope table) for exception handling,
3365 if (ydata_section
== 0)
3367 ydata_section
= subseg_new (".ydata", 0);
3368 bfd_set_section_flags (stdoutput
, ydata_section
,
3369 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3370 | SEC_READONLY
| SEC_DATA
));
3372 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
3376 ydata_section
= subseg_new (".ydata", 0);
3378 ppc_set_current_section(ydata_section
);
3381 /* pseudo-op: .reldata
3382 behaviour: predefined read write data section
3383 double word aligned (4-byte)
3384 FIXME: relocation is applied to it
3385 FIXME: what's the difference between this and .data?
3388 initial: .section .reldata "drw3"
3389 d - initialized data
3392 3 - double word aligned (that would be 8 byte boundary)
3395 Like .data, but intended to hold data subject to relocation, such as
3396 function descriptors, etc.
3402 if (reldata_section
== 0)
3404 reldata_section
= subseg_new (".reldata", 0);
3406 bfd_set_section_flags (stdoutput
, reldata_section
,
3407 ( SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3410 bfd_set_section_alignment (stdoutput
, reldata_section
, 2);
3414 reldata_section
= subseg_new (".reldata", 0);
3416 ppc_set_current_section(reldata_section
);
3419 /* pseudo-op: .rdata
3420 behaviour: predefined read only data section
3424 initial: .section .rdata "dr3"
3425 d - initialized data
3427 3 - double word aligned (that would be 4 byte boundary)
3433 if (rdata_section
== 0)
3435 rdata_section
= subseg_new (".rdata", 0);
3436 bfd_set_section_flags (stdoutput
, rdata_section
,
3437 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3438 | SEC_READONLY
| SEC_DATA
));
3440 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
3444 rdata_section
= subseg_new (".rdata", 0);
3446 ppc_set_current_section(rdata_section
);
3449 /* pseudo-op: .ualong
3450 behaviour: much like .int, with the exception that no alignment is
3452 FIXME: test the alignment statement
3464 /* pseudo-op: .znop <symbol name>
3465 behaviour: Issue a nop instruction
3466 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3467 the supplied symbol name.
3469 warnings: Missing symbol name
3476 const struct powerpc_opcode
*opcode
;
3482 /* Strip out the symbol name */
3490 symbol_name
= input_line_pointer
;
3491 c
= get_symbol_end ();
3493 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
3494 strcpy (name
, symbol_name
);
3496 sym
= symbol_find_or_make (name
);
3498 *input_line_pointer
= c
;
3502 /* Look up the opcode in the hash table. */
3503 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
3505 /* stick in the nop */
3506 insn
= opcode
->opcode
;
3508 /* Write out the instruction. */
3510 md_number_to_chars (f
, insn
, 4);
3512 f
- frag_now
->fr_literal
,
3517 BFD_RELOC_16_GOT_PCREL
);
3530 register char *name
;
3534 register symbolS
*symbolP
;
3537 name
= input_line_pointer
;
3538 c
= get_symbol_end ();
3540 /* just after name is now '\0' */
3541 p
= input_line_pointer
;
3544 if (*input_line_pointer
!= ',')
3546 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3547 ignore_rest_of_line ();
3551 input_line_pointer
++; /* skip ',' */
3552 if ((temp
= get_absolute_expression ()) < 0)
3554 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
3555 ignore_rest_of_line ();
3561 /* The third argument to .comm is the alignment. */
3562 if (*input_line_pointer
!= ',')
3566 ++input_line_pointer
;
3567 align
= get_absolute_expression ();
3570 as_warn (_("ignoring bad alignment"));
3577 symbolP
= symbol_find_or_make (name
);
3580 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
3582 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
3583 S_GET_NAME (symbolP
));
3584 ignore_rest_of_line ();
3588 if (S_GET_VALUE (symbolP
))
3590 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
3591 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3592 S_GET_NAME (symbolP
),
3593 (long) S_GET_VALUE (symbolP
),
3598 S_SET_VALUE (symbolP
, (valueT
) temp
);
3599 S_SET_EXTERNAL (symbolP
);
3602 demand_empty_rest_of_line ();
3606 * implement the .section pseudo op:
3607 * .section name {, "flags"}
3609 * | +--- optional flags: 'b' for bss
3611 * +-- section name 'l' for lib
3615 * 'd' (apparently m88k for data)
3617 * But if the argument is not a quoted string, treat it as a
3618 * subsegment number.
3620 * FIXME: this is a copy of the section processing from obj-coff.c, with
3621 * additions/changes for the moto-pas assembler support. There are three
3624 * FIXME: I just noticed this. This doesn't work at all really. It it
3625 * setting bits that bfd probably neither understands or uses. The
3626 * correct approach (?) will have to incorporate extra fields attached
3627 * to the section to hold the system specific stuff. (krk)
3630 * 'a' - unknown - referred to in documentation, but no definition supplied
3631 * 'c' - section has code
3632 * 'd' - section has initialized data
3633 * 'u' - section has uninitialized data
3634 * 'i' - section contains directives (info)
3635 * 'n' - section can be discarded
3636 * 'R' - remove section at link time
3638 * Section Protection:
3639 * 'r' - section is readable
3640 * 'w' - section is writeable
3641 * 'x' - section is executable
3642 * 's' - section is sharable
3644 * Section Alignment:
3645 * '0' - align to byte boundary
3646 * '1' - align to halfword undary
3647 * '2' - align to word boundary
3648 * '3' - align to doubleword boundary
3649 * '4' - align to quadword boundary
3650 * '5' - align to 32 byte boundary
3651 * '6' - align to 64 byte boundary
3656 ppc_pe_section (ignore
)
3659 /* Strip out the section name */
3668 section_name
= input_line_pointer
;
3669 c
= get_symbol_end ();
3671 name
= xmalloc (input_line_pointer
- section_name
+ 1);
3672 strcpy (name
, section_name
);
3674 *input_line_pointer
= c
;
3679 flags
= SEC_NO_FLAGS
;
3681 if (strcmp (name
, ".idata$2") == 0)
3685 else if (strcmp (name
, ".idata$3") == 0)
3689 else if (strcmp (name
, ".idata$4") == 0)
3693 else if (strcmp (name
, ".idata$5") == 0)
3697 else if (strcmp (name
, ".idata$6") == 0)
3702 align
= 4; /* default alignment to 16 byte boundary */
3704 if (*input_line_pointer
== ',')
3706 ++input_line_pointer
;
3708 if (*input_line_pointer
!= '"')
3709 exp
= get_absolute_expression ();
3712 ++input_line_pointer
;
3713 while (*input_line_pointer
!= '"'
3714 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
3716 switch (*input_line_pointer
)
3718 /* Section Contents */
3719 case 'a': /* unknown */
3720 as_bad (_("Unsupported section attribute -- 'a'"));
3722 case 'c': /* code section */
3725 case 'd': /* section has initialized data */
3728 case 'u': /* section has uninitialized data */
3729 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
3733 case 'i': /* section contains directives (info) */
3734 /* FIXME: This is IMAGE_SCN_LNK_INFO
3736 flags
|= SEC_HAS_CONTENTS
;
3738 case 'n': /* section can be discarded */
3741 case 'R': /* Remove section at link time */
3742 flags
|= SEC_NEVER_LOAD
;
3745 /* Section Protection */
3746 case 'r': /* section is readable */
3747 flags
|= IMAGE_SCN_MEM_READ
;
3749 case 'w': /* section is writeable */
3750 flags
|= IMAGE_SCN_MEM_WRITE
;
3752 case 'x': /* section is executable */
3753 flags
|= IMAGE_SCN_MEM_EXECUTE
;
3755 case 's': /* section is sharable */
3756 flags
|= IMAGE_SCN_MEM_SHARED
;
3759 /* Section Alignment */
3760 case '0': /* align to byte boundary */
3761 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
3764 case '1': /* align to halfword boundary */
3765 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
3768 case '2': /* align to word boundary */
3769 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
3772 case '3': /* align to doubleword boundary */
3773 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
3776 case '4': /* align to quadword boundary */
3777 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
3780 case '5': /* align to 32 byte boundary */
3781 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
3784 case '6': /* align to 64 byte boundary */
3785 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
3790 as_bad(_("unknown section attribute '%c'"),
3791 *input_line_pointer
);
3794 ++input_line_pointer
;
3796 if (*input_line_pointer
== '"')
3797 ++input_line_pointer
;
3801 sec
= subseg_new (name
, (subsegT
) exp
);
3803 ppc_set_current_section(sec
);
3805 if (flags
!= SEC_NO_FLAGS
)
3807 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
3808 as_bad (_("error setting flags for \"%s\": %s"),
3809 bfd_section_name (stdoutput
, sec
),
3810 bfd_errmsg (bfd_get_error ()));
3813 bfd_set_section_alignment(stdoutput
, sec
, align
);
3818 ppc_pe_function (ignore
)
3825 name
= input_line_pointer
;
3826 endc
= get_symbol_end ();
3828 ext_sym
= symbol_find_or_make (name
);
3830 *input_line_pointer
= endc
;
3832 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3833 SF_SET_FUNCTION (ext_sym
);
3834 SF_SET_PROCESS (ext_sym
);
3835 coff_add_linesym (ext_sym
);
3837 demand_empty_rest_of_line ();
3841 ppc_pe_tocd (ignore
)
3844 if (tocdata_section
== 0)
3846 tocdata_section
= subseg_new (".tocd", 0);
3847 /* FIXME: section flags won't work */
3848 bfd_set_section_flags (stdoutput
, tocdata_section
,
3849 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3850 | SEC_READONLY
| SEC_DATA
));
3852 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
3856 rdata_section
= subseg_new (".tocd", 0);
3859 ppc_set_current_section(tocdata_section
);
3861 demand_empty_rest_of_line ();
3864 /* Don't adjust TOC relocs to use the section symbol. */
3867 ppc_pe_fix_adjustable (fix
)
3870 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
3877 /* XCOFF specific symbol and file handling. */
3879 /* Canonicalize the symbol name. We use the to force the suffix, if
3880 any, to use square brackets, and to be in upper case. */
3883 ppc_canonicalize_symbol_name (name
)
3888 if (ppc_stab_symbol
)
3891 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
3905 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
3909 if (*s
== '\0' || s
[1] != '\0')
3910 as_bad (_("bad symbol suffix"));
3918 /* Set the class of a symbol based on the suffix, if any. This is
3919 called whenever a new symbol is created. */
3922 ppc_symbol_new_hook (sym
)
3925 struct ppc_tc_sy
*tc
;
3928 tc
= symbol_get_tc (sym
);
3932 tc
->real_name
= NULL
;
3938 if (ppc_stab_symbol
)
3941 s
= strchr (S_GET_NAME (sym
), '[');
3942 if (s
== (const char *) NULL
)
3944 /* There is no suffix. */
3953 if (strcmp (s
, "BS]") == 0)
3957 if (strcmp (s
, "DB]") == 0)
3959 else if (strcmp (s
, "DS]") == 0)
3963 if (strcmp (s
, "GL]") == 0)
3967 if (strcmp (s
, "PR]") == 0)
3971 if (strcmp (s
, "RO]") == 0)
3973 else if (strcmp (s
, "RW]") == 0)
3977 if (strcmp (s
, "SV]") == 0)
3981 if (strcmp (s
, "TC]") == 0)
3983 else if (strcmp (s
, "TI]") == 0)
3985 else if (strcmp (s
, "TB]") == 0)
3987 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
3988 tc
->class = XMC_TC0
;
3991 if (strcmp (s
, "UA]") == 0)
3993 else if (strcmp (s
, "UC]") == 0)
3997 if (strcmp (s
, "XO]") == 0)
4002 if (tc
->class == -1)
4003 as_bad (_("Unrecognized symbol suffix"));
4006 /* Set the class of a label based on where it is defined. This
4007 handles symbols without suffixes. Also, move the symbol so that it
4008 follows the csect symbol. */
4011 ppc_frob_label (sym
)
4014 if (ppc_current_csect
!= (symbolS
*) NULL
)
4016 if (symbol_get_tc (sym
)->class == -1)
4017 symbol_get_tc (sym
)->class = symbol_get_tc (ppc_current_csect
)->class;
4019 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
4020 symbol_append (sym
, symbol_get_tc (ppc_current_csect
)->within
,
4021 &symbol_rootP
, &symbol_lastP
);
4022 symbol_get_tc (ppc_current_csect
)->within
= sym
;
4026 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4027 seen. It tells ppc_adjust_symtab whether it needs to look through
4030 static boolean ppc_saw_abs
;
4032 /* Change the name of a symbol just before writing it out. Set the
4033 real name if the .rename pseudo-op was used. Otherwise, remove any
4034 class suffix. Return 1 if the symbol should not be included in the
4038 ppc_frob_symbol (sym
)
4041 static symbolS
*ppc_last_function
;
4042 static symbolS
*set_end
;
4044 /* Discard symbols that should not be included in the output symbol
4046 if (! symbol_used_in_reloc_p (sym
)
4047 && ((symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0
4048 || (! S_IS_EXTERNAL (sym
)
4049 && ! symbol_get_tc (sym
)->output
4050 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
4053 if (symbol_get_tc (sym
)->real_name
!= (char *) NULL
)
4054 S_SET_NAME (sym
, symbol_get_tc (sym
)->real_name
);
4060 name
= S_GET_NAME (sym
);
4061 s
= strchr (name
, '[');
4062 if (s
!= (char *) NULL
)
4068 snew
= xmalloc (len
+ 1);
4069 memcpy (snew
, name
, len
);
4072 S_SET_NAME (sym
, snew
);
4076 if (set_end
!= (symbolS
*) NULL
)
4078 SA_SET_SYM_ENDNDX (set_end
, sym
);
4082 if (SF_GET_FUNCTION (sym
))
4084 if (ppc_last_function
!= (symbolS
*) NULL
)
4085 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4086 ppc_last_function
= sym
;
4087 if (symbol_get_tc (sym
)->size
!= (symbolS
*) NULL
)
4089 resolve_symbol_value (symbol_get_tc (sym
)->size
, 1);
4090 SA_SET_SYM_FSIZE (sym
,
4091 (long) S_GET_VALUE (symbol_get_tc (sym
)->size
));
4094 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
4095 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
4097 if (ppc_last_function
== (symbolS
*) NULL
)
4098 as_bad (_(".ef with no preceding .function"));
4101 set_end
= ppc_last_function
;
4102 ppc_last_function
= NULL
;
4104 /* We don't have a C_EFCN symbol, but we need to force the
4105 COFF backend to believe that it has seen one. */
4106 coff_last_function
= NULL
;
4110 if (! S_IS_EXTERNAL (sym
)
4111 && (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) == 0
4112 && S_GET_STORAGE_CLASS (sym
) != C_FILE
4113 && S_GET_STORAGE_CLASS (sym
) != C_FCN
4114 && S_GET_STORAGE_CLASS (sym
) != C_BLOCK
4115 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
4116 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
4117 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
4118 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
4119 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
4120 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
4122 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
4123 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
4126 union internal_auxent
*a
;
4128 /* Create a csect aux. */
4129 i
= S_GET_NUMBER_AUXILIARY (sym
);
4130 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
4131 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].u
.auxent
;
4132 if (symbol_get_tc (sym
)->class == XMC_TC0
)
4134 /* This is the TOC table. */
4135 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
4136 a
->x_csect
.x_scnlen
.l
= 0;
4137 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4139 else if (symbol_get_tc (sym
)->subseg
!= 0)
4141 /* This is a csect symbol. x_scnlen is the size of the
4143 if (symbol_get_tc (sym
)->next
== (symbolS
*) NULL
)
4144 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4145 S_GET_SEGMENT (sym
))
4146 - S_GET_VALUE (sym
));
4149 resolve_symbol_value (symbol_get_tc (sym
)->next
, 1);
4150 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (symbol_get_tc (sym
)->next
)
4151 - S_GET_VALUE (sym
));
4153 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_SD
;
4155 else if (S_GET_SEGMENT (sym
) == bss_section
)
4157 /* This is a common symbol. */
4158 a
->x_csect
.x_scnlen
.l
= symbol_get_frag (sym
)->fr_offset
;
4159 a
->x_csect
.x_smtyp
= (symbol_get_tc (sym
)->align
<< 3) | XTY_CM
;
4160 if (S_IS_EXTERNAL (sym
))
4161 symbol_get_tc (sym
)->class = XMC_RW
;
4163 symbol_get_tc (sym
)->class = XMC_BS
;
4165 else if (S_GET_SEGMENT (sym
) == absolute_section
)
4167 /* This is an absolute symbol. The csect will be created by
4168 ppc_adjust_symtab. */
4170 a
->x_csect
.x_smtyp
= XTY_LD
;
4171 if (symbol_get_tc (sym
)->class == -1)
4172 symbol_get_tc (sym
)->class = XMC_XO
;
4174 else if (! S_IS_DEFINED (sym
))
4176 /* This is an external symbol. */
4177 a
->x_csect
.x_scnlen
.l
= 0;
4178 a
->x_csect
.x_smtyp
= XTY_ER
;
4180 else if (symbol_get_tc (sym
)->class == XMC_TC
)
4184 /* This is a TOC definition. x_scnlen is the size of the
4186 next
= symbol_next (sym
);
4187 while (symbol_get_tc (next
)->class == XMC_TC0
)
4188 next
= symbol_next (next
);
4189 if (next
== (symbolS
*) NULL
4190 || symbol_get_tc (next
)->class != XMC_TC
)
4192 if (ppc_after_toc_frag
== (fragS
*) NULL
)
4193 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
4195 - S_GET_VALUE (sym
));
4197 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
4198 - S_GET_VALUE (sym
));
4202 resolve_symbol_value (next
, 1);
4203 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
4204 - S_GET_VALUE (sym
));
4206 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
4212 /* This is a normal symbol definition. x_scnlen is the
4213 symbol index of the containing csect. */
4214 if (S_GET_SEGMENT (sym
) == text_section
)
4215 csect
= ppc_text_csects
;
4216 else if (S_GET_SEGMENT (sym
) == data_section
)
4217 csect
= ppc_data_csects
;
4221 /* Skip the initial dummy symbol. */
4222 csect
= symbol_get_tc (csect
)->next
;
4224 if (csect
== (symbolS
*) NULL
)
4226 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym
));
4227 a
->x_csect
.x_scnlen
.l
= 0;
4231 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
)
4233 resolve_symbol_value (symbol_get_tc (csect
)->next
, 1);
4234 if (S_GET_VALUE (symbol_get_tc (csect
)->next
)
4235 > S_GET_VALUE (sym
))
4237 csect
= symbol_get_tc (csect
)->next
;
4240 a
->x_csect
.x_scnlen
.p
=
4241 coffsymbol (symbol_get_bfdsym (csect
))->native
;
4242 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
+ 1].fix_scnlen
=
4245 a
->x_csect
.x_smtyp
= XTY_LD
;
4248 a
->x_csect
.x_parmhash
= 0;
4249 a
->x_csect
.x_snhash
= 0;
4250 if (symbol_get_tc (sym
)->class == -1)
4251 a
->x_csect
.x_smclas
= XMC_PR
;
4253 a
->x_csect
.x_smclas
= symbol_get_tc (sym
)->class;
4254 a
->x_csect
.x_stab
= 0;
4255 a
->x_csect
.x_snstab
= 0;
4257 /* Don't let the COFF backend resort these symbols. */
4258 symbol_get_bfdsym (sym
)->flags
|= BSF_NOT_AT_END
;
4260 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
4262 /* We want the value to be the symbol index of the referenced
4263 csect symbol. BFD will do that for us if we set the right
4267 coffsymbol (symbol_get_bfdsym
4268 (symbol_get_tc (sym
)->within
))->native
));
4269 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_value
= 1;
4271 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
4276 /* The value is the offset from the enclosing csect. */
4277 block
= symbol_get_tc (sym
)->within
;
4278 csect
= symbol_get_tc (block
)->within
;
4279 resolve_symbol_value (csect
, 1);
4280 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
4282 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
4283 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
4285 /* We want the value to be a file offset into the line numbers.
4286 BFD will do that for us if we set the right flags. We have
4287 already set the value correctly. */
4288 coffsymbol (symbol_get_bfdsym (sym
))->native
->fix_line
= 1;
4294 /* Adjust the symbol table. This creates csect symbols for all
4295 absolute symbols. */
4298 ppc_adjust_symtab ()
4305 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
4309 union internal_auxent
*a
;
4311 if (S_GET_SEGMENT (sym
) != absolute_section
)
4314 csect
= symbol_create (".abs[XO]", absolute_section
,
4315 S_GET_VALUE (sym
), &zero_address_frag
);
4316 symbol_get_bfdsym (csect
)->value
= S_GET_VALUE (sym
);
4317 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
4318 i
= S_GET_NUMBER_AUXILIARY (csect
);
4319 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
4320 a
= &coffsymbol (symbol_get_bfdsym (csect
))->native
[i
+ 1].u
.auxent
;
4321 a
->x_csect
.x_scnlen
.l
= 0;
4322 a
->x_csect
.x_smtyp
= XTY_SD
;
4323 a
->x_csect
.x_parmhash
= 0;
4324 a
->x_csect
.x_snhash
= 0;
4325 a
->x_csect
.x_smclas
= XMC_XO
;
4326 a
->x_csect
.x_stab
= 0;
4327 a
->x_csect
.x_snstab
= 0;
4329 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
4331 i
= S_GET_NUMBER_AUXILIARY (sym
);
4332 a
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].u
.auxent
;
4333 a
->x_csect
.x_scnlen
.p
= coffsymbol (symbol_get_bfdsym (csect
))->native
;
4334 coffsymbol (symbol_get_bfdsym (sym
))->native
[i
].fix_scnlen
= 1;
4337 ppc_saw_abs
= false;
4340 /* Set the VMA for a section. This is called on all the sections in
4344 ppc_frob_section (sec
)
4347 static bfd_size_type vma
= 0;
4349 bfd_set_section_vma (stdoutput
, sec
, vma
);
4350 vma
+= bfd_section_size (stdoutput
, sec
);
4353 #endif /* OBJ_XCOFF */
4355 /* Turn a string in input_line_pointer into a floating point constant
4356 of type type, and store the appropriate bytes in *litp. The number
4357 of LITTLENUMS emitted is stored in *sizep . An error message is
4358 returned, or NULL on OK. */
4361 md_atof (type
, litp
, sizep
)
4367 LITTLENUM_TYPE words
[4];
4383 return _("bad call to md_atof");
4386 t
= atof_ieee (input_line_pointer
, type
, words
);
4388 input_line_pointer
= t
;
4392 if (target_big_endian
)
4394 for (i
= 0; i
< prec
; i
++)
4396 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4402 for (i
= prec
- 1; i
>= 0; i
--)
4404 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
4412 /* Write a value out to the object file, using the appropriate
4416 md_number_to_chars (buf
, val
, n
)
4421 if (target_big_endian
)
4422 number_to_chars_bigendian (buf
, val
, n
);
4424 number_to_chars_littleendian (buf
, val
, n
);
4427 /* Align a section (I don't know why this is machine dependent). */
4430 md_section_align (seg
, addr
)
4434 int align
= bfd_get_section_alignment (stdoutput
, seg
);
4436 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
4439 /* We don't have any form of relaxing. */
4442 md_estimate_size_before_relax (fragp
, seg
)
4450 /* Convert a machine dependent frag. We never generate these. */
4453 md_convert_frag (abfd
, sec
, fragp
)
4461 /* We have no need to default values of symbols. */
4465 md_undefined_symbol (name
)
4471 /* Functions concerning relocs. */
4473 /* The location from which a PC relative jump should be calculated,
4474 given a PC relative reloc. */
4477 md_pcrel_from_section (fixp
, sec
)
4481 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4486 /* This is called to see whether a fixup should be adjusted to use a
4487 section symbol. We take the opportunity to change a fixup against
4488 a symbol in the TOC subsegment into a reloc against the
4489 corresponding .tc symbol. */
4492 ppc_fix_adjustable (fix
)
4497 resolve_symbol_value (fix
->fx_addsy
, 1);
4498 val
= S_GET_VALUE (fix
->fx_addsy
);
4499 if (ppc_toc_csect
!= (symbolS
*) NULL
4500 && fix
->fx_addsy
!= (symbolS
*) NULL
4501 && fix
->fx_addsy
!= ppc_toc_csect
4502 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
4503 && val
>= ppc_toc_frag
->fr_address
4504 && (ppc_after_toc_frag
== (fragS
*) NULL
4505 || val
< ppc_after_toc_frag
->fr_address
))
4509 for (sy
= symbol_next (ppc_toc_csect
);
4510 sy
!= (symbolS
*) NULL
;
4511 sy
= symbol_next (sy
))
4513 if (symbol_get_tc (sy
)->class == XMC_TC0
)
4515 if (symbol_get_tc (sy
)->class != XMC_TC
)
4517 resolve_symbol_value (sy
, 1);
4518 if (val
== S_GET_VALUE (sy
))
4521 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
4526 as_bad_where (fix
->fx_file
, fix
->fx_line
,
4527 _("symbol in .toc does not match any .tc"));
4530 /* Possibly adjust the reloc to be against the csect. */
4531 if (fix
->fx_addsy
!= (symbolS
*) NULL
4532 && symbol_get_tc (fix
->fx_addsy
)->subseg
== 0
4533 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC0
4534 && symbol_get_tc (fix
->fx_addsy
)->class != XMC_TC
4535 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
4536 /* Don't adjust if this is a reloc in the toc section. */
4537 && (S_GET_SEGMENT (fix
->fx_addsy
) != data_section
4538 || ppc_toc_csect
== NULL
4539 || val
< ppc_toc_frag
->fr_address
4540 || (ppc_after_toc_frag
!= NULL
4541 && val
>= ppc_after_toc_frag
->fr_address
)))
4545 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
4546 csect
= ppc_text_csects
;
4547 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
4548 csect
= ppc_data_csects
;
4552 /* Skip the initial dummy symbol. */
4553 csect
= symbol_get_tc (csect
)->next
;
4555 if (csect
!= (symbolS
*) NULL
)
4557 while (symbol_get_tc (csect
)->next
!= (symbolS
*) NULL
4558 && (symbol_get_frag (symbol_get_tc (csect
)->next
)->fr_address
4559 <= symbol_get_frag (fix
->fx_addsy
)->fr_address
))
4561 /* If the csect address equals the symbol value, then we
4562 have to look through the full symbol table to see
4563 whether this is the csect we want. Note that we will
4564 only get here if the csect has zero length. */
4565 if ((symbol_get_frag (csect
)->fr_address
4566 == symbol_get_frag (fix
->fx_addsy
)->fr_address
)
4567 && S_GET_VALUE (csect
) == S_GET_VALUE (fix
->fx_addsy
))
4571 for (scan
= symbol_next (csect
);
4573 scan
= symbol_next (scan
))
4575 if (symbol_get_tc (scan
)->subseg
!= 0)
4577 if (scan
== fix
->fx_addsy
)
4581 /* If we found the symbol before the next csect
4582 symbol, then this is the csect we want. */
4583 if (scan
== fix
->fx_addsy
)
4587 csect
= symbol_get_tc (csect
)->next
;
4590 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
4591 - symbol_get_frag (csect
)->fr_address
);
4592 fix
->fx_addsy
= csect
;
4596 /* Adjust a reloc against a .lcomm symbol to be against the base
4598 if (fix
->fx_addsy
!= (symbolS
*) NULL
4599 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
4600 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
4602 resolve_symbol_value (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
, 1);
4604 (S_GET_VALUE (fix
->fx_addsy
)
4605 - S_GET_VALUE (symbol_get_frag (fix
->fx_addsy
)->fr_symbol
));
4606 fix
->fx_addsy
= symbol_get_frag (fix
->fx_addsy
)->fr_symbol
;
4612 /* A reloc from one csect to another must be kept. The assembler
4613 will, of course, keep relocs between sections, and it will keep
4614 absolute relocs, but we need to force it to keep PC relative relocs
4615 between two csects in the same section. */
4618 ppc_force_relocation (fix
)
4621 /* At this point fix->fx_addsy should already have been converted to
4622 a csect symbol. If the csect does not include the fragment, then
4623 we need to force the relocation. */
4625 && fix
->fx_addsy
!= NULL
4626 && symbol_get_tc (fix
->fx_addsy
)->subseg
!= 0
4627 && ((symbol_get_frag (fix
->fx_addsy
)->fr_address
4628 > fix
->fx_frag
->fr_address
)
4629 || (symbol_get_tc (fix
->fx_addsy
)->next
!= NULL
4630 && (symbol_get_frag (symbol_get_tc (fix
->fx_addsy
)->next
)->fr_address
4631 <= fix
->fx_frag
->fr_address
))))
4637 #endif /* OBJ_XCOFF */
4639 /* See whether a symbol is in the TOC section. */
4642 ppc_is_toc_sym (sym
)
4646 return symbol_get_tc (sym
)->class == XMC_TC
;
4648 return strcmp (segment_name (S_GET_SEGMENT (sym
)), ".got") == 0;
4652 /* Apply a fixup to the object code. This is called for all the
4653 fixups we generated by the call to fix_new_exp, above. In the call
4654 above we used a reloc code which was the largest legal reloc code
4655 plus the operand index. Here we undo that to recover the operand
4656 index. At this point all symbol values should be fully resolved,
4657 and we attempt to completely resolve the reloc. If we can not do
4658 that, we determine the correct reloc code and put it back in the
4662 md_apply_fix3 (fixp
, valuep
, seg
)
4671 if (fixp
->fx_addsy
!= NULL
)
4673 /* `*valuep' may contain the value of the symbol on which the reloc
4674 will be based; we have to remove it. */
4675 if (symbol_used_in_reloc_p (fixp
->fx_addsy
)
4676 && S_GET_SEGMENT (fixp
->fx_addsy
) != absolute_section
4677 && S_GET_SEGMENT (fixp
->fx_addsy
) != undefined_section
4678 && ! bfd_is_com_section (S_GET_SEGMENT (fixp
->fx_addsy
)))
4679 value
-= S_GET_VALUE (fixp
->fx_addsy
);
4681 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
4682 supposed to be? I think this is related to various similar
4683 FIXMEs in tc-i386.c and tc-sparc.c. */
4685 value
+= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4692 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
4693 the symbol values. Since we are using BFD_ASSEMBLER, if we are
4694 doing this relocation the code in write.c is going to call
4695 bfd_install_relocation, which is also going to use the symbol
4696 value. That means that if the reloc is fully resolved we want to
4697 use *valuep since bfd_install_relocation is not being used.
4698 However, if the reloc is not fully resolved we do not want to use
4699 *valuep, and must use fx_offset instead. However, if the reloc
4700 is PC relative, we do want to use *valuep since it includes the
4701 result of md_pcrel_from. This is confusing. */
4702 if (fixp
->fx_addsy
== (symbolS
*) NULL
)
4707 else if (fixp
->fx_pcrel
)
4711 value
= fixp
->fx_offset
;
4712 if (fixp
->fx_subsy
!= (symbolS
*) NULL
)
4714 if (S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
4715 value
-= S_GET_VALUE (fixp
->fx_subsy
);
4718 /* We can't actually support subtracting a symbol. */
4719 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4720 _("expression too complex"));
4726 if ((int) fixp
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
4729 const struct powerpc_operand
*operand
;
4733 opindex
= (int) fixp
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
4735 operand
= &powerpc_operands
[opindex
];
4738 /* It appears that an instruction like
4740 when LC..1 is not a TOC symbol does not generate a reloc. It
4741 uses the offset of LC..1 within its csect. However, .long
4742 LC..1 will generate a reloc. I can't find any documentation
4743 on how these cases are to be distinguished, so this is a wild
4744 guess. These cases are generated by gcc -mminimal-toc. */
4745 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
4746 && operand
->bits
== 16
4747 && operand
->shift
== 0
4748 && operand
->insert
== NULL
4749 && fixp
->fx_addsy
!= NULL
4750 && symbol_get_tc (fixp
->fx_addsy
)->subseg
!= 0
4751 && symbol_get_tc (fixp
->fx_addsy
)->class != XMC_TC
4752 && symbol_get_tc (fixp
->fx_addsy
)->class != XMC_TC0
4753 && S_GET_SEGMENT (fixp
->fx_addsy
) != bss_section
)
4755 value
= fixp
->fx_offset
;
4760 /* Fetch the instruction, insert the fully resolved operand
4761 value, and stuff the instruction back again. */
4762 where
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
4763 if (target_big_endian
)
4764 insn
= bfd_getb32 ((unsigned char *) where
);
4766 insn
= bfd_getl32 ((unsigned char *) where
);
4767 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
4768 fixp
->fx_file
, fixp
->fx_line
);
4769 if (target_big_endian
)
4770 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
4772 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
4776 /* Nothing else to do here. */
4780 /* Determine a BFD reloc value based on the operand information.
4781 We are only prepared to turn a few of the operands into
4783 FIXME: We need to handle the DS field at the very least.
4784 FIXME: Selecting the reloc type is a bit haphazard; perhaps
4785 there should be a new field in the operand table. */
4786 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
4787 && operand
->bits
== 26
4788 && operand
->shift
== 0)
4789 fixp
->fx_r_type
= BFD_RELOC_PPC_B26
;
4790 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
4791 && operand
->bits
== 16
4792 && operand
->shift
== 0)
4793 fixp
->fx_r_type
= BFD_RELOC_PPC_B16
;
4794 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
4795 && operand
->bits
== 26
4796 && operand
->shift
== 0)
4797 fixp
->fx_r_type
= BFD_RELOC_PPC_BA26
;
4798 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
4799 && operand
->bits
== 16
4800 && operand
->shift
== 0)
4801 fixp
->fx_r_type
= BFD_RELOC_PPC_BA16
;
4802 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
4803 && operand
->bits
== 16
4804 && operand
->shift
== 0
4805 && operand
->insert
== NULL
4806 && fixp
->fx_addsy
!= NULL
4807 && ppc_is_toc_sym (fixp
->fx_addsy
))
4810 if (target_big_endian
)
4811 fixp
->fx_where
+= 2;
4812 fixp
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
4819 /* Use expr_symbol_where to see if this is an expression
4821 if (expr_symbol_where (fixp
->fx_addsy
, &sfile
, &sline
))
4822 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4823 _("unresolved expression that must be resolved"));
4825 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4826 _("unsupported relocation type"));
4834 ppc_elf_validate_fix (fixp
, seg
);
4836 switch (fixp
->fx_r_type
)
4839 case BFD_RELOC_CTOR
:
4841 fixp
->fx_r_type
= BFD_RELOC_32_PCREL
;
4845 case BFD_RELOC_32_PCREL
:
4846 case BFD_RELOC_32_BASEREL
:
4847 case BFD_RELOC_PPC_EMB_NADDR32
:
4848 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4852 case BFD_RELOC_LO16
:
4854 case BFD_RELOC_GPREL16
:
4855 case BFD_RELOC_16_GOT_PCREL
:
4856 case BFD_RELOC_16_GOTOFF
:
4857 case BFD_RELOC_LO16_GOTOFF
:
4858 case BFD_RELOC_HI16_GOTOFF
:
4859 case BFD_RELOC_HI16_S_GOTOFF
:
4860 case BFD_RELOC_LO16_BASEREL
:
4861 case BFD_RELOC_HI16_BASEREL
:
4862 case BFD_RELOC_HI16_S_BASEREL
:
4863 case BFD_RELOC_PPC_EMB_NADDR16
:
4864 case BFD_RELOC_PPC_EMB_NADDR16_LO
:
4865 case BFD_RELOC_PPC_EMB_NADDR16_HI
:
4866 case BFD_RELOC_PPC_EMB_NADDR16_HA
:
4867 case BFD_RELOC_PPC_EMB_SDAI16
:
4868 case BFD_RELOC_PPC_EMB_SDA2REL
:
4869 case BFD_RELOC_PPC_EMB_SDA2I16
:
4870 case BFD_RELOC_PPC_EMB_RELSEC16
:
4871 case BFD_RELOC_PPC_EMB_RELST_LO
:
4872 case BFD_RELOC_PPC_EMB_RELST_HI
:
4873 case BFD_RELOC_PPC_EMB_RELST_HA
:
4874 case BFD_RELOC_PPC_EMB_RELSDA
:
4875 case BFD_RELOC_PPC_TOC16
:
4878 if (fixp
->fx_addsy
!= NULL
)
4879 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4880 _("cannot emit PC relative %s relocation against %s"),
4881 bfd_get_reloc_code_name (fixp
->fx_r_type
),
4882 S_GET_NAME (fixp
->fx_addsy
));
4884 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4885 _("cannot emit PC relative %s relocation"),
4886 bfd_get_reloc_code_name (fixp
->fx_r_type
));
4889 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4893 /* This case happens when you write, for example,
4895 where L1 and L2 are defined later. */
4896 case BFD_RELOC_HI16
:
4899 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4902 case BFD_RELOC_HI16_S
:
4905 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4906 (value
+ 0x8000) >> 16, 2);
4909 /* Because SDA21 modifies the register field, the size is set to 4
4910 bytes, rather than 2, so offset it here appropriately */
4911 case BFD_RELOC_PPC_EMB_SDA21
:
4915 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
4916 + ((target_big_endian
) ? 2 : 0),
4924 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4928 case BFD_RELOC_24_PLT_PCREL
:
4929 case BFD_RELOC_PPC_LOCAL24PC
:
4930 if (!fixp
->fx_pcrel
&& !fixp
->fx_done
)
4938 /* Fetch the instruction, insert the fully resolved operand
4939 value, and stuff the instruction back again. */
4940 where
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
4941 if (target_big_endian
)
4942 insn
= bfd_getb32 ((unsigned char *) where
);
4944 insn
= bfd_getl32 ((unsigned char *) where
);
4945 if ((value
& 3) != 0)
4946 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4947 _("must branch to an address a multiple of 4"));
4948 if ((offsetT
) value
< -0x40000000
4949 || (offsetT
) value
>= 0x40000000)
4950 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4951 _("@local or @plt branch destination is too far away, %ld bytes"),
4953 insn
= insn
| (value
& 0x03fffffc);
4954 if (target_big_endian
)
4955 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
4957 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
4961 case BFD_RELOC_VTABLE_INHERIT
:
4964 && !S_IS_DEFINED (fixp
->fx_addsy
)
4965 && !S_IS_WEAK (fixp
->fx_addsy
))
4966 S_SET_WEAK (fixp
->fx_addsy
);
4969 case BFD_RELOC_VTABLE_ENTRY
:
4975 _("Gas failure, reloc value %d\n"), fixp
->fx_r_type
);
4982 fixp
->fx_addnumber
= value
;
4984 if (fixp
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
4985 fixp
->fx_addnumber
= 0;
4989 fixp
->fx_addnumber
= 0;
4991 /* We want to use the offset within the data segment of the
4992 symbol, not the actual VMA of the symbol. */
4993 fixp
->fx_addnumber
=
4994 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixp
->fx_addsy
));
5002 /* Generate a reloc for a fixup. */
5005 tc_gen_reloc (seg
, fixp
)
5011 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
5013 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
5014 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
5015 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
5016 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
5017 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
5019 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
5020 _("reloc %d not supported by object file format"), (int)fixp
->fx_r_type
);
5023 reloc
->addend
= fixp
->fx_addnumber
;