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 */
960 case 'D': /* 64-bit */
961 md_atof (type, tmp, &nbytes);
962 p = frag_more (nbytes);
963 memcpy (p, tmp, nbytes);
966 as_bad (_("unsupported DC type"));
970 demand_empty_rest_of_line ();
974 /* Provide minimal support for DS Define Storage. */
977 i370_ds (int unused ATTRIBUTE_UNUSED)
979 /* DS 0H or DS 0F or DS 0D. */
980 if ('0' == *input_line_pointer)
982 int alignment = 0; /* Left shift 1 << align. */
983 input_line_pointer ++;
984 switch (*input_line_pointer++)
986 case 'H': /* 16-bit */
989 case 'F': /* 32-bit */
992 case 'D': /* 64-bit */
996 as_bad (_("unsupported alignment"));
999 frag_align (alignment, 0, 0);
1000 record_alignment (now_seg, alignment);
1003 as_bad (_("this DS form not yet supported"));
1006 /* Solaris pseudo op to change to the .rodata section. */
1009 i370_elf_rdata (int sect)
1011 char *save_line = input_line_pointer;
1012 static char section[] = ".rodata\n";
1014 /* Just pretend this is .section .rodata. */
1015 input_line_pointer = section;
1016 obj_elf_section (sect);
1018 input_line_pointer = save_line;
1021 /* Pseudo op to make file scope bss items. */
1024 i370_elf_lcomm (int unused ATTRIBUTE_UNUSED)
1037 c = get_symbol_name (&name);
1039 /* Just after name is now '\0'. */
1040 p = input_line_pointer;
1041 (void) restore_line_pointer (c);
1043 if (*input_line_pointer != ',')
1045 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1046 ignore_rest_of_line ();
1051 input_line_pointer++;
1052 if ((size = get_absolute_expression ()) < 0)
1054 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
1055 ignore_rest_of_line ();
1059 /* The third argument to .lcomm is the alignment. */
1060 if (*input_line_pointer != ',')
1064 ++input_line_pointer;
1065 align = get_absolute_expression ();
1068 as_warn (_("ignoring bad alignment"));
1074 symbolP = symbol_find_or_make (name);
1077 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1079 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1080 S_GET_NAME (symbolP));
1081 ignore_rest_of_line ();
1085 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1087 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1088 S_GET_NAME (symbolP),
1089 (long) S_GET_VALUE (symbolP),
1092 ignore_rest_of_line ();
1098 old_subsec = now_subseg;
1101 /* Convert to a power of 2 alignment. */
1102 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2)
1106 as_bad (_("Common alignment not a power of 2"));
1107 ignore_rest_of_line ();
1114 record_alignment (bss_section, align2);
1115 subseg_set (bss_section, 0);
1117 frag_align (align2, 0, 0);
1118 if (S_GET_SEGMENT (symbolP) == bss_section)
1119 symbol_get_frag (symbolP)->fr_symbol = 0;
1120 symbol_set_frag (symbolP, frag_now);
1121 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1124 S_SET_SIZE (symbolP, size);
1125 S_SET_SEGMENT (symbolP, bss_section);
1126 subseg_set (old_sec, old_subsec);
1127 demand_empty_rest_of_line ();
1130 /* Validate any relocations emitted for -mrelocatable, possibly adding
1131 fixups for word relocations in writable segments, so we can adjust
1135 i370_elf_validate_fix (fixS *fixp, segT seg)
1137 if (fixp->fx_done || fixp->fx_pcrel)
1146 case SHILB_MRELOCATABLE:
1147 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1148 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1149 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1150 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1151 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1152 && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1153 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1154 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1155 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1156 && strcmp (segment_name (seg), ".got2") != 0
1157 && strcmp (segment_name (seg), ".dtors") != 0
1158 && strcmp (segment_name (seg), ".ctors") != 0
1159 && strcmp (segment_name (seg), ".fixup") != 0
1160 && strcmp (segment_name (seg), ".stab") != 0
1161 && strcmp (segment_name (seg), ".gcc_except_table") != 0
1162 && strcmp (segment_name (seg), ".ex_shared") != 0)
1164 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1165 || fixp->fx_r_type != BFD_RELOC_CTOR)
1166 as_bad_where (fixp->fx_file, fixp->fx_line,
1167 "Relocation cannot be done when using -mrelocatable");
1174 #endif /* OBJ_ELF */
1177 #define LITERAL_POOL_SUPPORT
1178 #ifdef LITERAL_POOL_SUPPORT
1179 /* Provide support for literal pools within the text section.
1180 Loosely based on similar code from tc-arm.c.
1181 We will use four symbols to locate four parts of the literal pool.
1182 These four sections contain 64,32,16 and 8-bit constants; we use
1183 four sections so that all memory access can be appropriately aligned.
1184 That is, we want to avoid mixing these together so that we don't
1185 waste space padding out to alignments. The four pointers
1186 longlong_poolP, word_poolP, etc. point to a symbol labeling the
1187 start of each pool part.
1189 lit_pool_num increments from zero to infinity and uniquely id's
1190 -- its used to generate the *_poolP symbol name. */
1192 #define MAX_LITERAL_POOL_SIZE 1024
1194 typedef struct literalS
1196 struct expressionS exp;
1198 char size; /* 1,2,4 or 8 */
1202 literalT literals[MAX_LITERAL_POOL_SIZE];
1203 int next_literal_pool_place = 0; /* Next free entry in the pool. */
1205 static symbolS *longlong_poolP = NULL; /* 64-bit pool entries. */
1206 static symbolS *word_poolP = NULL; /* 32-bit pool entries. */
1207 static symbolS *short_poolP = NULL; /* 16-bit pool entries. */
1208 static symbolS *byte_poolP = NULL; /* 8-bit pool entries. */
1210 static int lit_pool_num = 1;
1212 /* Create a new, empty symbol. */
1214 symbol_make_empty (void)
1216 return symbol_create (FAKE_LABEL_NAME, undefined_section,
1217 (valueT) 0, &zero_address_frag);
1220 /* Make the first argument an address-relative expression
1221 by subtracting the second argument. */
1224 i370_make_relative (expressionS *exx, expressionS *baseaddr)
1226 if (O_constant == baseaddr->X_op)
1228 exx->X_op = O_symbol;
1229 exx->X_add_number -= baseaddr->X_add_number;
1231 else if (O_symbol == baseaddr->X_op)
1233 exx->X_op = O_subtract;
1234 exx->X_op_symbol = baseaddr->X_add_symbol;
1235 exx->X_add_number -= baseaddr->X_add_number;
1237 else if (O_uminus == baseaddr->X_op)
1240 exx->X_op_symbol = baseaddr->X_add_symbol;
1241 exx->X_add_number += baseaddr->X_add_number;
1244 as_bad (_("Missing or bad .using directive"));
1246 /* Add an expression to the literal pool. */
1249 add_to_lit_pool (expressionS *exx, char *name, int sz)
1252 int offset_in_pool = 0;
1254 /* Start a new pool, if necessary. */
1255 if (8 == sz && NULL == longlong_poolP)
1256 longlong_poolP = symbol_make_empty ();
1257 else if (4 == sz && NULL == word_poolP)
1258 word_poolP = symbol_make_empty ();
1259 else if (2 == sz && NULL == short_poolP)
1260 short_poolP = symbol_make_empty ();
1261 else if (1 == sz && NULL == byte_poolP)
1262 byte_poolP = symbol_make_empty ();
1264 /* Check if this literal value is already in the pool.
1265 FIXME: We should probably be checking expressions
1266 of type O_symbol as well.
1267 FIXME: This is probably(certainly?) broken for O_big,
1268 which includes 64-bit long-longs. */
1269 while (lit_count < next_literal_pool_place)
1271 if (exx->X_op == O_constant
1272 && literals[lit_count].exp.X_op == exx->X_op
1273 && literals[lit_count].exp.X_add_number == exx->X_add_number
1274 && literals[lit_count].exp.X_unsigned == exx->X_unsigned
1275 && literals[lit_count].size == sz)
1277 else if (literals[lit_count].sym_name
1279 && !strcmp (name, literals[lit_count].sym_name))
1281 if (sz == literals[lit_count].size)
1282 offset_in_pool += sz;
1286 if (lit_count == next_literal_pool_place) /* new entry */
1288 if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE)
1289 as_bad (_("Literal Pool Overflow"));
1291 literals[next_literal_pool_place].exp = *exx;
1292 literals[next_literal_pool_place].size = sz;
1293 literals[next_literal_pool_place].offset = offset_in_pool;
1295 literals[next_literal_pool_place].sym_name = strdup (name);
1297 literals[next_literal_pool_place].sym_name = NULL;
1298 next_literal_pool_place++;
1301 /* ???_poolP points to the beginning of the literal pool.
1302 X_add_number is the offset from the beginning of the
1303 literal pool to this expr minus the location of the most
1304 recent .using directive. Thus, the grand total value of the
1305 expression is the distance from .using to the literal. */
1307 exx->X_add_symbol = longlong_poolP;
1309 exx->X_add_symbol = word_poolP;
1311 exx->X_add_symbol = short_poolP;
1313 exx->X_add_symbol = byte_poolP;
1314 exx->X_add_number = offset_in_pool;
1315 exx->X_op_symbol = NULL;
1317 /* If the user has set up a base reg in another section,
1318 use that; otherwise use the text section. */
1319 if (0 < i370_using_other_regno)
1320 i370_make_relative (exx, &i370_using_other_baseaddr);
1322 i370_make_relative (exx, &i370_using_text_baseaddr);
1325 /* The symbol setup for the literal pool is done in two steps. First,
1326 a symbol that represents the start of the literal pool is created,
1327 above, in the add_to_pool() routine. This sym ???_poolP.
1328 However, we don't know what fragment its in until a bit later.
1329 So we defer the frag_now thing, and the symbol name, until .ltorg time. */
1331 /* Can't use symbol_new here, so have to create a symbol and then at
1332 a later date assign it a value. Thats what these functions do. */
1335 symbol_locate (symbolS *symbolP,
1336 const char *name, /* It is copied, the caller can modify. */
1337 segT segment, /* Segment identifier (SEG_<something>). */
1338 valueT valu, /* Symbol value. */
1339 fragS *frag) /* Associated fragment. */
1342 char *preserved_copy_of_name;
1344 name_length = strlen (name) + 1; /* +1 for \0 */
1345 obstack_grow (¬es, name, name_length);
1346 preserved_copy_of_name = obstack_finish (¬es);
1348 S_SET_NAME (symbolP, preserved_copy_of_name);
1350 S_SET_SEGMENT (symbolP, segment);
1351 S_SET_VALUE (symbolP, valu);
1352 symbol_clear_list_pointers (symbolP);
1354 symbol_set_frag (symbolP, frag);
1356 /* Link to end of symbol chain. */
1358 extern int symbol_table_frozen;
1360 if (symbol_table_frozen)
1364 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
1366 obj_symbol_new_hook (symbolP);
1368 #ifdef tc_symbol_new_hook
1369 tc_symbol_new_hook (symbolP);
1374 verify_symbol_chain(symbol_rootP, symbol_lastP);
1375 #endif /* DEBUG_SYMS */
1378 /* i370_addr_offset() will convert operand expressions
1379 that appear to be absolute into their base-register
1380 relative form. These expressions come in two types:
1382 (1) of the form "* + const" * where "*" means
1383 relative offset since the last using
1384 i.e. "*" means ".-using_baseaddr"
1386 (2) labels, which are never absolute, but are always
1387 relative to the last "using". Anything with an alpha
1388 character is considered to be a label (since symbols
1389 can never be operands), and since we've already handled
1390 register operands. For example, "BL .L33" branch low
1391 to .L33 RX form insn frequently terminates for-loops. */
1394 i370_addr_offset (expressionS *exx)
1400 /* Search for a label; anything with an alpha char will do.
1401 Local labels consist of N digits followed by either b or f. */
1402 lab = input_line_pointer;
1403 while (*lab && (',' != *lab) && ('(' != *lab))
1407 else if (ISALPHA (*lab))
1414 else if (('f' == *lab) || ('b' == *lab))
1422 else if ('.' != *lab)
1427 /* See if operand has a * in it. */
1428 dot = strchr (input_line_pointer, '*');
1430 if (!dot && !islabel)
1433 /* Replace * with . and let expr munch on it. */
1438 /* OK, now we have to subtract the "using" location.
1439 Normally branches appear in the text section only. */
1440 if (0 == strncmp (now_seg->name, ".text", 5) || 0 > i370_using_other_regno)
1441 i370_make_relative (exx, &i370_using_text_baseaddr);
1443 i370_make_relative (exx, &i370_using_other_baseaddr);
1445 /* Put the * back. */
1452 /* Handle address constants of various sorts. */
1453 /* The currently supported types are
1456 =X'deadbeef' hexadecimal
1457 =F'1234' 32-bit const int
1458 =H'1234' 16-bit const int. */
1461 i370_addr_cons (expressionS *exp)
1464 char *sym_name, delim;
1469 name = input_line_pointer;
1470 sym_name = input_line_pointer;
1471 /* Find the spelling of the operand. */
1472 if (name[0] == '=' && ISALPHA (name[1]))
1473 name = ++input_line_pointer;
1479 case 'A': /* A == address-of. */
1480 case 'V': /* V == extern. */
1481 ++input_line_pointer;
1484 /* We use a simple string name to collapse together
1485 multiple references to the same address literal. */
1486 name_len = strcspn (sym_name, ", ");
1487 delim = *(sym_name + name_len);
1488 *(sym_name + name_len) = 0x0;
1489 add_to_lit_pool (exp, sym_name, 4);
1490 *(sym_name + name_len) = delim;
1496 case 'E': /* Single-precision float point. */
1497 case 'D': /* Double-precision float point. */
1499 /* H == 16-bit fixed-point const; expression must be const. */
1500 /* F == fixed-point const; expression must be const. */
1501 /* X == fixed-point const; expression must be const. */
1502 if ('H' == name[0]) cons_len = 2;
1503 else if ('F' == name[0]) cons_len = 4;
1504 else if ('X' == name[0]) cons_len = -1;
1505 else if ('E' == name[0]) cons_len = 4;
1506 else if ('D' == name[0]) cons_len = 8;
1508 /* Extract length, if it is present;
1509 FIXME: assume single-digit length. */
1512 /* Should work for ASCII and EBCDIC. */
1513 cons_len = name[2] - '0';
1514 input_line_pointer += 2;
1517 ++input_line_pointer;
1519 /* Get rid of pesky quotes. */
1520 if ('\'' == *input_line_pointer)
1524 ++input_line_pointer;
1525 clse = strchr (input_line_pointer, '\'');
1529 as_bad (_("missing end-quote"));
1531 if ('\"' == *input_line_pointer)
1535 ++input_line_pointer;
1536 clse = strchr (input_line_pointer, '\"');
1540 as_bad (_("missing end-quote"));
1542 if (('X' == name[0]) || ('E' == name[0]) || ('D' == name[0]))
1547 /* The length of hex constants is specified directly with L,
1548 or implied through the number of hex digits. For example:
1551 =X'000000AB' four bytes
1552 =XL4'AB' four bytes, left-padded withn zero. */
1553 if (('X' == name[0]) && (0 > cons_len))
1555 save = input_line_pointer;
1558 if (ISXDIGIT (*save))
1562 cons_len = (hex_len+1) /2;
1564 /* I believe this works even for =XL8'dada0000beeebaaa'
1565 which should parse out to X_op == O_big
1566 Note that floats and doubles get represented as
1567 0d3.14159265358979 or 0f 2.7. */
1571 strcat (tmp, input_line_pointer);
1572 save = input_line_pointer;
1573 input_line_pointer = tmp;
1575 input_line_pointer = save + (input_line_pointer-tmp-2);
1577 /* Fix up lengths for floats and doubles. */
1578 if (O_big == exp->X_op)
1579 exp->X_add_number = cons_len / CHARS_PER_LITTLENUM;
1584 /* O_big occurs when more than 4 bytes worth gets parsed. */
1585 if ((exp->X_op != O_constant) && (exp->X_op != O_big))
1587 as_bad (_("expression not a constant"));
1590 add_to_lit_pool (exp, 0x0, cons_len);
1594 as_bad (_("Unknown/unsupported address literal type"));
1602 /* Dump the contents of the literal pool that we've accumulated so far.
1603 This aligns the pool to the size of the largest literal in the pool. */
1606 i370_ltorg (int ignore ATTRIBUTE_UNUSED)
1610 int biggest_literal_size = 0;
1611 int biggest_align = 0;
1614 if (strncmp (now_seg->name, ".text", 5))
1616 if (i370_other_section == undefined_section)
1617 as_bad (_(".ltorg without prior .using in section %s"),
1620 if (i370_other_section != now_seg)
1621 as_bad (_(".ltorg in section %s paired to .using in section %s"),
1622 now_seg->name, i370_other_section->name);
1625 if (! longlong_poolP
1629 /* Nothing to do. */
1632 /* Find largest literal .. 2 4 or 8. */
1634 while (lit_count < next_literal_pool_place)
1636 if (biggest_literal_size < literals[lit_count].size)
1637 biggest_literal_size = literals[lit_count].size;
1640 if (1 == biggest_literal_size) biggest_align = 0;
1641 else if (2 == biggest_literal_size) biggest_align = 1;
1642 else if (4 == biggest_literal_size) biggest_align = 2;
1643 else if (8 == biggest_literal_size) biggest_align = 3;
1644 else as_bad (_("bad alignment of %d bytes in literal pool"), biggest_literal_size);
1645 if (0 == biggest_align) biggest_align = 1;
1647 /* Align pool for short, word, double word accesses. */
1648 frag_align (biggest_align, 0, 0);
1649 record_alignment (now_seg, biggest_align);
1651 /* Note that the gas listing will print only the first five
1652 entries in the pool .... wonder how to make it print more. */
1653 /* Output largest literals first, then the smaller ones. */
1654 for (litsize=8; litsize; litsize /=2)
1656 symbolS *current_poolP = NULL;
1660 current_poolP = longlong_poolP; break;
1662 current_poolP = word_poolP; break;
1664 current_poolP = short_poolP; break;
1666 current_poolP = byte_poolP; break;
1668 as_bad (_("bad literal size\n"));
1670 if (NULL == current_poolP)
1672 sprintf (pool_name, ".LITP%01d%06d", litsize, lit_pool_num);
1673 symbol_locate (current_poolP, pool_name, now_seg,
1674 (valueT) frag_now_fix (), frag_now);
1675 symbol_table_insert (current_poolP);
1678 while (lit_count < next_literal_pool_place)
1680 if (litsize == literals[lit_count].size)
1682 #define EMIT_ADDR_CONS_SYMBOLS
1683 #ifdef EMIT_ADDR_CONS_SYMBOLS
1684 /* Create a bogus symbol, add it to the pool ...
1685 For the most part, I think this is a useless exercise,
1686 except that having these symbol names in the objects
1687 is vaguely useful for debugging. */
1688 if (literals[lit_count].sym_name)
1690 symbolS * symP = symbol_make_empty ();
1691 symbol_locate (symP, literals[lit_count].sym_name, now_seg,
1692 (valueT) frag_now_fix (), frag_now);
1693 symbol_table_insert (symP);
1695 #endif /* EMIT_ADDR_CONS_SYMBOLS */
1697 emit_expr (&(literals[lit_count].exp), literals[lit_count].size);
1703 next_literal_pool_place = 0;
1704 longlong_poolP = NULL;
1711 #endif /* LITERAL_POOL_SUPPORT */
1714 /* Add support for the HLASM-like USING directive to indicate
1715 the base register to use ... we don't support the full
1716 hlasm semantics for this ... we merely pluck a base address
1717 and a register number out. We print a warning if using is
1718 called multiple times. I suppose we should check to see
1719 if the regno is valid. */
1722 i370_using (int ignore ATTRIBUTE_UNUSED)
1724 expressionS ex, baseaddr;
1728 /* If "*" appears in a using, it means "."
1729 replace it with "." so that expr doesn't get confused. */
1730 star = strchr (input_line_pointer, '*');
1734 /* The first arg to using will usually be ".", but it can
1735 be a more complex expression too. */
1736 expression (&baseaddr);
1739 if (O_constant != baseaddr.X_op
1740 && O_symbol != baseaddr.X_op
1741 && O_uminus != baseaddr.X_op)
1742 as_bad (_(".using: base address expression illegal or too complex"));
1744 if (*input_line_pointer != '\0') ++input_line_pointer;
1746 /* The second arg to using had better be a register. */
1747 register_name (&ex);
1748 demand_empty_rest_of_line ();
1749 iregno = ex.X_add_number;
1751 if (0 == strncmp (now_seg->name, ".text", 5))
1753 i370_using_text_baseaddr = baseaddr;
1754 i370_using_text_regno = iregno;
1758 i370_using_other_baseaddr = baseaddr;
1759 i370_using_other_regno = iregno;
1760 i370_other_section = now_seg;
1765 i370_drop (int ignore ATTRIBUTE_UNUSED)
1770 register_name (&ex);
1771 demand_empty_rest_of_line ();
1772 iregno = ex.X_add_number;
1774 if (0 == strncmp (now_seg->name, ".text", 5))
1776 if (iregno != i370_using_text_regno)
1777 as_bad (_("droping register %d in section %s does not match using register %d"),
1778 iregno, now_seg->name, i370_using_text_regno);
1780 i370_using_text_regno = -1;
1781 i370_using_text_baseaddr.X_op = O_absent;
1785 if (iregno != i370_using_other_regno)
1786 as_bad (_("droping register %d in section %s does not match using register %d"),
1787 iregno, now_seg->name, i370_using_other_regno);
1789 if (i370_other_section != now_seg)
1790 as_bad (_("droping register %d in section %s previously used in section %s"),
1791 iregno, now_seg->name, i370_other_section->name);
1793 i370_using_other_regno = -1;
1794 i370_using_other_baseaddr.X_op = O_absent;
1795 i370_other_section = undefined_section;
1800 /* We need to keep a list of fixups. We can't simply generate them as
1801 we go, because that would require us to first create the frag, and
1802 that would screw up references to ``.''. */
1808 bfd_reloc_code_real_type reloc;
1811 #define MAX_INSN_FIXUPS 5
1813 /* Handle a macro. Gather all the operands, transform them as
1814 described by the macro, and call md_assemble recursively. All the
1815 operands are separated by commas; we don't accept parentheses
1816 around operands here. */
1819 i370_macro (char *str, const struct i370_macro *macro)
1830 /* Gather the users operands into the operands array. */
1835 if (count >= sizeof operands / sizeof operands[0])
1837 operands[count++] = s;
1838 s = strchr (s, ',');
1839 if (s == (char *) NULL)
1844 if (count != macro->operands)
1846 as_bad (_("wrong number of operands"));
1850 /* Work out how large the string must be (the size is unbounded
1851 because it includes user input). */
1853 format = macro->format;
1854 while (*format != '\0')
1863 arg = strtol (format + 1, &send, 10);
1864 know (send != format && arg >= 0 && (unsigned) arg < count);
1865 len += strlen (operands[arg]);
1870 /* Put the string together. */
1871 complete = s = XNEWVEC (char, len + 1);
1872 format = macro->format;
1873 while (*format != '\0')
1879 arg = strtol (format + 1, &send, 10);
1880 strcpy (s, operands[arg]);
1887 /* Assemble the constructed instruction. */
1888 md_assemble (complete);
1892 /* This routine is called for each instruction to be assembled. */
1895 md_assemble (char *str)
1898 const struct i370_opcode *opcode;
1900 const unsigned char *opindex_ptr;
1901 int have_optional_index, have_optional_basereg, have_optional_reg;
1902 int skip_optional_index, skip_optional_basereg, skip_optional_reg;
1903 int use_text=0, use_other=0;
1905 struct i370_fixup fixups[MAX_INSN_FIXUPS];
1910 bfd_reloc_code_real_type reloc;
1913 /* Get the opcode. */
1914 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1919 /* Look up the opcode in the hash table. */
1920 opcode = (const struct i370_opcode *) hash_find (i370_hash, str);
1921 if (opcode == (const struct i370_opcode *) NULL)
1923 const struct i370_macro *macro;
1925 gas_assert (i370_macro_hash);
1926 macro = (const struct i370_macro *) hash_find (i370_macro_hash, str);
1927 if (macro == (const struct i370_macro *) NULL)
1928 as_bad (_("Unrecognized opcode: `%s'"), str);
1930 i370_macro (s, macro);
1935 insn = opcode->opcode;
1938 while (ISSPACE (*str))
1941 /* I370 operands are either expressions or address constants.
1942 Many operand types are optional. The optional operands
1943 are always surrounded by parens, and are used to denote the base
1944 register ... e.g. "A R1, D2" or "A R1, D2(,B2) as opposed to
1945 the fully-formed "A R1, D2(X2,B2)". Note also the = sign,
1946 such as A R1,=A(i) where the address-of operator =A implies
1947 use of both a base register, and a missing index register.
1949 So, before we start seriously parsing the operands, we check
1950 to see if we have an optional operand, and, if we do, we count
1951 the number of commas to see which operand should be omitted. */
1953 have_optional_index = have_optional_basereg = have_optional_reg = 0;
1954 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1956 const struct i370_operand *operand;
1958 operand = &i370_operands[*opindex_ptr];
1959 if ((operand->flags & I370_OPERAND_INDEX) != 0)
1960 have_optional_index = 1;
1961 if ((operand->flags & I370_OPERAND_BASE) != 0)
1962 have_optional_basereg = 1;
1963 if ((operand->flags & I370_OPERAND_OPTIONAL) != 0)
1964 have_optional_reg = 1;
1967 skip_optional_index = skip_optional_basereg = skip_optional_reg = 0;
1968 if (have_optional_index || have_optional_basereg)
1970 unsigned int opcount, nwanted;
1972 /* There is an optional operand. Count the number of
1973 commas and open-parens in the input line. */
1980 while ((s = strpbrk (s, ",(=")) != (char *) NULL)
1984 if (',' == *s) ++s; /* avoid counting things like (, */
1985 if ('=' == *s) { ++s; --opcount; }
1989 /* If there are fewer operands in the line then are called
1990 for by the instruction, we want to skip the optional
1992 nwanted = strlen ((char *) opcode->operands);
1993 if (have_optional_index)
1995 if (opcount < nwanted)
1996 skip_optional_index = 1;
1997 if (have_optional_basereg && ((opcount+1) < nwanted))
1998 skip_optional_basereg = 1;
1999 if (have_optional_reg && ((opcount+1) < nwanted))
2000 skip_optional_reg = 1;
2004 if (have_optional_basereg && (opcount < nwanted))
2005 skip_optional_basereg = 1;
2006 if (have_optional_reg && (opcount < nwanted))
2007 skip_optional_reg = 1;
2011 /* Perform some off-by-one hacks on the length field of certain instructions.
2012 Its such a shame to have to do this, but the problem is that HLASM got
2013 defined so that the lengths differ by one from the actual machine instructions.
2014 this code should probably be moved to a special inster-operand routine.
2015 Sigh. Affected instructions are Compare Logical, Move and Exclusive OR
2016 hack alert -- aren't *all* SS instructions affected ?? */
2018 if (0 == strcasecmp ("CLC", opcode->name)
2019 || 0 == strcasecmp ("ED", opcode->name)
2020 || 0 == strcasecmp ("EDMK", opcode->name)
2021 || 0 == strcasecmp ("MVC", opcode->name)
2022 || 0 == strcasecmp ("MVCIN", opcode->name)
2023 || 0 == strcasecmp ("MVN", opcode->name)
2024 || 0 == strcasecmp ("MVZ", opcode->name)
2025 || 0 == strcasecmp ("NC", opcode->name)
2026 || 0 == strcasecmp ("OC", opcode->name)
2027 || 0 == strcasecmp ("XC", opcode->name))
2030 /* Gather the operands. */
2032 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2034 const struct i370_operand *operand;
2038 operand = &i370_operands[*opindex_ptr];
2040 /* If this is an index operand, and we are skipping it,
2041 just insert a zero. */
2042 if (skip_optional_index &&
2043 ((operand->flags & I370_OPERAND_INDEX) != 0))
2045 insn = i370_insert_operand (insn, operand, 0);
2049 /* If this is the base operand, and we are skipping it,
2050 just insert the current using basreg. */
2051 if (skip_optional_basereg &&
2052 ((operand->flags & I370_OPERAND_BASE) != 0))
2057 if (0 == strncmp (now_seg->name, ".text", 5)
2058 || 0 > i370_using_other_regno)
2059 basereg = i370_using_text_regno;
2061 basereg = i370_using_other_regno;
2065 if (0 > i370_using_other_regno)
2066 basereg = i370_using_text_regno;
2068 basereg = i370_using_other_regno;
2071 as_bad (_("not using any base register"));
2073 insn = i370_insert_operand (insn, operand, basereg);
2077 /* If this is an optional operand, and we are skipping it,
2078 Use zero (since a non-zero value would denote a register) */
2079 if (skip_optional_reg
2080 && ((operand->flags & I370_OPERAND_OPTIONAL) != 0))
2082 insn = i370_insert_operand (insn, operand, 0);
2086 /* Gather the operand. */
2087 hold = input_line_pointer;
2088 input_line_pointer = str;
2090 /* Register names are only allowed where there are registers. */
2091 if ((operand->flags & I370_OPERAND_GPR) != 0)
2093 /* Quickie hack to get past things like (,r13). */
2094 if (skip_optional_index && (',' == *input_line_pointer))
2096 *input_line_pointer = ' ';
2097 input_line_pointer ++;
2100 if (! register_name (&ex))
2101 as_bad (_("expecting a register for operand %d"),
2102 (int) (opindex_ptr - opcode->operands + 1));
2105 /* Check for an address constant expression. */
2106 /* We will put PSW-relative addresses in the text section,
2107 and address literals in the .data (or other) section. */
2108 else if (i370_addr_cons (&ex))
2110 else if (i370_addr_offset (&ex))
2112 else expression (&ex);
2114 str = input_line_pointer;
2115 input_line_pointer = hold;
2117 /* Perform some off-by-one hacks on the length field of certain instructions.
2118 Its such a shame to have to do this, but the problem is that HLASM got
2119 defined so that the programmer specifies a length that is one greater
2120 than what the machine instruction wants. Sigh. */
2121 if (off_by_one && (0 == strcasecmp ("SS L", operand->name)))
2124 if (ex.X_op == O_illegal)
2125 as_bad (_("illegal operand"));
2126 else if (ex.X_op == O_absent)
2127 as_bad (_("missing operand"));
2128 else if (ex.X_op == O_register)
2129 insn = i370_insert_operand (insn, operand, ex.X_add_number);
2130 else if (ex.X_op == O_constant)
2133 /* Allow @HA, @L, @H on constants.
2134 Well actually, no we don't; there really don't make sense
2135 (at least not to me) for the i370. However, this code is
2136 left here for any dubious future expansion reasons. */
2137 char *orig_str = str;
2139 if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2146 case BFD_RELOC_LO16:
2147 /* X_unsigned is the default, so if the user has done
2148 something which cleared it, we always produce a
2150 ex.X_add_number = (((ex.X_add_number & 0xffff)
2155 case BFD_RELOC_HI16:
2156 ex.X_add_number = (ex.X_add_number >> 16) & 0xffff;
2159 case BFD_RELOC_HI16_S:
2160 ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
2161 + ((ex.X_add_number >> 15) & 1));
2165 insn = i370_insert_operand (insn, operand, ex.X_add_number);
2168 else if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2170 as_tsktsk ("md_assemble(): suffixed relocations not supported\n");
2172 /* We need to generate a fixup for this expression. */
2173 if (fc >= MAX_INSN_FIXUPS)
2174 as_fatal ("too many fixups");
2175 fixups[fc].exp = ex;
2176 fixups[fc].opindex = 0;
2177 fixups[fc].reloc = reloc;
2180 #endif /* OBJ_ELF */
2183 /* We need to generate a fixup for this expression. */
2184 /* Typically, the expression will just be a symbol ...
2185 printf ("insn %s needs fixup for %s \n",
2186 opcode->name, ex.X_add_symbol->bsym->name); */
2188 if (fc >= MAX_INSN_FIXUPS)
2189 as_fatal ("too many fixups");
2190 fixups[fc].exp = ex;
2191 fixups[fc].opindex = *opindex_ptr;
2192 fixups[fc].reloc = BFD_RELOC_UNUSED;
2196 /* Skip over delimiter (close paren, or comma). */
2197 if ((')' == *str) && (',' == *(str+1)))
2203 while (ISSPACE (*str))
2207 as_bad (_("junk at end of line: `%s'"), str);
2209 /* Write out the instruction. */
2210 f = frag_more (opcode->len);
2211 if (4 >= opcode->len)
2212 md_number_to_chars (f, insn.i[0], opcode->len);
2215 md_number_to_chars (f, insn.i[0], 4);
2217 if (6 == opcode->len)
2218 md_number_to_chars ((f + 4), ((insn.i[1])>>16), 2);
2221 /* Not used --- don't have any 8 byte instructions. */
2222 as_bad (_("Internal Error: bad instruction length"));
2223 md_number_to_chars ((f + 4), insn.i[1], opcode->len -4);
2227 /* Create any fixups. At this point we do not use a
2228 bfd_reloc_code_real_type, but instead just use the
2229 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2230 handle fixups for any operand type, although that is admittedly
2231 not a very exciting feature. We pick a BFD reloc type in
2233 for (i = 0; i < fc; i++)
2235 const struct i370_operand *operand;
2237 operand = &i370_operands[fixups[i].opindex];
2238 if (fixups[i].reloc != BFD_RELOC_UNUSED)
2240 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
2247 size = bfd_get_reloc_size (reloc_howto);
2249 if (size < 1 || size > 4)
2252 printf (" gwana doo fixup %d \n", i);
2253 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
2254 &fixups[i].exp, reloc_howto->pc_relative,
2257 /* Turn off complaints that the addend is too large for things like
2259 switch (fixups[i].reloc)
2261 case BFD_RELOC_16_GOTOFF:
2262 case BFD_RELOC_LO16:
2263 case BFD_RELOC_HI16:
2264 case BFD_RELOC_HI16_S:
2265 fixP->fx_no_overflow = 1;
2273 fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->len,
2275 (operand->flags & I370_OPERAND_RELATIVE) != 0,
2276 ((bfd_reloc_code_real_type)
2277 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2283 /* Pseudo-op handling. */
2285 /* The .byte pseudo-op. This is similar to the normal .byte
2286 pseudo-op, but it can also take a single ASCII string. */
2289 i370_byte (int ignore ATTRIBUTE_UNUSED)
2291 if (*input_line_pointer != '\"')
2297 /* Gather characters. A real double quote is doubled. Unusual
2298 characters are not permitted. */
2299 ++input_line_pointer;
2304 c = *input_line_pointer++;
2308 if (*input_line_pointer != '\"')
2310 ++input_line_pointer;
2313 FRAG_APPEND_1_CHAR (c);
2316 demand_empty_rest_of_line ();
2319 /* The .tc pseudo-op. This is used when generating XCOFF and ELF.
2320 This takes two or more arguments.
2322 When generating XCOFF output, the first argument is the name to
2323 give to this location in the toc; this will be a symbol with class
2324 TC. The rest of the arguments are 4 byte values to actually put at
2325 this location in the TOC; often there is just one more argument, a
2326 relocatable symbol reference.
2328 When not generating XCOFF output, the arguments are the same, but
2329 the first argument is simply ignored. */
2332 i370_tc (int ignore ATTRIBUTE_UNUSED)
2335 /* Skip the TOC symbol name. */
2336 while (is_part_of_name (*input_line_pointer)
2337 || *input_line_pointer == '['
2338 || *input_line_pointer == ']'
2339 || *input_line_pointer == '{'
2340 || *input_line_pointer == '}')
2341 ++input_line_pointer;
2343 /* Align to a four byte boundary. */
2344 frag_align (2, 0, 0);
2345 record_alignment (now_seg, 2);
2347 if (*input_line_pointer != ',')
2348 demand_empty_rest_of_line ();
2351 ++input_line_pointer;
2357 md_atof (int type, char *litp, int *sizep)
2359 /* 360/370/390 have two float formats: an old, funky 360 single-precision
2360 format, and the ieee format. Support only the ieee format. */
2361 return ieee_md_atof (type, litp, sizep, TRUE);
2364 /* Write a value out to the object file, using the appropriate
2368 md_number_to_chars (char *buf, valueT val, int n)
2370 number_to_chars_bigendian (buf, val, n);
2373 /* Align a section (I don't know why this is machine dependent). */
2376 md_section_align (asection *seg, valueT addr)
2378 int align = bfd_get_section_alignment (stdoutput, seg);
2380 return (addr + (1 << align) - 1) & -(1 << align);
2383 /* We don't have any form of relaxing. */
2386 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
2387 asection *seg ATTRIBUTE_UNUSED)
2393 /* Convert a machine dependent frag. We never generate these. */
2396 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2397 asection *sec ATTRIBUTE_UNUSED,
2398 fragS *fragp ATTRIBUTE_UNUSED)
2403 /* We have no need to default values of symbols. */
2406 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2411 /* Functions concerning relocs. */
2413 /* The location from which a PC relative jump should be calculated,
2414 given a PC relative reloc. */
2417 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
2419 return fixp->fx_frag->fr_address + fixp->fx_where;
2422 /* Apply a fixup to the object code. This is called for all the
2423 fixups we generated by the call to fix_new_exp, above. In the call
2424 above we used a reloc code which was the largest legal reloc code
2425 plus the operand index. Here we undo that to recover the operand
2426 index. At this point all symbol values should be fully resolved,
2427 and we attempt to completely resolve the reloc. If we can not do
2428 that, we determine the correct reloc code and put it back in the
2431 See gas/cgen.c for more sample code and explanations of what's
2435 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
2437 valueT value = * valP;
2439 if (fixP->fx_addsy != NULL)
2442 printf ("\nmd_apply_fix: symbol %s at 0x%x (%s:%d) val=0x%x addend=0x%x\n",
2443 S_GET_NAME (fixP->fx_addsy),
2444 fixP->fx_frag->fr_address + fixP->fx_where,
2445 fixP->fx_file, fixP->fx_line,
2446 S_GET_VALUE (fixP->fx_addsy), value);
2452 /* Apply fixups to operands. Note that there should be no relocations
2453 for any operands, since no instruction ever takes an operand
2454 that requires reloc. */
2455 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2458 const struct i370_operand *operand;
2462 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2464 operand = &i370_operands[opindex];
2467 printf ("\nmd_apply_fix: fixup operand %s at 0x%x in %s:%d addend=0x%x\n",
2469 fixP->fx_frag->fr_address + fixP->fx_where,
2470 fixP->fx_file, fixP->fx_line,
2473 /* Fetch the instruction, insert the fully resolved operand
2474 value, and stuff the instruction back again.
2475 fisxp->fx_size is the length of the instruction. */
2476 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2477 insn.i[0] = bfd_getb32 ((unsigned char *) where);
2479 if (6 <= fixP->fx_size)
2480 /* Deal with 48-bit insn's. */
2481 insn.i[1] = bfd_getb32 (((unsigned char *) where)+4);
2483 insn = i370_insert_operand (insn, operand, (offsetT) value);
2484 bfd_putb32 ((bfd_vma) insn.i[0], (unsigned char *) where);
2486 if (6 <= fixP->fx_size)
2487 /* Deal with 48-bit insn's. */
2488 bfd_putb32 ((bfd_vma) insn.i[1], (((unsigned char *) where)+4));
2490 /* We are done, right? right !! */
2493 /* Nothing else to do here. */
2496 /* Determine a BFD reloc value based on the operand information.
2497 We are only prepared to turn a few of the operands into
2498 relocs. In fact, we support *zero* operand relocations ...
2499 Why? Because we are not expecting the compiler to generate
2500 any operands that need relocation. Due to the 12-bit naturew of
2501 i370 addressing, this would be unusual. */
2506 /* Use expr_symbol_where to see if this is an expression
2508 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
2509 as_bad_where (fixP->fx_file, fixP->fx_line,
2510 "unresolved expression that must be resolved");
2512 as_bad_where (fixP->fx_file, fixP->fx_line,
2513 "unsupported relocation type");
2520 /* We branch to here if the fixup is not to a symbol that
2521 appears in an instruction operand, but is rather some
2522 declared storage. */
2524 i370_elf_validate_fix (fixP, seg);
2527 printf ("md_apply_fix: reloc case %d in segment %s %s:%d\n",
2528 fixP->fx_r_type, segment_name (seg), fixP->fx_file, fixP->fx_line);
2529 printf ("\tcurrent fixup value is 0x%x \n", value);
2531 switch (fixP->fx_r_type)
2534 case BFD_RELOC_CTOR:
2536 fixP->fx_r_type = BFD_RELOC_32_PCREL;
2540 case BFD_RELOC_32_PCREL:
2541 case BFD_RELOC_32_BASEREL:
2543 printf ("\t32 bit relocation at 0x%x\n",
2544 fixP->fx_frag->fr_address + fixP->fx_where);
2546 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2550 case BFD_RELOC_LO16:
2553 as_bad_where (fixP->fx_file, fixP->fx_line,
2554 "cannot emit PC relative %s relocation%s%s",
2555 bfd_get_reloc_code_name (fixP->fx_r_type),
2556 fixP->fx_addsy != NULL ? " against " : "",
2557 (fixP->fx_addsy != NULL
2558 ? S_GET_NAME (fixP->fx_addsy)
2561 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2565 /* This case happens when you write, for example,
2567 where L1 and L2 are defined later. */
2568 case BFD_RELOC_HI16:
2571 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2574 case BFD_RELOC_HI16_S:
2577 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2578 (value + 0x8000) >> 16, 2);
2585 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2591 "Gas failure, reloc value %d\n", fixP->fx_r_type);
2597 fixP->fx_addnumber = value;
2600 /* Generate a reloc for a fixup. */
2603 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
2607 reloc = XNEW (arelent);
2609 reloc->sym_ptr_ptr = XNEW (asymbol *);
2610 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2611 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2612 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2613 if (reloc->howto == (reloc_howto_type *) NULL)
2615 as_bad_where (fixp->fx_file, fixp->fx_line,
2616 "reloc %d not supported by object file format", (int)fixp->fx_r_type);
2619 reloc->addend = fixp->fx_addnumber;
2622 printf ("\ngen_reloc(): sym %s (%s:%d) at addr 0x%x addend=0x%x\n",
2623 fixp->fx_addsy->bsym->name,
2624 fixp->fx_file, fixp->fx_line,
2625 reloc->address, reloc->addend);
2631 /* The target specific pseudo-ops which we support. */
2633 const pseudo_typeS md_pseudo_table[] =
2635 /* Pseudo-ops which must be overridden. */
2636 { "byte", i370_byte, 0 },
2638 { "dc", i370_dc, 0 },
2639 { "ds", i370_ds, 0 },
2640 { "rmode", i370_rmode, 0 },
2641 { "csect", i370_csect, 0 },
2642 { "dsect", i370_dsect, 0 },
2644 /* enable ebcdic strings e.g. for 3270 support */
2645 { "ebcdic", i370_ebcdic, 0 },
2648 { "long", i370_elf_cons, 4 },
2649 { "word", i370_elf_cons, 4 },
2650 { "short", i370_elf_cons, 2 },
2651 { "rdata", i370_elf_rdata, 0 },
2652 { "rodata", i370_elf_rdata, 0 },
2653 { "lcomm", i370_elf_lcomm, 0 },
2656 /* This pseudo-op is used even when not generating XCOFF output. */
2657 { "tc", i370_tc, 0 },
2659 /* dump the literal pool */
2660 { "ltorg", i370_ltorg, 0 },
2662 /* support the hlasm-style USING directive */
2663 { "using", i370_using, 0 },
2664 { "drop", i370_drop, 0 },