1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994 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
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "opcode/ppc.h"
36 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
38 /* Tell the main code what the endianness is. */
39 extern int target_big_endian
;
41 /* Whether or not, we've set target_big_endian. */
42 static int set_target_endian
= 0;
44 static void ppc_set_cpu
PARAMS ((void));
45 static unsigned long ppc_insert_operand
46 PARAMS ((unsigned long insn
, const struct powerpc_operand
*operand
,
47 offsetT val
, char *file
, unsigned int line
));
48 static void ppc_macro
PARAMS ((char *str
, const struct powerpc_macro
*macro
));
49 static void ppc_byte
PARAMS ((int));
50 static int ppc_is_toc_sym
PARAMS ((symbolS
*sym
));
51 static void ppc_tc
PARAMS ((int));
54 static void ppc_comm
PARAMS ((int));
55 static void ppc_bb
PARAMS ((int));
56 static void ppc_bc
PARAMS ((int));
57 static void ppc_bf
PARAMS ((int));
58 static void ppc_biei
PARAMS ((int));
59 static void ppc_bs
PARAMS ((int));
60 static void ppc_eb
PARAMS ((int));
61 static void ppc_ec
PARAMS ((int));
62 static void ppc_ef
PARAMS ((int));
63 static void ppc_es
PARAMS ((int));
64 static void ppc_csect
PARAMS ((int));
65 static void ppc_change_csect
PARAMS ((symbolS
*));
66 static void ppc_function
PARAMS ((int));
67 static void ppc_extern
PARAMS ((int));
68 static void ppc_lglobl
PARAMS ((int));
69 static void ppc_section
PARAMS ((int));
70 static void ppc_stabx
PARAMS ((int));
71 static void ppc_rename
PARAMS ((int));
72 static void ppc_toc
PARAMS ((int));
76 static bfd_reloc_code_real_type ppc_elf_suffix
PARAMS ((char **));
77 static void ppc_elf_cons
PARAMS ((int));
78 static void ppc_elf_validate_fix
PARAMS ((fixS
*, segT
));
82 static void ppc_set_current_section
PARAMS ((segT
));
83 static void ppc_previous
PARAMS ((int));
84 static void ppc_pdata
PARAMS ((int));
85 static void ppc_ydata
PARAMS ((int));
86 static void ppc_reldata
PARAMS ((int));
87 static void ppc_rdata
PARAMS ((int));
88 static void ppc_ualong
PARAMS ((int));
89 static void ppc_znop
PARAMS ((int));
90 static void ppc_pe_comm
PARAMS ((int));
91 static void ppc_pe_section
PARAMS ((int));
92 static void ppc_pe_function
PARAMS ((int));
93 static void ppc_pe_tocd
PARAMS ((int));
96 /* Generic assembler global variables which must be defined by all
99 /* Characters which always start a comment. */
100 const char comment_chars
[] = "#";
102 /* Characters which start a comment at the beginning of a line. */
103 const char line_comment_chars
[] = "#";
105 /* Characters which may be used to separate multiple commands on a
107 const char line_separator_chars
[] = ";";
109 /* Characters which are used to indicate an exponent in a floating
111 const char EXP_CHARS
[] = "eE";
113 /* Characters which mean that a number is a floating point constant,
115 const char FLT_CHARS
[] = "dD";
117 /* The target specific pseudo-ops which we support. */
119 const pseudo_typeS md_pseudo_table
[] =
121 /* Pseudo-ops which must be overridden. */
122 { "byte", ppc_byte
, 0 },
125 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
126 legitimately belong in the obj-*.c file. However, XCOFF is based
127 on COFF, and is only implemented for the RS/6000. We just use
128 obj-coff.c, and add what we need here. */
129 { "comm", ppc_comm
, 0 },
130 { "lcomm", ppc_comm
, 1 },
134 { "bi", ppc_biei
, 0 },
136 { "csect", ppc_csect
, 0 },
137 { "data", ppc_section
, 'd' },
141 { "ei", ppc_biei
, 1 },
143 { "extern", ppc_extern
, 0 },
144 { "function", ppc_function
, 0 },
145 { "lglobl", ppc_lglobl
, 0 },
146 { "rename", ppc_rename
, 0 },
147 { "stabx", ppc_stabx
, 0 },
148 { "text", ppc_section
, 't' },
149 { "toc", ppc_toc
, 0 },
153 { "long", ppc_elf_cons
, 4 },
154 { "word", ppc_elf_cons
, 2 },
155 { "short", ppc_elf_cons
, 2 },
159 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
160 { "previous", ppc_previous
, 0 },
161 { "pdata", ppc_pdata
, 0 },
162 { "ydata", ppc_ydata
, 0 },
163 { "reldata", ppc_reldata
, 0 },
164 { "rdata", ppc_rdata
, 0 },
165 { "ualong", ppc_ualong
, 0 },
166 { "znop", ppc_znop
, 0 },
167 { "comm", ppc_pe_comm
, 0 },
168 { "lcomm", ppc_pe_comm
, 1 },
169 { "section", ppc_pe_section
, 0 },
170 { "function", ppc_pe_function
,0 },
171 { "tocd", ppc_pe_tocd
, 0 },
174 /* This pseudo-op is used even when not generating XCOFF output. */
182 /* The Windows NT PowerPC assembler uses predefined names. */
184 /* In general, there are lots of them, in an attempt to be compatible */
185 /* with a number of other Windows NT assemblers. */
187 /* Structure to hold information about predefined registers. */
194 /* List of registers that are pre-defined:
196 Each general register has predefined names of the form:
197 1. r<reg_num> which has the value <reg_num>.
198 2. r.<reg_num> which has the value <reg_num>.
201 Each floating point register has predefined names of the form:
202 1. f<reg_num> which has the value <reg_num>.
203 2. f.<reg_num> which has the value <reg_num>.
205 Each condition register has predefined names of the form:
206 1. cr<reg_num> which has the value <reg_num>.
207 2. cr.<reg_num> which has the value <reg_num>.
209 There are individual registers as well:
210 sp or r.sp has the value 1
211 rtoc or r.toc has the value 2
212 fpscr has the value 0
218 dsisr has the value 18
220 sdr1 has the value 25
221 srr0 has the value 26
222 srr1 has the value 27
224 The table is sorted. Suitable for searching by a binary search. */
226 static const struct pd_reg pre_defined_registers
[] =
228 { "cr.0", 0 }, /* Condition Registers */
248 { "dar", 19 }, /* Data Access Register */
249 { "dec", 22 }, /* Decrementer */
250 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
252 { "f.0", 0 }, /* Floating point registers */
320 { "lr", 8 }, /* Link Register */
324 { "r.0", 0 }, /* General Purpose Registers */
357 { "r.sp", 1 }, /* Stack Pointer */
359 { "r.toc", 2 }, /* Pointer to the table of contents */
361 { "r0", 0 }, /* More general purpose registers */
394 { "rtoc", 2 }, /* Table of contents */
396 { "sdr1", 25 }, /* Storage Description Register 1 */
400 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
401 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
407 #define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
409 /* Given NAME, find the register number associated with that name, return
410 the integer value associated with the given name or -1 on failure. */
412 static int reg_name_search
PARAMS ( (char * name
) );
415 reg_name_search (name
)
418 int middle
, low
, high
;
422 high
= REG_NAME_CNT
- 1;
426 middle
= (low
+ high
) / 2;
427 cmp
= strcasecmp (name
, pre_defined_registers
[middle
].name
);
433 return pre_defined_registers
[middle
].value
;
443 /* Local variables. */
445 /* The type of processor we are assembling for. This is one or more
446 of the PPC_OPCODE flags defined in opcode/ppc.h. */
447 static int ppc_cpu
= 0;
449 /* The size of the processor we are assembling for. This is either
450 PPC_OPCODE_32 or PPC_OPCODE_64. */
451 static int ppc_size
= PPC_OPCODE_32
;
453 /* Opcode hash table. */
454 static struct hash_control
*ppc_hash
;
456 /* Macro hash table. */
457 static struct hash_control
*ppc_macro_hash
;
460 /* Whether to warn about non PC relative relocations that aren't
461 in the .got2 section. */
462 static boolean mrelocatable
= false;
464 /* Flags to set in the elf header */
465 static flagword ppc_flags
= 0;
470 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
471 using a bunch of different sections. These assembler sections,
472 however, are all encompassed within the .text or .data sections of
473 the final output file. We handle this by using different
474 subsegments within these main segments. */
476 /* Next subsegment to allocate within the .text segment. */
477 static subsegT ppc_text_subsegment
= 2;
479 /* Linked list of csects in the text section. */
480 static symbolS
*ppc_text_csects
;
482 /* Next subsegment to allocate within the .data segment. */
483 static subsegT ppc_data_subsegment
= 2;
485 /* Linked list of csects in the data section. */
486 static symbolS
*ppc_data_csects
;
488 /* The current csect. */
489 static symbolS
*ppc_current_csect
;
491 /* The RS/6000 assembler uses a TOC which holds addresses of functions
492 and variables. Symbols are put in the TOC with the .tc pseudo-op.
493 A special relocation is used when accessing TOC entries. We handle
494 the TOC as a subsegment within the .data segment. We set it up if
495 we see a .toc pseudo-op, and save the csect symbol here. */
496 static symbolS
*ppc_toc_csect
;
498 /* The first frag in the TOC subsegment. */
499 static fragS
*ppc_toc_frag
;
501 /* The first frag in the first subsegment after the TOC in the .data
502 segment. NULL if there are no subsegments after the TOC. */
503 static fragS
*ppc_after_toc_frag
;
505 /* The current static block. */
506 static symbolS
*ppc_current_block
;
508 /* The COFF debugging section; set by md_begin. This is not the
509 .debug section, but is instead the secret BFD section which will
510 cause BFD to set the section number of a symbol to N_DEBUG. */
511 static asection
*ppc_coff_debug_section
;
513 /* The size of the .debug section. */
514 static bfd_size_type ppc_debug_name_section_size
;
516 #endif /* OBJ_XCOFF */
520 /* Various sections that we need for PE coff support. */
521 static segT ydata_section
;
522 static segT pdata_section
;
523 static segT reldata_section
;
524 static segT rdata_section
;
525 static segT tocdata_section
;
527 /* The current section and the previous section. See ppc_previous. */
528 static segT ppc_previous_section
;
529 static segT ppc_current_section
;
534 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
537 #ifndef WORKING_DOT_WORD
538 const int md_short_jump_size
= 4;
539 const int md_long_jump_size
= 4;
543 CONST
char *md_shortopts
= "um:VQ:";
545 CONST
char *md_shortopts
= "um:";
547 struct option md_longopts
[] = {
548 {NULL
, no_argument
, NULL
, 0}
550 size_t md_longopts_size
= sizeof(md_longopts
);
553 md_parse_option (c
, arg
)
560 /* -u means that any undefined symbols should be treated as
561 external, which is the default for gas anyhow. */
565 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
567 if (strcmp (arg
, "pwrx") == 0 || strcmp (arg
, "pwr2") == 0)
568 ppc_cpu
= PPC_OPCODE_POWER
| PPC_OPCODE_POWER2
;
569 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
570 else if (strcmp (arg
, "pwr") == 0)
571 ppc_cpu
= PPC_OPCODE_POWER
;
572 /* -m601 means to assemble for the Motorola PowerPC 601, which includes
573 instructions that are holdovers from the Power. */
574 else if (strcmp (arg
, "601") == 0)
575 ppc_cpu
= PPC_OPCODE_PPC
| PPC_OPCODE_601
;
576 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
577 Motorola PowerPC 603/604. */
578 else if (strcmp (arg
, "ppc") == 0
579 || strcmp (arg
, "ppc32") == 0
580 || strcmp (arg
, "403") == 0
581 || strcmp (arg
, "603") == 0
582 || strcmp (arg
, "604") == 0)
583 ppc_cpu
= PPC_OPCODE_PPC
;
584 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
586 else if (strcmp (arg
, "ppc64") == 0 || strcmp (arg
, "620") == 0)
588 ppc_cpu
= PPC_OPCODE_PPC
;
589 ppc_size
= PPC_OPCODE_64
;
591 /* -mcom means assemble for the common intersection between Power
592 and PowerPC. At present, we just allow the union, rather
593 than the intersection. */
594 else if (strcmp (arg
, "com") == 0)
595 ppc_cpu
= PPC_OPCODE_COMMON
;
596 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
597 else if (strcmp (arg
, "any") == 0)
598 ppc_cpu
= PPC_OPCODE_ANY
;
601 /* -mrelocatable/-mrelocatable-lib -- warn about initializations that require relocation */
602 else if (strcmp (arg
, "relocatable") == 0)
605 ppc_flags
|= EF_PPC_RELOCATABLE
;
608 else if (strcmp (arg
, "relocatable-lib") == 0)
611 ppc_flags
|= EF_PPC_RELOCATABLE_LIB
;
614 /* -memb, set embedded bit */
615 else if (strcmp (arg
, "emb") == 0)
616 ppc_flags
|= EF_PPC_EMB
;
618 /* -mlittle/-mbig set the endianess */
619 else if (strcmp (arg
, "little") == 0 || strcmp (arg
, "little-endian") == 0)
621 target_big_endian
= 0;
622 set_target_endian
= 1;
625 else if (strcmp (arg
, "big") == 0 || strcmp (arg
, "big-endian") == 0)
627 target_big_endian
= 1;
628 set_target_endian
= 1;
633 as_bad ("invalid switch -m%s", arg
);
639 /* -V: SVR4 argument to print version ID. */
644 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
645 should be emitted or not. FIXME: Not implemented. */
658 md_show_usage (stream
)
664 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
665 -mpwr generate code for IBM POWER (RIOS1)\n\
666 -m601 generate code for Motorola PowerPC 601\n\
667 -mppc, -mppc32, -m403, -m603, -m604\n\
668 generate code for Motorola PowerPC 603/604\n\
669 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
670 -mcom generate code Power/PowerPC common instructions\n
671 -many generate code for any architecture (PWR/PWRX/PPC)\n");
674 -mrelocatable support for GCC's -mrelocatble option\n\
675 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
676 -memb set PPC_EMB bit in ELF flags\n\
677 -mlittle, -mlittle-endian\n\
678 generate code for a little endian machine\n\
679 -mbig, -mbig-endian generate code for a big endian machine\n\
680 -V print assembler version number\n\
681 -Qy, -Qn ignored\n");
685 /* Set ppc_cpu if it is not already set. */
690 const char *default_cpu
= TARGET_CPU
;
694 if (strcmp (default_cpu
, "rs6000") == 0)
695 ppc_cpu
= PPC_OPCODE_POWER
;
696 else if (strcmp (default_cpu
, "powerpc") == 0
697 || strcmp (default_cpu
, "powerpcle") == 0)
698 ppc_cpu
= PPC_OPCODE_PPC
;
700 as_fatal ("Unknown default cpu = %s", default_cpu
);
704 /* Figure out the BFD architecture to use. */
706 enum bfd_architecture
709 const char *default_cpu
= TARGET_CPU
;
712 if ((ppc_cpu
& PPC_OPCODE_PPC
) != 0)
713 return bfd_arch_powerpc
;
714 else if ((ppc_cpu
& PPC_OPCODE_POWER
) != 0)
715 return bfd_arch_rs6000
;
716 else if ((ppc_cpu
& (PPC_OPCODE_COMMON
| PPC_OPCODE_ANY
)) != 0)
718 if (strcmp (default_cpu
, "rs6000") == 0)
719 return bfd_arch_rs6000
;
720 else if (strcmp (default_cpu
, "powerpc") == 0
721 || strcmp (default_cpu
, "powerpcle") == 0)
722 return bfd_arch_powerpc
;
725 as_fatal ("Neither Power nor PowerPC opcodes were selected.");
726 return bfd_arch_unknown
;
729 /* This function is called when the assembler starts up. It is called
730 after the options have been parsed and the output file has been
736 register const struct powerpc_opcode
*op
;
737 const struct powerpc_opcode
*op_end
;
738 const struct powerpc_macro
*macro
;
739 const struct powerpc_macro
*macro_end
;
740 boolean dup_insn
= false;
745 /* Set the ELF flags if desired. */
747 bfd_set_private_flags (stdoutput
, ppc_flags
);
750 /* Insert the opcodes into a hash table. */
751 ppc_hash
= hash_new ();
753 op_end
= powerpc_opcodes
+ powerpc_num_opcodes
;
754 for (op
= powerpc_opcodes
; op
< op_end
; op
++)
756 know ((op
->opcode
& op
->mask
) == op
->opcode
);
758 if ((op
->flags
& ppc_cpu
) != 0
759 && ((op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == 0
760 || (op
->flags
& (PPC_OPCODE_32
| PPC_OPCODE_64
)) == ppc_size
))
764 retval
= hash_insert (ppc_hash
, op
->name
, (PTR
) op
);
765 if (retval
!= (const char *) NULL
)
767 /* Ignore Power duplicates for -m601 */
768 if ((ppc_cpu
& PPC_OPCODE_601
) != 0
769 && (op
->flags
& PPC_OPCODE_POWER
) != 0)
772 as_bad ("Internal assembler error for instruction %s", op
->name
);
778 /* Insert the macros into a hash table. */
779 ppc_macro_hash
= hash_new ();
781 macro_end
= powerpc_macros
+ powerpc_num_macros
;
782 for (macro
= powerpc_macros
; macro
< macro_end
; macro
++)
784 if ((macro
->flags
& ppc_cpu
) != 0)
788 retval
= hash_insert (ppc_macro_hash
, macro
->name
, (PTR
) macro
);
789 if (retval
!= (const char *) NULL
)
791 as_bad ("Internal assembler error for macro %s", macro
->name
);
800 /* Tell the main code what the endianness is if it is not overidden by the user. */
801 if (!set_target_endian
)
803 set_target_endian
= 1;
804 target_big_endian
= PPC_BIG_ENDIAN
;
808 ppc_coff_debug_section
= coff_section_from_bfd_index (stdoutput
, N_DEBUG
);
810 /* Create dummy symbols to serve as initial csects. This forces the
811 text csects to precede the data csects. These symbols will not
813 ppc_text_csects
= symbol_make ("dummy\001");
814 ppc_text_csects
->sy_tc
.within
= ppc_text_csects
;
815 ppc_data_csects
= symbol_make ("dummy\001");
816 ppc_data_csects
->sy_tc
.within
= ppc_data_csects
;
821 ppc_current_section
= text_section
;
822 ppc_previous_section
= 0;
827 /* Insert an operand value into an instruction. */
830 ppc_insert_operand (insn
, operand
, val
, file
, line
)
832 const struct powerpc_operand
*operand
;
837 if (operand
->bits
!= 32)
842 if ((operand
->flags
& PPC_OPERAND_SIGNED
) != 0)
844 if ((operand
->flags
& PPC_OPERAND_SIGNOPT
) != 0
845 && ppc_size
== PPC_OPCODE_32
)
846 max
= (1 << operand
->bits
) - 1;
848 max
= (1 << (operand
->bits
- 1)) - 1;
849 min
= - (1 << (operand
->bits
- 1));
853 max
= (1 << operand
->bits
) - 1;
857 if ((operand
->flags
& PPC_OPERAND_NEGATIVE
) != 0)
862 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
865 "operand out of range (%s not between %ld and %ld)";
868 sprint_value (buf
, test
);
869 if (file
== (char *) NULL
)
870 as_warn (err
, buf
, min
, max
);
872 as_warn_where (file
, line
, err
, buf
, min
, max
);
881 insn
= (*operand
->insert
) (insn
, (long) val
, &errmsg
);
882 if (errmsg
!= (const char *) NULL
)
886 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
893 /* Parse @got, etc. and return the desired relocation. */
894 static bfd_reloc_code_real_type
895 ppc_elf_suffix (str_p
)
901 bfd_reloc_code_real_type reloc
;
911 #define MAP(str,reloc) { str, sizeof(str)-1, reloc }
913 static struct map_bfd mapping
[] = {
914 MAP ("got", BFD_RELOC_PPC_TOC16
),
915 MAP ("l", BFD_RELOC_LO16
),
916 MAP ("h", BFD_RELOC_HI16
),
917 MAP ("ha", BFD_RELOC_HI16_S
),
918 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN
),
919 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN
),
920 MAP ("got@l", BFD_RELOC_LO16_GOTOFF
),
921 MAP ("got@h", BFD_RELOC_HI16_GOTOFF
),
922 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF
),
923 MAP ("fixup", BFD_RELOC_CTOR
), /* warnings with -mrelocatable */
924 MAP ("pltrel24", BFD_RELOC_24_PLT_PCREL
),
925 MAP ("copy", BFD_RELOC_PPC_COPY
),
926 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT
),
927 MAP ("local24pc", BFD_RELOC_PPC_LOCAL24PC
),
928 MAP ("plt", BFD_RELOC_32_PLTOFF
),
929 MAP ("pltrel", BFD_RELOC_32_PLT_PCREL
),
930 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF
),
931 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF
),
932 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF
),
933 MAP ("sdarel", BFD_RELOC_GPREL16
),
934 MAP ("sectoff", BFD_RELOC_32_BASEREL
),
935 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL
),
936 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL
),
937 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL
),
939 { (char *)0, 0, BFD_RELOC_UNUSED
}
943 return BFD_RELOC_UNUSED
;
945 for (ch
= *str
, str2
= ident
;
946 str2
< ident
+ sizeof(ident
) - 1 && isalnum (ch
) || ch
== '@';
949 *str2
++ = (islower (ch
)) ? ch
: tolower (ch
);
956 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
957 if (ch
== ptr
->string
[0] && len
== ptr
->length
&& memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
963 return BFD_RELOC_UNUSED
;
966 /* Like normal .long/.short/.word, except support @got, etc. */
967 /* clobbers input_line_pointer, checks */
970 ppc_elf_cons (nbytes
)
971 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
974 bfd_reloc_code_real_type reloc
;
976 if (is_it_end_of_statement ())
978 demand_empty_rest_of_line ();
985 if (exp
.X_op
== O_symbol
986 && *input_line_pointer
== '@'
987 && (reloc
= ppc_elf_suffix (&input_line_pointer
)) != BFD_RELOC_UNUSED
)
989 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
990 int size
= bfd_get_reloc_size (reloc_howto
);
993 as_bad ("%s relocations do not fit in %d bytes\n", reloc_howto
->name
, nbytes
);
997 register char *p
= frag_more ((int) nbytes
);
998 int offset
= nbytes
- size
;
1000 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
, &exp
, 0, reloc
);
1004 emit_expr (&exp
, (unsigned int) nbytes
);
1006 while (*input_line_pointer
++ == ',');
1008 input_line_pointer
--; /* Put terminator back into stream. */
1009 demand_empty_rest_of_line ();
1012 /* Validate any relocations emitted for -mrelocatable, possibly adding
1013 fixups for word relocations in writable segments, so we can adjust
1016 ppc_elf_validate_fix (fixp
, seg
)
1023 && fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1024 && strcmp (segment_name (seg
), ".got2") != 0
1025 && strcmp (segment_name (seg
), ".dtors") != 0
1026 && strcmp (segment_name (seg
), ".ctors") != 0
1027 && strcmp (segment_name (seg
), ".fixup") != 0
1028 && strcmp (segment_name (seg
), ".stab") != 0)
1030 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1031 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1033 as_warn_where (fixp
->fx_file
, fixp
->fx_line
,
1034 "Relocation cannot be done when using -mrelocatable");
1039 #endif /* OBJ_ELF */
1043 * Summary of register_name().
1045 * in: Input_line_pointer points to 1st char of operand.
1047 * out: A expressionS.
1048 * The operand may have been a register: in this case, X_op == O_register,
1049 * X_add_number is set to the register number, and truth is returned.
1050 * Input_line_pointer->(next non-blank) char after operand, or is in its
1055 register_name (expressionP
)
1056 expressionS
*expressionP
;
1062 /* Find the spelling of the operand */
1063 name
= input_line_pointer
;
1064 c
= get_symbol_end ();
1065 reg_number
= reg_name_search (name
);
1067 /* look to see if it's in the register table */
1068 if (reg_number
>= 0)
1070 expressionP
->X_op
= O_register
;
1071 expressionP
->X_add_number
= reg_number
;
1073 /* make the rest nice */
1074 expressionP
->X_add_symbol
= NULL
;
1075 expressionP
->X_op_symbol
= NULL
;
1076 *input_line_pointer
= c
; /* put back the delimiting char */
1081 /* reset the line as if we had not done anything */
1082 *input_line_pointer
= c
; /* put back the delimiting char */
1083 input_line_pointer
= name
; /* reset input_line pointer */
1089 * Summary of parse_toc_entry().
1091 * in: Input_line_pointer points to the '[' in one of:
1093 * [toc] [tocv] [toc32] [toc64]
1095 * Anything else is an error of one kind or another.
1098 * return value: success or failure
1099 * toc_kind: kind of toc reference
1100 * input_line_pointer:
1101 * success: first char after the ']'
1102 * failure: unchanged
1106 * [toc] - rv == success, toc_kind = default_toc
1107 * [tocv] - rv == success, toc_kind = data_in_toc
1108 * [toc32] - rv == success, toc_kind = must_be_32
1109 * [toc64] - rv == success, toc_kind = must_be_64
1113 enum toc_size_qualifier
1115 default_toc
, /* The toc cell constructed should be the system default size */
1116 data_in_toc
, /* This is a direct reference to a toc cell */
1117 must_be_32
, /* The toc cell constructed must be 32 bits wide */
1118 must_be_64
/* The toc cell constructed must be 64 bits wide */
1122 parse_toc_entry(toc_kind
)
1123 enum toc_size_qualifier
*toc_kind
;
1128 enum toc_size_qualifier t
;
1130 /* save the input_line_pointer */
1131 start
= input_line_pointer
;
1133 /* skip over the '[' , and whitespace */
1134 ++input_line_pointer
;
1137 /* find the spelling of the operand */
1138 toc_spec
= input_line_pointer
;
1139 c
= get_symbol_end ();
1141 if (strcmp(toc_spec
, "toc") == 0)
1145 else if (strcmp(toc_spec
, "tocv") == 0)
1149 else if (strcmp(toc_spec
, "toc32") == 0)
1153 else if (strcmp(toc_spec
, "toc64") == 0)
1159 as_bad ("syntax error: invalid toc specifier `%s'", toc_spec
);
1160 *input_line_pointer
= c
; /* put back the delimiting char */
1161 input_line_pointer
= start
; /* reset input_line pointer */
1165 /* now find the ']' */
1166 *input_line_pointer
= c
; /* put back the delimiting char */
1168 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1169 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
1173 as_bad ("syntax error: expected `]', found `%c'", c
);
1174 input_line_pointer
= start
; /* reset input_line pointer */
1178 *toc_kind
= t
; /* set return value */
1185 /* We need to keep a list of fixups. We can't simply generate them as
1186 we go, because that would require us to first create the frag, and
1187 that would screw up references to ``.''. */
1193 bfd_reloc_code_real_type reloc
;
1196 #define MAX_INSN_FIXUPS (5)
1198 /* This routine is called for each instruction to be assembled. */
1205 const struct powerpc_opcode
*opcode
;
1207 const unsigned char *opindex_ptr
;
1211 struct ppc_fixup fixups
[MAX_INSN_FIXUPS
];
1216 bfd_reloc_code_real_type reloc
;
1219 /* Get the opcode. */
1220 for (s
= str
; *s
!= '\0' && ! isspace (*s
); s
++)
1225 /* Look up the opcode in the hash table. */
1226 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, str
);
1227 if (opcode
== (const struct powerpc_opcode
*) NULL
)
1229 const struct powerpc_macro
*macro
;
1231 macro
= (const struct powerpc_macro
*) hash_find (ppc_macro_hash
, str
);
1232 if (macro
== (const struct powerpc_macro
*) NULL
)
1233 as_bad ("Unrecognized opcode: `%s'", str
);
1235 ppc_macro (s
, macro
);
1240 insn
= opcode
->opcode
;
1243 while (isspace (*str
))
1246 /* PowerPC operands are just expressions. The only real issue is
1247 that a few operand types are optional. All cases which might use
1248 an optional operand separate the operands only with commas (in
1249 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1250 cases never have optional operands). There is never more than
1251 one optional operand for an instruction. So, before we start
1252 seriously parsing the operands, we check to see if we have an
1253 optional operand, and, if we do, we count the number of commas to
1254 see whether the operand should be omitted. */
1256 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1258 const struct powerpc_operand
*operand
;
1260 operand
= &powerpc_operands
[*opindex_ptr
];
1261 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0)
1263 unsigned int opcount
;
1265 /* There is an optional operand. Count the number of
1266 commas in the input line. */
1273 while ((s
= strchr (s
, ',')) != (char *) NULL
)
1280 /* If there are fewer operands in the line then are called
1281 for by the instruction, we want to skip the optional
1283 if (opcount
< strlen (opcode
->operands
))
1290 /* Gather the operands. */
1294 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1296 const struct powerpc_operand
*operand
;
1302 if (next_opindex
== 0)
1303 operand
= &powerpc_operands
[*opindex_ptr
];
1306 operand
= &powerpc_operands
[next_opindex
];
1312 /* If this is a fake operand, then we do not expect anything
1314 if ((operand
->flags
& PPC_OPERAND_FAKE
) != 0)
1316 insn
= (*operand
->insert
) (insn
, 0L, &errmsg
);
1317 if (errmsg
!= (const char *) NULL
)
1322 /* If this is an optional operand, and we are skipping it, just
1324 if ((operand
->flags
& PPC_OPERAND_OPTIONAL
) != 0
1327 if (operand
->insert
)
1329 insn
= (*operand
->insert
) (insn
, 0L, &errmsg
);
1330 if (errmsg
!= (const char *) NULL
)
1333 if ((operand
->flags
& PPC_OPERAND_NEXT
) != 0)
1334 next_opindex
= *opindex_ptr
+ 1;
1338 /* Gather the operand. */
1339 hold
= input_line_pointer
;
1340 input_line_pointer
= str
;
1343 if (*input_line_pointer
== '[')
1345 /* We are expecting something like the second argument here:
1347 lwz r4,[toc].GS.0.static_int(rtoc)
1348 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1349 The argument following the `]' must be a symbol name, and the
1350 register must be the toc register: 'rtoc' or '2'
1352 The effect is to 0 as the displacement field
1353 in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1354 the appropriate variation) reloc against it based on the symbol.
1355 The linker will build the toc, and insert the resolved toc offset.
1358 o The size of the toc entry is currently assumed to be
1359 32 bits. This should not be assumed to be a hard coded
1361 o In an effort to cope with a change from 32 to 64 bits,
1362 there are also toc entries that are specified to be
1363 either 32 or 64 bits:
1364 lwz r4,[toc32].GS.0.static_int(rtoc)
1365 lwz r4,[toc64].GS.0.static_int(rtoc)
1366 These demand toc entries of the specified size, and the
1367 instruction probably requires it.
1371 enum toc_size_qualifier toc_kind
;
1372 bfd_reloc_code_real_type toc_reloc
;
1374 /* go parse off the [tocXX] part */
1375 valid_toc
= parse_toc_entry(&toc_kind
);
1379 /* Note: message has already been issued. */
1380 /* FIXME: what sort of recovery should we do? */
1381 /* demand_rest_of_line(); return; ? */
1384 /* Now get the symbol following the ']' */
1390 /* In this case, we may not have seen the symbol yet, since */
1391 /* it is allowed to appear on a .extern or .globl or just be */
1392 /* a label in the .data section. */
1393 toc_reloc
= BFD_RELOC_PPC_TOC16
;
1396 /* 1. The symbol must be defined and either in the toc */
1397 /* section, or a global. */
1398 /* 2. The reloc generated must have the TOCDEFN flag set in */
1399 /* upper bit mess of the reloc type. */
1400 /* FIXME: It's a little confusing what the tocv qualifier can */
1401 /* be used for. At the very least, I've seen three */
1402 /* uses, only one of which I'm sure I can explain. */
1403 if (ex
.X_op
== O_symbol
)
1405 assert (ex
.X_add_symbol
!= NULL
);
1406 if (ex
.X_add_symbol
->bsym
->section
!= tocdata_section
)
1408 as_warn("[tocv] symbol is not a toc symbol");
1412 toc_reloc
= BFD_RELOC_PPC_TOC16
;
1415 /* FIXME: these next two specifically specify 32/64 bit toc */
1416 /* entries. We don't support them today. Is this the */
1417 /* right way to say that? */
1418 toc_reloc
= BFD_RELOC_UNUSED
;
1419 as_bad ("Unimplemented toc32 expression modifier");
1422 /* FIXME: see above */
1423 toc_reloc
= BFD_RELOC_UNUSED
;
1424 as_bad ("Unimplemented toc64 expression modifier");
1428 "Unexpected return value [%d] from parse_toc_entry!\n",
1434 /* We need to generate a fixup for this expression. */
1435 if (fc
>= MAX_INSN_FIXUPS
)
1436 as_fatal ("too many fixups");
1438 fixups
[fc
].reloc
= toc_reloc
;
1439 fixups
[fc
].exp
= ex
;
1440 fixups
[fc
].opindex
= *opindex_ptr
;
1443 /* Ok. We've set up the fixup for the instruction. Now make it
1444 look like the constant 0 was found here */
1446 ex
.X_op
= O_constant
;
1447 ex
.X_add_number
= 0;
1448 ex
.X_add_symbol
= NULL
;
1449 ex
.X_op_symbol
= NULL
;
1453 if (!register_name(&ex
))
1459 str
= input_line_pointer
;
1460 input_line_pointer
= hold
;
1463 str
= input_line_pointer
;
1464 input_line_pointer
= hold
;
1467 if (ex
.X_op
== O_illegal
)
1468 as_bad ("illegal operand");
1469 else if (ex
.X_op
== O_absent
)
1470 as_bad ("missing operand");
1471 else if (ex
.X_op
== O_constant
)
1474 /* Allow @HA, @L, @H on constants. */
1475 char *orig_str
= str
;
1477 if ((reloc
= ppc_elf_suffix (&str
)) != BFD_RELOC_UNUSED
)
1484 case BFD_RELOC_LO16
:
1485 ex
.X_add_number
= ((ex
.X_add_number
& 0xffff) ^ 0x8000) - 0x8000;
1488 case BFD_RELOC_HI16
:
1489 ex
.X_add_number
= (ex
.X_add_number
>> 16) & 0xffff;
1492 case BFD_RELOC_HI16_S
:
1493 ex
.X_add_number
= ((ex
.X_add_number
>> 16) & 0xffff)
1494 + ((ex
.X_add_number
>> 15) & 1);
1498 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
1502 else if (ex
.X_op
== O_register
)
1504 insn
= ppc_insert_operand (insn
, operand
, ex
.X_add_number
,
1509 else if ((reloc
= ppc_elf_suffix (&str
)) != BFD_RELOC_UNUSED
)
1511 /* For the absoulte forms of branchs, convert the PC relative form back into
1513 if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0)
1516 case BFD_RELOC_PPC_B26
: reloc
= BFD_RELOC_PPC_BA26
; break;
1517 case BFD_RELOC_PPC_B16
: reloc
= BFD_RELOC_PPC_BA16
; break;
1518 case BFD_RELOC_PPC_B16_BRTAKEN
: reloc
= BFD_RELOC_PPC_BA16_BRTAKEN
; break;
1519 case BFD_RELOC_PPC_B16_BRNTAKEN
: reloc
= BFD_RELOC_PPC_BA16_BRNTAKEN
; break;
1522 /* We need to generate a fixup for this expression. */
1523 if (fc
>= MAX_INSN_FIXUPS
)
1524 as_fatal ("too many fixups");
1525 fixups
[fc
].exp
= ex
;
1526 fixups
[fc
].opindex
= 0;
1527 fixups
[fc
].reloc
= reloc
;
1530 #endif /* OBJ_ELF */
1534 /* We need to generate a fixup for this expression. */
1535 if (fc
>= MAX_INSN_FIXUPS
)
1536 as_fatal ("too many fixups");
1537 fixups
[fc
].exp
= ex
;
1538 fixups
[fc
].opindex
= *opindex_ptr
;
1539 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1548 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0)
1556 /* The call to expression should have advanced str past any
1559 && (endc
!= ',' || *str
!= '\0'))
1561 as_bad ("syntax error; found `%c' but expected `%c'", *str
, endc
);
1569 while (isspace (*str
))
1573 as_bad ("junk at end of line: `%s'", str
);
1575 /* Write out the instruction. */
1577 md_number_to_chars (f
, insn
, 4);
1579 /* Create any fixups. At this point we do not use a
1580 bfd_reloc_code_real_type, but instead just use the
1581 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1582 handle fixups for any operand type, although that is admittedly
1583 not a very exciting feature. We pick a BFD reloc type in
1585 for (i
= 0; i
< fc
; i
++)
1587 const struct powerpc_operand
*operand
;
1589 operand
= &powerpc_operands
[fixups
[i
].opindex
];
1590 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1592 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1600 size
= bfd_get_reloc_size (reloc_howto
);
1601 offset
= target_big_endian
? (4 - size
) : 0;
1603 if (size
< 1 || size
> 4)
1606 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
+ offset
, size
,
1607 &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1610 /* Turn off complaints that the addend is too large for things like
1612 switch (fixups
[i
].reloc
)
1614 case BFD_RELOC_LO16
:
1615 case BFD_RELOC_HI16
:
1616 case BFD_RELOC_HI16_S
:
1617 fixP
->fx_no_overflow
= 1;
1624 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4,
1626 (operand
->flags
& PPC_OPERAND_RELATIVE
) != 0,
1627 ((bfd_reloc_code_real_type
)
1628 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1632 #ifndef WORKING_DOT_WORD
1633 /* Handle long and short jumps */
1635 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1637 addressT from_addr
, to_addr
;
1645 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1647 addressT from_addr
, to_addr
;
1655 /* Handle a macro. Gather all the operands, transform them as
1656 described by the macro, and call md_assemble recursively. All the
1657 operands are separated by commas; we don't accept parentheses
1658 around operands here. */
1661 ppc_macro (str
, macro
)
1663 const struct powerpc_macro
*macro
;
1674 /* Gather the users operands into the operands array. */
1679 if (count
>= sizeof operands
/ sizeof operands
[0])
1681 operands
[count
++] = s
;
1682 s
= strchr (s
, ',');
1683 if (s
== (char *) NULL
)
1688 if (count
!= macro
->operands
)
1690 as_bad ("wrong number of operands");
1694 /* Work out how large the string must be (the size is unbounded
1695 because it includes user input). */
1697 format
= macro
->format
;
1698 while (*format
!= '\0')
1707 arg
= strtol (format
+ 1, &send
, 10);
1708 know (send
!= format
&& arg
>= 0 && arg
< count
);
1709 len
+= strlen (operands
[arg
]);
1714 /* Put the string together. */
1715 complete
= s
= (char *) alloca (len
+ 1);
1716 format
= macro
->format
;
1717 while (*format
!= '\0')
1723 arg
= strtol (format
+ 1, &send
, 10);
1724 strcpy (s
, operands
[arg
]);
1731 /* Assemble the constructed instruction. */
1732 md_assemble (complete
);
1735 /* Pseudo-op handling. */
1737 /* The .byte pseudo-op. This is similar to the normal .byte
1738 pseudo-op, but it can also take a single ASCII string. */
1744 if (*input_line_pointer
!= '\"')
1750 /* Gather characters. A real double quote is doubled. Unusual
1751 characters are not permitted. */
1752 ++input_line_pointer
;
1757 c
= *input_line_pointer
++;
1761 if (*input_line_pointer
!= '\"')
1763 ++input_line_pointer
;
1766 FRAG_APPEND_1_CHAR (c
);
1769 demand_empty_rest_of_line ();
1774 /* XCOFF specific pseudo-op handling. */
1776 /* This is set if we are creating a .stabx symbol, since we don't want
1777 to handle symbol suffixes for such symbols. */
1778 static boolean ppc_stab_symbol
;
1780 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
1781 symbols in the .bss segment as though they were local common
1782 symbols, and uses a different smclas. */
1788 asection
*current_seg
= now_seg
;
1789 subsegT current_subseg
= now_subseg
;
1795 symbolS
*lcomm_sym
= NULL
;
1799 name
= input_line_pointer
;
1800 endc
= get_symbol_end ();
1801 end_name
= input_line_pointer
;
1804 if (*input_line_pointer
!= ',')
1806 as_bad ("missing size");
1807 ignore_rest_of_line ();
1810 ++input_line_pointer
;
1812 size
= get_absolute_expression ();
1815 as_bad ("negative size");
1816 ignore_rest_of_line ();
1822 /* The third argument to .comm is the alignment. */
1823 if (*input_line_pointer
!= ',')
1827 ++input_line_pointer
;
1828 align
= get_absolute_expression ();
1831 as_warn ("ignoring bad alignment");
1850 /* The third argument to .lcomm appears to be the real local
1851 common symbol to create. References to the symbol named in
1852 the first argument are turned into references to the third
1854 if (*input_line_pointer
!= ',')
1856 as_bad ("missing real symbol name");
1857 ignore_rest_of_line ();
1860 ++input_line_pointer
;
1862 lcomm_name
= input_line_pointer
;
1863 lcomm_endc
= get_symbol_end ();
1865 lcomm_sym
= symbol_find_or_make (lcomm_name
);
1867 *input_line_pointer
= lcomm_endc
;
1871 sym
= symbol_find_or_make (name
);
1874 if (S_IS_DEFINED (sym
)
1875 || S_GET_VALUE (sym
) != 0)
1877 as_bad ("attempt to redefine symbol");
1878 ignore_rest_of_line ();
1882 record_alignment (bss_section
, align
);
1885 || ! S_IS_DEFINED (lcomm_sym
))
1894 S_SET_EXTERNAL (sym
);
1898 lcomm_sym
->sy_tc
.output
= 1;
1899 def_sym
= lcomm_sym
;
1903 subseg_set (bss_section
, 1);
1904 frag_align (align
, 0);
1906 def_sym
->sy_frag
= frag_now
;
1907 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, def_sym
,
1908 def_size
, (char *) NULL
);
1910 S_SET_SEGMENT (def_sym
, bss_section
);
1911 def_sym
->sy_tc
.align
= align
;
1915 /* Align the size of lcomm_sym. */
1916 lcomm_sym
->sy_frag
->fr_offset
=
1917 ((lcomm_sym
->sy_frag
->fr_offset
+ (1 << align
) - 1)
1918 &~ ((1 << align
) - 1));
1919 if (align
> lcomm_sym
->sy_tc
.align
)
1920 lcomm_sym
->sy_tc
.align
= align
;
1925 /* Make sym an offset from lcomm_sym. */
1926 S_SET_SEGMENT (sym
, bss_section
);
1927 sym
->sy_frag
= lcomm_sym
->sy_frag
;
1928 S_SET_VALUE (sym
, lcomm_sym
->sy_frag
->fr_offset
);
1929 lcomm_sym
->sy_frag
->fr_offset
+= size
;
1932 subseg_set (current_seg
, current_subseg
);
1934 demand_empty_rest_of_line ();
1937 /* The .csect pseudo-op. This switches us into a different
1938 subsegment. The first argument is a symbol whose value is the
1939 start of the .csect. In COFF, csect symbols get special aux
1940 entries defined by the x_csect field of union internal_auxent. The
1941 optional second argument is the alignment (the default is 2). */
1951 name
= input_line_pointer
;
1952 endc
= get_symbol_end ();
1954 sym
= symbol_find_or_make (name
);
1956 *input_line_pointer
= endc
;
1958 ppc_change_csect (sym
);
1960 if (*input_line_pointer
== ',')
1962 ++input_line_pointer
;
1963 sym
->sy_tc
.align
= get_absolute_expression ();
1966 demand_empty_rest_of_line ();
1969 /* Change to a different csect. */
1972 ppc_change_csect (sym
)
1975 if (S_IS_DEFINED (sym
))
1976 subseg_set (S_GET_SEGMENT (sym
), sym
->sy_tc
.subseg
);
1983 /* This is a new csect. We need to look at the symbol class to
1984 figure out whether it should go in the text section or the
1987 switch (sym
->sy_tc
.class)
1997 S_SET_SEGMENT (sym
, text_section
);
1998 sym
->sy_tc
.subseg
= ppc_text_subsegment
;
1999 ++ppc_text_subsegment
;
2000 list_ptr
= &ppc_text_csects
;
2009 if (ppc_toc_csect
!= NULL
2010 && ppc_toc_csect
->sy_tc
.subseg
+ 1 == ppc_data_subsegment
)
2012 S_SET_SEGMENT (sym
, data_section
);
2013 sym
->sy_tc
.subseg
= ppc_data_subsegment
;
2014 ++ppc_data_subsegment
;
2015 list_ptr
= &ppc_data_csects
;
2021 subseg_new (segment_name (S_GET_SEGMENT (sym
)), sym
->sy_tc
.subseg
);
2023 ppc_after_toc_frag
= frag_now
;
2025 sym
->sy_frag
= frag_now
;
2026 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2028 sym
->sy_tc
.align
= 2;
2029 sym
->sy_tc
.output
= 1;
2030 sym
->sy_tc
.within
= sym
;
2032 for (list
= *list_ptr
;
2033 list
->sy_tc
.next
!= (symbolS
*) NULL
;
2034 list
= list
->sy_tc
.next
)
2036 list
->sy_tc
.next
= sym
;
2038 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2039 symbol_append (sym
, list
->sy_tc
.within
, &symbol_rootP
, &symbol_lastP
);
2042 ppc_current_csect
= sym
;
2045 /* This function handles the .text and .data pseudo-ops. These
2046 pseudo-ops aren't really used by XCOFF; we implement them for the
2047 convenience of people who aren't used to XCOFF. */
2058 else if (type
== 'd')
2063 sym
= symbol_find_or_make (name
);
2065 ppc_change_csect (sym
);
2067 demand_empty_rest_of_line ();
2070 /* The .extern pseudo-op. We create an undefined symbol. */
2079 name
= input_line_pointer
;
2080 endc
= get_symbol_end ();
2082 (void) symbol_find_or_make (name
);
2084 *input_line_pointer
= endc
;
2086 demand_empty_rest_of_line ();
2089 /* The .lglobl pseudo-op. I think the RS/6000 assembler only needs
2090 this because it can't handle undefined symbols. I think we can
2100 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2101 although I don't know why it bothers. */
2112 name
= input_line_pointer
;
2113 endc
= get_symbol_end ();
2115 sym
= symbol_find_or_make (name
);
2117 *input_line_pointer
= endc
;
2119 if (*input_line_pointer
!= ',')
2121 as_bad ("missing rename string");
2122 ignore_rest_of_line ();
2125 ++input_line_pointer
;
2127 sym
->sy_tc
.real_name
= demand_copy_C_string (&len
);
2129 demand_empty_rest_of_line ();
2132 /* The .stabx pseudo-op. This is similar to a normal .stabs
2133 pseudo-op, but slightly different. A sample is
2134 .stabx "main:F-1",.main,142,0
2135 The first argument is the symbol name to create. The second is the
2136 value, and the third is the storage class. The fourth seems to be
2137 always zero, and I am assuming it is the type. */
2148 name
= demand_copy_C_string (&len
);
2150 if (*input_line_pointer
!= ',')
2152 as_bad ("missing value");
2155 ++input_line_pointer
;
2157 ppc_stab_symbol
= true;
2158 sym
= symbol_make (name
);
2159 ppc_stab_symbol
= false;
2161 sym
->sy_tc
.real_name
= name
;
2163 (void) expression (&exp
);
2170 as_bad ("illegal .stabx expression; zero assumed");
2171 exp
.X_add_number
= 0;
2174 S_SET_VALUE (sym
, (valueT
) exp
.X_add_number
);
2175 sym
->sy_frag
= &zero_address_frag
;
2179 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
)
2180 sym
->sy_value
= exp
;
2184 exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
2185 sym
->sy_frag
= exp
.X_add_symbol
->sy_frag
;
2190 /* The value is some complex expression. This will probably
2191 fail at some later point, but this is probably the right
2192 thing to do here. */
2193 sym
->sy_value
= exp
;
2197 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
2198 sym
->bsym
->flags
|= BSF_DEBUGGING
;
2200 if (*input_line_pointer
!= ',')
2202 as_bad ("missing class");
2205 ++input_line_pointer
;
2207 S_SET_STORAGE_CLASS (sym
, get_absolute_expression ());
2209 if (*input_line_pointer
!= ',')
2211 as_bad ("missing type");
2214 ++input_line_pointer
;
2216 S_SET_DATA_TYPE (sym
, get_absolute_expression ());
2218 sym
->sy_tc
.output
= 1;
2220 if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
2221 sym
->sy_tc
.within
= ppc_current_block
;
2223 if (exp
.X_op
!= O_symbol
2224 || ! S_IS_EXTERNAL (exp
.X_add_symbol
)
2225 || S_GET_SEGMENT (exp
.X_add_symbol
) != bss_section
)
2226 ppc_frob_label (sym
);
2229 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2230 symbol_append (sym
, exp
.X_add_symbol
, &symbol_rootP
, &symbol_lastP
);
2231 if (ppc_current_csect
->sy_tc
.within
== exp
.X_add_symbol
)
2232 ppc_current_csect
->sy_tc
.within
= sym
;
2235 if (strlen (name
) > SYMNMLEN
)
2237 /* For some reason, each name is preceded by a two byte length
2238 and followed by a null byte. */
2239 ppc_debug_name_section_size
+= strlen (name
) + 3;
2242 demand_empty_rest_of_line ();
2245 /* The .function pseudo-op. This takes several arguments. The first
2246 argument seems to be the external name of the symbol. The second
2247 argment seems to be the label for the start of the function. gcc
2248 uses the same name for both. I have no idea what the third and
2249 fourth arguments are meant to be. The optional fifth argument is
2250 an expression for the size of the function. In COFF this symbol
2251 gets an aux entry like that used for a csect. */
2254 ppc_function (ignore
)
2263 name
= input_line_pointer
;
2264 endc
= get_symbol_end ();
2266 /* Ignore any [PR] suffix. */
2267 name
= ppc_canonicalize_symbol_name (name
);
2268 s
= strchr (name
, '[');
2269 if (s
!= (char *) NULL
2270 && strcmp (s
+ 1, "PR]") == 0)
2273 ext_sym
= symbol_find_or_make (name
);
2275 *input_line_pointer
= endc
;
2277 if (*input_line_pointer
!= ',')
2279 as_bad ("missing symbol name");
2280 ignore_rest_of_line ();
2283 ++input_line_pointer
;
2285 name
= input_line_pointer
;
2286 endc
= get_symbol_end ();
2288 lab_sym
= symbol_find_or_make (name
);
2290 *input_line_pointer
= endc
;
2292 if (ext_sym
!= lab_sym
)
2294 ext_sym
->sy_value
.X_op
= O_symbol
;
2295 ext_sym
->sy_value
.X_add_symbol
= lab_sym
;
2296 ext_sym
->sy_value
.X_op_symbol
= NULL
;
2297 ext_sym
->sy_value
.X_add_number
= 0;
2300 if (ext_sym
->sy_tc
.class == -1)
2301 ext_sym
->sy_tc
.class = XMC_PR
;
2302 ext_sym
->sy_tc
.output
= 1;
2304 if (*input_line_pointer
== ',')
2308 /* Ignore the third argument. */
2309 ++input_line_pointer
;
2310 expression (&ignore
);
2311 if (*input_line_pointer
== ',')
2313 /* Ignore the fourth argument. */
2314 ++input_line_pointer
;
2315 expression (&ignore
);
2316 if (*input_line_pointer
== ',')
2318 /* The fifth argument is the function size. */
2319 ++input_line_pointer
;
2320 ext_sym
->sy_tc
.size
= symbol_new ("L0\001",
2323 &zero_address_frag
);
2324 pseudo_set (ext_sym
->sy_tc
.size
);
2329 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
2330 SF_SET_FUNCTION (ext_sym
);
2331 SF_SET_PROCESS (ext_sym
);
2332 coff_add_linesym (ext_sym
);
2334 demand_empty_rest_of_line ();
2337 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
2346 sym
= symbol_make (".bf");
2347 S_SET_SEGMENT (sym
, text_section
);
2348 sym
->sy_frag
= frag_now
;
2349 S_SET_VALUE (sym
, frag_now_fix ());
2350 S_SET_STORAGE_CLASS (sym
, C_FCN
);
2352 coff_line_base
= get_absolute_expression ();
2354 S_SET_NUMBER_AUXILIARY (sym
, 1);
2355 SA_SET_SYM_LNNO (sym
, coff_line_base
);
2357 sym
->sy_tc
.output
= 1;
2359 ppc_frob_label (sym
);
2361 demand_empty_rest_of_line ();
2364 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
2365 ".ef", except that the line number is absolute, not relative to the
2366 most recent ".bf" symbol. */
2374 sym
= symbol_make (".ef");
2375 S_SET_SEGMENT (sym
, text_section
);
2376 sym
->sy_frag
= frag_now
;
2377 S_SET_VALUE (sym
, frag_now_fix ());
2378 S_SET_STORAGE_CLASS (sym
, C_FCN
);
2379 S_SET_NUMBER_AUXILIARY (sym
, 1);
2380 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
2381 sym
->sy_tc
.output
= 1;
2383 ppc_frob_label (sym
);
2385 demand_empty_rest_of_line ();
2388 /* The .bi and .ei pseudo-ops. These take a string argument and
2389 generates a C_BINCL or C_EINCL symbol, which goes at the start of
2401 name
= demand_copy_C_string (&len
);
2403 /* The value of these symbols is actually file offset. Here we set
2404 the value to the index into the line number entries. In
2405 ppc_frob_symbols we set the fix_line field, which will cause BFD
2406 to do the right thing. */
2408 sym
= symbol_make (name
);
2409 S_SET_SEGMENT (sym
, now_seg
);
2410 S_SET_VALUE (sym
, coff_n_line_nos
);
2411 sym
->bsym
->flags
|= BSF_DEBUGGING
;
2413 /* obj-coff.c currently only handles line numbers correctly in the
2415 assert (now_seg
== text_section
);
2417 S_SET_STORAGE_CLASS (sym
, ei
? C_EINCL
: C_BINCL
);
2418 sym
->sy_tc
.output
= 1;
2420 for (look
= symbol_rootP
;
2421 (look
!= (symbolS
*) NULL
2422 && (S_GET_STORAGE_CLASS (look
) == C_FILE
2423 || S_GET_STORAGE_CLASS (look
) == C_BINCL
2424 || S_GET_STORAGE_CLASS (look
) == C_EINCL
));
2425 look
= symbol_next (look
))
2427 if (look
!= (symbolS
*) NULL
)
2429 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2430 symbol_insert (sym
, look
, &symbol_rootP
, &symbol_lastP
);
2433 demand_empty_rest_of_line ();
2436 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
2437 There is one argument, which is a csect symbol. The value of the
2438 .bs symbol is the index of this csect symbol. */
2449 if (ppc_current_block
!= NULL
)
2450 as_bad ("nested .bs blocks");
2452 name
= input_line_pointer
;
2453 endc
= get_symbol_end ();
2455 csect
= symbol_find_or_make (name
);
2457 *input_line_pointer
= endc
;
2459 sym
= symbol_make (".bs");
2460 S_SET_SEGMENT (sym
, now_seg
);
2461 S_SET_STORAGE_CLASS (sym
, C_BSTAT
);
2462 sym
->bsym
->flags
|= BSF_DEBUGGING
;
2463 sym
->sy_tc
.output
= 1;
2465 sym
->sy_tc
.within
= csect
;
2467 ppc_frob_label (sym
);
2469 ppc_current_block
= sym
;
2471 demand_empty_rest_of_line ();
2474 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
2482 if (ppc_current_block
== NULL
)
2483 as_bad (".es without preceding .bs");
2485 sym
= symbol_make (".es");
2486 S_SET_SEGMENT (sym
, now_seg
);
2487 S_SET_STORAGE_CLASS (sym
, C_ESTAT
);
2488 sym
->bsym
->flags
|= BSF_DEBUGGING
;
2489 sym
->sy_tc
.output
= 1;
2491 ppc_frob_label (sym
);
2493 ppc_current_block
= NULL
;
2495 demand_empty_rest_of_line ();
2498 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
2507 sym
= symbol_make (".bb");
2508 S_SET_SEGMENT (sym
, text_section
);
2509 sym
->sy_frag
= frag_now
;
2510 S_SET_VALUE (sym
, frag_now_fix ());
2511 S_SET_STORAGE_CLASS (sym
, C_BLOCK
);
2513 S_SET_NUMBER_AUXILIARY (sym
, 1);
2514 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
2516 sym
->sy_tc
.output
= 1;
2518 ppc_frob_label (sym
);
2520 demand_empty_rest_of_line ();
2523 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
2532 sym
= symbol_make (".eb");
2533 S_SET_SEGMENT (sym
, text_section
);
2534 sym
->sy_frag
= frag_now
;
2535 S_SET_VALUE (sym
, frag_now_fix ());
2536 S_SET_STORAGE_CLASS (sym
, C_FCN
);
2537 S_SET_NUMBER_AUXILIARY (sym
, 1);
2538 SA_SET_SYM_LNNO (sym
, get_absolute_expression ());
2539 sym
->sy_tc
.output
= 1;
2541 ppc_frob_label (sym
);
2543 demand_empty_rest_of_line ();
2546 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
2557 name
= demand_copy_C_string (&len
);
2558 sym
= symbol_make (name
);
2559 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
2560 sym
->bsym
->flags
|= BSF_DEBUGGING
;
2561 S_SET_STORAGE_CLASS (sym
, C_BCOMM
);
2562 S_SET_VALUE (sym
, 0);
2563 sym
->sy_tc
.output
= 1;
2565 ppc_frob_label (sym
);
2567 if (strlen (name
) > SYMNMLEN
)
2568 ppc_debug_name_section_size
+= strlen (name
) + 3;
2570 demand_empty_rest_of_line ();
2573 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
2581 sym
= symbol_make (".ec");
2582 S_SET_SEGMENT (sym
, ppc_coff_debug_section
);
2583 sym
->bsym
->flags
|= BSF_DEBUGGING
;
2584 S_SET_STORAGE_CLASS (sym
, C_ECOMM
);
2585 S_SET_VALUE (sym
, 0);
2586 sym
->sy_tc
.output
= 1;
2588 ppc_frob_label (sym
);
2590 demand_empty_rest_of_line ();
2593 /* The .toc pseudo-op. Switch to the .toc subsegment. */
2599 if (ppc_toc_csect
!= (symbolS
*) NULL
)
2600 subseg_set (data_section
, ppc_toc_csect
->sy_tc
.subseg
);
2607 subseg
= ppc_data_subsegment
;
2608 ++ppc_data_subsegment
;
2610 subseg_new (segment_name (data_section
), subseg
);
2611 ppc_toc_frag
= frag_now
;
2613 sym
= symbol_find_or_make ("TOC[TC0]");
2614 sym
->sy_frag
= frag_now
;
2615 S_SET_SEGMENT (sym
, data_section
);
2616 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2617 sym
->sy_tc
.subseg
= subseg
;
2618 sym
->sy_tc
.output
= 1;
2619 sym
->sy_tc
.within
= sym
;
2621 ppc_toc_csect
= sym
;
2623 for (list
= ppc_data_csects
;
2624 list
->sy_tc
.next
!= (symbolS
*) NULL
;
2625 list
= list
->sy_tc
.next
)
2627 list
->sy_tc
.next
= sym
;
2629 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
2630 symbol_append (sym
, list
->sy_tc
.within
, &symbol_rootP
, &symbol_lastP
);
2633 ppc_current_csect
= ppc_toc_csect
;
2635 demand_empty_rest_of_line ();
2638 #endif /* OBJ_XCOFF */
2640 /* The .tc pseudo-op. This is used when generating either XCOFF or
2641 ELF. This takes two or more arguments.
2643 When generating XCOFF output, the first argument is the name to
2644 give to this location in the toc; this will be a symbol with class
2645 TC. The rest of the arguments are 4 byte values to actually put at
2646 this location in the TOC; often there is just one more argument, a
2647 relocateable symbol reference.
2649 When not generating XCOFF output, the arguments are the same, but
2650 the first argument is simply ignored. */
2658 /* Define the TOC symbol name. */
2664 if (ppc_toc_csect
== (symbolS
*) NULL
2665 || ppc_toc_csect
!= ppc_current_csect
)
2667 as_bad (".tc not in .toc section");
2668 ignore_rest_of_line ();
2672 name
= input_line_pointer
;
2673 endc
= get_symbol_end ();
2675 sym
= symbol_find_or_make (name
);
2677 *input_line_pointer
= endc
;
2679 if (S_IS_DEFINED (sym
))
2683 label
= ppc_current_csect
->sy_tc
.within
;
2684 if (label
->sy_tc
.class != XMC_TC0
)
2686 as_warn (".tc with no label");
2687 ignore_rest_of_line ();
2691 S_SET_SEGMENT (label
, S_GET_SEGMENT (sym
));
2692 label
->sy_frag
= sym
->sy_frag
;
2693 S_SET_VALUE (label
, S_GET_VALUE (sym
));
2695 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2696 ++input_line_pointer
;
2701 S_SET_SEGMENT (sym
, now_seg
);
2702 sym
->sy_frag
= frag_now
;
2703 S_SET_VALUE (sym
, (valueT
) frag_now_fix ());
2704 sym
->sy_tc
.class = XMC_TC
;
2705 sym
->sy_tc
.output
= 1;
2707 ppc_frob_label (sym
);
2710 #else /* ! defined (OBJ_XCOFF) */
2712 /* Skip the TOC symbol name. */
2713 while (is_part_of_name (*input_line_pointer
)
2714 || *input_line_pointer
== '['
2715 || *input_line_pointer
== ']'
2716 || *input_line_pointer
== '{'
2717 || *input_line_pointer
== '}')
2718 ++input_line_pointer
;
2720 /* Align to a four byte boundary. */
2722 record_alignment (now_seg
, 2);
2724 #endif /* ! defined (OBJ_XCOFF) */
2726 if (*input_line_pointer
!= ',')
2727 demand_empty_rest_of_line ();
2730 ++input_line_pointer
;
2737 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
2739 /* Set the current section. */
2741 ppc_set_current_section (new)
2744 ppc_previous_section
= ppc_current_section
;
2745 ppc_current_section
= new;
2748 /* pseudo-op: .previous
2749 behaviour: toggles the current section with the previous section.
2751 warnings: "No previous section"
2754 ppc_previous(ignore
)
2759 if (ppc_previous_section
== NULL
)
2761 as_warn("No previous section to return to. Directive ignored.");
2765 subseg_set(ppc_previous_section
, 0);
2767 ppc_set_current_section(ppc_previous_section
);
2770 /* pseudo-op: .pdata
2771 behaviour: predefined read only data section
2775 initial: .section .pdata "adr3"
2776 a - don't know -- maybe a misprint
2777 d - initialized data
2779 3 - double word aligned (that would be 4 byte boundary)
2782 Tag index tables (also known as the function table) for exception
2783 handling, debugging, etc.
2790 if (pdata_section
== 0)
2792 pdata_section
= subseg_new (".pdata", 0);
2794 bfd_set_section_flags (stdoutput
, pdata_section
,
2795 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
2796 | SEC_READONLY
| SEC_DATA
));
2798 bfd_set_section_alignment (stdoutput
, pdata_section
, 3);
2802 pdata_section
= subseg_new(".pdata", 0);
2804 ppc_set_current_section(pdata_section
);
2807 /* pseudo-op: .ydata
2808 behaviour: predefined read only data section
2812 initial: .section .ydata "drw3"
2813 a - don't know -- maybe a misprint
2814 d - initialized data
2816 3 - double word aligned (that would be 4 byte boundary)
2818 Tag tables (also known as the scope table) for exception handling,
2825 if (ydata_section
== 0)
2827 ydata_section
= subseg_new (".ydata", 0);
2828 bfd_set_section_flags (stdoutput
, ydata_section
,
2829 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
2830 | SEC_READONLY
| SEC_DATA
));
2832 bfd_set_section_alignment (stdoutput
, ydata_section
, 3);
2836 ydata_section
= subseg_new (".ydata", 0);
2838 ppc_set_current_section(ydata_section
);
2841 /* pseudo-op: .reldata
2842 behaviour: predefined read write data section
2843 double word aligned (4-byte)
2844 FIXME: relocation is applied to it
2845 FIXME: what's the difference between this and .data?
2848 initial: .section .reldata "drw3"
2849 d - initialized data
2852 3 - double word aligned (that would be 8 byte boundary)
2855 Like .data, but intended to hold data subject to relocation, such as
2856 function descriptors, etc.
2862 if (reldata_section
== 0)
2864 reldata_section
= subseg_new (".reldata", 0);
2866 bfd_set_section_flags (stdoutput
, reldata_section
,
2867 ( SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
2870 bfd_set_section_alignment (stdoutput
, reldata_section
, 3);
2874 reldata_section
= subseg_new (".reldata", 0);
2876 ppc_set_current_section(reldata_section
);
2879 /* pseudo-op: .rdata
2880 behaviour: predefined read only data section
2884 initial: .section .rdata "dr3"
2885 d - initialized data
2887 3 - double word aligned (that would be 4 byte boundary)
2893 if (rdata_section
== 0)
2895 rdata_section
= subseg_new (".rdata", 0);
2896 bfd_set_section_flags (stdoutput
, rdata_section
,
2897 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
2898 | SEC_READONLY
| SEC_DATA
));
2900 bfd_set_section_alignment (stdoutput
, rdata_section
, 2);
2904 rdata_section
= subseg_new (".rdata", 0);
2906 ppc_set_current_section(rdata_section
);
2909 /* pseudo-op: .ualong
2910 behaviour: much like .int, with the exception that no alignment is
2912 FIXME: test the alignment statement
2924 /* pseudo-op: .znop <symbol name>
2925 behaviour: Issue a nop instruction
2926 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
2927 the supplied symbol name.
2929 warnings: Missing symbol name
2936 const struct powerpc_opcode
*opcode
;
2942 /* Strip out the symbol name */
2950 symbol_name
= input_line_pointer
;
2951 c
= get_symbol_end ();
2953 name
= xmalloc (input_line_pointer
- symbol_name
+ 1);
2954 strcpy (name
, symbol_name
);
2956 sym
= symbol_find_or_make (name
);
2958 *input_line_pointer
= c
;
2962 /* Look up the opcode in the hash table. */
2963 opcode
= (const struct powerpc_opcode
*) hash_find (ppc_hash
, "nop");
2965 /* stick in the nop */
2966 insn
= opcode
->opcode
;
2968 /* Write out the instruction. */
2970 md_number_to_chars (f
, insn
, 4);
2972 f
- frag_now
->fr_literal
,
2977 BFD_RELOC_16_GOT_PCREL
);
2990 register char *name
;
2994 register symbolS
*symbolP
;
2997 name
= input_line_pointer
;
2998 c
= get_symbol_end ();
3000 /* just after name is now '\0' */
3001 p
= input_line_pointer
;
3004 if (*input_line_pointer
!= ',')
3006 as_bad ("Expected comma after symbol-name: rest of line ignored.");
3007 ignore_rest_of_line ();
3011 input_line_pointer
++; /* skip ',' */
3012 if ((temp
= get_absolute_expression ()) < 0)
3014 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
3015 ignore_rest_of_line ();
3021 /* The third argument to .comm is the alignment. */
3022 if (*input_line_pointer
!= ',')
3026 ++input_line_pointer
;
3027 align
= get_absolute_expression ();
3030 as_warn ("ignoring bad alignment");
3037 symbolP
= symbol_find_or_make (name
);
3040 if (S_IS_DEFINED (symbolP
))
3042 as_bad ("Ignoring attempt to re-define symbol `%s'.",
3043 S_GET_NAME (symbolP
));
3044 ignore_rest_of_line ();
3048 if (S_GET_VALUE (symbolP
))
3050 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
3051 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
3052 S_GET_NAME (symbolP
),
3053 (long) S_GET_VALUE (symbolP
),
3058 S_SET_VALUE (symbolP
, (valueT
) temp
);
3059 S_SET_EXTERNAL (symbolP
);
3062 demand_empty_rest_of_line ();
3066 * implement the .section pseudo op:
3067 * .section name {, "flags"}
3069 * | +--- optional flags: 'b' for bss
3071 * +-- section name 'l' for lib
3075 * 'd' (apparently m88k for data)
3077 * But if the argument is not a quoted string, treat it as a
3078 * subsegment number.
3080 * FIXME: this is a copy of the section processing from obj-coff.c, with
3081 * additions/changes for the moto-pas assembler support. There are three
3084 * FIXME: I just noticed this. This doesn't work at all really. It it
3085 * setting bits that bfd probably neither understands or uses. The
3086 * correct approach (?) will have to incorporate extra fields attached
3087 * to the section to hold the system specific stuff. (krk)
3090 * 'a' - unknown - referred to in documentation, but no definition supplied
3091 * 'c' - section has code
3092 * 'd' - section has initialized data
3093 * 'u' - section has uninitialized data
3094 * 'i' - section contains directives (info)
3095 * 'n' - section can be discarded
3096 * 'R' - remove section at link time
3098 * Section Protection:
3099 * 'r' - section is readable
3100 * 'w' - section is writeable
3101 * 'x' - section is executable
3102 * 's' - section is sharable
3104 * Section Alignment:
3105 * '0' - align to byte boundary
3106 * '1' - align to halfword undary
3107 * '2' - align to word boundary
3108 * '3' - align to doubleword boundary
3109 * '4' - align to quadword boundary
3110 * '5' - align to 32 byte boundary
3111 * '6' - align to 64 byte boundary
3116 ppc_pe_section (ignore
)
3119 /* Strip out the section name */
3128 align
= 4; /* default alignment to 16 byte boundary */
3130 section_name
= input_line_pointer
;
3131 c
= get_symbol_end ();
3133 name
= xmalloc (input_line_pointer
- section_name
+ 1);
3134 strcpy (name
, section_name
);
3136 *input_line_pointer
= c
;
3141 flags
= SEC_NO_FLAGS
;
3143 if (*input_line_pointer
== ',')
3145 ++input_line_pointer
;
3147 if (*input_line_pointer
!= '"')
3148 exp
= get_absolute_expression ();
3151 ++input_line_pointer
;
3152 while (*input_line_pointer
!= '"'
3153 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
3155 switch (*input_line_pointer
)
3157 /* Section Contents */
3158 case 'a': /* unknown */
3159 as_warn ("Unsupported section attribute -- 'a'");
3161 case 'c': /* code section */
3164 case 'd': /* section has initialized data */
3167 case 'u': /* section has uninitialized data */
3168 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
3172 case 'i': /* section contains directives (info) */
3173 /* FIXME: This is IMAGE_SCN_LNK_INFO
3175 flags
|= SEC_HAS_CONTENTS
;
3177 case 'n': /* section can be discarded */
3180 case 'R': /* Remove section at link time */
3181 flags
|= SEC_NEVER_LOAD
;
3184 /* Section Protection */
3185 case 'r': /* section is readable */
3186 flags
|= IMAGE_SCN_MEM_READ
;
3188 case 'w': /* section is writeable */
3189 flags
|= IMAGE_SCN_MEM_WRITE
;
3191 case 'x': /* section is executable */
3192 flags
|= IMAGE_SCN_MEM_EXECUTE
;
3194 case 's': /* section is sharable */
3195 flags
|= IMAGE_SCN_MEM_SHARED
;
3198 /* Section Alignment */
3199 case '0': /* align to byte boundary */
3200 flags
|= IMAGE_SCN_ALIGN_1BYTES
;
3203 case '1': /* align to halfword boundary */
3204 flags
|= IMAGE_SCN_ALIGN_2BYTES
;
3207 case '2': /* align to word boundary */
3208 flags
|= IMAGE_SCN_ALIGN_4BYTES
;
3211 case '3': /* align to doubleword boundary */
3212 flags
|= IMAGE_SCN_ALIGN_8BYTES
;
3215 case '4': /* align to quadword boundary */
3216 flags
|= IMAGE_SCN_ALIGN_16BYTES
;
3219 case '5': /* align to 32 byte boundary */
3220 flags
|= IMAGE_SCN_ALIGN_32BYTES
;
3223 case '6': /* align to 64 byte boundary */
3224 flags
|= IMAGE_SCN_ALIGN_64BYTES
;
3229 as_warn("unknown section attribute '%c'",
3230 *input_line_pointer
);
3233 ++input_line_pointer
;
3235 if (*input_line_pointer
== '"')
3236 ++input_line_pointer
;
3240 sec
= subseg_new (name
, (subsegT
) exp
);
3242 ppc_set_current_section(sec
);
3244 if (flags
!= SEC_NO_FLAGS
)
3246 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
3247 as_warn ("error setting flags for \"%s\": %s",
3248 bfd_section_name (stdoutput
, sec
),
3249 bfd_errmsg (bfd_get_error ()));
3252 bfd_set_section_alignment(stdoutput
, sec
, align
);
3257 ppc_pe_function (ignore
)
3264 name
= input_line_pointer
;
3265 endc
= get_symbol_end ();
3267 ext_sym
= symbol_find_or_make (name
);
3269 *input_line_pointer
= endc
;
3271 S_SET_DATA_TYPE (ext_sym
, DT_FCN
<< N_BTSHFT
);
3272 SF_SET_FUNCTION (ext_sym
);
3273 SF_SET_PROCESS (ext_sym
);
3274 coff_add_linesym (ext_sym
);
3276 demand_empty_rest_of_line ();
3280 ppc_pe_tocd (ignore
)
3283 if (tocdata_section
== 0)
3285 tocdata_section
= subseg_new (".tocd", 0);
3286 /* FIXME: section flags won't work */
3287 bfd_set_section_flags (stdoutput
, tocdata_section
,
3288 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
3289 | SEC_READONLY
| SEC_DATA
));
3291 bfd_set_section_alignment (stdoutput
, tocdata_section
, 2);
3295 rdata_section
= subseg_new (".tocd", 0);
3298 ppc_set_current_section(tocdata_section
);
3300 demand_empty_rest_of_line ();
3303 /* Don't adjust TOC relocs to use the section symbol. */
3306 ppc_pe_fix_adjustable (fix
)
3309 return fix
->fx_r_type
!= BFD_RELOC_PPC_TOC16
;
3316 /* XCOFF specific symbol and file handling. */
3318 /* Canonicalize the symbol name. We use the to force the suffix, if
3319 any, to use square brackets, and to be in upper case. */
3322 ppc_canonicalize_symbol_name (name
)
3327 if (ppc_stab_symbol
)
3330 for (s
= name
; *s
!= '\0' && *s
!= '{' && *s
!= '['; s
++)
3344 for (s
++; *s
!= '\0' && *s
!= brac
; s
++)
3348 if (*s
== '\0' || s
[1] != '\0')
3349 as_bad ("bad symbol suffix");
3357 /* Set the class of a symbol based on the suffix, if any. This is
3358 called whenever a new symbol is created. */
3361 ppc_symbol_new_hook (sym
)
3366 sym
->sy_tc
.next
= NULL
;
3367 sym
->sy_tc
.output
= 0;
3368 sym
->sy_tc
.class = -1;
3369 sym
->sy_tc
.real_name
= NULL
;
3370 sym
->sy_tc
.subseg
= 0;
3371 sym
->sy_tc
.align
= 0;
3372 sym
->sy_tc
.size
= NULL
;
3373 sym
->sy_tc
.within
= NULL
;
3375 if (ppc_stab_symbol
)
3378 s
= strchr (S_GET_NAME (sym
), '[');
3379 if (s
== (const char *) NULL
)
3381 /* There is no suffix. */
3390 if (strcmp (s
, "BS]") == 0)
3391 sym
->sy_tc
.class = XMC_BS
;
3394 if (strcmp (s
, "DB]") == 0)
3395 sym
->sy_tc
.class = XMC_DB
;
3396 else if (strcmp (s
, "DS]") == 0)
3397 sym
->sy_tc
.class = XMC_DS
;
3400 if (strcmp (s
, "GL]") == 0)
3401 sym
->sy_tc
.class = XMC_GL
;
3404 if (strcmp (s
, "PR]") == 0)
3405 sym
->sy_tc
.class = XMC_PR
;
3408 if (strcmp (s
, "RO]") == 0)
3409 sym
->sy_tc
.class = XMC_RO
;
3410 else if (strcmp (s
, "RW]") == 0)
3411 sym
->sy_tc
.class = XMC_RW
;
3414 if (strcmp (s
, "SV]") == 0)
3415 sym
->sy_tc
.class = XMC_SV
;
3418 if (strcmp (s
, "TC]") == 0)
3419 sym
->sy_tc
.class = XMC_TC
;
3420 else if (strcmp (s
, "TI]") == 0)
3421 sym
->sy_tc
.class = XMC_TI
;
3422 else if (strcmp (s
, "TB]") == 0)
3423 sym
->sy_tc
.class = XMC_TB
;
3424 else if (strcmp (s
, "TC0]") == 0 || strcmp (s
, "T0]") == 0)
3425 sym
->sy_tc
.class = XMC_TC0
;
3428 if (strcmp (s
, "UA]") == 0)
3429 sym
->sy_tc
.class = XMC_UA
;
3430 else if (strcmp (s
, "UC]") == 0)
3431 sym
->sy_tc
.class = XMC_UC
;
3434 if (strcmp (s
, "XO]") == 0)
3435 sym
->sy_tc
.class = XMC_XO
;
3439 if (sym
->sy_tc
.class == -1)
3440 as_bad ("Unrecognized symbol suffix");
3443 /* Set the class of a label based on where it is defined. This
3444 handles symbols without suffixes. Also, move the symbol so that it
3445 follows the csect symbol. */
3448 ppc_frob_label (sym
)
3451 if (ppc_current_csect
!= (symbolS
*) NULL
)
3453 if (sym
->sy_tc
.class == -1)
3454 sym
->sy_tc
.class = ppc_current_csect
->sy_tc
.class;
3456 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3457 symbol_append (sym
, ppc_current_csect
->sy_tc
.within
, &symbol_rootP
,
3459 ppc_current_csect
->sy_tc
.within
= sym
;
3463 /* This variable is set by ppc_frob_symbol if any absolute symbols are
3464 seen. It tells ppc_adjust_symtab whether it needs to look through
3467 static boolean ppc_saw_abs
;
3469 /* Change the name of a symbol just before writing it out. Set the
3470 real name if the .rename pseudo-op was used. Otherwise, remove any
3471 class suffix. Return 1 if the symbol should not be included in the
3475 ppc_frob_symbol (sym
)
3478 static symbolS
*ppc_last_function
;
3479 static symbolS
*set_end
;
3481 /* Discard symbols that should not be included in the output symbol
3483 if (! sym
->sy_used_in_reloc
3484 && ((sym
->bsym
->flags
& BSF_SECTION_SYM
) != 0
3485 || (! S_IS_EXTERNAL (sym
)
3486 && ! sym
->sy_tc
.output
3487 && S_GET_STORAGE_CLASS (sym
) != C_FILE
)))
3490 if (sym
->sy_tc
.real_name
!= (char *) NULL
)
3491 S_SET_NAME (sym
, sym
->sy_tc
.real_name
);
3497 name
= S_GET_NAME (sym
);
3498 s
= strchr (name
, '[');
3499 if (s
!= (char *) NULL
)
3505 snew
= xmalloc (len
+ 1);
3506 memcpy (snew
, name
, len
);
3509 S_SET_NAME (sym
, snew
);
3513 if (set_end
!= (symbolS
*) NULL
)
3515 SA_SET_SYM_ENDNDX (set_end
, sym
);
3519 if (SF_GET_FUNCTION (sym
))
3521 if (ppc_last_function
!= (symbolS
*) NULL
)
3522 as_warn ("two .function pseudo-ops with no intervening .ef");
3523 ppc_last_function
= sym
;
3524 if (sym
->sy_tc
.size
!= (symbolS
*) NULL
)
3526 resolve_symbol_value (sym
->sy_tc
.size
);
3527 SA_SET_SYM_FSIZE (sym
, (long) S_GET_VALUE (sym
->sy_tc
.size
));
3530 else if (S_GET_STORAGE_CLASS (sym
) == C_FCN
3531 && strcmp (S_GET_NAME (sym
), ".ef") == 0)
3533 if (ppc_last_function
== (symbolS
*) NULL
)
3534 as_warn (".ef with no preceding .function");
3537 set_end
= ppc_last_function
;
3538 ppc_last_function
= NULL
;
3540 /* We don't have a C_EFCN symbol, but we need to force the
3541 COFF backend to believe that it has seen one. */
3542 coff_last_function
= NULL
;
3546 if (! S_IS_EXTERNAL (sym
)
3547 && (sym
->bsym
->flags
& BSF_SECTION_SYM
) == 0
3548 && S_GET_STORAGE_CLASS (sym
) != C_FILE
3549 && S_GET_STORAGE_CLASS (sym
) != C_FCN
3550 && S_GET_STORAGE_CLASS (sym
) != C_BSTAT
3551 && S_GET_STORAGE_CLASS (sym
) != C_ESTAT
3552 && S_GET_STORAGE_CLASS (sym
) != C_BINCL
3553 && S_GET_STORAGE_CLASS (sym
) != C_EINCL
3554 && S_GET_SEGMENT (sym
) != ppc_coff_debug_section
)
3555 S_SET_STORAGE_CLASS (sym
, C_HIDEXT
);
3557 if (S_GET_STORAGE_CLASS (sym
) == C_EXT
3558 || S_GET_STORAGE_CLASS (sym
) == C_HIDEXT
)
3561 union internal_auxent
*a
;
3563 /* Create a csect aux. */
3564 i
= S_GET_NUMBER_AUXILIARY (sym
);
3565 S_SET_NUMBER_AUXILIARY (sym
, i
+ 1);
3566 a
= &coffsymbol (sym
->bsym
)->native
[i
+ 1].u
.auxent
;
3567 if (sym
->sy_tc
.class == XMC_TC0
)
3569 /* This is the TOC table. */
3570 know (strcmp (S_GET_NAME (sym
), "TOC") == 0);
3571 a
->x_csect
.x_scnlen
.l
= 0;
3572 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
3574 else if (sym
->sy_tc
.subseg
!= 0)
3576 /* This is a csect symbol. x_scnlen is the size of the
3578 if (sym
->sy_tc
.next
== (symbolS
*) NULL
)
3579 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
3580 S_GET_SEGMENT (sym
))
3581 - S_GET_VALUE (sym
));
3584 resolve_symbol_value (sym
->sy_tc
.next
);
3585 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (sym
->sy_tc
.next
)
3586 - S_GET_VALUE (sym
));
3588 a
->x_csect
.x_smtyp
= (sym
->sy_tc
.align
<< 3) | XTY_SD
;
3590 else if (S_GET_SEGMENT (sym
) == bss_section
)
3592 /* This is a common symbol. */
3593 a
->x_csect
.x_scnlen
.l
= sym
->sy_frag
->fr_offset
;
3594 a
->x_csect
.x_smtyp
= (sym
->sy_tc
.align
<< 3) | XTY_CM
;
3595 if (S_IS_EXTERNAL (sym
))
3596 sym
->sy_tc
.class = XMC_RW
;
3598 sym
->sy_tc
.class = XMC_BS
;
3600 else if (S_GET_SEGMENT (sym
) == absolute_section
)
3602 /* This is an absolute symbol. The csect will be created by
3603 ppc_adjust_symtab. */
3605 a
->x_csect
.x_smtyp
= XTY_LD
;
3606 if (sym
->sy_tc
.class == -1)
3607 sym
->sy_tc
.class = XMC_XO
;
3609 else if (! S_IS_DEFINED (sym
))
3611 /* This is an external symbol. */
3612 a
->x_csect
.x_scnlen
.l
= 0;
3613 a
->x_csect
.x_smtyp
= XTY_ER
;
3615 else if (sym
->sy_tc
.class == XMC_TC
)
3619 /* This is a TOC definition. x_scnlen is the size of the
3621 next
= symbol_next (sym
);
3622 while (next
->sy_tc
.class == XMC_TC0
)
3623 next
= symbol_next (next
);
3624 if (next
== (symbolS
*) NULL
3625 || next
->sy_tc
.class != XMC_TC
)
3627 if (ppc_after_toc_frag
== (fragS
*) NULL
)
3628 a
->x_csect
.x_scnlen
.l
= (bfd_section_size (stdoutput
,
3630 - S_GET_VALUE (sym
));
3632 a
->x_csect
.x_scnlen
.l
= (ppc_after_toc_frag
->fr_address
3633 - S_GET_VALUE (sym
));
3637 resolve_symbol_value (next
);
3638 a
->x_csect
.x_scnlen
.l
= (S_GET_VALUE (next
)
3639 - S_GET_VALUE (sym
));
3641 a
->x_csect
.x_smtyp
= (2 << 3) | XTY_SD
;
3647 /* This is a normal symbol definition. x_scnlen is the
3648 symbol index of the containing csect. */
3649 if (S_GET_SEGMENT (sym
) == text_section
)
3650 csect
= ppc_text_csects
;
3651 else if (S_GET_SEGMENT (sym
) == data_section
)
3652 csect
= ppc_data_csects
;
3656 /* Skip the initial dummy symbol. */
3657 csect
= csect
->sy_tc
.next
;
3659 if (csect
== (symbolS
*) NULL
)
3661 as_warn ("warning: symbol %s has no csect", S_GET_NAME (sym
));
3662 a
->x_csect
.x_scnlen
.l
= 0;
3666 while (csect
->sy_tc
.next
!= (symbolS
*) NULL
)
3668 resolve_symbol_value (csect
->sy_tc
.next
);
3669 if (S_GET_VALUE (csect
->sy_tc
.next
) > S_GET_VALUE (sym
))
3671 csect
= csect
->sy_tc
.next
;
3674 a
->x_csect
.x_scnlen
.p
= coffsymbol (csect
->bsym
)->native
;
3675 coffsymbol (sym
->bsym
)->native
[i
+ 1].fix_scnlen
= 1;
3677 a
->x_csect
.x_smtyp
= XTY_LD
;
3680 a
->x_csect
.x_parmhash
= 0;
3681 a
->x_csect
.x_snhash
= 0;
3682 if (sym
->sy_tc
.class == -1)
3683 a
->x_csect
.x_smclas
= XMC_PR
;
3685 a
->x_csect
.x_smclas
= sym
->sy_tc
.class;
3686 a
->x_csect
.x_stab
= 0;
3687 a
->x_csect
.x_snstab
= 0;
3689 else if (S_GET_STORAGE_CLASS (sym
) == C_BSTAT
)
3691 /* We want the value to be the symbol index of the referenced
3692 csect symbol. BFD will do that for us if we set the right
3695 (valueT
) coffsymbol (sym
->sy_tc
.within
->bsym
)->native
);
3696 coffsymbol (sym
->bsym
)->native
->fix_value
= 1;
3698 else if (S_GET_STORAGE_CLASS (sym
) == C_STSYM
)
3703 /* The value is the offset from the enclosing csect. */
3704 block
= sym
->sy_tc
.within
;
3705 csect
= block
->sy_tc
.within
;
3706 resolve_symbol_value (csect
);
3707 S_SET_VALUE (sym
, S_GET_VALUE (sym
) - S_GET_VALUE (csect
));
3709 else if (S_GET_STORAGE_CLASS (sym
) == C_BINCL
3710 || S_GET_STORAGE_CLASS (sym
) == C_EINCL
)
3712 /* We want the value to be a file offset into the line numbers.
3713 BFD will do that for us if we set the right flags. We have
3714 already set the value correctly. */
3715 coffsymbol (sym
->bsym
)->native
->fix_line
= 1;
3721 /* Adjust the symbol table. This creates csect symbols for all
3722 absolute symbols. */
3725 ppc_adjust_symtab ()
3732 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
3736 union internal_auxent
*a
;
3738 if (S_GET_SEGMENT (sym
) != absolute_section
)
3741 csect
= symbol_create (".abs[XO]", absolute_section
,
3742 S_GET_VALUE (sym
), &zero_address_frag
);
3743 csect
->bsym
->value
= S_GET_VALUE (sym
);
3744 S_SET_STORAGE_CLASS (csect
, C_HIDEXT
);
3745 i
= S_GET_NUMBER_AUXILIARY (csect
);
3746 S_SET_NUMBER_AUXILIARY (csect
, i
+ 1);
3747 a
= &coffsymbol (csect
->bsym
)->native
[i
+ 1].u
.auxent
;
3748 a
->x_csect
.x_scnlen
.l
= 0;
3749 a
->x_csect
.x_smtyp
= XTY_SD
;
3750 a
->x_csect
.x_parmhash
= 0;
3751 a
->x_csect
.x_snhash
= 0;
3752 a
->x_csect
.x_smclas
= XMC_XO
;
3753 a
->x_csect
.x_stab
= 0;
3754 a
->x_csect
.x_snstab
= 0;
3756 symbol_insert (csect
, sym
, &symbol_rootP
, &symbol_lastP
);
3758 i
= S_GET_NUMBER_AUXILIARY (sym
);
3759 a
= &coffsymbol (sym
->bsym
)->native
[i
].u
.auxent
;
3760 a
->x_csect
.x_scnlen
.p
= coffsymbol (csect
->bsym
)->native
;
3761 coffsymbol (sym
->bsym
)->native
[i
].fix_scnlen
= 1;
3764 ppc_saw_abs
= false;
3767 /* Set the VMA for a section. This is called on all the sections in
3771 ppc_frob_section (sec
)
3774 static bfd_size_type vma
= 0;
3776 bfd_set_section_vma (stdoutput
, sec
, vma
);
3777 vma
+= bfd_section_size (stdoutput
, sec
);
3780 /* Adjust the file by adding a .debug section if needed. */
3785 if (ppc_debug_name_section_size
> 0)
3789 sec
= bfd_make_section (stdoutput
, ".debug");
3790 if (sec
== (asection
*) NULL
3791 || ! bfd_set_section_size (stdoutput
, sec
,
3792 ppc_debug_name_section_size
)
3793 || ! bfd_set_section_flags (stdoutput
, sec
,
3794 SEC_HAS_CONTENTS
| SEC_LOAD
))
3795 as_fatal ("can't make .debug section");
3799 #endif /* OBJ_XCOFF */
3801 /* Turn a string in input_line_pointer into a floating point constant
3802 of type type, and store the appropriate bytes in *litp. The number
3803 of LITTLENUMS emitted is stored in *sizep . An error message is
3804 returned, or NULL on OK. */
3807 md_atof (type
, litp
, sizep
)
3813 LITTLENUM_TYPE words
[4];
3829 return "bad call to md_atof";
3832 t
= atof_ieee (input_line_pointer
, type
, words
);
3834 input_line_pointer
= t
;
3838 if (target_big_endian
)
3840 for (i
= 0; i
< prec
; i
++)
3842 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
3848 for (i
= prec
- 1; i
>= 0; i
--)
3850 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
3858 /* Write a value out to the object file, using the appropriate
3862 md_number_to_chars (buf
, val
, n
)
3867 if (target_big_endian
)
3868 number_to_chars_bigendian (buf
, val
, n
);
3870 number_to_chars_littleendian (buf
, val
, n
);
3873 /* Align a section (I don't know why this is machine dependent). */
3876 md_section_align (seg
, addr
)
3880 int align
= bfd_get_section_alignment (stdoutput
, seg
);
3882 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
3885 /* We don't have any form of relaxing. */
3888 md_estimate_size_before_relax (fragp
, seg
)
3896 /* Convert a machine dependent frag. We never generate these. */
3899 md_convert_frag (abfd
, sec
, fragp
)
3907 /* We have no need to default values of symbols. */
3911 md_undefined_symbol (name
)
3917 /* Functions concerning relocs. */
3919 /* The location from which a PC relative jump should be calculated,
3920 given a PC relative reloc. */
3923 md_pcrel_from_section (fixp
, sec
)
3928 if (fixp
->fx_addsy
!= (symbolS
*) NULL
3929 && (! S_IS_DEFINED (fixp
->fx_addsy
)
3930 || TC_FORCE_RELOCATION_SECTION (fixp
, sec
)))
3934 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3939 /* This is called to see whether a fixup should be adjusted to use a
3940 section symbol. We take the opportunity to change a fixup against
3941 a symbol in the TOC subsegment into a reloc against the
3942 corresponding .tc symbol. */
3945 ppc_fix_adjustable (fix
)
3950 resolve_symbol_value (fix
->fx_addsy
);
3951 val
= S_GET_VALUE (fix
->fx_addsy
);
3952 if (ppc_toc_csect
!= (symbolS
*) NULL
3953 && fix
->fx_addsy
!= (symbolS
*) NULL
3954 && fix
->fx_addsy
!= ppc_toc_csect
3955 && S_GET_SEGMENT (fix
->fx_addsy
) == data_section
3956 && val
>= ppc_toc_frag
->fr_address
3957 && (ppc_after_toc_frag
== (fragS
*) NULL
3958 || val
< ppc_after_toc_frag
->fr_address
))
3962 for (sy
= symbol_next (ppc_toc_csect
);
3963 sy
!= (symbolS
*) NULL
;
3964 sy
= symbol_next (sy
))
3966 if (sy
->sy_tc
.class == XMC_TC0
)
3968 if (sy
->sy_tc
.class != XMC_TC
)
3970 resolve_symbol_value (sy
);
3971 if (val
== S_GET_VALUE (sy
))
3974 fix
->fx_addnumber
= val
- ppc_toc_frag
->fr_address
;
3979 as_bad_where (fix
->fx_file
, fix
->fx_line
,
3980 "symbol in .toc does not match any .tc");
3983 /* Possibly adjust the reloc to be against the csect. */
3984 if (fix
->fx_addsy
!= (symbolS
*) NULL
3985 && fix
->fx_addsy
->sy_tc
.subseg
== 0
3986 && fix
->fx_addsy
->sy_tc
.class != XMC_TC0
3987 && fix
->fx_addsy
->sy_tc
.class != XMC_TC
3988 && S_GET_SEGMENT (fix
->fx_addsy
) != bss_section
)
3992 if (S_GET_SEGMENT (fix
->fx_addsy
) == text_section
)
3993 csect
= ppc_text_csects
;
3994 else if (S_GET_SEGMENT (fix
->fx_addsy
) == data_section
)
3995 csect
= ppc_data_csects
;
3999 /* Skip the initial dummy symbol. */
4000 csect
= csect
->sy_tc
.next
;
4002 if (csect
!= (symbolS
*) NULL
)
4004 while (csect
->sy_tc
.next
!= (symbolS
*) NULL
4005 && (csect
->sy_tc
.next
->sy_frag
->fr_address
4006 <= fix
->fx_addsy
->sy_frag
->fr_address
))
4007 csect
= csect
->sy_tc
.next
;
4009 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
4010 - csect
->sy_frag
->fr_address
);
4011 fix
->fx_addsy
= csect
;
4015 /* Adjust a reloc against a .lcomm symbol to be against the base
4017 if (fix
->fx_addsy
!= (symbolS
*) NULL
4018 && S_GET_SEGMENT (fix
->fx_addsy
) == bss_section
4019 && ! S_IS_EXTERNAL (fix
->fx_addsy
))
4021 resolve_symbol_value (fix
->fx_addsy
->sy_frag
->fr_symbol
);
4022 fix
->fx_offset
+= (S_GET_VALUE (fix
->fx_addsy
)
4023 - S_GET_VALUE (fix
->fx_addsy
->sy_frag
->fr_symbol
));
4024 fix
->fx_addsy
= fix
->fx_addsy
->sy_frag
->fr_symbol
;
4032 /* See whether a symbol is in the TOC section. */
4035 ppc_is_toc_sym (sym
)
4039 return sym
->sy_tc
.class == XMC_TC
;
4041 return strcmp (segment_name (S_GET_SEGMENT (sym
)), ".got") == 0;
4045 /* Apply a fixup to the object code. This is called for all the
4046 fixups we generated by the call to fix_new_exp, above. In the call
4047 above we used a reloc code which was the largest legal reloc code
4048 plus the operand index. Here we undo that to recover the operand
4049 index. At this point all symbol values should be fully resolved,
4050 and we attempt to completely resolve the reloc. If we can not do
4051 that, we determine the correct reloc code and put it back in the
4055 md_apply_fix3 (fixp
, valuep
, seg
)
4062 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
4063 the symbol values. Since we are using BFD_ASSEMBLER, if we are
4064 doing this relocation the code in write.c is going to call
4065 bfd_perform_relocation, which is also going to use the symbol
4066 value. That means that if the reloc is fully resolved we want to
4067 use *valuep since bfd_perform_relocation is not being used.
4068 However, if the reloc is not fully resolved we do not want to use
4069 *valuep, and must use fx_offset instead. However, if the reloc
4070 is PC relative, we do want to use *valuep since it includes the
4071 result of md_pcrel_from. This is confusing. */
4073 if (fixp
->fx_addsy
== (symbolS
*) NULL
)
4078 else if (fixp
->fx_pcrel
)
4082 value
= fixp
->fx_offset
;
4083 if (fixp
->fx_subsy
!= (symbolS
*) NULL
)
4085 if (S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
4086 value
-= S_GET_VALUE (fixp
->fx_subsy
);
4089 /* We can't actually support subtracting a symbol. */
4090 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4091 "expression too complex");
4096 if ((int) fixp
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
4099 const struct powerpc_operand
*operand
;
4103 opindex
= (int) fixp
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
4105 operand
= &powerpc_operands
[opindex
];
4108 /* It appears that an instruction like
4110 when LC..1 is not a TOC symbol does not generate a reloc. It
4111 uses the offset of LC..1 within its csect. However, .long
4112 LC..1 will generate a reloc. I can't find any documentation
4113 on how these cases are to be distinguished, so this is a wild
4114 guess. These cases are generated by gcc -mminimal-toc. */
4115 if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
4116 && operand
->bits
== 16
4117 && operand
->shift
== 0
4118 && operand
->insert
== NULL
4119 && fixp
->fx_addsy
!= NULL
4120 && fixp
->fx_addsy
->sy_tc
.subseg
!= 0
4121 && fixp
->fx_addsy
->sy_tc
.class != XMC_TC
4122 && fixp
->fx_addsy
->sy_tc
.class != XMC_TC0
4123 && S_GET_SEGMENT (fixp
->fx_addsy
) != bss_section
)
4125 value
= fixp
->fx_offset
;
4130 /* Fetch the instruction, insert the fully resolved operand
4131 value, and stuff the instruction back again. */
4132 where
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
4133 if (target_big_endian
)
4134 insn
= bfd_getb32 ((unsigned char *) where
);
4136 insn
= bfd_getl32 ((unsigned char *) where
);
4137 insn
= ppc_insert_operand (insn
, operand
, (offsetT
) value
,
4138 fixp
->fx_file
, fixp
->fx_line
);
4139 if (target_big_endian
)
4140 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
4142 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
4146 /* Nothing else to do here. */
4150 /* Determine a BFD reloc value based on the operand information.
4151 We are only prepared to turn a few of the operands into
4153 FIXME: We need to handle the DS field at the very least.
4154 FIXME: Selecting the reloc type is a bit haphazard; perhaps
4155 there should be a new field in the operand table. */
4156 if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
4157 && operand
->bits
== 26
4158 && operand
->shift
== 0)
4159 fixp
->fx_r_type
= BFD_RELOC_PPC_B26
;
4160 else if ((operand
->flags
& PPC_OPERAND_RELATIVE
) != 0
4161 && operand
->bits
== 16
4162 && operand
->shift
== 0)
4163 fixp
->fx_r_type
= BFD_RELOC_PPC_B16
;
4164 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
4165 && operand
->bits
== 26
4166 && operand
->shift
== 0)
4167 fixp
->fx_r_type
= BFD_RELOC_PPC_BA26
;
4168 else if ((operand
->flags
& PPC_OPERAND_ABSOLUTE
) != 0
4169 && operand
->bits
== 16
4170 && operand
->shift
== 0)
4171 fixp
->fx_r_type
= BFD_RELOC_PPC_BA16
;
4172 else if ((operand
->flags
& PPC_OPERAND_PARENS
) != 0
4173 && operand
->bits
== 16
4174 && operand
->shift
== 0
4175 && operand
->insert
== NULL
4176 && fixp
->fx_addsy
!= NULL
4177 && ppc_is_toc_sym (fixp
->fx_addsy
))
4180 if (target_big_endian
)
4181 fixp
->fx_where
+= 2;
4182 fixp
->fx_r_type
= BFD_RELOC_PPC_TOC16
;
4186 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4187 "unresolved expression that must be resolved");
4195 ppc_elf_validate_fix (fixp
, seg
);
4197 switch (fixp
->fx_r_type
)
4200 case BFD_RELOC_CTOR
:
4203 fixp
->fx_r_type
= BFD_RELOC_32_PCREL
;
4204 value
+= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4205 } /* fall through */
4207 case BFD_RELOC_32_PCREL
:
4208 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4212 case BFD_RELOC_LO16
:
4213 case BFD_RELOC_HI16
:
4214 case BFD_RELOC_HI16_S
:
4215 case BFD_RELOC_PPC_TOC16
:
4217 case BFD_RELOC_GPREL16
:
4218 case BFD_RELOC_16_GOT_PCREL
:
4222 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4230 md_number_to_chars (fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
,
4240 fixp
->fx_addnumber
= value
;
4242 if (fixp
->fx_r_type
!= BFD_RELOC_PPC_TOC16
)
4243 fixp
->fx_addnumber
= 0;
4247 fixp
->fx_addnumber
= 0;
4249 /* We want to use the offset within the data segment of the
4250 symbol, not the actual VMA of the symbol. */
4251 fixp
->fx_addnumber
=
4252 - bfd_get_section_vma (stdoutput
, S_GET_SEGMENT (fixp
->fx_addsy
));
4260 /* Generate a reloc for a fixup. */
4263 tc_gen_reloc (seg
, fixp
)
4269 reloc
= (arelent
*) bfd_alloc_by_size_t (stdoutput
, sizeof (arelent
));
4271 reloc
->sym_ptr_ptr
= &fixp
->fx_addsy
->bsym
;
4272 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4273 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
4274 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
4276 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4277 "reloc %d not supported by object file format", (int)fixp
->fx_r_type
);
4280 reloc
->addend
= fixp
->fx_addnumber
;