1 /* tc-i370.c -- Assembler for the IBM 360/370/390 instruction set.
2 Loosely based on the ppc files by Linas Vepstas <linas@linas.org> 1998, 99
3 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2005 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
7 This file is part of GAS, the GNU Assembler.
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 /* This assembler implements a very hacked version of an elf-like thing
25 * that gcc emits (when gcc is suitably hacked). To make it behave more
26 * HLASM-like, try turning on the -M or --mri flag (as there are various
27 * similarities between HLASM and the MRI assemblers, such as section
28 * names, lack of leading . in pseudo-ops, DC and DS, etc ...
33 #include "safe-ctype.h"
35 #include "struc-symbol.h"
37 #include "opcode/i370.h"
43 /* This is the assembler for the System/390 Architecture */
45 /* Tell the main code what the endianness is. */
46 extern int target_big_endian
;
49 /* Generic assembler global variables which must be defined by all
53 /* This string holds the chars that always start a comment. If the
54 pre-processor is disabled, these aren't very useful. The macro
55 tc_comment_chars points to this. We use this, rather than the
56 usual comment_chars, so that we can switch for Solaris conventions. */
57 static const char i370_eabi_comment_chars
[] = "#";
59 const char *i370_comment_chars
= i370_eabi_comment_chars
;
61 const char comment_chars
[] = "#";
64 /* Characters which start a comment at the beginning of a line. */
65 const char line_comment_chars
[] = "#*";
67 /* Characters which may be used to separate multiple commands on a
69 const char line_separator_chars
[] = ";";
71 /* Characters which are used to indicate an exponent in a floating
73 const char EXP_CHARS
[] = "eE";
75 /* Characters which mean that a number is a floating point constant,
77 const char FLT_CHARS
[] = "dD";
80 md_show_usage (stream
)
84 S/370 options: (these have not yet been tested and may not work) \n\
86 -mregnames Allow symbolic names for registers\n\
87 -mno-regnames Do not allow symbolic names for registers\n");
90 -mrelocatable support for GCC's -mrelocatble option\n\
91 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
92 -V print assembler version number\n");
97 static void i370_byte
PARAMS ((int));
98 static void i370_tc
PARAMS ((int));
99 static void i370_ebcdic
PARAMS ((int));
101 static void i370_dc
PARAMS ((int));
102 static void i370_ds
PARAMS ((int));
103 static void i370_rmode
PARAMS ((int));
104 static void i370_csect
PARAMS ((int));
105 static void i370_dsect
PARAMS ((int));
106 static void i370_ltorg
PARAMS ((int));
107 static void i370_using
PARAMS ((int));
108 static void i370_drop
PARAMS ((int));
109 static void i370_make_relative
PARAMS ((expressionS
*exp
, expressionS
*baseaddr
));
112 static bfd_reloc_code_real_type i370_elf_suffix
PARAMS ((char **, expressionS
*));
113 static void i370_elf_cons
PARAMS ((int));
114 static void i370_elf_rdata
PARAMS ((int));
115 static void i370_elf_lcomm
PARAMS ((int));
116 static void i370_elf_validate_fix
PARAMS ((fixS
*, segT
));
120 /* The target specific pseudo-ops which we support. */
122 const pseudo_typeS md_pseudo_table
[] =
124 /* Pseudo-ops which must be overridden. */
125 { "byte", i370_byte
, 0 },
127 { "dc", i370_dc
, 0 },
128 { "ds", i370_ds
, 0 },
129 { "rmode", i370_rmode
, 0 },
130 { "csect", i370_csect
, 0 },
131 { "dsect", i370_dsect
, 0 },
133 /* enable ebcdic strings e.g. for 3270 support */
134 { "ebcdic", i370_ebcdic
, 0 },
137 { "long", i370_elf_cons
, 4 },
138 { "word", i370_elf_cons
, 4 },
139 { "short", i370_elf_cons
, 2 },
140 { "rdata", i370_elf_rdata
, 0 },
141 { "rodata", i370_elf_rdata
, 0 },
142 { "lcomm", i370_elf_lcomm
, 0 },
145 /* This pseudo-op is used even when not generating XCOFF output. */
146 { "tc", i370_tc
, 0 },
148 /* dump the literal pool */
149 { "ltorg", i370_ltorg
, 0 },
151 /* support the hlasm-style USING directive */
152 { "using", i370_using
, 0 },
153 { "drop", i370_drop
, 0 },
158 /* ***************************************************************** */
160 /* Whether to use user friendly register names. */
161 #define TARGET_REG_NAMES_P TRUE
163 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
165 static bfd_boolean register_name
PARAMS ((expressionS
*));
166 static void i370_set_cpu
PARAMS ((void));
167 static i370_insn_t i370_insert_operand
168 PARAMS ((i370_insn_t insn
, const struct i370_operand
*operand
, offsetT val
));
169 static void i370_macro
PARAMS ((char *str
, const struct i370_macro
*macro
));
171 /* Predefined register names if -mregnames */
172 /* In general, there are lots of them, in an attempt to be compatible */
173 /* with a number of assemblers. */
175 /* Structure to hold information about predefined registers. */
182 /* List of registers that are pre-defined:
184 Each general register has predefined names of the form:
185 1. r<reg_num> which has the value <reg_num>.
186 2. r.<reg_num> which has the value <reg_num>.
188 Each floating point register has predefined names of the form:
189 1. f<reg_num> which has the value <reg_num>.
190 2. f.<reg_num> which has the value <reg_num>.
192 There are only four floating point registers, and these are
193 commonly labelled 0,2,4 and 6. Thus, there is no f1, f3, etc.
195 There are individual registers as well:
196 rbase or r.base has the value 3 (base register)
197 rpgt or r.pgt has the value 4 (page origin table pointer)
198 rarg or r.arg has the value 11 (argument pointer)
199 rtca or r.tca has the value 12 (table of contents pointer)
200 rtoc or r.toc has the value 12 (table of contents pointer)
201 sp or r.sp has the value 13 (stack pointer)
202 dsa or r.dsa has the value 13 (stack pointer)
203 lr has the value 14 (link reg)
205 The table is sorted. Suitable for searching by a binary search. */
207 static const struct pd_reg pre_defined_registers
[] =
209 { "arg", 11 }, /* Argument Pointer */
210 { "base", 3 }, /* Base Reg */
212 { "f.0", 0 }, /* Floating point registers */
222 { "dsa",13 }, /* stack pointer */
223 { "lr", 14 }, /* Link Register */
224 { "pgt", 4 }, /* Page Origin Table Pointer */
226 { "r.0", 0 }, /* General Purpose Registers */
243 { "r.arg", 11 }, /* Argument Pointer */
244 { "r.base", 3 }, /* Base Reg */
245 { "r.dsa", 13 }, /* Stack Pointer */
246 { "r.pgt", 4 }, /* Page Origin Table Pointer */
247 { "r.sp", 13 }, /* Stack Pointer */
249 { "r.tca", 12 }, /* Pointer to the table of contents */
250 { "r.toc", 12 }, /* Pointer to the table of contents */
252 { "r0", 0 }, /* More general purpose registers */
269 { "rbase", 3 }, /* Base Reg */
271 { "rtca", 12 }, /* Pointer to the table of contents */
272 { "rtoc", 12 }, /* Pointer to the table of contents */
274 { "sp", 13 }, /* Stack Pointer */
278 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
280 /* Given NAME, find the register number associated with that name, return
281 the integer value associated with the given name or -1 on failure. */
283 static int reg_name_search
284 PARAMS ((const struct pd_reg
*, int, const char * name
));
287 reg_name_search (regs
, regcount
, name
)
288 const struct pd_reg
*regs
;
292 int middle
, low
, high
;
300 middle
= (low
+ high
) / 2;
301 cmp
= strcasecmp (name
, regs
[middle
].name
);
307 return regs
[middle
].value
;
315 * Summary of register_name().
317 * in: Input_line_pointer points to 1st char of operand.
319 * out: An expressionS.
320 * The operand may have been a register: in this case, X_op == O_register,
321 * X_add_number is set to the register number, and truth is returned.
322 * Input_line_pointer->(next non-blank) char after operand, or is in its
327 register_name (expressionP
)
328 expressionS
*expressionP
;
335 /* Find the spelling of the operand. */
336 start
= name
= input_line_pointer
;
337 if (name
[0] == '%' && ISALPHA (name
[1]))
338 name
= ++input_line_pointer
;
340 else if (!reg_names_p
)
344 name
= ++input_line_pointer
;
346 /* If it's a number, treat it as a number. If it's alpha, look to
347 see if it's in the register table. */
348 if (!ISALPHA (name
[0]))
350 reg_number
= get_single_number ();
354 c
= get_symbol_end ();
355 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
357 /* Put back the delimiting char. */
358 *input_line_pointer
= c
;
361 /* If numeric, make sure its not out of bounds. */
362 if ((0 <= reg_number
) && (16 >= reg_number
))
364 expressionP
->X_op
= O_register
;
365 expressionP
->X_add_number
= reg_number
;
367 /* Make the rest nice. */
368 expressionP
->X_add_symbol
= NULL
;
369 expressionP
->X_op_symbol
= NULL
;
373 /* Reset the line as if we had not done anything. */
374 input_line_pointer
= start
;
378 /* Local variables. */
380 /* The type of processor we are assembling for. This is one or more
381 of the I370_OPCODE flags defined in opcode/i370.h. */
382 static int i370_cpu
= 0;
384 /* The base register to use for opcode with optional operands.
385 * We define two of these: "text" and "other". Normally, "text"
386 * would get used in the .text section for branches, while "other"
387 * gets used in the .data section for address constants.
389 * The idea of a second base register in a different section
390 * is foreign to the usual HLASM-style semantics; however, it
391 * allows us to provide support for dynamically loaded libraries,
392 * by allowing us to place address constants in a section other
393 * than the text section. The "other" section need not be the
394 * .data section, it can be any section that isn't the .text section.
396 * Note that HLASM defines a multiple, concurrent .using semantic
397 * that we do not: in calculating offsets, it uses either the most
398 * recent .using directive, or the one with the smallest displacement.
399 * This allows HLASM to support a quasi-block-scope-like behaviour.
400 * Handy for people writing assembly by hand ... but not supported
403 static int i370_using_text_regno
= -1;
404 static int i370_using_other_regno
= -1;
406 /* The base address for address literals */
407 static expressionS i370_using_text_baseaddr
;
408 static expressionS i370_using_other_baseaddr
;
410 /* the "other" section, used only for syntax error detection */
411 static segT i370_other_section
= undefined_section
;
413 /* Opcode hash table. */
414 static struct hash_control
*i370_hash
;
416 /* Macro hash table. */
417 static struct hash_control
*i370_macro_hash
;
420 /* What type of shared library support to use */
421 static enum { SHLIB_NONE
, SHLIB_PIC
, SHILB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
424 /* Flags to set in the elf header */
425 static flagword i370_flags
= 0;
427 #ifndef WORKING_DOT_WORD
428 int md_short_jump_size
= 4;
429 int md_long_jump_size
= 4;
433 const char *md_shortopts
= "l:um:K:VQ:";
435 const char *md_shortopts
= "um:";
437 struct option md_longopts
[] =
439 {NULL
, no_argument
, NULL
, 0}
441 size_t md_longopts_size
= sizeof (md_longopts
);
444 md_parse_option (c
, arg
)
451 /* -u means that any undefined symbols should be treated as
452 external, which is the default for gas anyhow. */
457 /* Recognize -K PIC */
458 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
461 i370_flags
|= EF_I370_RELOCATABLE_LIB
;
471 /* -m360 mean to assemble for the ancient 360 architecture */
472 if (strcmp (arg
, "360") == 0 || strcmp (arg
, "i360") == 0)
473 i370_cpu
= I370_OPCODE_360
;
474 /* -mxa means to assemble for the IBM 370 XA */
475 else if (strcmp (arg
, "xa") == 0)
476 i370_cpu
= I370_OPCODE_370_XA
;
477 /* -many means to assemble for any architecture (370/XA). */
478 else if (strcmp (arg
, "any") == 0)
479 i370_cpu
= I370_OPCODE_370
;
481 else if (strcmp (arg
, "regnames") == 0)
484 else if (strcmp (arg
, "no-regnames") == 0)
488 /* -mrelocatable/-mrelocatable-lib -- warn about initializations that require relocation */
489 else if (strcmp (arg
, "relocatable") == 0)
491 shlib
= SHILB_MRELOCATABLE
;
492 i370_flags
|= EF_I370_RELOCATABLE
;
495 else if (strcmp (arg
, "relocatable-lib") == 0)
497 shlib
= SHILB_MRELOCATABLE
;
498 i370_flags
|= EF_I370_RELOCATABLE_LIB
;
504 as_bad ("invalid switch -m%s", arg
);
510 /* -V: SVR4 argument to print version ID. */
515 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
516 should be emitted or not. FIXME: Not implemented. */
530 /* Set i370_cpu if it is not already set.
531 Currently defaults to the reasonable superset;
532 but can be made more fine grained if desred. */
537 const char *default_os
= TARGET_OS
;
538 const char *default_cpu
= TARGET_CPU
;
540 /* override with the superset for the moment. */
541 i370_cpu
= I370_OPCODE_ESA390_SUPERSET
;
544 if (strcmp (default_cpu
, "i360") == 0)
545 i370_cpu
= I370_OPCODE_360
;
546 else if (strcmp (default_cpu
, "i370") == 0)
547 i370_cpu
= I370_OPCODE_370
;
548 else if (strcmp (default_cpu
, "XA") == 0)
549 i370_cpu
= I370_OPCODE_370_XA
;
551 as_fatal ("Unknown default cpu = %s, os = %s", default_cpu
, default_os
);
555 /* Figure out the BFD architecture to use. */
556 /* hack alert -- specify the different 370 architectures */
558 enum bfd_architecture
561 return bfd_arch_i370
;
564 /* This function is called when the assembler starts up. It is called
565 after the options have been parsed and the output file has been
571 register const struct i370_opcode
*op
;
572 const struct i370_opcode
*op_end
;
573 const struct i370_macro
*macro
;
574 const struct i370_macro
*macro_end
;
575 bfd_boolean dup_insn
= FALSE
;
580 /* Set the ELF flags if desired. */
582 bfd_set_private_flags (stdoutput
, i370_flags
);
585 /* Insert the opcodes into a hash table. */
586 i370_hash
= hash_new ();
588 op_end
= i370_opcodes
+ i370_num_opcodes
;
589 for (op
= i370_opcodes
; op
< op_end
; op
++)
591 know ((op
->opcode
& op
->mask
) == op
->opcode
);
593 if ((op
->flags
& i370_cpu
) != 0)
597 retval
= hash_insert (i370_hash
, op
->name
, (PTR
) op
);
598 if (retval
!= (const char *) NULL
)
600 as_bad ("Internal assembler error for instruction %s", op
->name
);
606 /* Insert the macros into a hash table. */
607 i370_macro_hash
= hash_new ();
609 macro_end
= i370_macros
+ i370_num_macros
;
610 for (macro
= i370_macros
; macro
< macro_end
; macro
++)
612 if ((macro
->flags
& i370_cpu
) != 0)
616 retval
= hash_insert (i370_macro_hash
, macro
->name
, (PTR
) macro
);
617 if (retval
!= (const char *) NULL
)
619 as_bad ("Internal assembler error for macro %s", macro
->name
);
629 /* Insert an operand value into an instruction. */
632 i370_insert_operand (insn
, operand
, val
)
634 const struct i370_operand
*operand
;
641 /* used for 48-bit insn's */
643 insn
= (*operand
->insert
) (insn
, (long) val
, &errmsg
);
645 as_bad ("%s", errmsg
);
649 /* this is used only for 16, 32 bit insn's */
650 insn
.i
[0] |= (((long) val
& ((1 << operand
->bits
) - 1))
659 /* Parse @got, etc. and return the desired relocation.
660 Currently, i370 does not support (don't really need to support) any
661 of these fancier markups ... for example, no one is going to
662 write 'L 6,=V(bogus)@got' it just doesn't make sense (at least to me).
663 So basically, we could get away with this routine returning
664 BFD_RELOC_UNUSED in all circumstances. However, I'll leave
665 in for now in case someone ambitious finds a good use for this stuff ...
666 this routine was pretty much just copied from the powerpc code ... */
667 static bfd_reloc_code_real_type
668 i370_elf_suffix (str_p
, exp_p
)
676 bfd_reloc_code_real_type reloc
;
686 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
688 static struct map_bfd mapping
[] =
690 /* warnings with -mrelocatable. */
691 MAP ("fixup", BFD_RELOC_CTOR
),
692 { (char *)0, 0, BFD_RELOC_UNUSED
}
696 return BFD_RELOC_UNUSED
;
698 for (ch
= *str
, str2
= ident
;
699 (str2
< ident
+ sizeof (ident
) - 1
700 && (ISALNUM (ch
) || ch
== '@'));
703 *str2
++ = TOLOWER (ch
);
710 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
711 if (ch
== ptr
->string
[0]
712 && len
== ptr
->length
713 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
715 if (exp_p
->X_add_number
!= 0
716 && (ptr
->reloc
== BFD_RELOC_16_GOTOFF
717 || ptr
->reloc
== BFD_RELOC_LO16_GOTOFF
718 || ptr
->reloc
== BFD_RELOC_HI16_GOTOFF
719 || ptr
->reloc
== BFD_RELOC_HI16_S_GOTOFF
))
720 as_warn ("identifier+constant@got means identifier@got+constant");
722 /* Now check for identifier@suffix+constant */
723 if (*str
== '-' || *str
== '+')
725 char *orig_line
= input_line_pointer
;
728 input_line_pointer
= str
;
729 expression (&new_exp
);
730 if (new_exp
.X_op
== O_constant
)
732 exp_p
->X_add_number
+= new_exp
.X_add_number
;
733 str
= input_line_pointer
;
736 if (&input_line_pointer
!= str_p
)
737 input_line_pointer
= orig_line
;
744 return BFD_RELOC_UNUSED
;
747 /* Like normal .long/.short/.word, except support @got, etc. */
748 /* clobbers input_line_pointer, checks end-of-line. */
750 i370_elf_cons (nbytes
)
751 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
754 bfd_reloc_code_real_type reloc
;
756 if (is_it_end_of_statement ())
758 demand_empty_rest_of_line ();
765 if (exp
.X_op
== O_symbol
766 && *input_line_pointer
== '@'
767 && (reloc
= i370_elf_suffix (&input_line_pointer
, &exp
)) != BFD_RELOC_UNUSED
)
769 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
770 int size
= bfd_get_reloc_size (reloc_howto
);
773 as_bad ("%s relocations do not fit in %d bytes\n", reloc_howto
->name
, nbytes
);
777 register char *p
= frag_more ((int) nbytes
);
778 int offset
= nbytes
- size
;
780 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
, &exp
, 0, reloc
);
784 emit_expr (&exp
, (unsigned int) nbytes
);
786 while (*input_line_pointer
++ == ',');
788 input_line_pointer
--; /* Put terminator back into stream. */
789 demand_empty_rest_of_line ();
793 /* ASCII to EBCDIC conversion table. */
794 static unsigned char ascebc
[256] =
796 /*00 NL SH SX EX ET NQ AK BL */
797 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
798 /*08 BS HT LF VT FF CR SO SI */
799 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
800 /*10 DL D1 D2 D3 D4 NK SN EB */
801 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
802 /*18 CN EM SB EC FS GS RS US */
803 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
804 /*20 SP ! " # $ % & ' */
805 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
806 /*28 ( ) * + , - . / */
807 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
808 /*30 0 1 2 3 4 5 6 7 */
809 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
810 /*38 8 9 : ; < = > ? */
811 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
812 /*40 @ A B C D E F G */
813 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
814 /*48 H I J K L M N O */
815 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
816 /*50 P Q R S T U V W */
817 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
818 /*58 X Y Z [ \ ] ^ _ */
819 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D,
820 /*60 ` a b c d e f g */
821 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
822 /*68 h i j k l m n o */
823 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
824 /*70 p q r s t u v w */
825 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
826 /*78 x y z { | } ~ DL */
827 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07,
828 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
829 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
830 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
831 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
832 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
833 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
834 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
835 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
836 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
837 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
838 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
839 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
840 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
841 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
842 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
843 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0xFF
846 /* EBCDIC to ASCII conversion table. */
847 unsigned char ebcasc
[256] =
849 /*00 NU SH SX EX PF HT LC DL */
850 0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7F,
851 /*08 SM VT FF CR SO SI */
852 0x00, 0x00, 0x00, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
853 /*10 DE D1 D2 TM RS NL BS IL */
854 0x10, 0x11, 0x12, 0x13, 0x14, 0x0A, 0x08, 0x00,
855 /*18 CN EM CC C1 FS GS RS US */
856 0x18, 0x19, 0x00, 0x00, 0x1C, 0x1D, 0x1E, 0x1F,
857 /*20 DS SS FS BP LF EB EC */
858 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x17, 0x1B,
859 /*28 SM C2 EQ AK BL */
860 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, 0x00,
861 /*30 SY PN RS UC ET */
862 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
864 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1A,
866 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
868 0x00, 0x00, 0x00, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
870 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
872 0x00, 0x00, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
874 0x2D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
876 0x00, 0x00, 0x00, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
878 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
879 /*78 ` : # @ ' = " */
880 0x00, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
881 /*80 a b c d e f g */
882 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
884 0x68, 0x69, 0x00, 0x7B, 0x00, 0x00, 0x00, 0x00,
885 /*90 j k l m n o p */
886 0x00, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
888 0x71, 0x72, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00,
889 /*A0 ~ s t u v w x */
890 0x00, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
892 0x79, 0x7A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00,
894 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
896 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00,
897 /*C0 { A B C D E F G */
898 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
900 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
901 /*D0 } J K L M N O P */
902 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
904 0x51, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
905 /*E0 \ S T U V W X */
906 0x5C, 0x00, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
908 0x59, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
909 /*F0 0 1 2 3 4 5 6 7 */
910 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
912 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF
915 /* ebcdic translation tables needed for 3270 support */
918 int unused ATTRIBUTE_UNUSED
;
924 nbytes
= strlen (input_line_pointer
);
925 end
= input_line_pointer
+ nbytes
;
926 while ('\r' == *end
) end
--;
927 while ('\n' == *end
) end
--;
929 delim
= *input_line_pointer
;
930 if (('\'' == delim
) || ('\"' == delim
)) {
931 input_line_pointer
++;
932 end
= rindex (input_line_pointer
, delim
);
935 if (end
> input_line_pointer
)
937 nbytes
= end
- input_line_pointer
+1;
938 p
= frag_more (nbytes
);
939 while (end
> input_line_pointer
)
941 *p
= ascebc
[(unsigned char) (*input_line_pointer
)];
942 ++p
; ++input_line_pointer
;
946 if (delim
== *input_line_pointer
) ++input_line_pointer
;
950 /* stub out a couple of routines */
953 int unused ATTRIBUTE_UNUSED
;
955 as_tsktsk ("rmode ignored");
962 char *save_line
= input_line_pointer
;
963 static char section
[] = ".data\n";
965 /* Just pretend this is .section .data */
966 input_line_pointer
= section
;
967 obj_elf_section (sect
);
969 input_line_pointer
= save_line
;
974 int unused ATTRIBUTE_UNUSED
;
976 as_tsktsk ("csect not supported");
980 /* DC Define Const is only partially supported.
981 * For samplecode on what to do, look at i370_elf_cons() above.
982 * This code handles pseudoops of the style
983 * DC D'3.141592653' # in sysv4, .double 3.14159265
984 * DC F'1' # in sysv4, .long 1
988 int unused ATTRIBUTE_UNUSED
;
995 if (is_it_end_of_statement ())
997 demand_empty_rest_of_line ();
1001 /* figure out the size */
1002 type
= *input_line_pointer
++;
1005 case 'H': /* 16-bit */
1008 case 'E': /* 32-bit */
1009 case 'F': /* 32-bit */
1012 case 'D': /* 64-bit */
1016 as_bad ("unsupported DC type");
1020 /* get rid of pesky quotes */
1021 if ('\'' == *input_line_pointer
)
1024 ++input_line_pointer
;
1025 close
= strchr (input_line_pointer
, '\'');
1029 as_bad ("missing end-quote");
1031 if ('\"' == *input_line_pointer
)
1034 ++input_line_pointer
;
1035 close
= strchr (input_line_pointer
, '\"');
1039 as_bad ("missing end-quote");
1044 case 'H': /* 16-bit */
1045 case 'F': /* 32-bit */
1047 emit_expr (&exp
, nbytes
);
1049 case 'E': /* 32-bit */
1050 case 'D': /* 64-bit */
1051 md_atof (type
, tmp
, &nbytes
);
1052 p
= frag_more (nbytes
);
1053 memcpy (p
, tmp
, nbytes
);
1056 as_bad ("unsupported DC type");
1060 demand_empty_rest_of_line ();
1064 /* provide minimal support for DS Define Storage */
1067 int unused ATTRIBUTE_UNUSED
;
1069 /* DS 0H or DS 0F or DS 0D */
1070 if ('0' == *input_line_pointer
)
1072 int alignment
= 0; /* left shift 1<<align */
1073 input_line_pointer
++;
1074 switch (*input_line_pointer
++)
1076 case 'H': /* 16-bit */
1079 case 'F': /* 32-bit */
1082 case 'D': /* 64-bit */
1086 as_bad ("unsupported alignment");
1089 frag_align (alignment
, 0, 0);
1090 record_alignment (now_seg
, alignment
);
1094 as_bad ("this DS form not yet supported");
1098 /* Solaris pseudo op to change to the .rodata section. */
1100 i370_elf_rdata (sect
)
1103 char *save_line
= input_line_pointer
;
1104 static char section
[] = ".rodata\n";
1106 /* Just pretend this is .section .rodata */
1107 input_line_pointer
= section
;
1108 obj_elf_section (sect
);
1110 input_line_pointer
= save_line
;
1113 /* Pseudo op to make file scope bss items */
1115 i370_elf_lcomm (unused
)
1116 int unused ATTRIBUTE_UNUSED
;
1118 register char *name
;
1122 register symbolS
*symbolP
;
1129 name
= input_line_pointer
;
1130 c
= get_symbol_end ();
1132 /* just after name is now '\0' */
1133 p
= input_line_pointer
;
1136 if (*input_line_pointer
!= ',')
1138 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1139 ignore_rest_of_line ();
1143 input_line_pointer
++; /* skip ',' */
1144 if ((size
= get_absolute_expression ()) < 0)
1146 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) size
);
1147 ignore_rest_of_line ();
1151 /* The third argument to .lcomm is the alignment. */
1152 if (*input_line_pointer
!= ',')
1156 ++input_line_pointer
;
1157 align
= get_absolute_expression ();
1160 as_warn ("ignoring bad alignment");
1166 symbolP
= symbol_find_or_make (name
);
1169 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1171 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1172 S_GET_NAME (symbolP
));
1173 ignore_rest_of_line ();
1177 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1179 as_bad ("Length of .lcomm \"%s\" is already %ld. Not changed to %ld.",
1180 S_GET_NAME (symbolP
),
1181 (long) S_GET_VALUE (symbolP
),
1184 ignore_rest_of_line ();
1190 old_subsec
= now_subseg
;
1193 /* convert to a power of 2 alignment */
1194 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
)
1198 as_bad ("Common alignment not a power of 2");
1199 ignore_rest_of_line ();
1206 record_alignment (bss_section
, align2
);
1207 subseg_set (bss_section
, 0);
1209 frag_align (align2
, 0, 0);
1210 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1211 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1212 symbol_set_frag (symbolP
, frag_now
);
1213 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1216 S_SET_SIZE (symbolP
, size
);
1217 S_SET_SEGMENT (symbolP
, bss_section
);
1218 subseg_set (old_sec
, old_subsec
);
1219 demand_empty_rest_of_line ();
1222 /* Validate any relocations emitted for -mrelocatable, possibly adding
1223 fixups for word relocations in writable segments, so we can adjust
1226 i370_elf_validate_fix (fixp
, seg
)
1230 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1239 case SHILB_MRELOCATABLE
:
1240 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1241 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1242 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1243 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1244 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1245 && fixp
->fx_r_type
!= BFD_RELOC_32_BASEREL
1246 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1247 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1248 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1249 && strcmp (segment_name (seg
), ".got2") != 0
1250 && strcmp (segment_name (seg
), ".dtors") != 0
1251 && strcmp (segment_name (seg
), ".ctors") != 0
1252 && strcmp (segment_name (seg
), ".fixup") != 0
1253 && strcmp (segment_name (seg
), ".stab") != 0
1254 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1255 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1257 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1258 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1260 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1261 "Relocation cannot be done when using -mrelocatable");
1267 #endif /* OBJ_ELF */
1270 #define LITERAL_POOL_SUPPORT
1271 #ifdef LITERAL_POOL_SUPPORT
1272 /* Provide support for literal pools within the text section. */
1273 /* Loosely based on similar code from tc-arm.c */
1275 * We will use four symbols to locate four parts of the literal pool.
1276 * These four sections contain 64,32,16 and 8-bit constants; we use
1277 * four sections so that all memory access can be appropriately aligned.
1278 * That is, we want to avoid mixing these together so that we don't
1279 * waste space padding out to alignments. The four pointers
1280 * longlong_poolP, word_poolP, etc. point to a symbol labeling the
1281 * start of each pool part.
1283 * lit_pool_num increments from zero to infinity and uniquely id's
1284 * -- its used to generate the *_poolP symbol name.
1287 #define MAX_LITERAL_POOL_SIZE 1024
1289 typedef struct literalS
1291 struct expressionS exp
;
1293 char size
; /* 1,2,4 or 8 */
1297 literalT literals
[MAX_LITERAL_POOL_SIZE
];
1298 int next_literal_pool_place
= 0; /* Next free entry in the pool */
1300 static symbolS
*longlong_poolP
= NULL
; /* 64-bit pool entries */
1301 static symbolS
*word_poolP
= NULL
; /* 32-bit pool entries */
1302 static symbolS
*short_poolP
= NULL
; /* 16-bit pool entries */
1303 static symbolS
*byte_poolP
= NULL
; /* 8-bit pool entries */
1305 static int lit_pool_num
= 1;
1307 /* create a new, empty symbol */
1309 symbol_make_empty (void)
1311 return symbol_create (FAKE_LABEL_NAME
, undefined_section
,
1312 (valueT
) 0, &zero_address_frag
);
1315 /* add an expression to the literal pool */
1317 add_to_lit_pool (expressionS
*exx
, char *name
, int sz
)
1320 int offset_in_pool
= 0;
1322 /* start a new pool, if necessary */
1323 if (8 == sz
&& NULL
== longlong_poolP
)
1324 longlong_poolP
= symbol_make_empty ();
1325 else if (4 == sz
&& NULL
== word_poolP
)
1326 word_poolP
= symbol_make_empty ();
1327 else if (2 == sz
&& NULL
== short_poolP
)
1328 short_poolP
= symbol_make_empty ();
1329 else if (1 == sz
&& NULL
== byte_poolP
)
1330 byte_poolP
= symbol_make_empty ();
1332 /* Check if this literal value is already in the pool: */
1333 /* hack alert -- we should probably be checking expressions
1334 * of type O_symbol as well ... */
1335 /* hack alert XXX this is probably(certainly?) broken for O_big,
1336 * which includes 64-bit long-longs ...
1338 while (lit_count
< next_literal_pool_place
)
1340 if (exx
->X_op
== O_constant
1341 && literals
[lit_count
].exp
.X_op
== exx
->X_op
1342 && literals
[lit_count
].exp
.X_add_number
== exx
->X_add_number
1343 && literals
[lit_count
].exp
.X_unsigned
== exx
->X_unsigned
1344 && literals
[lit_count
].size
== sz
)
1346 else if (literals
[lit_count
].sym_name
1348 && !strcmp (name
, literals
[lit_count
].sym_name
))
1350 if (sz
== literals
[lit_count
].size
)
1351 offset_in_pool
+= sz
;
1355 if (lit_count
== next_literal_pool_place
) /* new entry */
1357 if (next_literal_pool_place
> MAX_LITERAL_POOL_SIZE
)
1359 as_bad ("Literal Pool Overflow");
1362 literals
[next_literal_pool_place
].exp
= *exx
;
1363 literals
[next_literal_pool_place
].size
= sz
;
1364 literals
[next_literal_pool_place
].offset
= offset_in_pool
;
1367 literals
[next_literal_pool_place
].sym_name
= strdup (name
);
1371 literals
[next_literal_pool_place
].sym_name
= NULL
;
1373 next_literal_pool_place
++;
1376 /* ???_poolP points to the beginning of the literal pool.
1377 * X_add_number is the offset from the beginning of the
1378 * literal pool to this expr minus the location of the most
1379 * recent .using directive. Thus, the grand total value of the
1380 * expression is the distance from .using to the literal.
1383 exx
->X_add_symbol
= longlong_poolP
;
1385 exx
->X_add_symbol
= word_poolP
;
1387 exx
->X_add_symbol
= short_poolP
;
1389 exx
->X_add_symbol
= byte_poolP
;
1390 exx
->X_add_number
= offset_in_pool
;
1391 exx
->X_op_symbol
= NULL
;
1393 /* If the user has set up a base reg in another section,
1394 * use that; otherwise use the text section. */
1395 if (0 < i370_using_other_regno
)
1397 i370_make_relative (exx
, &i370_using_other_baseaddr
);
1401 i370_make_relative (exx
, &i370_using_text_baseaddr
);
1405 /* The symbol setup for the literal pool is done in two steps. First,
1406 * a symbol that represents the start of the literal pool is created,
1407 * above, in the add_to_pool() routine. This sym ???_poolP.
1408 * However, we don't know what fragment its in until a bit later.
1409 * So we defer the frag_now thing, and the symbol name, until .ltorg time
1412 /* Can't use symbol_new here, so have to create a symbol and then at
1413 a later date assign it a value. Thats what these functions do */
1414 static void symbol_locate
1415 PARAMS ((symbolS
*, const char *, segT
, valueT
, fragS
*));
1418 symbol_locate (symbolP
, name
, segment
, valu
, frag
)
1420 const char *name
; /* It is copied, the caller can modify */
1421 segT segment
; /* Segment identifier (SEG_<something>) */
1422 valueT valu
; /* Symbol value */
1423 fragS
*frag
; /* Associated fragment */
1426 char *preserved_copy_of_name
;
1428 name_length
= strlen (name
) + 1; /* +1 for \0 */
1429 obstack_grow (¬es
, name
, name_length
);
1430 preserved_copy_of_name
= obstack_finish (¬es
);
1432 S_SET_NAME (symbolP
, preserved_copy_of_name
);
1434 S_SET_SEGMENT (symbolP
, segment
);
1435 S_SET_VALUE (symbolP
, valu
);
1436 symbol_clear_list_pointers (symbolP
);
1438 symbol_set_frag (symbolP
, frag
);
1441 * Link to end of symbol chain.
1444 extern int symbol_table_frozen
;
1445 if (symbol_table_frozen
)
1449 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1451 obj_symbol_new_hook (symbolP
);
1453 #ifdef tc_symbol_new_hook
1454 tc_symbol_new_hook (symbolP
);
1459 verify_symbol_chain(symbol_rootP
, symbol_lastP
);
1460 #endif /* DEBUG_SYMS */
1463 /* i370_addr_offset() will convert operand expressions
1464 * that appear to be absolute into thier base-register
1465 * relative form. These expressions come in two types:
1467 * (1) of the form "* + const" * where "*" means
1468 * relative offset since the last using
1469 * i.e. "*" means ".-using_baseaddr"
1471 * (2) labels, which are never absolute, but are always
1472 * relative to the last "using". Anything with an alpha
1473 * character is considered to be a label (since symbols
1474 * can never be operands), and since we've already handled
1475 * register operands. For example, "BL .L33" branch low
1476 * to .L33 RX form insn frequently terminates for-loops,
1479 i370_addr_offset (expressionS
*exx
)
1485 /* search for a label; anything with an alpha char will do */
1486 /* local labels consist of N digits followed by either b or f */
1487 lab
= input_line_pointer
;
1488 while (*lab
&& (',' != *lab
) && ('(' != *lab
))
1494 else if (ISALPHA (*lab
))
1501 else if (('f' == *lab
) || ('b' == *lab
))
1509 else if ('.' != *lab
)
1514 /* See if operand has a * in it */
1515 dot
= strchr (input_line_pointer
, '*');
1517 if (!dot
&& !islabel
)
1520 /* replace * with . and let expr munch on it. */
1525 /* OK, now we have to subtract the "using" location */
1526 /* normally branches appear in the text section only... */
1527 if (0 == strncmp (now_seg
->name
, ".text", 5) || 0 > i370_using_other_regno
)
1529 i370_make_relative (exx
, &i370_using_text_baseaddr
);
1533 i370_make_relative (exx
, &i370_using_other_baseaddr
);
1536 /* put the * back */
1543 /* handle address constants of various sorts */
1544 /* The currently supported types are
1547 * =X'deadbeef' hexadecimal
1548 * =F'1234' 32-bit const int
1549 * =H'1234' 16-bit const int
1552 i370_addr_cons (expressionS
*exp
)
1555 char *sym_name
, delim
;
1560 name
= input_line_pointer
;
1561 sym_name
= input_line_pointer
;
1562 /* Find the spelling of the operand */
1563 if (name
[0] == '=' && ISALPHA (name
[1]))
1565 name
= ++input_line_pointer
;
1575 /* A == address-of */
1577 ++input_line_pointer
;
1580 /* we use a simple string name to collapse together
1581 * multiple refrences to the same address literal
1583 name_len
= strcspn (sym_name
, ", ");
1584 delim
= *(sym_name
+ name_len
);
1585 *(sym_name
+ name_len
) = 0x0;
1586 add_to_lit_pool (exp
, sym_name
, 4);
1587 *(sym_name
+ name_len
) = delim
;
1593 case 'E': /* single-precision float point */
1594 case 'D': /* double-precision float point */
1596 /* H == 16-bit fixed-point const; expression must be const */
1597 /* F == fixed-point const; expression must be const */
1598 /* X == fixed-point const; expression must be const */
1599 if ('H' == name
[0]) cons_len
= 2;
1600 else if ('F' == name
[0]) cons_len
= 4;
1601 else if ('X' == name
[0]) cons_len
= -1;
1602 else if ('E' == name
[0]) cons_len
= 4;
1603 else if ('D' == name
[0]) cons_len
= 8;
1605 /* extract length, if it is present; hack alert -- assume single-digit
1609 cons_len
= name
[2] - '0'; /* should work for ascii and ebcdic */
1610 input_line_pointer
+= 2;
1613 ++input_line_pointer
;
1615 /* get rid of pesky quotes */
1616 if ('\'' == *input_line_pointer
)
1619 ++input_line_pointer
;
1620 close
= strchr (input_line_pointer
, '\'');
1624 as_bad ("missing end-quote");
1626 if ('\"' == *input_line_pointer
)
1629 ++input_line_pointer
;
1630 close
= strchr (input_line_pointer
, '\"');
1634 as_bad ("missing end-quote");
1636 if (('X' == name
[0]) || ('E' == name
[0]) || ('D' == name
[0]))
1641 /* The length of hex constants is specified directly with L,
1642 * or implied through the number of hex digits. For example:
1644 * =X'abcd' two bytes
1645 * =X'000000AB' four bytes
1646 * =XL4'AB' four bytes, left-padded withn zero
1648 if (('X' == name
[0]) && (0 > cons_len
))
1650 save
= input_line_pointer
;
1653 if (ISXDIGIT (*save
))
1657 cons_len
= (hex_len
+1) /2;
1659 /* I believe this works even for =XL8'dada0000beeebaaa'
1660 * which should parse out to X_op == O_big
1661 * Note that floats and doubles get represented as
1662 * 0d3.14159265358979 or 0f 2.7
1667 strcat (tmp
, input_line_pointer
);
1668 save
= input_line_pointer
;
1669 input_line_pointer
= tmp
;
1671 input_line_pointer
= save
+ (input_line_pointer
-tmp
-2);
1673 /* fix up lengths for floats and doubles */
1674 if (O_big
== exp
->X_op
)
1676 exp
->X_add_number
= cons_len
/ CHARS_PER_LITTLENUM
;
1683 /* O_big occurs when more than 4 bytes worth gets parsed */
1684 if ((exp
->X_op
!= O_constant
) && (exp
->X_op
!= O_big
))
1686 as_bad ("expression not a constant");
1689 add_to_lit_pool (exp
, 0x0, cons_len
);
1693 as_bad ("Unknown/unsupported address literal type");
1701 /* Dump the contents of the literal pool that we've accumulated so far.
1702 * This aligns the pool to the size of the largest literal in the pool.
1707 int ignore ATTRIBUTE_UNUSED
;
1711 int biggest_literal_size
= 0;
1712 int biggest_align
= 0;
1715 if (strncmp (now_seg
->name
, ".text", 5))
1717 if (i370_other_section
== undefined_section
)
1719 as_bad (".ltorg without prior .using in section %s",
1722 if (i370_other_section
!= now_seg
)
1724 as_bad (".ltorg in section %s paired to .using in section %s",
1725 now_seg
->name
, i370_other_section
->name
);
1728 if (! longlong_poolP
1734 /* as_tsktsk ("Nothing to put in the pool\n"); */
1738 /* find largest literal .. 2 4 or 8 */
1740 while (lit_count
< next_literal_pool_place
)
1742 if (biggest_literal_size
< literals
[lit_count
].size
)
1743 biggest_literal_size
= literals
[lit_count
].size
;
1746 if (1 == biggest_literal_size
) biggest_align
= 0;
1747 else if (2 == biggest_literal_size
) biggest_align
= 1;
1748 else if (4 == biggest_literal_size
) biggest_align
= 2;
1749 else if (8 == biggest_literal_size
) biggest_align
= 3;
1750 else as_bad ("bad alignment of %d bytes in literal pool", biggest_literal_size
);
1751 if (0 == biggest_align
) biggest_align
= 1;
1753 /* Align pool for short, word, double word accesses */
1754 frag_align (biggest_align
, 0, 0);
1755 record_alignment (now_seg
, biggest_align
);
1757 /* Note that the gas listing will print only the first five
1758 * entries in the pool .... wonder how to make it print more ...
1760 /* output largest literals first, then the smaller ones. */
1761 for (litsize
=8; litsize
; litsize
/=2)
1763 symbolS
*current_poolP
= NULL
;
1767 current_poolP
= longlong_poolP
; break;
1769 current_poolP
= word_poolP
; break;
1771 current_poolP
= short_poolP
; break;
1773 current_poolP
= byte_poolP
; break;
1775 as_bad ("bad literal size\n");
1777 if (NULL
== current_poolP
)
1779 sprintf (pool_name
, ".LITP%01d%06d", litsize
, lit_pool_num
);
1780 symbol_locate (current_poolP
, pool_name
, now_seg
,
1781 (valueT
) frag_now_fix (), frag_now
);
1782 symbol_table_insert (current_poolP
);
1785 while (lit_count
< next_literal_pool_place
)
1787 if (litsize
== literals
[lit_count
].size
)
1789 #define EMIT_ADDR_CONS_SYMBOLS
1790 #ifdef EMIT_ADDR_CONS_SYMBOLS
1791 /* create a bogus symbol, add it to the pool ...
1792 * For the most part, I think this is a useless exercise,
1793 * except that having these symbol names in the objects
1794 * is vaguely useful for debugging ...
1796 if (literals
[lit_count
].sym_name
)
1798 symbolS
* symP
= symbol_make_empty ();
1799 symbol_locate (symP
, literals
[lit_count
].sym_name
, now_seg
,
1800 (valueT
) frag_now_fix (), frag_now
);
1801 symbol_table_insert (symP
);
1803 #endif /* EMIT_ADDR_CONS_SYMBOLS */
1805 emit_expr (&(literals
[lit_count
].exp
), literals
[lit_count
].size
);
1811 next_literal_pool_place
= 0;
1812 longlong_poolP
= NULL
;
1819 #endif /* LITERAL_POOL_SUPPORT */
1822 /* add support for the HLASM-like USING directive to indicate
1823 * the base register to use ... we don't support the full
1824 * hlasm semantics for this ... we merely pluck a base address
1825 * and a register number out. We print a warning if using is
1826 * called multiple times. I suppose we should check to see
1827 * if the regno is valid ...
1831 int ignore ATTRIBUTE_UNUSED
;
1833 expressionS ex
, baseaddr
;
1837 /* if "*" appears in a using, it means "." */
1838 /* replace it with "." so that expr doesn't get confused. */
1839 star
= strchr (input_line_pointer
, '*');
1843 /* the first arg to using will usually be ".", but it can
1844 * be a more complex expression too ... */
1845 expression (&baseaddr
);
1848 if (O_constant
!= baseaddr
.X_op
1849 && O_symbol
!= baseaddr
.X_op
1850 && O_uminus
!= baseaddr
.X_op
)
1852 as_bad (".using: base address expression illegal or too complex");
1855 if (*input_line_pointer
!= '\0') ++input_line_pointer
;
1857 /* the second arg to using had better be a register */
1858 register_name (&ex
);
1859 demand_empty_rest_of_line ();
1860 iregno
= ex
.X_add_number
;
1862 if (0 == strncmp (now_seg
->name
, ".text", 5))
1864 i370_using_text_baseaddr
= baseaddr
;
1865 i370_using_text_regno
= iregno
;
1869 i370_using_other_baseaddr
= baseaddr
;
1870 i370_using_other_regno
= iregno
;
1871 i370_other_section
= now_seg
;
1877 int ignore ATTRIBUTE_UNUSED
;
1882 register_name (&ex
);
1883 demand_empty_rest_of_line ();
1884 iregno
= ex
.X_add_number
;
1886 if (0 == strncmp (now_seg
->name
, ".text", 5))
1888 if (iregno
!= i370_using_text_regno
)
1890 as_bad ("droping register %d in section %s does not match using register %d",
1891 iregno
, now_seg
->name
, i370_using_text_regno
);
1893 i370_using_text_regno
= -1;
1894 i370_using_text_baseaddr
.X_op
= O_absent
;
1898 if (iregno
!= i370_using_other_regno
)
1900 as_bad ("droping register %d in section %s does not match using register %d",
1901 iregno
, now_seg
->name
, i370_using_other_regno
);
1903 if (i370_other_section
!= now_seg
)
1905 as_bad ("droping register %d in section %s previously used in section %s",
1906 iregno
, now_seg
->name
, i370_other_section
->name
);
1908 i370_using_other_regno
= -1;
1909 i370_using_other_baseaddr
.X_op
= O_absent
;
1910 i370_other_section
= undefined_section
;
1914 /* Make the first argument an address-relative expression
1915 * by subtracting the second argument.
1918 i370_make_relative (expressionS
*exx
, expressionS
*baseaddr
)
1921 if (O_constant
== baseaddr
->X_op
)
1923 exx
->X_op
= O_symbol
;
1924 exx
->X_add_number
-= baseaddr
->X_add_number
;
1926 else if (O_symbol
== baseaddr
->X_op
)
1928 exx
->X_op
= O_subtract
;
1929 exx
->X_op_symbol
= baseaddr
->X_add_symbol
;
1930 exx
->X_add_number
-= baseaddr
->X_add_number
;
1932 else if (O_uminus
== baseaddr
->X_op
)
1935 exx
->X_op_symbol
= baseaddr
->X_add_symbol
;
1936 exx
->X_add_number
+= baseaddr
->X_add_number
;
1940 as_bad ("Missing or bad .using directive");
1944 /* We need to keep a list of fixups. We can't simply generate them as
1945 we go, because that would require us to first create the frag, and
1946 that would screw up references to ``.''. */
1952 bfd_reloc_code_real_type reloc
;
1955 #define MAX_INSN_FIXUPS (5)
1957 /* This routine is called for each instruction to be assembled. */
1963 char *s
, *opcode_str
;
1964 const struct i370_opcode
*opcode
;
1966 const unsigned char *opindex_ptr
;
1967 int have_optional_index
, have_optional_basereg
, have_optional_reg
;
1968 int skip_optional_index
, skip_optional_basereg
, skip_optional_reg
;
1969 int use_text
=0, use_other
=0;
1971 struct i370_fixup fixups
[MAX_INSN_FIXUPS
];
1976 bfd_reloc_code_real_type reloc
;
1979 /* Get the opcode. */
1980 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1986 /* Look up the opcode in the hash table. */
1987 opcode
= (const struct i370_opcode
*) hash_find (i370_hash
, str
);
1988 if (opcode
== (const struct i370_opcode
*) NULL
)
1990 const struct i370_macro
*macro
;
1992 assert (i370_macro_hash
);
1993 macro
= (const struct i370_macro
*) hash_find (i370_macro_hash
, str
);
1994 if (macro
== (const struct i370_macro
*) NULL
)
1995 as_bad ("Unrecognized opcode: `%s'", str
);
1997 i370_macro (s
, macro
);
2002 insn
= opcode
->opcode
;
2005 while (ISSPACE (*str
))
2008 /* I370 operands are either expressions or address constants.
2009 Many operand types are optional. The optional operands
2010 are always surrounded by parens, and are used to denote the base
2011 register ... e.g. "A R1, D2" or "A R1, D2(,B2) as opposed to
2012 the fully-formed "A R1, D2(X2,B2)". Note also the = sign,
2013 such as A R1,=A(i) where the address-of operator =A implies
2014 use of both a base register, and a missing index register.
2016 So, before we start seriously parsing the operands, we check
2017 to see if we have an optional operand, and, if we do, we count
2018 the number of commas to see which operand should be omitted. */
2020 have_optional_index
= have_optional_basereg
= have_optional_reg
= 0;
2021 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2023 const struct i370_operand
*operand
;
2024 operand
= &i370_operands
[*opindex_ptr
];
2025 if ((operand
->flags
& I370_OPERAND_INDEX
) != 0)
2026 have_optional_index
= 1;
2027 if ((operand
->flags
& I370_OPERAND_BASE
) != 0)
2028 have_optional_basereg
= 1;
2029 if ((operand
->flags
& I370_OPERAND_OPTIONAL
) != 0)
2030 have_optional_reg
= 1;
2033 skip_optional_index
= skip_optional_basereg
= skip_optional_reg
= 0;
2034 if (have_optional_index
|| have_optional_basereg
)
2036 unsigned int opcount
, nwanted
;
2038 /* There is an optional operand. Count the number of
2039 commas and open-parens in the input line. */
2046 while ((s
= strpbrk (s
, ",(=")) != (char *) NULL
)
2050 if (',' == *s
) ++s
; /* avoid counting things like (, */
2051 if ('=' == *s
) { ++s
; --opcount
; }
2055 /* If there are fewer operands in the line then are called
2056 for by the instruction, we want to skip the optional
2058 nwanted
= strlen ((char *) opcode
->operands
);
2059 if (have_optional_index
)
2061 if (opcount
< nwanted
)
2062 skip_optional_index
= 1;
2063 if (have_optional_basereg
&& ((opcount
+1) < nwanted
))
2064 skip_optional_basereg
= 1;
2065 if (have_optional_reg
&& ((opcount
+1) < nwanted
))
2066 skip_optional_reg
= 1;
2070 if (have_optional_basereg
&& (opcount
< nwanted
))
2071 skip_optional_basereg
= 1;
2072 if (have_optional_reg
&& (opcount
< nwanted
))
2073 skip_optional_reg
= 1;
2077 /* Perform some off-by-one hacks on the length field of certain instructions.
2078 * Its such a shame to have to do this, but the problem is that HLASM got
2079 * defined so that the lengths differ by one from the actual machine instructions.
2080 * this code should probably be moved to a special inster-operand routine.
2081 * Sigh. Affected instructions are Compare Logical, Move and Exclusive OR
2082 * hack alert -- aren't *all* SS instructions affected ??
2085 if (0 == strcasecmp ("CLC", opcode
->name
)
2086 || 0 == strcasecmp ("ED", opcode
->name
)
2087 || 0 == strcasecmp ("EDMK", opcode
->name
)
2088 || 0 == strcasecmp ("MVC", opcode
->name
)
2089 || 0 == strcasecmp ("MVCIN", opcode
->name
)
2090 || 0 == strcasecmp ("MVN", opcode
->name
)
2091 || 0 == strcasecmp ("MVZ", opcode
->name
)
2092 || 0 == strcasecmp ("NC", opcode
->name
)
2093 || 0 == strcasecmp ("OC", opcode
->name
)
2094 || 0 == strcasecmp ("XC", opcode
->name
))
2097 /* Gather the operands. */
2099 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2101 const struct i370_operand
*operand
;
2106 operand
= &i370_operands
[*opindex_ptr
];
2109 /* If this is an index operand, and we are skipping it,
2110 just insert a zero. */
2111 if (skip_optional_index
&&
2112 ((operand
->flags
& I370_OPERAND_INDEX
) != 0))
2114 insn
= i370_insert_operand (insn
, operand
, 0);
2118 /* If this is the base operand, and we are skipping it,
2119 just insert the current using basreg. */
2120 if (skip_optional_basereg
&&
2121 ((operand
->flags
& I370_OPERAND_BASE
) != 0))
2126 if (0 == strncmp (now_seg
->name
, ".text", 5)
2127 || 0 > i370_using_other_regno
)
2129 basereg
= i370_using_text_regno
;
2133 basereg
= i370_using_other_regno
;
2138 if (0 > i370_using_other_regno
)
2140 basereg
= i370_using_text_regno
;
2144 basereg
= i370_using_other_regno
;
2149 as_bad ("not using any base register");
2151 insn
= i370_insert_operand (insn
, operand
, basereg
);
2155 /* If this is an optional operand, and we are skipping it,
2156 Use zero (since a non-zero value would denote a register) */
2157 if (skip_optional_reg
2158 && ((operand
->flags
& I370_OPERAND_OPTIONAL
) != 0))
2160 insn
= i370_insert_operand (insn
, operand
, 0);
2164 /* Gather the operand. */
2165 hold
= input_line_pointer
;
2166 input_line_pointer
= str
;
2168 /* register names are only allowed where there are registers ... */
2169 if ((operand
->flags
& I370_OPERAND_GPR
) != 0)
2171 /* quickie hack to get past things like (,r13) */
2172 if (skip_optional_index
&& (',' == *input_line_pointer
))
2174 *input_line_pointer
= ' ';
2175 input_line_pointer
++;
2177 if (! register_name (&ex
))
2179 as_bad ("expecting a register for operand %d",
2180 opindex_ptr
- opcode
->operands
+ 1);
2184 /* Check for an address constant expression. */
2185 /* We will put PSW-relative addresses in the text section,
2186 * and address literals in the .data (or other) section. */
2187 else if (i370_addr_cons (&ex
))
2189 else if (i370_addr_offset (&ex
))
2191 else expression (&ex
);
2193 str
= input_line_pointer
;
2194 input_line_pointer
= hold
;
2196 /* perform some off-by-one hacks on the length field of certain instructions.
2197 * Its such a shame to have to do this, but the problem is that HLASM got
2198 * defined so that the programmer specifies a length that is one greater
2199 * than what the machine instruction wants.
2202 if (off_by_one
&& (0 == strcasecmp ("SS L", operand
->name
)))
2207 if (ex
.X_op
== O_illegal
)
2208 as_bad ("illegal operand");
2209 else if (ex
.X_op
== O_absent
)
2210 as_bad ("missing operand");
2211 else if (ex
.X_op
== O_register
)
2213 insn
= i370_insert_operand (insn
, operand
, ex
.X_add_number
);
2215 else if (ex
.X_op
== O_constant
)
2218 /* Allow @HA, @L, @H on constants.
2219 * Well actually, no we don't; there really don't make sense
2220 * (at least not to me) for the i370. However, this code is
2221 * left here for any dubious future expansion reasons ... */
2222 char *orig_str
= str
;
2224 if ((reloc
= i370_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2231 case BFD_RELOC_LO16
:
2232 /* X_unsigned is the default, so if the user has done
2233 something which cleared it, we always produce a
2235 ex
.X_add_number
= (((ex
.X_add_number
& 0xffff)
2240 case BFD_RELOC_HI16
:
2241 ex
.X_add_number
= (ex
.X_add_number
>> 16) & 0xffff;
2244 case BFD_RELOC_HI16_S
:
2245 ex
.X_add_number
= (((ex
.X_add_number
>> 16) & 0xffff)
2246 + ((ex
.X_add_number
>> 15) & 1));
2250 insn
= i370_insert_operand (insn
, operand
, ex
.X_add_number
);
2253 else if ((reloc
= i370_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2255 as_tsktsk ("md_assemble(): suffixed relocations not supported\n");
2257 /* We need to generate a fixup for this expression. */
2258 if (fc
>= MAX_INSN_FIXUPS
)
2259 as_fatal ("too many fixups");
2260 fixups
[fc
].exp
= ex
;
2261 fixups
[fc
].opindex
= 0;
2262 fixups
[fc
].reloc
= reloc
;
2265 #endif /* OBJ_ELF */
2269 /* We need to generate a fixup for this expression. */
2270 /* Typically, the expression will just be a symbol ...
2271 * printf ("insn %s needs fixup for %s \n",
2272 * opcode->name, ex.X_add_symbol->bsym->name);
2275 if (fc
>= MAX_INSN_FIXUPS
)
2276 as_fatal ("too many fixups");
2277 fixups
[fc
].exp
= ex
;
2278 fixups
[fc
].opindex
= *opindex_ptr
;
2279 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2283 /* skip over delimiter (close paren, or comma) */
2284 if ((')' == *str
) && (',' == *(str
+1)))
2290 while (ISSPACE (*str
))
2294 as_bad ("junk at end of line: `%s'", str
);
2296 /* Write out the instruction. */
2297 f
= frag_more (opcode
->len
);
2298 if (4 >= opcode
->len
)
2300 md_number_to_chars (f
, insn
.i
[0], opcode
->len
);
2304 md_number_to_chars (f
, insn
.i
[0], 4);
2305 if (6 == opcode
->len
)
2307 md_number_to_chars ((f
+4), ((insn
.i
[1])>>16), 2);
2311 /* not used --- don't have any 8 byte instructions */
2312 as_bad ("Internal Error: bad instruction length");
2313 md_number_to_chars ((f
+4), insn
.i
[1], opcode
->len
-4);
2317 /* Create any fixups. At this point we do not use a
2318 bfd_reloc_code_real_type, but instead just use the
2319 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2320 handle fixups for any operand type, although that is admittedly
2321 not a very exciting feature. We pick a BFD reloc type in
2323 for (i
= 0; i
< fc
; i
++)
2325 const struct i370_operand
*operand
;
2327 operand
= &i370_operands
[fixups
[i
].opindex
];
2328 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2330 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2337 size
= bfd_get_reloc_size (reloc_howto
);
2339 if (size
< 1 || size
> 4)
2342 printf (" gwana doo fixup %d \n", i
);
2343 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, size
,
2344 &fixups
[i
].exp
, reloc_howto
->pc_relative
,
2347 /* Turn off complaints that the addend is too large for things like
2349 switch (fixups
[i
].reloc
)
2351 case BFD_RELOC_16_GOTOFF
:
2352 case BFD_RELOC_LO16
:
2353 case BFD_RELOC_HI16
:
2354 case BFD_RELOC_HI16_S
:
2355 fixP
->fx_no_overflow
= 1;
2363 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->len
,
2365 (operand
->flags
& I370_OPERAND_RELATIVE
) != 0,
2366 ((bfd_reloc_code_real_type
)
2367 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2372 /* Handle a macro. Gather all the operands, transform them as
2373 described by the macro, and call md_assemble recursively. All the
2374 operands are separated by commas; we don't accept parentheses
2375 around operands here. */
2378 i370_macro (str
, macro
)
2380 const struct i370_macro
*macro
;
2391 /* Gather the users operands into the operands array. */
2396 if (count
>= sizeof operands
/ sizeof operands
[0])
2398 operands
[count
++] = s
;
2399 s
= strchr (s
, ',');
2400 if (s
== (char *) NULL
)
2405 if (count
!= macro
->operands
)
2407 as_bad ("wrong number of operands");
2411 /* Work out how large the string must be (the size is unbounded
2412 because it includes user input). */
2414 format
= macro
->format
;
2415 while (*format
!= '\0')
2424 arg
= strtol (format
+ 1, &send
, 10);
2425 know (send
!= format
&& arg
>= 0 && arg
< count
);
2426 len
+= strlen (operands
[arg
]);
2431 /* Put the string together. */
2432 complete
= s
= (char *) alloca (len
+ 1);
2433 format
= macro
->format
;
2434 while (*format
!= '\0')
2440 arg
= strtol (format
+ 1, &send
, 10);
2441 strcpy (s
, operands
[arg
]);
2448 /* Assemble the constructed instruction. */
2449 md_assemble (complete
);
2452 /* Pseudo-op handling. */
2454 /* The .byte pseudo-op. This is similar to the normal .byte
2455 pseudo-op, but it can also take a single ASCII string. */
2459 int ignore ATTRIBUTE_UNUSED
;
2461 if (*input_line_pointer
!= '\"')
2467 /* Gather characters. A real double quote is doubled. Unusual
2468 characters are not permitted. */
2469 ++input_line_pointer
;
2474 c
= *input_line_pointer
++;
2478 if (*input_line_pointer
!= '\"')
2480 ++input_line_pointer
;
2483 FRAG_APPEND_1_CHAR (c
);
2486 demand_empty_rest_of_line ();
2489 /* The .tc pseudo-op. This is used when generating XCOFF and ELF.
2490 This takes two or more arguments.
2492 When generating XCOFF output, the first argument is the name to
2493 give to this location in the toc; this will be a symbol with class
2494 TC. The rest of the arguments are 4 byte values to actually put at
2495 this location in the TOC; often there is just one more argument, a
2496 relocatable symbol reference.
2498 When not generating XCOFF output, the arguments are the same, but
2499 the first argument is simply ignored. */
2503 int ignore ATTRIBUTE_UNUSED
;
2506 /* Skip the TOC symbol name. */
2507 while (is_part_of_name (*input_line_pointer
)
2508 || *input_line_pointer
== '['
2509 || *input_line_pointer
== ']'
2510 || *input_line_pointer
== '{'
2511 || *input_line_pointer
== '}')
2512 ++input_line_pointer
;
2514 /* Align to a four byte boundary. */
2515 frag_align (2, 0, 0);
2516 record_alignment (now_seg
, 2);
2518 if (*input_line_pointer
!= ',')
2519 demand_empty_rest_of_line ();
2522 ++input_line_pointer
;
2527 /* Turn a string in input_line_pointer into a floating point constant
2528 of type TYPE, and store the appropriate bytes in *LITP. The number
2529 of LITTLENUMS emitted is stored in *SIZEP. An error message is
2530 returned, or NULL on OK. */
2533 md_atof (type
, litp
, sizep
)
2539 LITTLENUM_TYPE words
[4];
2559 return "bad call to md_atof";
2562 /* 360/370/390 have two float formats: an old, funky 360 single-precision
2563 * format, and the ieee format. Support only the ieee format. */
2564 t
= atof_ieee (input_line_pointer
, type
, words
);
2566 input_line_pointer
= t
;
2570 for (i
= 0; i
< prec
; i
++)
2572 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
2579 /* Write a value out to the object file, using the appropriate
2583 md_number_to_chars (buf
, val
, n
)
2588 number_to_chars_bigendian (buf
, val
, n
);
2591 /* Align a section (I don't know why this is machine dependent). */
2594 md_section_align (seg
, addr
)
2598 int align
= bfd_get_section_alignment (stdoutput
, seg
);
2600 return (addr
+ (1 << align
) - 1) & (-1 << align
);
2603 /* We don't have any form of relaxing. */
2606 md_estimate_size_before_relax (fragp
, seg
)
2607 fragS
*fragp ATTRIBUTE_UNUSED
;
2608 asection
*seg ATTRIBUTE_UNUSED
;
2614 /* Convert a machine dependent frag. We never generate these. */
2617 md_convert_frag (abfd
, sec
, fragp
)
2618 bfd
*abfd ATTRIBUTE_UNUSED
;
2619 asection
*sec ATTRIBUTE_UNUSED
;
2620 fragS
*fragp ATTRIBUTE_UNUSED
;
2625 /* We have no need to default values of symbols. */
2628 md_undefined_symbol (name
)
2629 char *name ATTRIBUTE_UNUSED
;
2634 /* Functions concerning relocs. */
2636 /* The location from which a PC relative jump should be calculated,
2637 given a PC relative reloc. */
2640 md_pcrel_from_section (fixp
, sec
)
2642 segT sec ATTRIBUTE_UNUSED
;
2644 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2647 /* Apply a fixup to the object code. This is called for all the
2648 fixups we generated by the call to fix_new_exp, above. In the call
2649 above we used a reloc code which was the largest legal reloc code
2650 plus the operand index. Here we undo that to recover the operand
2651 index. At this point all symbol values should be fully resolved,
2652 and we attempt to completely resolve the reloc. If we can not do
2653 that, we determine the correct reloc code and put it back in the
2656 See gas/cgen.c for more sample code and explanations of what's
2661 md_apply_fix3 (fixP
, valP
, seg
)
2666 valueT value
= * valP
;
2668 if (fixP
->fx_addsy
!= NULL
)
2671 printf ("\nmd_apply_fix3: symbol %s at 0x%x (%s:%d) val=0x%x addend=0x%x\n",
2672 S_GET_NAME (fixP
->fx_addsy
),
2673 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
,
2674 fixP
->fx_file
, fixP
->fx_line
,
2675 S_GET_VALUE (fixP
->fx_addsy
), value
);
2681 /* Apply fixups to operands. Note that there should be no relocations
2682 for any operands, since no instruction ever takes an operand
2683 that requires reloc. */
2684 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2687 const struct i370_operand
*operand
;
2691 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2693 operand
= &i370_operands
[opindex
];
2696 printf ("\nmd_apply_fix3: fixup operand %s at 0x%x in %s:%d addend=0x%x\n",
2698 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
,
2699 fixP
->fx_file
, fixP
->fx_line
,
2702 /* Fetch the instruction, insert the fully resolved operand
2703 value, and stuff the instruction back again.
2704 fisxp->fx_size is the length of the instruction. */
2705 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2706 insn
.i
[0] = bfd_getb32 ((unsigned char *) where
);
2708 if (6 <= fixP
->fx_size
)
2709 /* Deal with 48-bit insn's. */
2710 insn
.i
[1] = bfd_getb32 (((unsigned char *) where
)+4);
2712 insn
= i370_insert_operand (insn
, operand
, (offsetT
) value
);
2713 bfd_putb32 ((bfd_vma
) insn
.i
[0], (unsigned char *) where
);
2715 if (6 <= fixP
->fx_size
)
2716 /* Deal with 48-bit insn's. */
2717 bfd_putb32 ((bfd_vma
) insn
.i
[1], (((unsigned char *) where
)+4));
2719 /* We are done, right? right !! */
2722 /* Nothing else to do here. */
2725 /* Determine a BFD reloc value based on the operand information.
2726 We are only prepared to turn a few of the operands into
2727 relocs. In fact, we support *zero* operand relocations ...
2728 Why? Because we are not expecting the compiler to generate
2729 any operands that need relocation. Due to the 12-bit naturew of
2730 i370 addressing, this would be unusual. */
2735 /* Use expr_symbol_where to see if this is an expression
2737 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2738 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2739 "unresolved expression that must be resolved");
2741 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2742 "unsupported relocation type");
2749 /* We branch to here if the fixup is not to a symbol that
2750 appears in an instruction operand, but is rather some
2751 declared storage. */
2753 i370_elf_validate_fix (fixP
, seg
);
2756 printf ("md_apply_fix3: reloc case %d in segment %s %s:%d\n",
2757 fixP
->fx_r_type
, segment_name (seg
), fixP
->fx_file
, fixP
->fx_line
);
2758 printf ("\tcurrent fixup value is 0x%x \n", value
);
2760 switch (fixP
->fx_r_type
)
2763 case BFD_RELOC_CTOR
:
2765 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2769 case BFD_RELOC_32_PCREL
:
2770 case BFD_RELOC_32_BASEREL
:
2772 printf ("\t32 bit relocation at 0x%x\n",
2773 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
);
2775 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2779 case BFD_RELOC_LO16
:
2782 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2783 "cannot emit PC relative %s relocation%s%s",
2784 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2785 fixP
->fx_addsy
!= NULL
? " against " : "",
2786 (fixP
->fx_addsy
!= NULL
2787 ? S_GET_NAME (fixP
->fx_addsy
)
2790 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2794 /* This case happens when you write, for example,
2796 where L1 and L2 are defined later. */
2797 case BFD_RELOC_HI16
:
2800 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2803 case BFD_RELOC_HI16_S
:
2806 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2807 (value
+ 0x8000) >> 16, 2);
2814 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2820 "Gas failure, reloc value %d\n", fixP
->fx_r_type
);
2826 fixP
->fx_addnumber
= value
;
2829 /* Generate a reloc for a fixup. */
2832 tc_gen_reloc (seg
, fixp
)
2833 asection
*seg ATTRIBUTE_UNUSED
;
2838 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2840 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2841 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2842 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2843 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
2844 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
2846 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2847 "reloc %d not supported by object file format", (int)fixp
->fx_r_type
);
2850 reloc
->addend
= fixp
->fx_addnumber
;
2853 printf ("\ngen_reloc(): sym %s (%s:%d) at addr 0x%x addend=0x%x\n",
2854 fixp
->fx_addsy
->bsym
->name
,
2855 fixp
->fx_file
, fixp
->fx_line
,
2856 reloc
->address
, reloc
->addend
);