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 (C) 1994-2016 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This assembler implements a very hacked version of an elf-like thing
24 that gcc emits (when gcc is suitably hacked). To make it behave more
25 HLASM-like, try turning on the -M or --mri flag (as there are various
26 similarities between HLASM and the MRI assemblers, such as section
27 names, lack of leading . in pseudo-ops, DC and DS, etc. */
30 #include "safe-ctype.h"
32 #include "struc-symbol.h"
34 #include "opcode/i370.h"
40 /* This is the assembler for the System/390 Architecture. */
42 /* Tell the main code what the endianness is. */
43 extern int target_big_endian
;
46 /* Generic assembler global variables which must be defined by all
50 /* This string holds the chars that always start a comment. If the
51 pre-processor is disabled, these aren't very useful. The macro
52 tc_comment_chars points to this. We use this, rather than the
53 usual comment_chars, so that we can switch for Solaris conventions. */
54 static const char i370_eabi_comment_chars
[] = "#";
56 const char *i370_comment_chars
= i370_eabi_comment_chars
;
58 const char comment_chars
[] = "#";
61 /* Characters which start a comment at the beginning of a line. */
62 const char line_comment_chars
[] = "#*";
64 /* Characters which may be used to separate multiple commands on a
66 const char line_separator_chars
[] = ";";
68 /* Characters which are used to indicate an exponent in a floating
70 const char EXP_CHARS
[] = "eE";
72 /* Characters which mean that a number is a floating point constant,
74 const char FLT_CHARS
[] = "dD";
77 md_show_usage (FILE *stream
)
80 S/370 options: (these have not yet been tested and may not work) \n\
82 -mregnames Allow symbolic names for registers\n\
83 -mno-regnames Do not allow symbolic names for registers\n");
86 -mrelocatable support for GCC's -mrelocatble option\n\
87 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
88 -V print assembler version number\n");
92 /* Whether to use user friendly register names. */
93 #define TARGET_REG_NAMES_P TRUE
95 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
98 /* Predefined register names if -mregnames
99 In general, there are lots of them, in an attempt to be compatible
100 with a number of assemblers. */
102 /* Structure to hold information about predefined registers. */
109 /* List of registers that are pre-defined:
111 Each general register has predefined names of the form:
112 1. r<reg_num> which has the value <reg_num>.
113 2. r.<reg_num> which has the value <reg_num>.
115 Each floating point register has predefined names of the form:
116 1. f<reg_num> which has the value <reg_num>.
117 2. f.<reg_num> which has the value <reg_num>.
119 There are only four floating point registers, and these are
120 commonly labelled 0,2,4 and 6. Thus, there is no f1, f3, etc.
122 There are individual registers as well:
123 rbase or r.base has the value 3 (base register)
124 rpgt or r.pgt has the value 4 (page origin table pointer)
125 rarg or r.arg has the value 11 (argument pointer)
126 rtca or r.tca has the value 12 (table of contents pointer)
127 rtoc or r.toc has the value 12 (table of contents pointer)
128 sp or r.sp has the value 13 (stack pointer)
129 dsa or r.dsa has the value 13 (stack pointer)
130 lr has the value 14 (link reg)
132 The table is sorted. Suitable for searching by a binary search. */
134 static const struct pd_reg pre_defined_registers
[] =
136 { "arg", 11 }, /* Argument Pointer. */
137 { "base", 3 }, /* Base Reg. */
139 { "f.0", 0 }, /* Floating point registers. */
149 { "dsa",13 }, /* Stack pointer. */
150 { "lr", 14 }, /* Link Register. */
151 { "pgt", 4 }, /* Page Origin Table Pointer. */
153 { "r.0", 0 }, /* General Purpose Registers. */
170 { "r.arg", 11 }, /* Argument Pointer. */
171 { "r.base", 3 }, /* Base Reg. */
172 { "r.dsa", 13 }, /* Stack Pointer. */
173 { "r.pgt", 4 }, /* Page Origin Table Pointer. */
174 { "r.sp", 13 }, /* Stack Pointer. */
176 { "r.tca", 12 }, /* Pointer to the table of contents. */
177 { "r.toc", 12 }, /* Pointer to the table of contents. */
179 { "r0", 0 }, /* More general purpose registers. */
196 { "rbase", 3 }, /* Base Reg. */
198 { "rtca", 12 }, /* Pointer to the table of contents. */
199 { "rtoc", 12 }, /* Pointer to the table of contents. */
201 { "sp", 13 }, /* Stack Pointer. */
205 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
207 /* Given NAME, find the register number associated with that name, return
208 the integer value associated with the given name or -1 on failure. */
211 reg_name_search (const struct pd_reg
*regs
,
215 int middle
, low
, high
;
223 middle
= (low
+ high
) / 2;
224 cmp
= strcasecmp (name
, regs
[middle
].name
);
230 return regs
[middle
].value
;
237 /* Summary of register_name().
239 in: Input_line_pointer points to 1st char of operand.
242 The operand may have been a register: in this case, X_op == O_register,
243 X_add_number is set to the register number, and truth is returned.
244 Input_line_pointer->(next non-blank) char after operand, or is in its
248 register_name (expressionS
*expressionP
)
255 /* Find the spelling of the operand. */
256 start
= name
= input_line_pointer
;
257 if (name
[0] == '%' && ISALPHA (name
[1]))
258 name
= ++input_line_pointer
;
260 else if (!reg_names_p
)
264 name
= ++input_line_pointer
;
266 /* If it's a number, treat it as a number. If it's alpha, look to
267 see if it's in the register table. */
268 if (!ISALPHA (name
[0]))
269 reg_number
= get_single_number ();
272 c
= get_symbol_name (&name
);
273 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
275 /* Put back the delimiting char. */
276 (void) restore_line_pointer (c
);
279 /* If numeric, make sure its not out of bounds. */
280 if ((0 <= reg_number
) && (16 >= reg_number
))
282 expressionP
->X_op
= O_register
;
283 expressionP
->X_add_number
= reg_number
;
285 /* Make the rest nice. */
286 expressionP
->X_add_symbol
= NULL
;
287 expressionP
->X_op_symbol
= NULL
;
291 /* Reset the line as if we had not done anything. */
292 input_line_pointer
= start
;
296 /* Local variables. */
298 /* The type of processor we are assembling for. This is one or more
299 of the I370_OPCODE flags defined in opcode/i370.h. */
300 static int i370_cpu
= 0;
302 /* The base register to use for opcode with optional operands.
303 We define two of these: "text" and "other". Normally, "text"
304 would get used in the .text section for branches, while "other"
305 gets used in the .data section for address constants.
307 The idea of a second base register in a different section
308 is foreign to the usual HLASM-style semantics; however, it
309 allows us to provide support for dynamically loaded libraries,
310 by allowing us to place address constants in a section other
311 than the text section. The "other" section need not be the
312 .data section, it can be any section that isn't the .text section.
314 Note that HLASM defines a multiple, concurrent .using semantic
315 that we do not: in calculating offsets, it uses either the most
316 recent .using directive, or the one with the smallest displacement.
317 This allows HLASM to support a quasi-block-scope-like behaviour.
318 Handy for people writing assembly by hand ... but not supported
320 static int i370_using_text_regno
= -1;
321 static int i370_using_other_regno
= -1;
323 /* The base address for address literals. */
324 static expressionS i370_using_text_baseaddr
;
325 static expressionS i370_using_other_baseaddr
;
327 /* the "other" section, used only for syntax error detection. */
328 static segT i370_other_section
= undefined_section
;
330 /* Opcode hash table. */
331 static struct hash_control
*i370_hash
;
333 /* Macro hash table. */
334 static struct hash_control
*i370_macro_hash
;
337 /* What type of shared library support to use. */
338 static enum { SHLIB_NONE
, SHLIB_PIC
, SHILB_MRELOCATABLE
} shlib
= SHLIB_NONE
;
341 /* Flags to set in the elf header. */
342 static flagword i370_flags
= 0;
344 #ifndef WORKING_DOT_WORD
345 int md_short_jump_size
= 4;
346 int md_long_jump_size
= 4;
350 const char *md_shortopts
= "l:um:K:VQ:";
352 const char *md_shortopts
= "um:";
354 struct option md_longopts
[] =
356 {NULL
, no_argument
, NULL
, 0}
358 size_t md_longopts_size
= sizeof (md_longopts
);
361 md_parse_option (int c
, const char *arg
)
366 /* -u means that any undefined symbols should be treated as
367 external, which is the default for gas anyhow. */
372 /* Recognize -K PIC */
373 if (strcmp (arg
, "PIC") == 0 || strcmp (arg
, "pic") == 0)
376 i370_flags
|= EF_I370_RELOCATABLE_LIB
;
386 /* -m360 mean to assemble for the ancient 360 architecture. */
387 if (strcmp (arg
, "360") == 0 || strcmp (arg
, "i360") == 0)
388 i370_cpu
= I370_OPCODE_360
;
389 /* -mxa means to assemble for the IBM 370 XA. */
390 else if (strcmp (arg
, "xa") == 0)
391 i370_cpu
= I370_OPCODE_370_XA
;
392 /* -many means to assemble for any architecture (370/XA). */
393 else if (strcmp (arg
, "any") == 0)
394 i370_cpu
= I370_OPCODE_370
;
396 else if (strcmp (arg
, "regnames") == 0)
399 else if (strcmp (arg
, "no-regnames") == 0)
403 /* -mrelocatable/-mrelocatable-lib -- warn about
404 initializations that require relocation. */
405 else if (strcmp (arg
, "relocatable") == 0)
407 shlib
= SHILB_MRELOCATABLE
;
408 i370_flags
|= EF_I370_RELOCATABLE
;
410 else if (strcmp (arg
, "relocatable-lib") == 0)
412 shlib
= SHILB_MRELOCATABLE
;
413 i370_flags
|= EF_I370_RELOCATABLE_LIB
;
418 as_bad (_("invalid switch -m%s"), arg
);
424 /* -V: SVR4 argument to print version ID. */
429 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
430 should be emitted or not. FIXME: Not implemented. */
444 /* Set i370_cpu if it is not already set.
445 Currently defaults to the reasonable superset;
446 but can be made more fine grained if desred. */
451 const char *default_os
= TARGET_OS
;
452 const char *default_cpu
= TARGET_CPU
;
454 /* Override with the superset for the moment. */
455 i370_cpu
= I370_OPCODE_ESA390_SUPERSET
;
458 if (strcmp (default_cpu
, "i360") == 0)
459 i370_cpu
= I370_OPCODE_360
;
460 else if (strcmp (default_cpu
, "i370") == 0)
461 i370_cpu
= I370_OPCODE_370
;
462 else if (strcmp (default_cpu
, "XA") == 0)
463 i370_cpu
= I370_OPCODE_370_XA
;
465 as_fatal ("Unknown default cpu = %s, os = %s", default_cpu
, default_os
);
469 /* Figure out the BFD architecture to use.
470 FIXME: specify the different 370 architectures. */
472 enum bfd_architecture
475 return bfd_arch_i370
;
478 /* This function is called when the assembler starts up. It is called
479 after the options have been parsed and the output file has been
485 const struct i370_opcode
*op
;
486 const struct i370_opcode
*op_end
;
487 const struct i370_macro
*macro
;
488 const struct i370_macro
*macro_end
;
489 bfd_boolean dup_insn
= FALSE
;
494 /* Set the ELF flags if desired. */
496 bfd_set_private_flags (stdoutput
, i370_flags
);
499 /* Insert the opcodes into a hash table. */
500 i370_hash
= hash_new ();
502 op_end
= i370_opcodes
+ i370_num_opcodes
;
503 for (op
= i370_opcodes
; op
< op_end
; op
++)
505 know ((op
->opcode
.i
[0] & op
->mask
.i
[0]) == op
->opcode
.i
[0]
506 && (op
->opcode
.i
[1] & op
->mask
.i
[1]) == op
->opcode
.i
[1]);
508 if ((op
->flags
& i370_cpu
) != 0)
512 retval
= hash_insert (i370_hash
, op
->name
, (void *) op
);
513 if (retval
!= (const char *) NULL
)
515 as_bad (_("Internal assembler error for instruction %s"), op
->name
);
521 /* Insert the macros into a hash table. */
522 i370_macro_hash
= hash_new ();
524 macro_end
= i370_macros
+ i370_num_macros
;
525 for (macro
= i370_macros
; macro
< macro_end
; macro
++)
527 if ((macro
->flags
& i370_cpu
) != 0)
531 retval
= hash_insert (i370_macro_hash
, macro
->name
, (void *) macro
);
532 if (retval
!= (const char *) NULL
)
534 as_bad (_("Internal assembler error for macro %s"), macro
->name
);
544 /* Insert an operand value into an instruction. */
547 i370_insert_operand (i370_insn_t insn
,
548 const struct i370_operand
*operand
,
555 /* Used for 48-bit insn's. */
557 insn
= (*operand
->insert
) (insn
, (long) val
, &errmsg
);
559 as_bad ("%s", errmsg
);
562 /* This is used only for 16, 32 bit insn's. */
563 insn
.i
[0] |= (((long) val
& ((1 << operand
->bits
) - 1))
571 /* Parse @got, etc. and return the desired relocation.
572 Currently, i370 does not support (don't really need to support) any
573 of these fancier markups ... for example, no one is going to
574 write 'L 6,=V(bogus)@got' it just doesn't make sense (at least to me).
575 So basically, we could get away with this routine returning
576 BFD_RELOC_UNUSED in all circumstances. However, I'll leave
577 in for now in case someone ambitious finds a good use for this stuff ...
578 this routine was pretty much just copied from the powerpc code ... */
580 static bfd_reloc_code_real_type
581 i370_elf_suffix (char **str_p
, expressionS
*exp_p
)
587 bfd_reloc_code_real_type reloc
;
597 #define MAP(str,reloc) { str, sizeof (str) - 1, reloc }
599 static struct map_bfd mapping
[] =
601 /* warnings with -mrelocatable. */
602 MAP ("fixup", BFD_RELOC_CTOR
),
603 { (char *)0, 0, BFD_RELOC_UNUSED
}
607 return BFD_RELOC_UNUSED
;
609 for (ch
= *str
, str2
= ident
;
610 (str2
< ident
+ sizeof (ident
) - 1
611 && (ISALNUM (ch
) || ch
== '@'));
613 *str2
++ = TOLOWER (ch
);
619 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
620 if (ch
== ptr
->string
[0]
621 && len
== ptr
->length
622 && memcmp (ident
, ptr
->string
, ptr
->length
) == 0)
624 if (exp_p
->X_add_number
!= 0
625 && (ptr
->reloc
== BFD_RELOC_16_GOTOFF
626 || ptr
->reloc
== BFD_RELOC_LO16_GOTOFF
627 || ptr
->reloc
== BFD_RELOC_HI16_GOTOFF
628 || ptr
->reloc
== BFD_RELOC_HI16_S_GOTOFF
))
629 as_warn (_("identifier+constant@got means identifier@got+constant"));
631 /* Now check for identifier@suffix+constant */
632 if (*str
== '-' || *str
== '+')
634 char *orig_line
= input_line_pointer
;
637 input_line_pointer
= str
;
638 expression (&new_exp
);
639 if (new_exp
.X_op
== O_constant
)
641 exp_p
->X_add_number
+= new_exp
.X_add_number
;
642 str
= input_line_pointer
;
645 if (&input_line_pointer
!= str_p
)
646 input_line_pointer
= orig_line
;
653 return BFD_RELOC_UNUSED
;
656 /* Like normal .long/.short/.word, except support @got, etc.
657 Clobbers input_line_pointer, checks end-of-line. */
660 i370_elf_cons (int nbytes
) /* 1=.byte, 2=.word, 4=.long. */
663 bfd_reloc_code_real_type reloc
;
665 if (is_it_end_of_statement ())
667 demand_empty_rest_of_line ();
675 if (exp
.X_op
== O_symbol
676 && *input_line_pointer
== '@'
677 && (reloc
= i370_elf_suffix (&input_line_pointer
, &exp
)) != BFD_RELOC_UNUSED
)
679 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
680 int size
= bfd_get_reloc_size (reloc_howto
);
683 as_bad (_("%s relocations do not fit in %d bytes\n"),
684 reloc_howto
->name
, nbytes
);
687 char *p
= frag_more ((int) nbytes
);
688 int offset
= nbytes
- size
;
690 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
, size
, &exp
, 0, reloc
);
694 emit_expr (&exp
, (unsigned int) nbytes
);
696 while (*input_line_pointer
++ == ',');
698 input_line_pointer
--; /* Put terminator back into stream. */
699 demand_empty_rest_of_line ();
703 /* ASCII to EBCDIC conversion table. */
704 static unsigned char ascebc
[256] =
706 /*00 NL SH SX EX ET NQ AK BL */
707 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
708 /*08 BS HT LF VT FF CR SO SI */
709 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
710 /*10 DL D1 D2 D3 D4 NK SN EB */
711 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
712 /*18 CN EM SB EC FS GS RS US */
713 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
714 /*20 SP ! " # $ % & ' */
715 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
716 /*28 ( ) * + , - . / */
717 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
718 /*30 0 1 2 3 4 5 6 7 */
719 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
720 /*38 8 9 : ; < = > ? */
721 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
722 /*40 @ A B C D E F G */
723 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
724 /*48 H I J K L M N O */
725 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
726 /*50 P Q R S T U V W */
727 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
728 /*58 X Y Z [ \ ] ^ _ */
729 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D,
730 /*60 ` a b c d e f g */
731 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
732 /*68 h i j k l m n o */
733 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
734 /*70 p q r s t u v w */
735 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
736 /*78 x y z { | } ~ DL */
737 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07,
738 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
739 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
740 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
741 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
742 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
743 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
744 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
745 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
746 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
747 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
748 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
749 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
750 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
751 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
752 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
753 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0xFF
756 /* EBCDIC to ASCII conversion table. */
757 unsigned char ebcasc
[256] =
759 /*00 NU SH SX EX PF HT LC DL */
760 0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7F,
761 /*08 SM VT FF CR SO SI */
762 0x00, 0x00, 0x00, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
763 /*10 DE D1 D2 TM RS NL BS IL */
764 0x10, 0x11, 0x12, 0x13, 0x14, 0x0A, 0x08, 0x00,
765 /*18 CN EM CC C1 FS GS RS US */
766 0x18, 0x19, 0x00, 0x00, 0x1C, 0x1D, 0x1E, 0x1F,
767 /*20 DS SS FS BP LF EB EC */
768 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x17, 0x1B,
769 /*28 SM C2 EQ AK BL */
770 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, 0x00,
771 /*30 SY PN RS UC ET */
772 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
774 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1A,
776 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
778 0x00, 0x00, 0x00, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
780 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
782 0x00, 0x00, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
784 0x2D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
786 0x00, 0x00, 0x00, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
788 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
789 /*78 ` : # @ ' = " */
790 0x00, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
791 /*80 a b c d e f g */
792 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
794 0x68, 0x69, 0x00, 0x7B, 0x00, 0x00, 0x00, 0x00,
795 /*90 j k l m n o p */
796 0x00, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
798 0x71, 0x72, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00,
799 /*A0 ~ s t u v w x */
800 0x00, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
802 0x79, 0x7A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00,
804 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
806 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00,
807 /*C0 { A B C D E F G */
808 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
810 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
811 /*D0 } J K L M N O P */
812 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
814 0x51, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
815 /*E0 \ S T U V W X */
816 0x5C, 0x00, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
818 0x59, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
819 /*F0 0 1 2 3 4 5 6 7 */
820 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
822 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF
825 /* EBCDIC translation tables needed for 3270 support. */
828 i370_ebcdic (int unused ATTRIBUTE_UNUSED
)
834 nbytes
= strlen (input_line_pointer
);
835 end
= input_line_pointer
+ nbytes
;
836 while ('\r' == *end
) end
--;
837 while ('\n' == *end
) end
--;
839 delim
= *input_line_pointer
;
840 if (('\'' == delim
) || ('\"' == delim
))
842 input_line_pointer
++;
843 end
= rindex (input_line_pointer
, delim
);
846 if (end
> input_line_pointer
)
848 nbytes
= end
- input_line_pointer
+1;
849 p
= frag_more (nbytes
);
850 while (end
> input_line_pointer
)
852 *p
= ascebc
[(unsigned char) (*input_line_pointer
)];
853 ++p
; ++input_line_pointer
;
857 if (delim
== *input_line_pointer
) ++input_line_pointer
;
861 /* Stub out a couple of routines. */
864 i370_rmode (int unused ATTRIBUTE_UNUSED
)
866 as_tsktsk ("rmode ignored");
870 i370_dsect (int sect
)
872 char *save_line
= input_line_pointer
;
873 static char section
[] = ".data\n";
875 /* Just pretend this is .section .data. */
876 input_line_pointer
= section
;
877 obj_elf_section (sect
);
879 input_line_pointer
= save_line
;
883 i370_csect (int unused ATTRIBUTE_UNUSED
)
885 as_tsktsk ("csect not supported");
889 /* DC Define Const is only partially supported.
890 For samplecode on what to do, look at i370_elf_cons() above.
891 This code handles pseudoops of the style
892 DC D'3.141592653' # in sysv4, .double 3.14159265
893 DC F'1' # in sysv4, .long 1. */
896 i370_dc (int unused ATTRIBUTE_UNUSED
)
904 if (is_it_end_of_statement ())
906 demand_empty_rest_of_line ();
910 /* Figure out the size. */
911 type
= *input_line_pointer
++;
914 case 'H': /* 16-bit */
917 case 'E': /* 32-bit */
918 case 'F': /* 32-bit */
921 case 'D': /* 64-bit */
925 as_bad (_("unsupported DC type"));
929 /* Get rid of pesky quotes. */
930 if ('\'' == *input_line_pointer
)
932 ++input_line_pointer
;
933 clse
= strchr (input_line_pointer
, '\'');
937 as_bad (_("missing end-quote"));
940 if ('\"' == *input_line_pointer
)
942 ++input_line_pointer
;
943 clse
= strchr (input_line_pointer
, '\"');
947 as_bad (_("missing end-quote"));
952 case 'H': /* 16-bit */
953 case 'F': /* 32-bit */
955 emit_expr (&exp
, nbytes
);
957 case 'E': /* 32-bit */
959 case 'D': /* 64-bit */
960 md_atof (type
, tmp
, &nbytes
);
961 p
= frag_more (nbytes
);
962 memcpy (p
, tmp
, nbytes
);
965 as_bad (_("unsupported DC type"));
969 demand_empty_rest_of_line ();
973 /* Provide minimal support for DS Define Storage. */
976 i370_ds (int unused ATTRIBUTE_UNUSED
)
978 /* DS 0H or DS 0F or DS 0D. */
979 if ('0' == *input_line_pointer
)
981 int alignment
= 0; /* Left shift 1 << align. */
982 input_line_pointer
++;
983 switch (*input_line_pointer
++)
985 case 'H': /* 16-bit */
988 case 'F': /* 32-bit */
991 case 'D': /* 64-bit */
995 as_bad (_("unsupported alignment"));
998 frag_align (alignment
, 0, 0);
999 record_alignment (now_seg
, alignment
);
1002 as_bad (_("this DS form not yet supported"));
1005 /* Solaris pseudo op to change to the .rodata section. */
1008 i370_elf_rdata (int sect
)
1010 char *save_line
= input_line_pointer
;
1011 static char section
[] = ".rodata\n";
1013 /* Just pretend this is .section .rodata. */
1014 input_line_pointer
= section
;
1015 obj_elf_section (sect
);
1017 input_line_pointer
= save_line
;
1020 /* Pseudo op to make file scope bss items. */
1023 i370_elf_lcomm (int unused ATTRIBUTE_UNUSED
)
1036 c
= get_symbol_name (&name
);
1038 /* Just after name is now '\0'. */
1039 p
= input_line_pointer
;
1040 (void) restore_line_pointer (c
);
1042 if (*input_line_pointer
!= ',')
1044 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1045 ignore_rest_of_line ();
1050 input_line_pointer
++;
1051 if ((size
= get_absolute_expression ()) < 0)
1053 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
1054 ignore_rest_of_line ();
1058 /* The third argument to .lcomm is the alignment. */
1059 if (*input_line_pointer
!= ',')
1063 ++input_line_pointer
;
1064 align
= get_absolute_expression ();
1067 as_warn (_("ignoring bad alignment"));
1073 symbolP
= symbol_find_or_make (name
);
1076 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1078 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1079 S_GET_NAME (symbolP
));
1080 ignore_rest_of_line ();
1084 if (S_GET_VALUE (symbolP
) && S_GET_VALUE (symbolP
) != (valueT
) size
)
1086 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1087 S_GET_NAME (symbolP
),
1088 (long) S_GET_VALUE (symbolP
),
1091 ignore_rest_of_line ();
1097 old_subsec
= now_subseg
;
1100 /* Convert to a power of 2 alignment. */
1101 for (align2
= 0; (align
& 1) == 0; align
>>= 1, ++align2
)
1105 as_bad (_("Common alignment not a power of 2"));
1106 ignore_rest_of_line ();
1113 record_alignment (bss_section
, align2
);
1114 subseg_set (bss_section
, 0);
1116 frag_align (align2
, 0, 0);
1117 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1118 symbol_get_frag (symbolP
)->fr_symbol
= 0;
1119 symbol_set_frag (symbolP
, frag_now
);
1120 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
1123 S_SET_SIZE (symbolP
, size
);
1124 S_SET_SEGMENT (symbolP
, bss_section
);
1125 subseg_set (old_sec
, old_subsec
);
1126 demand_empty_rest_of_line ();
1129 /* Validate any relocations emitted for -mrelocatable, possibly adding
1130 fixups for word relocations in writable segments, so we can adjust
1134 i370_elf_validate_fix (fixS
*fixp
, segT seg
)
1136 if (fixp
->fx_done
|| fixp
->fx_pcrel
)
1145 case SHILB_MRELOCATABLE
:
1146 if (fixp
->fx_r_type
<= BFD_RELOC_UNUSED
1147 && fixp
->fx_r_type
!= BFD_RELOC_16_GOTOFF
1148 && fixp
->fx_r_type
!= BFD_RELOC_HI16_GOTOFF
1149 && fixp
->fx_r_type
!= BFD_RELOC_LO16_GOTOFF
1150 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_GOTOFF
1151 && fixp
->fx_r_type
!= BFD_RELOC_32_BASEREL
1152 && fixp
->fx_r_type
!= BFD_RELOC_LO16_BASEREL
1153 && fixp
->fx_r_type
!= BFD_RELOC_HI16_BASEREL
1154 && fixp
->fx_r_type
!= BFD_RELOC_HI16_S_BASEREL
1155 && strcmp (segment_name (seg
), ".got2") != 0
1156 && strcmp (segment_name (seg
), ".dtors") != 0
1157 && strcmp (segment_name (seg
), ".ctors") != 0
1158 && strcmp (segment_name (seg
), ".fixup") != 0
1159 && strcmp (segment_name (seg
), ".stab") != 0
1160 && strcmp (segment_name (seg
), ".gcc_except_table") != 0
1161 && strcmp (segment_name (seg
), ".ex_shared") != 0)
1163 if ((seg
->flags
& (SEC_READONLY
| SEC_CODE
)) != 0
1164 || fixp
->fx_r_type
!= BFD_RELOC_CTOR
)
1165 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1166 "Relocation cannot be done when using -mrelocatable");
1173 #endif /* OBJ_ELF */
1176 #define LITERAL_POOL_SUPPORT
1177 #ifdef LITERAL_POOL_SUPPORT
1178 /* Provide support for literal pools within the text section.
1179 Loosely based on similar code from tc-arm.c.
1180 We will use four symbols to locate four parts of the literal pool.
1181 These four sections contain 64,32,16 and 8-bit constants; we use
1182 four sections so that all memory access can be appropriately aligned.
1183 That is, we want to avoid mixing these together so that we don't
1184 waste space padding out to alignments. The four pointers
1185 longlong_poolP, word_poolP, etc. point to a symbol labeling the
1186 start of each pool part.
1188 lit_pool_num increments from zero to infinity and uniquely id's
1189 -- its used to generate the *_poolP symbol name. */
1191 #define MAX_LITERAL_POOL_SIZE 1024
1193 typedef struct literalS
1195 struct expressionS exp
;
1197 char size
; /* 1,2,4 or 8 */
1201 literalT literals
[MAX_LITERAL_POOL_SIZE
];
1202 int next_literal_pool_place
= 0; /* Next free entry in the pool. */
1204 static symbolS
*longlong_poolP
= NULL
; /* 64-bit pool entries. */
1205 static symbolS
*word_poolP
= NULL
; /* 32-bit pool entries. */
1206 static symbolS
*short_poolP
= NULL
; /* 16-bit pool entries. */
1207 static symbolS
*byte_poolP
= NULL
; /* 8-bit pool entries. */
1209 static int lit_pool_num
= 1;
1211 /* Create a new, empty symbol. */
1213 symbol_make_empty (void)
1215 return symbol_create (FAKE_LABEL_NAME
, undefined_section
,
1216 (valueT
) 0, &zero_address_frag
);
1219 /* Make the first argument an address-relative expression
1220 by subtracting the second argument. */
1223 i370_make_relative (expressionS
*exx
, expressionS
*baseaddr
)
1225 if (O_constant
== baseaddr
->X_op
)
1227 exx
->X_op
= O_symbol
;
1228 exx
->X_add_number
-= baseaddr
->X_add_number
;
1230 else if (O_symbol
== baseaddr
->X_op
)
1232 exx
->X_op
= O_subtract
;
1233 exx
->X_op_symbol
= baseaddr
->X_add_symbol
;
1234 exx
->X_add_number
-= baseaddr
->X_add_number
;
1236 else if (O_uminus
== baseaddr
->X_op
)
1239 exx
->X_op_symbol
= baseaddr
->X_add_symbol
;
1240 exx
->X_add_number
+= baseaddr
->X_add_number
;
1243 as_bad (_("Missing or bad .using directive"));
1245 /* Add an expression to the literal pool. */
1248 add_to_lit_pool (expressionS
*exx
, char *name
, int sz
)
1251 int offset_in_pool
= 0;
1253 /* Start a new pool, if necessary. */
1254 if (8 == sz
&& NULL
== longlong_poolP
)
1255 longlong_poolP
= symbol_make_empty ();
1256 else if (4 == sz
&& NULL
== word_poolP
)
1257 word_poolP
= symbol_make_empty ();
1258 else if (2 == sz
&& NULL
== short_poolP
)
1259 short_poolP
= symbol_make_empty ();
1260 else if (1 == sz
&& NULL
== byte_poolP
)
1261 byte_poolP
= symbol_make_empty ();
1263 /* Check if this literal value is already in the pool.
1264 FIXME: We should probably be checking expressions
1265 of type O_symbol as well.
1266 FIXME: This is probably(certainly?) broken for O_big,
1267 which includes 64-bit long-longs. */
1268 while (lit_count
< next_literal_pool_place
)
1270 if (exx
->X_op
== O_constant
1271 && literals
[lit_count
].exp
.X_op
== exx
->X_op
1272 && literals
[lit_count
].exp
.X_add_number
== exx
->X_add_number
1273 && literals
[lit_count
].exp
.X_unsigned
== exx
->X_unsigned
1274 && literals
[lit_count
].size
== sz
)
1276 else if (literals
[lit_count
].sym_name
1278 && !strcmp (name
, literals
[lit_count
].sym_name
))
1280 if (sz
== literals
[lit_count
].size
)
1281 offset_in_pool
+= sz
;
1285 if (lit_count
== next_literal_pool_place
) /* new entry */
1287 if (next_literal_pool_place
> MAX_LITERAL_POOL_SIZE
)
1288 as_bad (_("Literal Pool Overflow"));
1290 literals
[next_literal_pool_place
].exp
= *exx
;
1291 literals
[next_literal_pool_place
].size
= sz
;
1292 literals
[next_literal_pool_place
].offset
= offset_in_pool
;
1294 literals
[next_literal_pool_place
].sym_name
= strdup (name
);
1296 literals
[next_literal_pool_place
].sym_name
= NULL
;
1297 next_literal_pool_place
++;
1300 /* ???_poolP points to the beginning of the literal pool.
1301 X_add_number is the offset from the beginning of the
1302 literal pool to this expr minus the location of the most
1303 recent .using directive. Thus, the grand total value of the
1304 expression is the distance from .using to the literal. */
1306 exx
->X_add_symbol
= longlong_poolP
;
1308 exx
->X_add_symbol
= word_poolP
;
1310 exx
->X_add_symbol
= short_poolP
;
1312 exx
->X_add_symbol
= byte_poolP
;
1313 exx
->X_add_number
= offset_in_pool
;
1314 exx
->X_op_symbol
= NULL
;
1316 /* If the user has set up a base reg in another section,
1317 use that; otherwise use the text section. */
1318 if (0 < i370_using_other_regno
)
1319 i370_make_relative (exx
, &i370_using_other_baseaddr
);
1321 i370_make_relative (exx
, &i370_using_text_baseaddr
);
1324 /* The symbol setup for the literal pool is done in two steps. First,
1325 a symbol that represents the start of the literal pool is created,
1326 above, in the add_to_pool() routine. This sym ???_poolP.
1327 However, we don't know what fragment its in until a bit later.
1328 So we defer the frag_now thing, and the symbol name, until .ltorg time. */
1330 /* Can't use symbol_new here, so have to create a symbol and then at
1331 a later date assign it a value. Thats what these functions do. */
1334 symbol_locate (symbolS
*symbolP
,
1335 const char *name
, /* It is copied, the caller can modify. */
1336 segT segment
, /* Segment identifier (SEG_<something>). */
1337 valueT valu
, /* Symbol value. */
1338 fragS
*frag
) /* Associated fragment. */
1341 char *preserved_copy_of_name
;
1343 name_length
= strlen (name
) + 1; /* +1 for \0 */
1344 obstack_grow (¬es
, name
, name_length
);
1345 preserved_copy_of_name
= obstack_finish (¬es
);
1347 S_SET_NAME (symbolP
, preserved_copy_of_name
);
1349 S_SET_SEGMENT (symbolP
, segment
);
1350 S_SET_VALUE (symbolP
, valu
);
1351 symbol_clear_list_pointers (symbolP
);
1353 symbol_set_frag (symbolP
, frag
);
1355 /* Link to end of symbol chain. */
1357 extern int symbol_table_frozen
;
1359 if (symbol_table_frozen
)
1363 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1365 obj_symbol_new_hook (symbolP
);
1367 #ifdef tc_symbol_new_hook
1368 tc_symbol_new_hook (symbolP
);
1373 verify_symbol_chain(symbol_rootP
, symbol_lastP
);
1374 #endif /* DEBUG_SYMS */
1377 /* i370_addr_offset() will convert operand expressions
1378 that appear to be absolute into thier base-register
1379 relative form. These expressions come in two types:
1381 (1) of the form "* + const" * where "*" means
1382 relative offset since the last using
1383 i.e. "*" means ".-using_baseaddr"
1385 (2) labels, which are never absolute, but are always
1386 relative to the last "using". Anything with an alpha
1387 character is considered to be a label (since symbols
1388 can never be operands), and since we've already handled
1389 register operands. For example, "BL .L33" branch low
1390 to .L33 RX form insn frequently terminates for-loops. */
1393 i370_addr_offset (expressionS
*exx
)
1399 /* Search for a label; anything with an alpha char will do.
1400 Local labels consist of N digits followed by either b or f. */
1401 lab
= input_line_pointer
;
1402 while (*lab
&& (',' != *lab
) && ('(' != *lab
))
1406 else if (ISALPHA (*lab
))
1413 else if (('f' == *lab
) || ('b' == *lab
))
1421 else if ('.' != *lab
)
1426 /* See if operand has a * in it. */
1427 dot
= strchr (input_line_pointer
, '*');
1429 if (!dot
&& !islabel
)
1432 /* Replace * with . and let expr munch on it. */
1437 /* OK, now we have to subtract the "using" location.
1438 Normally branches appear in the text section only. */
1439 if (0 == strncmp (now_seg
->name
, ".text", 5) || 0 > i370_using_other_regno
)
1440 i370_make_relative (exx
, &i370_using_text_baseaddr
);
1442 i370_make_relative (exx
, &i370_using_other_baseaddr
);
1444 /* Put the * back. */
1451 /* Handle address constants of various sorts. */
1452 /* The currently supported types are
1455 =X'deadbeef' hexadecimal
1456 =F'1234' 32-bit const int
1457 =H'1234' 16-bit const int. */
1460 i370_addr_cons (expressionS
*exp
)
1463 char *sym_name
, delim
;
1468 name
= input_line_pointer
;
1469 sym_name
= input_line_pointer
;
1470 /* Find the spelling of the operand. */
1471 if (name
[0] == '=' && ISALPHA (name
[1]))
1472 name
= ++input_line_pointer
;
1478 case 'A': /* A == address-of. */
1479 case 'V': /* V == extern. */
1480 ++input_line_pointer
;
1483 /* We use a simple string name to collapse together
1484 multiple refrences to the same address literal. */
1485 name_len
= strcspn (sym_name
, ", ");
1486 delim
= *(sym_name
+ name_len
);
1487 *(sym_name
+ name_len
) = 0x0;
1488 add_to_lit_pool (exp
, sym_name
, 4);
1489 *(sym_name
+ name_len
) = delim
;
1495 case 'E': /* Single-precision float point. */
1496 case 'D': /* Double-precision float point. */
1498 /* H == 16-bit fixed-point const; expression must be const. */
1499 /* F == fixed-point const; expression must be const. */
1500 /* X == fixed-point const; expression must be const. */
1501 if ('H' == name
[0]) cons_len
= 2;
1502 else if ('F' == name
[0]) cons_len
= 4;
1503 else if ('X' == name
[0]) cons_len
= -1;
1504 else if ('E' == name
[0]) cons_len
= 4;
1505 else if ('D' == name
[0]) cons_len
= 8;
1507 /* Extract length, if it is present;
1508 FIXME: assume single-digit length. */
1511 /* Should work for ASCII and EBCDIC. */
1512 cons_len
= name
[2] - '0';
1513 input_line_pointer
+= 2;
1516 ++input_line_pointer
;
1518 /* Get rid of pesky quotes. */
1519 if ('\'' == *input_line_pointer
)
1523 ++input_line_pointer
;
1524 clse
= strchr (input_line_pointer
, '\'');
1528 as_bad (_("missing end-quote"));
1530 if ('\"' == *input_line_pointer
)
1534 ++input_line_pointer
;
1535 clse
= strchr (input_line_pointer
, '\"');
1539 as_bad (_("missing end-quote"));
1541 if (('X' == name
[0]) || ('E' == name
[0]) || ('D' == name
[0]))
1546 /* The length of hex constants is specified directly with L,
1547 or implied through the number of hex digits. For example:
1550 =X'000000AB' four bytes
1551 =XL4'AB' four bytes, left-padded withn zero. */
1552 if (('X' == name
[0]) && (0 > cons_len
))
1554 save
= input_line_pointer
;
1557 if (ISXDIGIT (*save
))
1561 cons_len
= (hex_len
+1) /2;
1563 /* I believe this works even for =XL8'dada0000beeebaaa'
1564 which should parse out to X_op == O_big
1565 Note that floats and doubles get represented as
1566 0d3.14159265358979 or 0f 2.7. */
1570 strcat (tmp
, input_line_pointer
);
1571 save
= input_line_pointer
;
1572 input_line_pointer
= tmp
;
1574 input_line_pointer
= save
+ (input_line_pointer
-tmp
-2);
1576 /* Fix up lengths for floats and doubles. */
1577 if (O_big
== exp
->X_op
)
1578 exp
->X_add_number
= cons_len
/ CHARS_PER_LITTLENUM
;
1583 /* O_big occurs when more than 4 bytes worth gets parsed. */
1584 if ((exp
->X_op
!= O_constant
) && (exp
->X_op
!= O_big
))
1586 as_bad (_("expression not a constant"));
1589 add_to_lit_pool (exp
, 0x0, cons_len
);
1593 as_bad (_("Unknown/unsupported address literal type"));
1601 /* Dump the contents of the literal pool that we've accumulated so far.
1602 This aligns the pool to the size of the largest literal in the pool. */
1605 i370_ltorg (int ignore ATTRIBUTE_UNUSED
)
1609 int biggest_literal_size
= 0;
1610 int biggest_align
= 0;
1613 if (strncmp (now_seg
->name
, ".text", 5))
1615 if (i370_other_section
== undefined_section
)
1616 as_bad (_(".ltorg without prior .using in section %s"),
1619 if (i370_other_section
!= now_seg
)
1620 as_bad (_(".ltorg in section %s paired to .using in section %s"),
1621 now_seg
->name
, i370_other_section
->name
);
1624 if (! longlong_poolP
1628 /* Nothing to do. */
1631 /* Find largest literal .. 2 4 or 8. */
1633 while (lit_count
< next_literal_pool_place
)
1635 if (biggest_literal_size
< literals
[lit_count
].size
)
1636 biggest_literal_size
= literals
[lit_count
].size
;
1639 if (1 == biggest_literal_size
) biggest_align
= 0;
1640 else if (2 == biggest_literal_size
) biggest_align
= 1;
1641 else if (4 == biggest_literal_size
) biggest_align
= 2;
1642 else if (8 == biggest_literal_size
) biggest_align
= 3;
1643 else as_bad (_("bad alignment of %d bytes in literal pool"), biggest_literal_size
);
1644 if (0 == biggest_align
) biggest_align
= 1;
1646 /* Align pool for short, word, double word accesses. */
1647 frag_align (biggest_align
, 0, 0);
1648 record_alignment (now_seg
, biggest_align
);
1650 /* Note that the gas listing will print only the first five
1651 entries in the pool .... wonder how to make it print more. */
1652 /* Output largest literals first, then the smaller ones. */
1653 for (litsize
=8; litsize
; litsize
/=2)
1655 symbolS
*current_poolP
= NULL
;
1659 current_poolP
= longlong_poolP
; break;
1661 current_poolP
= word_poolP
; break;
1663 current_poolP
= short_poolP
; break;
1665 current_poolP
= byte_poolP
; break;
1667 as_bad (_("bad literal size\n"));
1669 if (NULL
== current_poolP
)
1671 sprintf (pool_name
, ".LITP%01d%06d", litsize
, lit_pool_num
);
1672 symbol_locate (current_poolP
, pool_name
, now_seg
,
1673 (valueT
) frag_now_fix (), frag_now
);
1674 symbol_table_insert (current_poolP
);
1677 while (lit_count
< next_literal_pool_place
)
1679 if (litsize
== literals
[lit_count
].size
)
1681 #define EMIT_ADDR_CONS_SYMBOLS
1682 #ifdef EMIT_ADDR_CONS_SYMBOLS
1683 /* Create a bogus symbol, add it to the pool ...
1684 For the most part, I think this is a useless exercise,
1685 except that having these symbol names in the objects
1686 is vaguely useful for debugging. */
1687 if (literals
[lit_count
].sym_name
)
1689 symbolS
* symP
= symbol_make_empty ();
1690 symbol_locate (symP
, literals
[lit_count
].sym_name
, now_seg
,
1691 (valueT
) frag_now_fix (), frag_now
);
1692 symbol_table_insert (symP
);
1694 #endif /* EMIT_ADDR_CONS_SYMBOLS */
1696 emit_expr (&(literals
[lit_count
].exp
), literals
[lit_count
].size
);
1702 next_literal_pool_place
= 0;
1703 longlong_poolP
= NULL
;
1710 #endif /* LITERAL_POOL_SUPPORT */
1713 /* Add support for the HLASM-like USING directive to indicate
1714 the base register to use ... we don't support the full
1715 hlasm semantics for this ... we merely pluck a base address
1716 and a register number out. We print a warning if using is
1717 called multiple times. I suppose we should check to see
1718 if the regno is valid. */
1721 i370_using (int ignore ATTRIBUTE_UNUSED
)
1723 expressionS ex
, baseaddr
;
1727 /* If "*" appears in a using, it means "."
1728 replace it with "." so that expr doesn't get confused. */
1729 star
= strchr (input_line_pointer
, '*');
1733 /* The first arg to using will usually be ".", but it can
1734 be a more complex expression too. */
1735 expression (&baseaddr
);
1738 if (O_constant
!= baseaddr
.X_op
1739 && O_symbol
!= baseaddr
.X_op
1740 && O_uminus
!= baseaddr
.X_op
)
1741 as_bad (_(".using: base address expression illegal or too complex"));
1743 if (*input_line_pointer
!= '\0') ++input_line_pointer
;
1745 /* The second arg to using had better be a register. */
1746 register_name (&ex
);
1747 demand_empty_rest_of_line ();
1748 iregno
= ex
.X_add_number
;
1750 if (0 == strncmp (now_seg
->name
, ".text", 5))
1752 i370_using_text_baseaddr
= baseaddr
;
1753 i370_using_text_regno
= iregno
;
1757 i370_using_other_baseaddr
= baseaddr
;
1758 i370_using_other_regno
= iregno
;
1759 i370_other_section
= now_seg
;
1764 i370_drop (int ignore ATTRIBUTE_UNUSED
)
1769 register_name (&ex
);
1770 demand_empty_rest_of_line ();
1771 iregno
= ex
.X_add_number
;
1773 if (0 == strncmp (now_seg
->name
, ".text", 5))
1775 if (iregno
!= i370_using_text_regno
)
1776 as_bad (_("droping register %d in section %s does not match using register %d"),
1777 iregno
, now_seg
->name
, i370_using_text_regno
);
1779 i370_using_text_regno
= -1;
1780 i370_using_text_baseaddr
.X_op
= O_absent
;
1784 if (iregno
!= i370_using_other_regno
)
1785 as_bad (_("droping register %d in section %s does not match using register %d"),
1786 iregno
, now_seg
->name
, i370_using_other_regno
);
1788 if (i370_other_section
!= now_seg
)
1789 as_bad (_("droping register %d in section %s previously used in section %s"),
1790 iregno
, now_seg
->name
, i370_other_section
->name
);
1792 i370_using_other_regno
= -1;
1793 i370_using_other_baseaddr
.X_op
= O_absent
;
1794 i370_other_section
= undefined_section
;
1799 /* We need to keep a list of fixups. We can't simply generate them as
1800 we go, because that would require us to first create the frag, and
1801 that would screw up references to ``.''. */
1807 bfd_reloc_code_real_type reloc
;
1810 #define MAX_INSN_FIXUPS 5
1812 /* Handle a macro. Gather all the operands, transform them as
1813 described by the macro, and call md_assemble recursively. All the
1814 operands are separated by commas; we don't accept parentheses
1815 around operands here. */
1818 i370_macro (char *str
, const struct i370_macro
*macro
)
1829 /* Gather the users operands into the operands array. */
1834 if (count
>= sizeof operands
/ sizeof operands
[0])
1836 operands
[count
++] = s
;
1837 s
= strchr (s
, ',');
1838 if (s
== (char *) NULL
)
1843 if (count
!= macro
->operands
)
1845 as_bad (_("wrong number of operands"));
1849 /* Work out how large the string must be (the size is unbounded
1850 because it includes user input). */
1852 format
= macro
->format
;
1853 while (*format
!= '\0')
1862 arg
= strtol (format
+ 1, &send
, 10);
1863 know (send
!= format
&& arg
>= 0 && (unsigned) arg
< count
);
1864 len
+= strlen (operands
[arg
]);
1869 /* Put the string together. */
1870 complete
= s
= xmalloc (len
+ 1);
1871 format
= macro
->format
;
1872 while (*format
!= '\0')
1878 arg
= strtol (format
+ 1, &send
, 10);
1879 strcpy (s
, operands
[arg
]);
1886 /* Assemble the constructed instruction. */
1887 md_assemble (complete
);
1891 /* This routine is called for each instruction to be assembled. */
1894 md_assemble (char *str
)
1897 const struct i370_opcode
*opcode
;
1899 const unsigned char *opindex_ptr
;
1900 int have_optional_index
, have_optional_basereg
, have_optional_reg
;
1901 int skip_optional_index
, skip_optional_basereg
, skip_optional_reg
;
1902 int use_text
=0, use_other
=0;
1904 struct i370_fixup fixups
[MAX_INSN_FIXUPS
];
1909 bfd_reloc_code_real_type reloc
;
1912 /* Get the opcode. */
1913 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1918 /* Look up the opcode in the hash table. */
1919 opcode
= (const struct i370_opcode
*) hash_find (i370_hash
, str
);
1920 if (opcode
== (const struct i370_opcode
*) NULL
)
1922 const struct i370_macro
*macro
;
1924 gas_assert (i370_macro_hash
);
1925 macro
= (const struct i370_macro
*) hash_find (i370_macro_hash
, str
);
1926 if (macro
== (const struct i370_macro
*) NULL
)
1927 as_bad (_("Unrecognized opcode: `%s'"), str
);
1929 i370_macro (s
, macro
);
1934 insn
= opcode
->opcode
;
1937 while (ISSPACE (*str
))
1940 /* I370 operands are either expressions or address constants.
1941 Many operand types are optional. The optional operands
1942 are always surrounded by parens, and are used to denote the base
1943 register ... e.g. "A R1, D2" or "A R1, D2(,B2) as opposed to
1944 the fully-formed "A R1, D2(X2,B2)". Note also the = sign,
1945 such as A R1,=A(i) where the address-of operator =A implies
1946 use of both a base register, and a missing index register.
1948 So, before we start seriously parsing the operands, we check
1949 to see if we have an optional operand, and, if we do, we count
1950 the number of commas to see which operand should be omitted. */
1952 have_optional_index
= have_optional_basereg
= have_optional_reg
= 0;
1953 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1955 const struct i370_operand
*operand
;
1957 operand
= &i370_operands
[*opindex_ptr
];
1958 if ((operand
->flags
& I370_OPERAND_INDEX
) != 0)
1959 have_optional_index
= 1;
1960 if ((operand
->flags
& I370_OPERAND_BASE
) != 0)
1961 have_optional_basereg
= 1;
1962 if ((operand
->flags
& I370_OPERAND_OPTIONAL
) != 0)
1963 have_optional_reg
= 1;
1966 skip_optional_index
= skip_optional_basereg
= skip_optional_reg
= 0;
1967 if (have_optional_index
|| have_optional_basereg
)
1969 unsigned int opcount
, nwanted
;
1971 /* There is an optional operand. Count the number of
1972 commas and open-parens in the input line. */
1979 while ((s
= strpbrk (s
, ",(=")) != (char *) NULL
)
1983 if (',' == *s
) ++s
; /* avoid counting things like (, */
1984 if ('=' == *s
) { ++s
; --opcount
; }
1988 /* If there are fewer operands in the line then are called
1989 for by the instruction, we want to skip the optional
1991 nwanted
= strlen ((char *) opcode
->operands
);
1992 if (have_optional_index
)
1994 if (opcount
< nwanted
)
1995 skip_optional_index
= 1;
1996 if (have_optional_basereg
&& ((opcount
+1) < nwanted
))
1997 skip_optional_basereg
= 1;
1998 if (have_optional_reg
&& ((opcount
+1) < nwanted
))
1999 skip_optional_reg
= 1;
2003 if (have_optional_basereg
&& (opcount
< nwanted
))
2004 skip_optional_basereg
= 1;
2005 if (have_optional_reg
&& (opcount
< nwanted
))
2006 skip_optional_reg
= 1;
2010 /* Perform some off-by-one hacks on the length field of certain instructions.
2011 Its such a shame to have to do this, but the problem is that HLASM got
2012 defined so that the lengths differ by one from the actual machine instructions.
2013 this code should probably be moved to a special inster-operand routine.
2014 Sigh. Affected instructions are Compare Logical, Move and Exclusive OR
2015 hack alert -- aren't *all* SS instructions affected ?? */
2017 if (0 == strcasecmp ("CLC", opcode
->name
)
2018 || 0 == strcasecmp ("ED", opcode
->name
)
2019 || 0 == strcasecmp ("EDMK", opcode
->name
)
2020 || 0 == strcasecmp ("MVC", opcode
->name
)
2021 || 0 == strcasecmp ("MVCIN", opcode
->name
)
2022 || 0 == strcasecmp ("MVN", opcode
->name
)
2023 || 0 == strcasecmp ("MVZ", opcode
->name
)
2024 || 0 == strcasecmp ("NC", opcode
->name
)
2025 || 0 == strcasecmp ("OC", opcode
->name
)
2026 || 0 == strcasecmp ("XC", opcode
->name
))
2029 /* Gather the operands. */
2031 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
2033 const struct i370_operand
*operand
;
2037 operand
= &i370_operands
[*opindex_ptr
];
2039 /* If this is an index operand, and we are skipping it,
2040 just insert a zero. */
2041 if (skip_optional_index
&&
2042 ((operand
->flags
& I370_OPERAND_INDEX
) != 0))
2044 insn
= i370_insert_operand (insn
, operand
, 0);
2048 /* If this is the base operand, and we are skipping it,
2049 just insert the current using basreg. */
2050 if (skip_optional_basereg
&&
2051 ((operand
->flags
& I370_OPERAND_BASE
) != 0))
2056 if (0 == strncmp (now_seg
->name
, ".text", 5)
2057 || 0 > i370_using_other_regno
)
2058 basereg
= i370_using_text_regno
;
2060 basereg
= i370_using_other_regno
;
2064 if (0 > i370_using_other_regno
)
2065 basereg
= i370_using_text_regno
;
2067 basereg
= i370_using_other_regno
;
2070 as_bad (_("not using any base register"));
2072 insn
= i370_insert_operand (insn
, operand
, basereg
);
2076 /* If this is an optional operand, and we are skipping it,
2077 Use zero (since a non-zero value would denote a register) */
2078 if (skip_optional_reg
2079 && ((operand
->flags
& I370_OPERAND_OPTIONAL
) != 0))
2081 insn
= i370_insert_operand (insn
, operand
, 0);
2085 /* Gather the operand. */
2086 hold
= input_line_pointer
;
2087 input_line_pointer
= str
;
2089 /* Register names are only allowed where there are registers. */
2090 if ((operand
->flags
& I370_OPERAND_GPR
) != 0)
2092 /* Quickie hack to get past things like (,r13). */
2093 if (skip_optional_index
&& (',' == *input_line_pointer
))
2095 *input_line_pointer
= ' ';
2096 input_line_pointer
++;
2099 if (! register_name (&ex
))
2100 as_bad (_("expecting a register for operand %d"),
2101 (int) (opindex_ptr
- opcode
->operands
+ 1));
2104 /* Check for an address constant expression. */
2105 /* We will put PSW-relative addresses in the text section,
2106 and address literals in the .data (or other) section. */
2107 else if (i370_addr_cons (&ex
))
2109 else if (i370_addr_offset (&ex
))
2111 else expression (&ex
);
2113 str
= input_line_pointer
;
2114 input_line_pointer
= hold
;
2116 /* Perform some off-by-one hacks on the length field of certain instructions.
2117 Its such a shame to have to do this, but the problem is that HLASM got
2118 defined so that the programmer specifies a length that is one greater
2119 than what the machine instruction wants. Sigh. */
2120 if (off_by_one
&& (0 == strcasecmp ("SS L", operand
->name
)))
2123 if (ex
.X_op
== O_illegal
)
2124 as_bad (_("illegal operand"));
2125 else if (ex
.X_op
== O_absent
)
2126 as_bad (_("missing operand"));
2127 else if (ex
.X_op
== O_register
)
2128 insn
= i370_insert_operand (insn
, operand
, ex
.X_add_number
);
2129 else if (ex
.X_op
== O_constant
)
2132 /* Allow @HA, @L, @H on constants.
2133 Well actually, no we don't; there really don't make sense
2134 (at least not to me) for the i370. However, this code is
2135 left here for any dubious future expansion reasons. */
2136 char *orig_str
= str
;
2138 if ((reloc
= i370_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2145 case BFD_RELOC_LO16
:
2146 /* X_unsigned is the default, so if the user has done
2147 something which cleared it, we always produce a
2149 ex
.X_add_number
= (((ex
.X_add_number
& 0xffff)
2154 case BFD_RELOC_HI16
:
2155 ex
.X_add_number
= (ex
.X_add_number
>> 16) & 0xffff;
2158 case BFD_RELOC_HI16_S
:
2159 ex
.X_add_number
= (((ex
.X_add_number
>> 16) & 0xffff)
2160 + ((ex
.X_add_number
>> 15) & 1));
2164 insn
= i370_insert_operand (insn
, operand
, ex
.X_add_number
);
2167 else if ((reloc
= i370_elf_suffix (&str
, &ex
)) != BFD_RELOC_UNUSED
)
2169 as_tsktsk ("md_assemble(): suffixed relocations not supported\n");
2171 /* We need to generate a fixup for this expression. */
2172 if (fc
>= MAX_INSN_FIXUPS
)
2173 as_fatal ("too many fixups");
2174 fixups
[fc
].exp
= ex
;
2175 fixups
[fc
].opindex
= 0;
2176 fixups
[fc
].reloc
= reloc
;
2179 #endif /* OBJ_ELF */
2182 /* We need to generate a fixup for this expression. */
2183 /* Typically, the expression will just be a symbol ...
2184 printf ("insn %s needs fixup for %s \n",
2185 opcode->name, ex.X_add_symbol->bsym->name); */
2187 if (fc
>= MAX_INSN_FIXUPS
)
2188 as_fatal ("too many fixups");
2189 fixups
[fc
].exp
= ex
;
2190 fixups
[fc
].opindex
= *opindex_ptr
;
2191 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2195 /* Skip over delimiter (close paren, or comma). */
2196 if ((')' == *str
) && (',' == *(str
+1)))
2202 while (ISSPACE (*str
))
2206 as_bad (_("junk at end of line: `%s'"), str
);
2208 /* Write out the instruction. */
2209 f
= frag_more (opcode
->len
);
2210 if (4 >= opcode
->len
)
2211 md_number_to_chars (f
, insn
.i
[0], opcode
->len
);
2214 md_number_to_chars (f
, insn
.i
[0], 4);
2216 if (6 == opcode
->len
)
2217 md_number_to_chars ((f
+ 4), ((insn
.i
[1])>>16), 2);
2220 /* Not used --- don't have any 8 byte instructions. */
2221 as_bad (_("Internal Error: bad instruction length"));
2222 md_number_to_chars ((f
+ 4), insn
.i
[1], opcode
->len
-4);
2226 /* Create any fixups. At this point we do not use a
2227 bfd_reloc_code_real_type, but instead just use the
2228 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2229 handle fixups for any operand type, although that is admittedly
2230 not a very exciting feature. We pick a BFD reloc type in
2232 for (i
= 0; i
< fc
; i
++)
2234 const struct i370_operand
*operand
;
2236 operand
= &i370_operands
[fixups
[i
].opindex
];
2237 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
2239 reloc_howto_type
*reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
2246 size
= bfd_get_reloc_size (reloc_howto
);
2248 if (size
< 1 || size
> 4)
2251 printf (" gwana doo fixup %d \n", i
);
2252 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, size
,
2253 &fixups
[i
].exp
, reloc_howto
->pc_relative
,
2256 /* Turn off complaints that the addend is too large for things like
2258 switch (fixups
[i
].reloc
)
2260 case BFD_RELOC_16_GOTOFF
:
2261 case BFD_RELOC_LO16
:
2262 case BFD_RELOC_HI16
:
2263 case BFD_RELOC_HI16_S
:
2264 fixP
->fx_no_overflow
= 1;
2272 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->len
,
2274 (operand
->flags
& I370_OPERAND_RELATIVE
) != 0,
2275 ((bfd_reloc_code_real_type
)
2276 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
2282 /* Pseudo-op handling. */
2284 /* The .byte pseudo-op. This is similar to the normal .byte
2285 pseudo-op, but it can also take a single ASCII string. */
2288 i370_byte (int ignore ATTRIBUTE_UNUSED
)
2290 if (*input_line_pointer
!= '\"')
2296 /* Gather characters. A real double quote is doubled. Unusual
2297 characters are not permitted. */
2298 ++input_line_pointer
;
2303 c
= *input_line_pointer
++;
2307 if (*input_line_pointer
!= '\"')
2309 ++input_line_pointer
;
2312 FRAG_APPEND_1_CHAR (c
);
2315 demand_empty_rest_of_line ();
2318 /* The .tc pseudo-op. This is used when generating XCOFF and ELF.
2319 This takes two or more arguments.
2321 When generating XCOFF output, the first argument is the name to
2322 give to this location in the toc; this will be a symbol with class
2323 TC. The rest of the arguments are 4 byte values to actually put at
2324 this location in the TOC; often there is just one more argument, a
2325 relocatable symbol reference.
2327 When not generating XCOFF output, the arguments are the same, but
2328 the first argument is simply ignored. */
2331 i370_tc (int ignore ATTRIBUTE_UNUSED
)
2334 /* Skip the TOC symbol name. */
2335 while (is_part_of_name (*input_line_pointer
)
2336 || *input_line_pointer
== '['
2337 || *input_line_pointer
== ']'
2338 || *input_line_pointer
== '{'
2339 || *input_line_pointer
== '}')
2340 ++input_line_pointer
;
2342 /* Align to a four byte boundary. */
2343 frag_align (2, 0, 0);
2344 record_alignment (now_seg
, 2);
2346 if (*input_line_pointer
!= ',')
2347 demand_empty_rest_of_line ();
2350 ++input_line_pointer
;
2356 md_atof (int type
, char *litp
, int *sizep
)
2358 /* 360/370/390 have two float formats: an old, funky 360 single-precision
2359 format, and the ieee format. Support only the ieee format. */
2360 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
2363 /* Write a value out to the object file, using the appropriate
2367 md_number_to_chars (char *buf
, valueT val
, int n
)
2369 number_to_chars_bigendian (buf
, val
, n
);
2372 /* Align a section (I don't know why this is machine dependent). */
2375 md_section_align (asection
*seg
, valueT addr
)
2377 int align
= bfd_get_section_alignment (stdoutput
, seg
);
2379 return (addr
+ (1 << align
) - 1) & -(1 << align
);
2382 /* We don't have any form of relaxing. */
2385 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
2386 asection
*seg ATTRIBUTE_UNUSED
)
2392 /* Convert a machine dependent frag. We never generate these. */
2395 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
2396 asection
*sec ATTRIBUTE_UNUSED
,
2397 fragS
*fragp ATTRIBUTE_UNUSED
)
2402 /* We have no need to default values of symbols. */
2405 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
2410 /* Functions concerning relocs. */
2412 /* The location from which a PC relative jump should be calculated,
2413 given a PC relative reloc. */
2416 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
2418 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2421 /* Apply a fixup to the object code. This is called for all the
2422 fixups we generated by the call to fix_new_exp, above. In the call
2423 above we used a reloc code which was the largest legal reloc code
2424 plus the operand index. Here we undo that to recover the operand
2425 index. At this point all symbol values should be fully resolved,
2426 and we attempt to completely resolve the reloc. If we can not do
2427 that, we determine the correct reloc code and put it back in the
2430 See gas/cgen.c for more sample code and explanations of what's
2434 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg
)
2436 valueT value
= * valP
;
2438 if (fixP
->fx_addsy
!= NULL
)
2441 printf ("\nmd_apply_fix: symbol %s at 0x%x (%s:%d) val=0x%x addend=0x%x\n",
2442 S_GET_NAME (fixP
->fx_addsy
),
2443 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
,
2444 fixP
->fx_file
, fixP
->fx_line
,
2445 S_GET_VALUE (fixP
->fx_addsy
), value
);
2451 /* Apply fixups to operands. Note that there should be no relocations
2452 for any operands, since no instruction ever takes an operand
2453 that requires reloc. */
2454 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2457 const struct i370_operand
*operand
;
2461 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2463 operand
= &i370_operands
[opindex
];
2466 printf ("\nmd_apply_fix: fixup operand %s at 0x%x in %s:%d addend=0x%x\n",
2468 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
,
2469 fixP
->fx_file
, fixP
->fx_line
,
2472 /* Fetch the instruction, insert the fully resolved operand
2473 value, and stuff the instruction back again.
2474 fisxp->fx_size is the length of the instruction. */
2475 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2476 insn
.i
[0] = bfd_getb32 ((unsigned char *) where
);
2478 if (6 <= fixP
->fx_size
)
2479 /* Deal with 48-bit insn's. */
2480 insn
.i
[1] = bfd_getb32 (((unsigned char *) where
)+4);
2482 insn
= i370_insert_operand (insn
, operand
, (offsetT
) value
);
2483 bfd_putb32 ((bfd_vma
) insn
.i
[0], (unsigned char *) where
);
2485 if (6 <= fixP
->fx_size
)
2486 /* Deal with 48-bit insn's. */
2487 bfd_putb32 ((bfd_vma
) insn
.i
[1], (((unsigned char *) where
)+4));
2489 /* We are done, right? right !! */
2492 /* Nothing else to do here. */
2495 /* Determine a BFD reloc value based on the operand information.
2496 We are only prepared to turn a few of the operands into
2497 relocs. In fact, we support *zero* operand relocations ...
2498 Why? Because we are not expecting the compiler to generate
2499 any operands that need relocation. Due to the 12-bit naturew of
2500 i370 addressing, this would be unusual. */
2505 /* Use expr_symbol_where to see if this is an expression
2507 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2508 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2509 "unresolved expression that must be resolved");
2511 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2512 "unsupported relocation type");
2519 /* We branch to here if the fixup is not to a symbol that
2520 appears in an instruction operand, but is rather some
2521 declared storage. */
2523 i370_elf_validate_fix (fixP
, seg
);
2526 printf ("md_apply_fix: reloc case %d in segment %s %s:%d\n",
2527 fixP
->fx_r_type
, segment_name (seg
), fixP
->fx_file
, fixP
->fx_line
);
2528 printf ("\tcurrent fixup value is 0x%x \n", value
);
2530 switch (fixP
->fx_r_type
)
2533 case BFD_RELOC_CTOR
:
2535 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2539 case BFD_RELOC_32_PCREL
:
2540 case BFD_RELOC_32_BASEREL
:
2542 printf ("\t32 bit relocation at 0x%x\n",
2543 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
);
2545 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2549 case BFD_RELOC_LO16
:
2552 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2553 "cannot emit PC relative %s relocation%s%s",
2554 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2555 fixP
->fx_addsy
!= NULL
? " against " : "",
2556 (fixP
->fx_addsy
!= NULL
2557 ? S_GET_NAME (fixP
->fx_addsy
)
2560 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2564 /* This case happens when you write, for example,
2566 where L1 and L2 are defined later. */
2567 case BFD_RELOC_HI16
:
2570 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2573 case BFD_RELOC_HI16_S
:
2576 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2577 (value
+ 0x8000) >> 16, 2);
2584 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2590 "Gas failure, reloc value %d\n", fixP
->fx_r_type
);
2596 fixP
->fx_addnumber
= value
;
2599 /* Generate a reloc for a fixup. */
2602 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2606 reloc
= xmalloc (sizeof (arelent
));
2608 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
2609 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2610 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2611 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
2612 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
2614 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2615 "reloc %d not supported by object file format", (int)fixp
->fx_r_type
);
2618 reloc
->addend
= fixp
->fx_addnumber
;
2621 printf ("\ngen_reloc(): sym %s (%s:%d) at addr 0x%x addend=0x%x\n",
2622 fixp
->fx_addsy
->bsym
->name
,
2623 fixp
->fx_file
, fixp
->fx_line
,
2624 reloc
->address
, reloc
->addend
);
2630 /* The target specific pseudo-ops which we support. */
2632 const pseudo_typeS md_pseudo_table
[] =
2634 /* Pseudo-ops which must be overridden. */
2635 { "byte", i370_byte
, 0 },
2637 { "dc", i370_dc
, 0 },
2638 { "ds", i370_ds
, 0 },
2639 { "rmode", i370_rmode
, 0 },
2640 { "csect", i370_csect
, 0 },
2641 { "dsect", i370_dsect
, 0 },
2643 /* enable ebcdic strings e.g. for 3270 support */
2644 { "ebcdic", i370_ebcdic
, 0 },
2647 { "long", i370_elf_cons
, 4 },
2648 { "word", i370_elf_cons
, 4 },
2649 { "short", i370_elf_cons
, 2 },
2650 { "rdata", i370_elf_rdata
, 0 },
2651 { "rodata", i370_elf_rdata
, 0 },
2652 { "lcomm", i370_elf_lcomm
, 0 },
2655 /* This pseudo-op is used even when not generating XCOFF output. */
2656 { "tc", i370_tc
, 0 },
2658 /* dump the literal pool */
2659 { "ltorg", i370_ltorg
, 0 },
2661 /* support the hlasm-style USING directive */
2662 { "using", i370_using
, 0 },
2663 { "drop", i370_drop
, 0 },