gas/config/tc-i370.c

   1 /* tc-i370.c -- Assembler for the IBM 360/370/390 instruction set.
   2    Loosely based on the ppc files by Linas Vepstas <linas@linas.org> 1998, 99
   3    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   4    2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   5    Written by Ian Lance Taylor, Cygnus Support.
   6
   7    This file is part of GAS, the GNU Assembler.
   8
   9    GAS is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    GAS is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with GAS; see the file COPYING.  If not, write to the Free
  21    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23
  24 /* This assembler implements a very hacked version of an elf-like thing
  25    that gcc emits (when gcc is suitably hacked).  To make it behave more
  26    HLASM-like, try turning on the -M or --mri flag (as there are various
  27    similarities between HLASM and the MRI assemblers, such as section
  28    names, lack of leading . in pseudo-ops, DC and DS, etc.  */
  29
  30 #include "as.h"
  31 #include "safe-ctype.h"
  32 #include "subsegs.h"
  33 #include "struc-symbol.h"
  34
  35 #include "opcode/i370.h"
  36
  37 #ifdef OBJ_ELF
  38 #include "elf/i370.h"
  39 #endif
  40
  41 /* This is the assembler for the System/390 Architecture.  */
  42
  43 /* Tell the main code what the endianness is.  */
  44 extern int target_big_endian;
  45
  46 \f
  47 /* Generic assembler global variables which must be defined by all
  48    targets.  */
  49
  50 #ifdef OBJ_ELF
  51 /* This string holds the chars that always start a comment.  If the
  52    pre-processor is disabled, these aren't very useful.  The macro
  53    tc_comment_chars points to this.  We use this, rather than the
  54    usual comment_chars, so that we can switch for Solaris conventions.  */
  55 static const char i370_eabi_comment_chars[] = "#";
  56
  57 const char *i370_comment_chars = i370_eabi_comment_chars;
  58 #else
  59 const char comment_chars[] = "#";
  60 #endif
  61
  62 /* Characters which start a comment at the beginning of a line.  */
  63 const char line_comment_chars[] = "#*";
  64
  65 /* Characters which may be used to separate multiple commands on a
  66    single line.  */
  67 const char line_separator_chars[] = ";";
  68
  69 /* Characters which are used to indicate an exponent in a floating
  70    point number.  */
  71 const char EXP_CHARS[] = "eE";
  72
  73 /* Characters which mean that a number is a floating point constant,
  74    as in 0d1.0.  */
  75 const char FLT_CHARS[] = "dD";
  76
  77 void
  78 md_show_usage (FILE *stream)
  79 {
  80   fprintf (stream, "\
  81 S/370 options: (these have not yet been tested and may not work) \n\
  82 -u                      ignored\n\
  83 -mregnames              Allow symbolic names for registers\n\
  84 -mno-regnames           Do not allow symbolic names for registers\n");
  85 #ifdef OBJ_ELF
  86   fprintf (stream, "\
  87 -mrelocatable           support for GCC's -mrelocatble option\n\
  88 -mrelocatable-lib       support for GCC's -mrelocatble-lib option\n\
  89 -V                      print assembler version number\n");
  90 #endif
  91 }
  92
  93 /* Whether to use user friendly register names.  */
  94 #define TARGET_REG_NAMES_P TRUE
  95
  96 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
  97
  98 \f
  99 /* Predefined register names if -mregnames
 100    In general, there are lots of them, in an attempt to be compatible
 101    with a number of assemblers.  */
 102
 103 /* Structure to hold information about predefined registers.  */
 104 struct pd_reg
 105   {
 106     char *name;
 107     int value;
 108   };
 109
 110 /* List of registers that are pre-defined:
 111
 112    Each general register has predefined names of the form:
 113    1. r<reg_num> which has the value <reg_num>.
 114    2. r.<reg_num> which has the value <reg_num>.
 115
 116    Each floating point register has predefined names of the form:
 117    1. f<reg_num> which has the value <reg_num>.
 118    2. f.<reg_num> which has the value <reg_num>.
 119
 120    There are only four floating point registers, and these are
 121    commonly labelled 0,2,4 and 6.  Thus, there is no f1, f3, etc.
 122
 123    There are individual registers as well:
 124    rbase or r.base has the value  3  (base register)
 125    rpgt or r.pgt   has the value  4  (page origin table pointer)
 126    rarg or r.arg   has the value 11  (argument pointer)
 127    rtca or r.tca   has the value 12  (table of contents pointer)
 128    rtoc or r.toc   has the value 12  (table of contents pointer)
 129    sp or r.sp      has the value 13  (stack pointer)
 130    dsa or r.dsa    has the value 13  (stack pointer)
 131    lr              has the value 14  (link reg)
 132
 133    The table is sorted. Suitable for searching by a binary search.  */
 134
 135 static const struct pd_reg pre_defined_registers[] =
 136 {
 137   { "arg", 11 },   /* Argument Pointer.  */
 138   { "base", 3 },   /* Base Reg.  */
 139
 140   { "f.0", 0 },    /* Floating point registers.  */
 141   { "f.2", 2 },
 142   { "f.4", 4 },
 143   { "f.6", 6 },
 144
 145   { "f0", 0 },
 146   { "f2", 2 },
 147   { "f4", 4 },
 148   { "f6", 6 },
 149
 150   { "dsa",13 },    /* Stack pointer.  */
 151   { "lr", 14 },    /* Link Register.  */
 152   { "pgt", 4 },    /* Page Origin Table Pointer.  */
 153
 154   { "r.0", 0 },    /* General Purpose Registers.  */
 155   { "r.1", 1 },
 156   { "r.10", 10 },
 157   { "r.11", 11 },
 158   { "r.12", 12 },
 159   { "r.13", 13 },
 160   { "r.14", 14 },
 161   { "r.15", 15 },
 162   { "r.2", 2 },
 163   { "r.3", 3 },
 164   { "r.4", 4 },
 165   { "r.5", 5 },
 166   { "r.6", 6 },
 167   { "r.7", 7 },
 168   { "r.8", 8 },
 169   { "r.9", 9 },
 170
 171   { "r.arg", 11 },  /* Argument Pointer.  */
 172   { "r.base", 3 },  /* Base Reg.  */
 173   { "r.dsa", 13 },  /* Stack Pointer.  */
 174   { "r.pgt", 4 },   /* Page Origin Table Pointer.  */
 175   { "r.sp", 13 },   /* Stack Pointer.  */
 176
 177   { "r.tca", 12 },  /* Pointer to the table of contents.  */
 178   { "r.toc", 12 },  /* Pointer to the table of contents.  */
 179
 180   { "r0", 0 },      /* More general purpose registers.  */
 181   { "r1", 1 },
 182   { "r10", 10 },
 183   { "r11", 11 },
 184   { "r12", 12 },
 185   { "r13", 13 },
 186   { "r14", 14 },
 187   { "r15", 15 },
 188   { "r2", 2 },
 189   { "r3", 3 },
 190   { "r4", 4 },
 191   { "r5", 5 },
 192   { "r6", 6 },
 193   { "r7", 7 },
 194   { "r8", 8 },
 195   { "r9", 9 },
 196
 197   { "rbase", 3 },  /* Base Reg.  */
 198
 199   { "rtca", 12 },  /* Pointer to the table of contents.  */
 200   { "rtoc", 12 },  /* Pointer to the table of contents.  */
 201
 202   { "sp", 13 },   /* Stack Pointer.  */
 203
 204 };
 205
 206 #define REG_NAME_CNT        (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
 207
 208 /* Given NAME, find the register number associated with that name, return
 209    the integer value associated with the given name or -1 on failure.  */
 210
 211 static int
 212 reg_name_search (const struct pd_reg *regs,
 213                  int regcount,
 214                  const char *name)
 215 {
 216   int middle, low, high;
 217   int cmp;
 218
 219   low = 0;
 220   high = regcount - 1;
 221
 222   do
 223     {
 224       middle = (low + high) / 2;
 225       cmp = strcasecmp (name, regs[middle].name);
 226       if (cmp < 0)
 227         high = middle - 1;
 228       else if (cmp > 0)
 229         low = middle + 1;
 230       else
 231         return regs[middle].value;
 232     }
 233   while (low <= high);
 234
 235   return -1;
 236 }
 237
 238 /* Summary of register_name().
 239
 240    in:        Input_line_pointer points to 1st char of operand.
 241
 242    out:        An expressionS.
 243         The operand may have been a register: in this case, X_op == O_register,
 244         X_add_number is set to the register number, and truth is returned.
 245           Input_line_pointer->(next non-blank) char after operand, or is in its
 246         original state.  */
 247
 248 static bfd_boolean
 249 register_name (expressionS *expressionP)
 250 {
 251   int reg_number;
 252   char *name;
 253   char *start;
 254   char c;
 255
 256   /* Find the spelling of the operand.  */
 257   start = name = input_line_pointer;
 258   if (name[0] == '%' && ISALPHA (name[1]))
 259     name = ++input_line_pointer;
 260
 261   else if (!reg_names_p)
 262     return FALSE;
 263
 264   while (' ' == *name)
 265     name = ++input_line_pointer;
 266
 267   /* If it's a number, treat it as a number.  If it's alpha, look to
 268      see if it's in the register table.  */
 269   if (!ISALPHA (name[0]))
 270     reg_number = get_single_number ();
 271   else
 272     {
 273       c = get_symbol_end ();
 274       reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
 275
 276       /* Put back the delimiting char.  */
 277       *input_line_pointer = c;
 278     }
 279
 280   /* If numeric, make sure its not out of bounds.  */
 281   if ((0 <= reg_number) && (16 >= reg_number))
 282     {
 283       expressionP->X_op = O_register;
 284       expressionP->X_add_number = reg_number;
 285
 286       /* Make the rest nice.  */
 287       expressionP->X_add_symbol = NULL;
 288       expressionP->X_op_symbol = NULL;
 289       return TRUE;
 290     }
 291
 292   /* Reset the line as if we had not done anything.  */
 293   input_line_pointer = start;
 294   return FALSE;
 295 }
 296 \f
 297 /* Local variables.  */
 298
 299 /* The type of processor we are assembling for.  This is one or more
 300    of the I370_OPCODE flags defined in opcode/i370.h.  */
 301 static int i370_cpu = 0;
 302
 303 /* The base register to use for opcode with optional operands.
 304    We define two of these: "text" and "other".  Normally, "text"
 305    would get used in the .text section for branches, while "other"
 306    gets used in the .data section for address constants.
 307
 308    The idea of a second base register in a different section
 309    is foreign to the usual HLASM-style semantics; however, it
 310    allows us to provide support for dynamically loaded libraries,
 311    by allowing us to place address constants in a section other
 312    than the text section. The "other" section need not be the
 313    .data section, it can be any section that isn't the .text section.
 314
 315    Note that HLASM defines a multiple, concurrent .using semantic
 316    that we do not: in calculating offsets, it uses either the most
 317    recent .using directive, or the one with the smallest displacement.
 318    This allows HLASM to support a quasi-block-scope-like behaviour.
 319    Handy for people writing assembly by hand ... but not supported
 320    by us.  */
 321 static int i370_using_text_regno = -1;
 322 static int i370_using_other_regno = -1;
 323
 324 /* The base address for address literals.  */
 325 static expressionS i370_using_text_baseaddr;
 326 static expressionS i370_using_other_baseaddr;
 327
 328 /* the "other" section, used only for syntax error detection.  */
 329 static segT i370_other_section = undefined_section;
 330
 331 /* Opcode hash table.  */
 332 static struct hash_control *i370_hash;
 333
 334 /* Macro hash table.  */
 335 static struct hash_control *i370_macro_hash;
 336
 337 #ifdef OBJ_ELF
 338 /* What type of shared library support to use.  */
 339 static enum { SHLIB_NONE, SHLIB_PIC, SHILB_MRELOCATABLE } shlib = SHLIB_NONE;
 340 #endif
 341
 342 /* Flags to set in the elf header.  */
 343 static flagword i370_flags = 0;
 344
 345 #ifndef WORKING_DOT_WORD
 346 int md_short_jump_size = 4;
 347 int md_long_jump_size = 4;
 348 #endif
 349 \f
 350 #ifdef OBJ_ELF
 351 const char *md_shortopts = "l:um:K:VQ:";
 352 #else
 353 const char *md_shortopts = "um:";
 354 #endif
 355 struct option md_longopts[] =
 356 {
 357   {NULL, no_argument, NULL, 0}
 358 };
 359 size_t md_longopts_size = sizeof (md_longopts);
 360
 361 int
 362 md_parse_option (int c, char *arg)
 363 {
 364   switch (c)
 365     {
 366     case 'u':
 367       /* -u means that any undefined symbols should be treated as
 368          external, which is the default for gas anyhow.  */
 369       break;
 370
 371 #ifdef OBJ_ELF
 372     case 'K':
 373       /* Recognize -K PIC */
 374       if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
 375         {
 376           shlib = SHLIB_PIC;
 377           i370_flags |= EF_I370_RELOCATABLE_LIB;
 378         }
 379       else
 380         return 0;
 381
 382       break;
 383 #endif
 384
 385     case 'm':
 386
 387       /* -m360 mean to assemble for the ancient 360 architecture.  */
 388       if (strcmp (arg, "360") == 0 || strcmp (arg, "i360") == 0)
 389         i370_cpu = I370_OPCODE_360;
 390       /* -mxa means to assemble for the IBM 370 XA.  */
 391       else if (strcmp (arg, "xa") == 0)
 392         i370_cpu = I370_OPCODE_370_XA;
 393       /* -many means to assemble for any architecture (370/XA).  */
 394       else if (strcmp (arg, "any") == 0)
 395         i370_cpu = I370_OPCODE_370;
 396
 397       else if (strcmp (arg, "regnames") == 0)
 398         reg_names_p = TRUE;
 399
 400       else if (strcmp (arg, "no-regnames") == 0)
 401         reg_names_p = FALSE;
 402
 403 #ifdef OBJ_ELF
 404       /* -mrelocatable/-mrelocatable-lib -- warn about
 405          initializations that require relocation.  */
 406       else if (strcmp (arg, "relocatable") == 0)
 407         {
 408           shlib = SHILB_MRELOCATABLE;
 409           i370_flags |= EF_I370_RELOCATABLE;
 410         }
 411       else if (strcmp (arg, "relocatable-lib") == 0)
 412         {
 413           shlib = SHILB_MRELOCATABLE;
 414           i370_flags |= EF_I370_RELOCATABLE_LIB;
 415         }
 416 #endif
 417       else
 418         {
 419           as_bad ("invalid switch -m%s", arg);
 420           return 0;
 421         }
 422       break;
 423
 424 #ifdef OBJ_ELF
 425       /* -V: SVR4 argument to print version ID.  */
 426     case 'V':
 427       print_version_id ();
 428       break;
 429
 430       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
 431          should be emitted or not.  FIXME: Not implemented.  */
 432     case 'Q':
 433       break;
 434
 435 #endif
 436
 437     default:
 438       return 0;
 439     }
 440
 441   return 1;
 442 }
 443
 444 \f
 445 /* Set i370_cpu if it is not already set.
 446    Currently defaults to the reasonable superset;
 447    but can be made more fine grained if desred.  */
 448
 449 static void
 450 i370_set_cpu (void)
 451 {
 452   const char *default_os  = TARGET_OS;
 453   const char *default_cpu = TARGET_CPU;
 454
 455   /* Override with the superset for the moment.  */
 456   i370_cpu = I370_OPCODE_ESA390_SUPERSET;
 457   if (i370_cpu == 0)
 458     {
 459       if (strcmp (default_cpu, "i360") == 0)
 460         i370_cpu = I370_OPCODE_360;
 461       else if (strcmp (default_cpu, "i370") == 0)
 462         i370_cpu = I370_OPCODE_370;
 463       else if (strcmp (default_cpu, "XA") == 0)
 464         i370_cpu = I370_OPCODE_370_XA;
 465       else
 466         as_fatal ("Unknown default cpu = %s, os = %s", default_cpu, default_os);
 467     }
 468 }
 469
 470 /* Figure out the BFD architecture to use.
 471    FIXME: specify the different 370 architectures.  */
 472
 473 enum bfd_architecture
 474 i370_arch (void)
 475 {
 476    return bfd_arch_i370;
 477 }
 478
 479 /* This function is called when the assembler starts up.  It is called
 480    after the options have been parsed and the output file has been
 481    opened.  */
 482
 483 void
 484 md_begin (void)
 485 {
 486   const struct i370_opcode *op;
 487   const struct i370_opcode *op_end;
 488   const struct i370_macro *macro;
 489   const struct i370_macro *macro_end;
 490   bfd_boolean dup_insn = FALSE;
 491
 492   i370_set_cpu ();
 493
 494 #ifdef OBJ_ELF
 495   /* Set the ELF flags if desired.  */
 496   if (i370_flags)
 497     bfd_set_private_flags (stdoutput, i370_flags);
 498 #endif
 499
 500   /* Insert the opcodes into a hash table.  */
 501   i370_hash = hash_new ();
 502
 503    op_end = i370_opcodes + i370_num_opcodes;
 504    for (op = i370_opcodes; op < op_end; op++)
 505      {
 506        know ((op->opcode.i[0] & op->mask.i[0]) == op->opcode.i[0]
 507              && (op->opcode.i[1] & op->mask.i[1]) == op->opcode.i[1]);
 508
 509        if ((op->flags & i370_cpu) != 0)
 510          {
 511            const char *retval;
 512
 513            retval = hash_insert (i370_hash, op->name, (void *) op);
 514            if (retval != (const char *) NULL)
 515              {
 516                as_bad ("Internal assembler error for instruction %s", op->name);
 517                dup_insn = TRUE;
 518              }
 519          }
 520      }
 521
 522   /* Insert the macros into a hash table.  */
 523   i370_macro_hash = hash_new ();
 524
 525   macro_end = i370_macros + i370_num_macros;
 526   for (macro = i370_macros; macro < macro_end; macro++)
 527     {
 528       if ((macro->flags & i370_cpu) != 0)
 529         {
 530           const char *retval;
 531
 532           retval = hash_insert (i370_macro_hash, macro->name, (void *) macro);
 533           if (retval != (const char *) NULL)
 534             {
 535               as_bad ("Internal assembler error for macro %s", macro->name);
 536               dup_insn = TRUE;
 537             }
 538         }
 539     }
 540
 541   if (dup_insn)
 542     abort ();
 543 }
 544
 545 /* Insert an operand value into an instruction.  */
 546
 547 static i370_insn_t
 548 i370_insert_operand (i370_insn_t insn,
 549                      const struct i370_operand *operand,
 550                      offsetT val)
 551 {
 552   if (operand->insert)
 553     {
 554       const char *errmsg;
 555
 556       /* Used for 48-bit insn's.  */
 557       errmsg = NULL;
 558       insn = (*operand->insert) (insn, (long) val, &errmsg);
 559       if (errmsg)
 560         as_bad ("%s", errmsg);
 561     }
 562   else
 563     /* This is used only for 16, 32 bit insn's.  */
 564     insn.i[0] |= (((long) val & ((1 << operand->bits) - 1))
 565                   << operand->shift);
 566
 567   return insn;
 568 }
 569
 570 \f
 571 #ifdef OBJ_ELF
 572 /* Parse @got, etc. and return the desired relocation.
 573    Currently, i370 does not support (don't really need to support) any
 574    of these fancier markups ... for example, no one is going to
 575    write 'L 6,=V(bogus)@got' it just doesn't make sense (at least to me).
 576    So basically, we could get away with this routine returning
 577    BFD_RELOC_UNUSED in all circumstances.  However, I'll leave
 578    in for now in case someone ambitious finds a good use for this stuff ...
 579    this routine was pretty much just copied from the powerpc code ...  */
 580
 581 static bfd_reloc_code_real_type
 582 i370_elf_suffix (char **str_p, expressionS *exp_p)
 583 {
 584   struct map_bfd
 585   {
 586     char *string;
 587     int length;
 588     bfd_reloc_code_real_type reloc;
 589   };
 590
 591   char ident[20];
 592   char *str = *str_p;
 593   char *str2;
 594   int ch;
 595   int len;
 596   struct map_bfd *ptr;
 597
 598 #define MAP(str,reloc) { str, sizeof (str) - 1, reloc }
 599
 600   static struct map_bfd mapping[] =
 601   {
 602     /* warnings with -mrelocatable.  */
 603     MAP ("fixup",       BFD_RELOC_CTOR),
 604     { (char *)0, 0,     BFD_RELOC_UNUSED }
 605   };
 606
 607   if (*str++ != '@')
 608     return BFD_RELOC_UNUSED;
 609
 610   for (ch = *str, str2 = ident;
 611        (str2 < ident + sizeof (ident) - 1
 612         && (ISALNUM (ch) || ch == '@'));
 613        ch = *++str)
 614     *str2++ = TOLOWER (ch);
 615
 616   *str2 = '\0';
 617   len = str2 - ident;
 618
 619   ch = ident[0];
 620   for (ptr = &mapping[0]; ptr->length > 0; ptr++)
 621     if (ch == ptr->string[0]
 622         && len == ptr->length
 623         && memcmp (ident, ptr->string, ptr->length) == 0)
 624       {
 625         if (exp_p->X_add_number != 0
 626             && (ptr->reloc == BFD_RELOC_16_GOTOFF
 627                 || ptr->reloc == BFD_RELOC_LO16_GOTOFF
 628                 || ptr->reloc == BFD_RELOC_HI16_GOTOFF
 629                 || ptr->reloc == BFD_RELOC_HI16_S_GOTOFF))
 630           as_warn ("identifier+constant@got means identifier@got+constant");
 631
 632         /* Now check for identifier@suffix+constant */
 633         if (*str == '-' || *str == '+')
 634           {
 635             char *orig_line = input_line_pointer;
 636             expressionS new_exp;
 637
 638             input_line_pointer = str;
 639             expression (&new_exp);
 640             if (new_exp.X_op == O_constant)
 641               {
 642                 exp_p->X_add_number += new_exp.X_add_number;
 643                 str = input_line_pointer;
 644               }
 645
 646             if (&input_line_pointer != str_p)
 647               input_line_pointer = orig_line;
 648           }
 649
 650         *str_p = str;
 651         return ptr->reloc;
 652       }
 653
 654   return BFD_RELOC_UNUSED;
 655 }
 656
 657 /* Like normal .long/.short/.word, except support @got, etc.
 658    Clobbers input_line_pointer, checks end-of-line.  */
 659
 660 static void
 661 i370_elf_cons (int nbytes)   /* 1=.byte, 2=.word, 4=.long.  */
 662 {
 663   expressionS exp;
 664   bfd_reloc_code_real_type reloc;
 665
 666   if (is_it_end_of_statement ())
 667     {
 668       demand_empty_rest_of_line ();
 669       return;
 670     }
 671
 672   do
 673     {
 674       expression (&exp);
 675
 676       if (exp.X_op == O_symbol
 677           && *input_line_pointer == '@'
 678           && (reloc = i370_elf_suffix (&input_line_pointer, &exp)) != BFD_RELOC_UNUSED)
 679         {
 680           reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
 681           int size = bfd_get_reloc_size (reloc_howto);
 682
 683           if (size > nbytes)
 684             as_bad ("%s relocations do not fit in %d bytes\n", reloc_howto->name, nbytes);
 685           else
 686             {
 687               char *p = frag_more ((int) nbytes);
 688               int offset = nbytes - size;
 689
 690               fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc);
 691             }
 692         }
 693       else
 694         emit_expr (&exp, (unsigned int) nbytes);
 695     }
 696   while (*input_line_pointer++ == ',');
 697
 698   input_line_pointer--;         /* Put terminator back into stream.  */
 699   demand_empty_rest_of_line ();
 700 }
 701
 702 \f
 703 /* ASCII to EBCDIC conversion table.  */
 704 static unsigned char ascebc[256] =
 705 {
 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
 754 };
 755
 756 /* EBCDIC to ASCII conversion table.  */
 757 unsigned char ebcasc[256] =
 758 {
 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,
 773  /*38                    C3    D4    NK          SU */
 774      0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1A,
 775  /*40  SP                                           */
 776      0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 777  /*48                     .     <     (     +     | */
 778      0x00, 0x00, 0x00, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
 779  /*50   &                                           */
 780      0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 781  /*58               !     $     *     )     ;     ^ */
 782      0x00, 0x00, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
 783  /*60   -     /                                     */
 784      0x2D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 785  /*68                     ,     %     _     >     ? */
 786      0x00, 0x00, 0x00, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
 787  /*70                                               */
 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,
 793  /*88   h     i           {                         */
 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,
 797  /*98   q     r           }                         */
 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,
 801  /*A8   y     z                       [             */
 802      0x79, 0x7A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00,
 803  /*B0                                               */
 804      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 805  /*B8                                 ]             */
 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,
 809  /*C8   H     I                                     */
 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,
 813  /*D8   Q     R                                     */
 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,
 817  /*E8   Y     Z                                     */
 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,
 821  /*F8   8     9                                     */
 822      0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF
 823 };
 824
 825 /* EBCDIC translation tables needed for 3270 support.  */
 826
 827 static void
 828 i370_ebcdic (int unused ATTRIBUTE_UNUSED)
 829 {
 830   char *p, *end;
 831   char delim = 0;
 832   size_t nbytes;
 833
 834   nbytes = strlen (input_line_pointer);
 835   end = input_line_pointer + nbytes;
 836   while ('\r' == *end) end --;
 837   while ('\n' == *end) end --;
 838
 839   delim = *input_line_pointer;
 840   if (('\'' == delim) || ('\"' == delim))
 841     {
 842       input_line_pointer ++;
 843       end = rindex (input_line_pointer, delim);
 844     }
 845
 846   if (end > input_line_pointer)
 847     {
 848       nbytes = end - input_line_pointer +1;
 849       p = frag_more (nbytes);
 850       while (end > input_line_pointer)
 851         {
 852           *p = ascebc [(unsigned char) (*input_line_pointer)];
 853           ++p; ++input_line_pointer;
 854         }
 855       *p = '\0';
 856     }
 857   if (delim == *input_line_pointer) ++input_line_pointer;
 858 }
 859
 860 \f
 861 /* Stub out a couple of routines.  */
 862
 863 static void
 864 i370_rmode (int unused ATTRIBUTE_UNUSED)
 865 {
 866   as_tsktsk ("rmode ignored");
 867 }
 868
 869 static void
 870 i370_dsect (int sect)
 871 {
 872   char *save_line = input_line_pointer;
 873   static char section[] = ".data\n";
 874
 875   /* Just pretend this is .section .data.  */
 876   input_line_pointer = section;
 877   obj_elf_section (sect);
 878
 879   input_line_pointer = save_line;
 880 }
 881
 882 static void
 883 i370_csect (int unused ATTRIBUTE_UNUSED)
 884 {
 885   as_tsktsk ("csect not supported");
 886 }
 887
 888 \f
 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.  */
 894
 895 static void
 896 i370_dc (int unused ATTRIBUTE_UNUSED)
 897 {
 898   char * p, tmp[50];
 899   int nbytes=0;
 900   expressionS exp;
 901   char type=0;
 902
 903   if (is_it_end_of_statement ())
 904     {
 905       demand_empty_rest_of_line ();
 906       return;
 907     }
 908
 909   /* Figure out the size.  */
 910   type = *input_line_pointer++;
 911   switch (type)
 912     {
 913     case 'H':  /* 16-bit */
 914       nbytes = 2;
 915       break;
 916     case 'E':  /* 32-bit */
 917     case 'F':  /* 32-bit */
 918       nbytes = 4;
 919       break;
 920     case 'D':  /* 64-bit */
 921       nbytes = 8;
 922       break;
 923     default:
 924       as_bad ("unsupported DC type");
 925       return;
 926     }
 927
 928   /* Get rid of pesky quotes.  */
 929   if ('\'' == *input_line_pointer)
 930     {
 931       char * close;
 932
 933       ++input_line_pointer;
 934       close = strchr (input_line_pointer, '\'');
 935       if (close)
 936         *close= ' ';
 937       else
 938         as_bad ("missing end-quote");
 939     }
 940
 941   if ('\"' == *input_line_pointer)
 942     {
 943       char * close;
 944
 945       ++input_line_pointer;
 946       close = strchr (input_line_pointer, '\"');
 947       if (close)
 948         *close= ' ';
 949       else
 950         as_bad ("missing end-quote");
 951     }
 952
 953   switch (type)
 954     {
 955     case 'H':  /* 16-bit */
 956     case 'F':  /* 32-bit */
 957       expression (&exp);
 958       emit_expr (&exp, nbytes);
 959       break;
 960     case 'E':  /* 32-bit */
 961       type = 'f';
 962     case 'D':  /* 64-bit */
 963       md_atof (type, tmp, &nbytes);
 964       p = frag_more (nbytes);
 965       memcpy (p, tmp, nbytes);
 966       break;
 967     default:
 968       as_bad ("unsupported DC type");
 969       return;
 970     }
 971
 972   demand_empty_rest_of_line ();
 973 }
 974
 975 \f
 976 /* Provide minimal support for DS Define Storage.  */
 977
 978 static void
 979 i370_ds (int unused ATTRIBUTE_UNUSED)
 980 {
 981   /* DS 0H or DS 0F or DS 0D.  */
 982   if ('0' == *input_line_pointer)
 983     {
 984       int alignment = 0;  /* Left shift 1 << align.  */
 985       input_line_pointer ++;
 986       switch (*input_line_pointer++)
 987         {
 988         case 'H':  /* 16-bit */
 989           alignment = 1;
 990           break;
 991         case 'F':  /* 32-bit */
 992           alignment = 2;
 993           break;
 994         case 'D':  /* 64-bit */
 995           alignment = 3;
 996           break;
 997         default:
 998           as_bad ("unsupported alignment");
 999           return;
1000         }
1001       frag_align (alignment, 0, 0);
1002       record_alignment (now_seg, alignment);
1003     }
1004   else
1005     as_bad ("this DS form not yet supported");
1006 }
1007
1008 /* Solaris pseudo op to change to the .rodata section.  */
1009
1010 static void
1011 i370_elf_rdata (int sect)
1012 {
1013   char *save_line = input_line_pointer;
1014   static char section[] = ".rodata\n";
1015
1016   /* Just pretend this is .section .rodata.  */
1017   input_line_pointer = section;
1018   obj_elf_section (sect);
1019
1020   input_line_pointer = save_line;
1021 }
1022
1023 /* Pseudo op to make file scope bss items.  */
1024
1025 static void
1026 i370_elf_lcomm (int unused ATTRIBUTE_UNUSED)
1027 {
1028   char *name;
1029   char c;
1030   char *p;
1031   offsetT size;
1032   symbolS *symbolP;
1033   offsetT align;
1034   segT old_sec;
1035   int old_subsec;
1036   char *pfrag;
1037   int align2;
1038
1039   name = input_line_pointer;
1040   c = get_symbol_end ();
1041
1042   /* Just after name is now '\0'.  */
1043   p = input_line_pointer;
1044   *p = c;
1045   SKIP_WHITESPACE ();
1046   if (*input_line_pointer != ',')
1047     {
1048       as_bad ("Expected comma after symbol-name: rest of line ignored.");
1049       ignore_rest_of_line ();
1050       return;
1051     }
1052
1053   /* Skip ','.  */
1054   input_line_pointer++;
1055   if ((size = get_absolute_expression ()) < 0)
1056     {
1057       as_warn (".COMMon length (%ld.) <0! Ignored.", (long) size);
1058       ignore_rest_of_line ();
1059       return;
1060     }
1061
1062   /* The third argument to .lcomm is the alignment.  */
1063   if (*input_line_pointer != ',')
1064     align = 8;
1065   else
1066     {
1067       ++input_line_pointer;
1068       align = get_absolute_expression ();
1069       if (align <= 0)
1070         {
1071           as_warn ("ignoring bad alignment");
1072           align = 8;
1073         }
1074     }
1075
1076   *p = 0;
1077   symbolP = symbol_find_or_make (name);
1078   *p = c;
1079
1080   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1081     {
1082       as_bad ("Ignoring attempt to re-define symbol `%s'.",
1083               S_GET_NAME (symbolP));
1084       ignore_rest_of_line ();
1085       return;
1086     }
1087
1088   if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1089     {
1090       as_bad ("Length of .lcomm \"%s\" is already %ld. Not changed to %ld.",
1091               S_GET_NAME (symbolP),
1092               (long) S_GET_VALUE (symbolP),
1093               (long) size);
1094
1095       ignore_rest_of_line ();
1096       return;
1097     }
1098
1099   /* Allocate_bss:  */
1100   old_sec = now_seg;
1101   old_subsec = now_subseg;
1102   if (align)
1103     {
1104       /* Convert to a power of 2 alignment.  */
1105       for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2)
1106         ;
1107       if (align != 1)
1108         {
1109           as_bad ("Common alignment not a power of 2");
1110           ignore_rest_of_line ();
1111           return;
1112         }
1113     }
1114   else
1115     align2 = 0;
1116
1117   record_alignment (bss_section, align2);
1118   subseg_set (bss_section, 0);
1119   if (align2)
1120     frag_align (align2, 0, 0);
1121   if (S_GET_SEGMENT (symbolP) == bss_section)
1122     symbol_get_frag (symbolP)->fr_symbol = 0;
1123   symbol_set_frag (symbolP, frag_now);
1124   pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1125                     (char *) 0);
1126   *pfrag = 0;
1127   S_SET_SIZE (symbolP, size);
1128   S_SET_SEGMENT (symbolP, bss_section);
1129   subseg_set (old_sec, old_subsec);
1130   demand_empty_rest_of_line ();
1131 }
1132
1133 /* Validate any relocations emitted for -mrelocatable, possibly adding
1134    fixups for word relocations in writable segments, so we can adjust
1135    them at runtime.  */
1136
1137 static void
1138 i370_elf_validate_fix (fixS *fixp, segT seg)
1139 {
1140   if (fixp->fx_done || fixp->fx_pcrel)
1141     return;
1142
1143   switch (shlib)
1144     {
1145     case SHLIB_NONE:
1146     case SHLIB_PIC:
1147       return;
1148
1149     case SHILB_MRELOCATABLE:
1150       if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1151           && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1152           && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1153           && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1154           && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1155           && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1156           && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1157           && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1158           && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1159           && strcmp (segment_name (seg), ".got2") != 0
1160           && strcmp (segment_name (seg), ".dtors") != 0
1161           && strcmp (segment_name (seg), ".ctors") != 0
1162           && strcmp (segment_name (seg), ".fixup") != 0
1163           && strcmp (segment_name (seg), ".stab") != 0
1164           && strcmp (segment_name (seg), ".gcc_except_table") != 0
1165           && strcmp (segment_name (seg), ".ex_shared") != 0)
1166         {
1167           if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1168               || fixp->fx_r_type != BFD_RELOC_CTOR)
1169             as_bad_where (fixp->fx_file, fixp->fx_line,
1170                           "Relocation cannot be done when using -mrelocatable");
1171         }
1172       return;
1173     default:
1174       break;
1175     }
1176 }
1177 #endif /* OBJ_ELF */
1178
1179 \f
1180 #define LITERAL_POOL_SUPPORT
1181 #ifdef LITERAL_POOL_SUPPORT
1182 /* Provide support for literal pools within the text section.
1183    Loosely based on similar code from tc-arm.c.
1184    We will use four symbols to locate four parts of the literal pool.
1185    These four sections contain 64,32,16 and 8-bit constants; we use
1186    four sections so that all memory access can be appropriately aligned.
1187    That is, we want to avoid mixing these together so that we don't
1188    waste space padding out to alignments.  The four pointers
1189    longlong_poolP, word_poolP, etc. point to a symbol labeling the
1190    start of each pool part.
1191
1192    lit_pool_num increments from zero to infinity and uniquely id's
1193      -- its used to generate the *_poolP symbol name.  */
1194
1195 #define MAX_LITERAL_POOL_SIZE 1024
1196
1197 typedef struct literalS
1198 {
1199   struct expressionS  exp;
1200   char * sym_name;
1201   char size;  /* 1,2,4 or 8 */
1202   short offset;
1203 } literalT;
1204
1205 literalT literals[MAX_LITERAL_POOL_SIZE];
1206 int next_literal_pool_place = 0; /* Next free entry in the pool.  */
1207
1208 static symbolS *longlong_poolP = NULL;   /* 64-bit pool entries.  */
1209 static symbolS *word_poolP = NULL;       /* 32-bit pool entries.  */
1210 static symbolS *short_poolP = NULL;      /* 16-bit pool entries.  */
1211 static symbolS *byte_poolP = NULL;       /* 8-bit  pool entries.  */
1212
1213 static int lit_pool_num = 1;
1214
1215 /* Create a new, empty symbol.  */
1216 static symbolS *
1217 symbol_make_empty (void)
1218 {
1219   return symbol_create (FAKE_LABEL_NAME, undefined_section,
1220                         (valueT) 0, &zero_address_frag);
1221 }
1222
1223 /* Make the first argument an address-relative expression
1224    by subtracting the second argument.  */
1225
1226 static void
1227 i370_make_relative (expressionS *exx, expressionS *baseaddr)
1228 {
1229   if (O_constant == baseaddr->X_op)
1230     {
1231        exx->X_op = O_symbol;
1232        exx->X_add_number -= baseaddr->X_add_number;
1233     }
1234   else if (O_symbol == baseaddr->X_op)
1235     {
1236        exx->X_op = O_subtract;
1237        exx->X_op_symbol = baseaddr->X_add_symbol;
1238        exx->X_add_number -= baseaddr->X_add_number;
1239     }
1240   else if (O_uminus == baseaddr->X_op)
1241     {
1242        exx->X_op = O_add;
1243        exx->X_op_symbol = baseaddr->X_add_symbol;
1244        exx->X_add_number += baseaddr->X_add_number;
1245     }
1246   else
1247     as_bad ("Missing or bad .using directive");
1248 }
1249 /* Add an expression to the literal pool.  */
1250
1251 static  void
1252 add_to_lit_pool (expressionS *exx, char *name, int sz)
1253 {
1254   int lit_count = 0;
1255   int offset_in_pool = 0;
1256
1257   /* Start a new pool, if necessary.  */
1258   if (8 == sz && NULL == longlong_poolP)
1259     longlong_poolP = symbol_make_empty ();
1260   else if (4 == sz && NULL == word_poolP)
1261     word_poolP = symbol_make_empty ();
1262   else if (2 == sz && NULL == short_poolP)
1263     short_poolP = symbol_make_empty ();
1264   else if (1 == sz && NULL == byte_poolP)
1265     byte_poolP = symbol_make_empty ();
1266
1267   /* Check if this literal value is already in the pool.
1268      FIXME: We should probably be checking expressions
1269             of type O_symbol as well.
1270      FIXME: This is probably(certainly?) broken for O_big,
1271             which includes 64-bit long-longs.  */
1272   while (lit_count < next_literal_pool_place)
1273     {
1274       if (exx->X_op == O_constant
1275           && literals[lit_count].exp.X_op == exx->X_op
1276           && literals[lit_count].exp.X_add_number == exx->X_add_number
1277           && literals[lit_count].exp.X_unsigned == exx->X_unsigned
1278           && literals[lit_count].size == sz)
1279         break;
1280       else if (literals[lit_count].sym_name
1281                && name
1282                && !strcmp (name, literals[lit_count].sym_name))
1283         break;
1284       if (sz == literals[lit_count].size)
1285         offset_in_pool += sz;
1286       lit_count ++;
1287     }
1288
1289   if (lit_count == next_literal_pool_place) /* new entry */
1290     {
1291       if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE)
1292         as_bad ("Literal Pool Overflow");
1293
1294       literals[next_literal_pool_place].exp = *exx;
1295       literals[next_literal_pool_place].size = sz;
1296       literals[next_literal_pool_place].offset = offset_in_pool;
1297       if (name)
1298         literals[next_literal_pool_place].sym_name = strdup (name);
1299       else
1300         literals[next_literal_pool_place].sym_name = NULL;
1301       next_literal_pool_place++;
1302     }
1303
1304   /* ???_poolP points to the beginning of the literal pool.
1305      X_add_number is the offset from the beginning of the
1306      literal pool to this expr minus the location of the most
1307      recent .using directive.  Thus, the grand total value of the
1308      expression is the distance from .using to the literal.  */
1309   if (8 == sz)
1310     exx->X_add_symbol = longlong_poolP;
1311   else if (4 == sz)
1312     exx->X_add_symbol = word_poolP;
1313   else if (2 == sz)
1314     exx->X_add_symbol = short_poolP;
1315   else if (1 == sz)
1316     exx->X_add_symbol = byte_poolP;
1317   exx->X_add_number = offset_in_pool;
1318   exx->X_op_symbol = NULL;
1319
1320   /* If the user has set up a base reg in another section,
1321      use that; otherwise use the text section.  */
1322   if (0 < i370_using_other_regno)
1323     i370_make_relative (exx, &i370_using_other_baseaddr);
1324   else
1325     i370_make_relative (exx, &i370_using_text_baseaddr);
1326 }
1327
1328 /* The symbol setup for the literal pool is done in two steps.  First,
1329    a symbol that represents the start of the literal pool is created,
1330    above, in the add_to_pool() routine. This sym ???_poolP.
1331    However, we don't know what fragment its in until a bit later.
1332    So we defer the frag_now thing, and the symbol name, until .ltorg time.  */
1333
1334 /* Can't use symbol_new here, so have to create a symbol and then at
1335    a later date assign it a value. Thats what these functions do.  */
1336
1337 static void
1338 symbol_locate (symbolS *symbolP,
1339                const char *name,        /* It is copied, the caller can modify.  */
1340                segT segment,            /* Segment identifier (SEG_<something>).  */
1341                valueT valu,             /* Symbol value.  */
1342                fragS *frag)             /* Associated fragment.  */
1343 {
1344   size_t name_length;
1345   char *preserved_copy_of_name;
1346
1347   name_length = strlen (name) + 1;      /* +1 for \0 */
1348   obstack_grow (&notes, name, name_length);
1349   preserved_copy_of_name = obstack_finish (&notes);
1350
1351   S_SET_NAME (symbolP, preserved_copy_of_name);
1352
1353   S_SET_SEGMENT (symbolP, segment);
1354   S_SET_VALUE (symbolP, valu);
1355   symbol_clear_list_pointers (symbolP);
1356
1357   symbol_set_frag (symbolP, frag);
1358
1359   /* Link to end of symbol chain.  */
1360   {
1361     extern int symbol_table_frozen;
1362
1363     if (symbol_table_frozen)
1364       abort ();
1365   }
1366
1367   symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
1368
1369   obj_symbol_new_hook (symbolP);
1370
1371 #ifdef tc_symbol_new_hook
1372   tc_symbol_new_hook (symbolP);
1373 #endif
1374
1375 #define DEBUG_SYMS
1376 #ifdef DEBUG_SYMS
1377   verify_symbol_chain(symbol_rootP, symbol_lastP);
1378 #endif /* DEBUG_SYMS */
1379 }
1380
1381 /* i370_addr_offset() will convert operand expressions
1382    that appear to be absolute into thier base-register
1383    relative form.  These expressions come in two types:
1384
1385    (1) of the form "* + const" * where "*" means
1386    relative offset since the last using
1387    i.e. "*" means ".-using_baseaddr"
1388
1389    (2) labels, which are never absolute, but are always
1390    relative to the last "using".  Anything with an alpha
1391    character is considered to be a label (since symbols
1392    can never be operands), and since we've already handled
1393    register operands. For example, "BL .L33" branch low
1394    to .L33 RX form insn frequently terminates for-loops.  */
1395
1396 static bfd_boolean
1397 i370_addr_offset (expressionS *exx)
1398 {
1399   char *dot, *lab;
1400   int islabel = 0;
1401   int all_digits = 0;
1402
1403   /* Search for a label; anything with an alpha char will do.
1404      Local labels consist of N digits followed by either b or f.  */
1405   lab = input_line_pointer;
1406   while (*lab && (',' != *lab) && ('(' != *lab))
1407     {
1408       if (ISDIGIT (*lab))
1409         all_digits = 1;
1410       else if (ISALPHA (*lab))
1411         {
1412           if (!all_digits)
1413             {
1414               islabel = 1;
1415               break;
1416             }
1417           else if (('f' == *lab) || ('b' == *lab))
1418             {
1419               islabel = 1;
1420               break;
1421             }
1422           if (all_digits)
1423             break;
1424         }
1425       else if ('.' != *lab)
1426         break;
1427       ++lab;
1428     }
1429
1430   /* See if operand has a * in it.  */
1431   dot = strchr (input_line_pointer, '*');
1432
1433   if (!dot && !islabel)
1434     return FALSE;
1435
1436   /* Replace * with . and let expr munch on it.  */
1437   if (dot)
1438     *dot = '.';
1439   expression (exx);
1440
1441   /* OK, now we have to subtract the "using" location.
1442      Normally branches appear in the text section only.  */
1443   if (0 == strncmp (now_seg->name, ".text", 5) || 0 > i370_using_other_regno)
1444     i370_make_relative (exx, &i370_using_text_baseaddr);
1445   else
1446     i370_make_relative (exx, &i370_using_other_baseaddr);
1447
1448   /* Put the * back.  */
1449   if (dot)
1450     *dot = '*';
1451
1452   return TRUE;
1453 }
1454
1455 /* Handle address constants of various sorts.  */
1456 /* The currently supported types are
1457       =A(some_symb)
1458       =V(some_extern)
1459       =X'deadbeef'    hexadecimal
1460       =F'1234'        32-bit const int
1461       =H'1234'        16-bit const int.  */
1462
1463 static bfd_boolean
1464 i370_addr_cons (expressionS *exp)
1465 {
1466   char *name;
1467   char *sym_name, delim;
1468   int name_len;
1469   int hex_len = 0;
1470   int cons_len = 0;
1471
1472   name = input_line_pointer;
1473   sym_name = input_line_pointer;
1474   /* Find the spelling of the operand.  */
1475   if (name[0] == '=' && ISALPHA (name[1]))
1476     name = ++input_line_pointer;
1477   else
1478     return FALSE;
1479
1480   switch (name[0])
1481     {
1482     case 'A': /* A == address-of.  */
1483     case 'V': /* V == extern.  */
1484       ++input_line_pointer;
1485       expression (exp);
1486
1487       /* We use a simple string name to collapse together
1488          multiple refrences to the same address literal.  */
1489       name_len = strcspn (sym_name, ", ");
1490       delim = *(sym_name + name_len);
1491       *(sym_name + name_len) = 0x0;
1492       add_to_lit_pool (exp, sym_name, 4);
1493       *(sym_name + name_len) = delim;
1494
1495       break;
1496     case 'H':
1497     case 'F':
1498     case 'X':
1499     case 'E':  /* Single-precision float point.  */
1500     case 'D':  /* Double-precision float point.  */
1501
1502       /* H == 16-bit fixed-point const; expression must be const.  */
1503       /* F == fixed-point const; expression must be const.  */
1504       /* X == fixed-point const; expression must be const.  */
1505       if ('H' == name[0]) cons_len = 2;
1506       else if ('F' == name[0]) cons_len = 4;
1507       else if ('X' == name[0]) cons_len = -1;
1508       else if ('E' == name[0]) cons_len = 4;
1509       else if ('D' == name[0]) cons_len = 8;
1510
1511       /* Extract length, if it is present;
1512          FIXME: assume single-digit length.  */
1513       if ('L' == name[1])
1514         {
1515           /* Should work for ASCII and EBCDIC.  */
1516           cons_len = name[2] - '0';
1517           input_line_pointer += 2;
1518         }
1519
1520       ++input_line_pointer;
1521
1522       /* Get rid of pesky quotes.  */
1523       if ('\'' == *input_line_pointer)
1524         {
1525           char * close;
1526           ++input_line_pointer;
1527           close = strchr (input_line_pointer, '\'');
1528           if (close)
1529             *close= ' ';
1530           else
1531             as_bad ("missing end-quote");
1532         }
1533       if ('\"' == *input_line_pointer)
1534         {
1535           char * close;
1536           ++input_line_pointer;
1537           close = strchr (input_line_pointer, '\"');
1538           if (close)
1539             *close= ' ';
1540           else
1541             as_bad ("missing end-quote");
1542         }
1543       if (('X' == name[0]) || ('E' == name[0]) || ('D' == name[0]))
1544         {
1545           char tmp[50];
1546           char *save;
1547
1548           /* The length of hex constants is specified directly with L,
1549              or implied through the number of hex digits. For example:
1550              =X'AB'       one byte
1551              =X'abcd'     two bytes
1552              =X'000000AB' four bytes
1553              =XL4'AB'     four bytes, left-padded withn zero.  */
1554           if (('X' == name[0]) && (0 > cons_len))
1555             {
1556               save = input_line_pointer;
1557               while (*save)
1558                 {
1559                   if (ISXDIGIT (*save))
1560                     hex_len++;
1561                   save++;
1562                 }
1563               cons_len = (hex_len+1) /2;
1564             }
1565           /* I believe this works even for =XL8'dada0000beeebaaa'
1566              which should parse out to X_op == O_big
1567              Note that floats and doubles get represented as
1568              0d3.14159265358979  or 0f 2.7.  */
1569           tmp[0] = '0';
1570           tmp[1] = name[0];
1571           tmp[2] = 0;
1572           strcat (tmp, input_line_pointer);
1573           save = input_line_pointer;
1574           input_line_pointer = tmp;
1575           expression (exp);
1576           input_line_pointer = save + (input_line_pointer-tmp-2);
1577
1578           /* Fix up lengths for floats and doubles.  */
1579           if (O_big == exp->X_op)
1580             exp->X_add_number = cons_len / CHARS_PER_LITTLENUM;
1581         }
1582       else
1583         expression (exp);
1584
1585       /* O_big occurs when more than 4 bytes worth gets parsed.  */
1586       if ((exp->X_op != O_constant) && (exp->X_op != O_big))
1587         {
1588           as_bad ("expression not a constant");
1589           return FALSE;
1590         }
1591       add_to_lit_pool (exp, 0x0, cons_len);
1592       break;
1593
1594     default:
1595       as_bad ("Unknown/unsupported address literal type");
1596       return FALSE;
1597     }
1598
1599   return TRUE;
1600 }
1601
1602 \f
1603 /* Dump the contents of the literal pool that we've accumulated so far.
1604    This aligns the pool to the size of the largest literal in the pool.  */
1605
1606 static void
1607 i370_ltorg (int ignore ATTRIBUTE_UNUSED)
1608 {
1609   int litsize;
1610   int lit_count = 0;
1611   int biggest_literal_size = 0;
1612   int biggest_align = 0;
1613   char pool_name[20];
1614
1615   if (strncmp (now_seg->name, ".text", 5))
1616     {
1617       if (i370_other_section == undefined_section)
1618         as_bad (".ltorg without prior .using in section %s",
1619                 now_seg->name);
1620
1621       if (i370_other_section != now_seg)
1622         as_bad (".ltorg in section %s paired to .using in section %s",
1623                 now_seg->name, i370_other_section->name);
1624     }
1625
1626   if (! longlong_poolP
1627       && ! word_poolP
1628       && ! short_poolP
1629       && ! byte_poolP)
1630     /* Nothing to do.  */
1631     return;
1632
1633   /* Find largest literal .. 2 4 or 8.  */
1634   lit_count = 0;
1635   while (lit_count < next_literal_pool_place)
1636     {
1637       if (biggest_literal_size < literals[lit_count].size)
1638         biggest_literal_size = literals[lit_count].size;
1639       lit_count ++;
1640     }
1641   if (1 == biggest_literal_size) biggest_align = 0;
1642   else if (2 == biggest_literal_size) biggest_align = 1;
1643   else if (4 == biggest_literal_size) biggest_align = 2;
1644   else if (8 == biggest_literal_size) biggest_align = 3;
1645   else as_bad ("bad alignment of %d bytes in literal pool", biggest_literal_size);
1646   if (0 == biggest_align) biggest_align = 1;
1647
1648   /* Align pool for short, word, double word accesses.  */
1649   frag_align (biggest_align, 0, 0);
1650   record_alignment (now_seg, biggest_align);
1651
1652   /* Note that the gas listing will print only the first five
1653      entries in the pool .... wonder how to make it print more.  */
1654   /* Output largest literals first, then the smaller ones.  */
1655   for (litsize=8; litsize; litsize /=2)
1656     {
1657       symbolS *current_poolP = NULL;
1658       switch (litsize)
1659         {
1660         case 8:
1661           current_poolP = longlong_poolP; break;
1662         case 4:
1663           current_poolP = word_poolP; break;
1664         case 2:
1665           current_poolP = short_poolP; break;
1666         case 1:
1667           current_poolP = byte_poolP; break;
1668         default:
1669           as_bad ("bad literal size\n");
1670         }
1671       if (NULL == current_poolP)
1672         continue;
1673       sprintf (pool_name, ".LITP%01d%06d", litsize, lit_pool_num);
1674       symbol_locate (current_poolP, pool_name, now_seg,
1675                      (valueT) frag_now_fix (), frag_now);
1676       symbol_table_insert (current_poolP);
1677
1678       lit_count = 0;
1679       while (lit_count < next_literal_pool_place)
1680         {
1681           if (litsize == literals[lit_count].size)
1682             {
1683 #define EMIT_ADDR_CONS_SYMBOLS
1684 #ifdef EMIT_ADDR_CONS_SYMBOLS
1685               /* Create a bogus symbol, add it to the pool ...
1686                  For the most part, I think this is a useless exercise,
1687                  except that having these symbol names in the objects
1688                  is vaguely useful for debugging.  */
1689               if (literals[lit_count].sym_name)
1690                 {
1691                   symbolS * symP = symbol_make_empty ();
1692                   symbol_locate (symP, literals[lit_count].sym_name, now_seg,
1693                                  (valueT) frag_now_fix (), frag_now);
1694                   symbol_table_insert (symP);
1695                 }
1696 #endif /* EMIT_ADDR_CONS_SYMBOLS */
1697
1698               emit_expr (&(literals[lit_count].exp), literals[lit_count].size);
1699             }
1700           lit_count ++;
1701         }
1702     }
1703
1704   next_literal_pool_place = 0;
1705   longlong_poolP = NULL;
1706   word_poolP = NULL;
1707   short_poolP = NULL;
1708   byte_poolP = NULL;
1709   lit_pool_num++;
1710 }
1711
1712 #endif /* LITERAL_POOL_SUPPORT */
1713
1714 \f
1715 /* Add support for the HLASM-like USING directive to indicate
1716    the base register to use ...  we don't support the full
1717    hlasm semantics for this ... we merely pluck a base address
1718    and a register number out.  We print a warning if using is
1719    called multiple times.  I suppose we should check to see
1720    if the regno is valid.  */
1721
1722 static void
1723 i370_using (int ignore ATTRIBUTE_UNUSED)
1724 {
1725   expressionS ex, baseaddr;
1726   int iregno;
1727   char *star;
1728
1729   /* If "*" appears in a using, it means "."
1730      replace it with "." so that expr doesn't get confused.  */
1731   star = strchr (input_line_pointer, '*');
1732   if (star)
1733     *star = '.';
1734
1735   /* The first arg to using will usually be ".", but it can
1736      be a more complex expression too.  */
1737   expression (&baseaddr);
1738   if (star)
1739     *star = '*';
1740   if (O_constant != baseaddr.X_op
1741       && O_symbol != baseaddr.X_op
1742       && O_uminus != baseaddr.X_op)
1743     as_bad (".using: base address expression illegal or too complex");
1744
1745   if (*input_line_pointer != '\0') ++input_line_pointer;
1746
1747   /* The second arg to using had better be a register.  */
1748   register_name (&ex);
1749   demand_empty_rest_of_line ();
1750   iregno = ex.X_add_number;
1751
1752   if (0 == strncmp (now_seg->name, ".text", 5))
1753     {
1754       i370_using_text_baseaddr = baseaddr;
1755       i370_using_text_regno = iregno;
1756     }
1757   else
1758     {
1759       i370_using_other_baseaddr = baseaddr;
1760       i370_using_other_regno = iregno;
1761       i370_other_section = now_seg;
1762     }
1763 }
1764
1765 static void
1766 i370_drop (int ignore ATTRIBUTE_UNUSED)
1767 {
1768   expressionS ex;
1769   int iregno;
1770
1771   register_name (&ex);
1772   demand_empty_rest_of_line ();
1773   iregno = ex.X_add_number;
1774
1775   if (0 == strncmp (now_seg->name, ".text", 5))
1776     {
1777       if (iregno != i370_using_text_regno)
1778         as_bad ("droping register %d in section %s does not match using register %d",
1779                 iregno, now_seg->name, i370_using_text_regno);
1780
1781       i370_using_text_regno = -1;
1782       i370_using_text_baseaddr.X_op = O_absent;
1783     }
1784   else
1785     {
1786       if (iregno != i370_using_other_regno)
1787         as_bad ("droping register %d in section %s does not match using register %d",
1788                 iregno, now_seg->name, i370_using_other_regno);
1789
1790       if (i370_other_section != now_seg)
1791         as_bad ("droping register %d in section %s previously used in section %s",
1792                 iregno, now_seg->name, i370_other_section->name);
1793
1794       i370_using_other_regno = -1;
1795       i370_using_other_baseaddr.X_op = O_absent;
1796       i370_other_section = undefined_section;
1797     }
1798 }
1799
1800 \f
1801 /* We need to keep a list of fixups.  We can't simply generate them as
1802    we go, because that would require us to first create the frag, and
1803    that would screw up references to ``.''.  */
1804
1805 struct i370_fixup
1806 {
1807   expressionS exp;
1808   int opindex;
1809   bfd_reloc_code_real_type reloc;
1810 };
1811
1812 #define MAX_INSN_FIXUPS 5
1813
1814 /* Handle a macro.  Gather all the operands, transform them as
1815    described by the macro, and call md_assemble recursively.  All the
1816    operands are separated by commas; we don't accept parentheses
1817    around operands here.  */
1818
1819 static void
1820 i370_macro (char *str, const struct i370_macro *macro)
1821 {
1822   char *operands[10];
1823   unsigned int count;
1824   char *s;
1825   unsigned int len;
1826   const char *format;
1827   int arg;
1828   char *send;
1829   char *complete;
1830
1831   /* Gather the users operands into the operands array.  */
1832   count = 0;
1833   s = str;
1834   while (1)
1835     {
1836       if (count >= sizeof operands / sizeof operands[0])
1837         break;
1838       operands[count++] = s;
1839       s = strchr (s, ',');
1840       if (s == (char *) NULL)
1841         break;
1842       *s++ = '\0';
1843     }
1844
1845   if (count != macro->operands)
1846     {
1847       as_bad ("wrong number of operands");
1848       return;
1849     }
1850
1851   /* Work out how large the string must be (the size is unbounded
1852      because it includes user input).  */
1853   len = 0;
1854   format = macro->format;
1855   while (*format != '\0')
1856     {
1857       if (*format != '%')
1858         {
1859           ++len;
1860           ++format;
1861         }
1862       else
1863         {
1864           arg = strtol (format + 1, &send, 10);
1865           know (send != format && arg >= 0 && (unsigned) arg < count);
1866           len += strlen (operands[arg]);
1867           format = send;
1868         }
1869     }
1870
1871   /* Put the string together.  */
1872   complete = s = alloca (len + 1);
1873   format = macro->format;
1874   while (*format != '\0')
1875     {
1876       if (*format != '%')
1877         *s++ = *format++;
1878       else
1879         {
1880           arg = strtol (format + 1, &send, 10);
1881           strcpy (s, operands[arg]);
1882           s += strlen (s);
1883           format = send;
1884         }
1885     }
1886   *s = '\0';
1887
1888   /* Assemble the constructed instruction.  */
1889   md_assemble (complete);
1890 }
1891
1892 /* This routine is called for each instruction to be assembled.  */
1893
1894 void
1895 md_assemble (char *str)
1896 {
1897   char *s, *opcode_str;
1898   const struct i370_opcode *opcode;
1899   i370_insn_t insn;
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;
1904   int off_by_one;
1905   struct i370_fixup fixups[MAX_INSN_FIXUPS];
1906   int fc;
1907   char *f;
1908   int i;
1909 #ifdef OBJ_ELF
1910   bfd_reloc_code_real_type reloc;
1911 #endif
1912
1913   /* Get the opcode.  */
1914   for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1915     ;
1916   if (*s != '\0')
1917     *s++ = '\0';
1918   opcode_str = str;
1919
1920   /* Look up the opcode in the hash table.  */
1921   opcode = (const struct i370_opcode *) hash_find (i370_hash, str);
1922   if (opcode == (const struct i370_opcode *) NULL)
1923     {
1924       const struct i370_macro *macro;
1925
1926       assert (i370_macro_hash);
1927       macro = (const struct i370_macro *) hash_find (i370_macro_hash, str);
1928       if (macro == (const struct i370_macro *) NULL)
1929         as_bad ("Unrecognized opcode: `%s'", str);
1930       else
1931         i370_macro (s, macro);
1932
1933       return;
1934     }
1935
1936   insn = opcode->opcode;
1937
1938   str = s;
1939   while (ISSPACE (*str))
1940     ++str;
1941
1942   /* I370 operands are either expressions or address constants.
1943      Many operand types are optional.  The optional operands
1944      are always surrounded by parens, and are used to denote the base
1945      register ... e.g. "A R1, D2" or "A R1, D2(,B2) as opposed to
1946      the fully-formed "A R1, D2(X2,B2)".  Note also the = sign,
1947      such as A R1,=A(i) where the address-of operator =A implies
1948      use of both a base register, and a missing index register.
1949
1950      So, before we start seriously parsing the operands, we check
1951      to see if we have an optional operand, and, if we do, we count
1952      the number of commas to see which operand should be omitted.  */
1953
1954   have_optional_index = have_optional_basereg = have_optional_reg = 0;
1955   for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1956     {
1957       const struct i370_operand *operand;
1958
1959       operand = &i370_operands[*opindex_ptr];
1960       if ((operand->flags & I370_OPERAND_INDEX) != 0)
1961         have_optional_index = 1;
1962       if ((operand->flags & I370_OPERAND_BASE) != 0)
1963         have_optional_basereg = 1;
1964       if ((operand->flags & I370_OPERAND_OPTIONAL) != 0)
1965         have_optional_reg = 1;
1966     }
1967
1968   skip_optional_index = skip_optional_basereg = skip_optional_reg = 0;
1969   if (have_optional_index || have_optional_basereg)
1970     {
1971       unsigned int opcount, nwanted;
1972
1973       /* There is an optional operand.  Count the number of
1974          commas and open-parens in the input line.  */
1975       if (*str == '\0')
1976         opcount = 0;
1977       else
1978         {
1979           opcount = 1;
1980           s = str;
1981           while ((s = strpbrk (s, ",(=")) != (char *) NULL)
1982             {
1983               ++opcount;
1984               ++s;
1985               if (',' == *s) ++s;  /* avoid counting things like (, */
1986               if ('=' == *s) { ++s; --opcount; }
1987             }
1988         }
1989
1990       /* If there are fewer operands in the line then are called
1991          for by the instruction, we want to skip the optional
1992          operand.  */
1993       nwanted = strlen ((char *) opcode->operands);
1994       if (have_optional_index)
1995         {
1996           if (opcount < nwanted)
1997             skip_optional_index = 1;
1998           if (have_optional_basereg && ((opcount+1) < nwanted))
1999             skip_optional_basereg = 1;
2000           if (have_optional_reg && ((opcount+1) < nwanted))
2001             skip_optional_reg = 1;
2002         }
2003       else
2004         {
2005           if (have_optional_basereg && (opcount < nwanted))
2006             skip_optional_basereg = 1;
2007           if (have_optional_reg && (opcount < nwanted))
2008             skip_optional_reg = 1;
2009         }
2010     }
2011
2012   /* Perform some off-by-one hacks on the length field of certain instructions.
2013      Its such a shame to have to do this, but the problem is that HLASM got
2014      defined so that the lengths differ by one from the actual machine instructions.
2015      this code should probably be moved to a special inster-operand routine.
2016      Sigh. Affected instructions are Compare Logical, Move and Exclusive OR
2017      hack alert -- aren't *all* SS instructions affected ??  */
2018   off_by_one = 0;
2019   if (0 == strcasecmp ("CLC", opcode->name)
2020       || 0 == strcasecmp ("ED", opcode->name)
2021       || 0 == strcasecmp ("EDMK", opcode->name)
2022       || 0 == strcasecmp ("MVC", opcode->name)
2023       || 0 == strcasecmp ("MVCIN", opcode->name)
2024       || 0 == strcasecmp ("MVN", opcode->name)
2025       || 0 == strcasecmp ("MVZ", opcode->name)
2026       || 0 == strcasecmp ("NC", opcode->name)
2027       || 0 == strcasecmp ("OC", opcode->name)
2028       || 0 == strcasecmp ("XC", opcode->name))
2029     off_by_one = 1;
2030
2031   /* Gather the operands.  */
2032   fc = 0;
2033   for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2034     {
2035       const struct i370_operand *operand;
2036       const char *errmsg;
2037       char *hold;
2038       expressionS ex;
2039
2040       operand = &i370_operands[*opindex_ptr];
2041       errmsg = NULL;
2042
2043       /* If this is an index operand, and we are skipping it,
2044          just insert a zero.  */
2045       if (skip_optional_index &&
2046           ((operand->flags & I370_OPERAND_INDEX) != 0))
2047         {
2048           insn = i370_insert_operand (insn, operand, 0);
2049           continue;
2050         }
2051
2052       /* If this is the base operand, and we are skipping it,
2053          just insert the current using basreg.  */
2054       if (skip_optional_basereg &&
2055           ((operand->flags & I370_OPERAND_BASE) != 0))
2056         {
2057           int basereg = -1;
2058           if (use_text)
2059             {
2060               if (0 == strncmp (now_seg->name, ".text", 5)
2061                   || 0 > i370_using_other_regno)
2062                 basereg = i370_using_text_regno;
2063               else
2064                 basereg = i370_using_other_regno;
2065             }
2066           else if (use_other)
2067             {
2068               if (0 > i370_using_other_regno)
2069                 basereg = i370_using_text_regno;
2070               else
2071                 basereg = i370_using_other_regno;
2072             }
2073           if (0 > basereg)
2074             as_bad ("not using any base register");
2075
2076           insn = i370_insert_operand (insn, operand, basereg);
2077           continue;
2078         }
2079
2080       /* If this is an optional operand, and we are skipping it,
2081          Use zero (since a non-zero value would denote a register)  */
2082       if (skip_optional_reg
2083           && ((operand->flags & I370_OPERAND_OPTIONAL) != 0))
2084         {
2085           insn = i370_insert_operand (insn, operand, 0);
2086           continue;
2087         }
2088
2089       /* Gather the operand.  */
2090       hold = input_line_pointer;
2091       input_line_pointer = str;
2092
2093       /* Register names are only allowed where there are registers.  */
2094       if ((operand->flags & I370_OPERAND_GPR) != 0)
2095         {
2096           /* Quickie hack to get past things like (,r13).  */
2097           if (skip_optional_index && (',' == *input_line_pointer))
2098             {
2099               *input_line_pointer = ' ';
2100               input_line_pointer ++;
2101             }
2102
2103           if (! register_name (&ex))
2104             as_bad ("expecting a register for operand %d",
2105                     (int) (opindex_ptr - opcode->operands + 1));
2106         }
2107
2108       /* Check for an address constant expression.  */
2109       /* We will put PSW-relative addresses in the text section,
2110          and address literals in the .data (or other) section.  */
2111       else if (i370_addr_cons (&ex))
2112         use_other = 1;
2113       else if (i370_addr_offset (&ex))
2114         use_text = 1;
2115       else expression (&ex);
2116
2117       str = input_line_pointer;
2118       input_line_pointer = hold;
2119
2120       /* Perform some off-by-one hacks on the length field of certain instructions.
2121          Its such a shame to have to do this, but the problem is that HLASM got
2122          defined so that the programmer specifies a length that is one greater
2123          than what the machine instruction wants.  Sigh.  */
2124       if (off_by_one && (0 == strcasecmp ("SS L", operand->name)))
2125         ex.X_add_number --;
2126
2127       if (ex.X_op == O_illegal)
2128         as_bad ("illegal operand");
2129       else if (ex.X_op == O_absent)
2130         as_bad ("missing operand");
2131       else if (ex.X_op == O_register)
2132         insn = i370_insert_operand (insn, operand, ex.X_add_number);
2133       else if (ex.X_op == O_constant)
2134         {
2135 #ifdef OBJ_ELF
2136           /* Allow @HA, @L, @H on constants.
2137              Well actually, no we don't; there really don't make sense
2138              (at least not to me) for the i370.  However, this code is
2139              left here for any dubious future expansion reasons.  */
2140           char *orig_str = str;
2141
2142           if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2143             switch (reloc)
2144               {
2145               default:
2146                 str = orig_str;
2147                 break;
2148
2149               case BFD_RELOC_LO16:
2150                 /* X_unsigned is the default, so if the user has done
2151                    something which cleared it, we always produce a
2152                    signed value.  */
2153                 ex.X_add_number = (((ex.X_add_number & 0xffff)
2154                                     ^ 0x8000)
2155                                    - 0x8000);
2156                 break;
2157
2158               case BFD_RELOC_HI16:
2159                 ex.X_add_number = (ex.X_add_number >> 16) & 0xffff;
2160                 break;
2161
2162               case BFD_RELOC_HI16_S:
2163                 ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
2164                                    + ((ex.X_add_number >> 15) & 1));
2165                 break;
2166               }
2167 #endif
2168           insn = i370_insert_operand (insn, operand, ex.X_add_number);
2169         }
2170 #ifdef OBJ_ELF
2171       else if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2172         {
2173           as_tsktsk ("md_assemble(): suffixed relocations not supported\n");
2174
2175           /* We need to generate a fixup for this expression.  */
2176           if (fc >= MAX_INSN_FIXUPS)
2177             as_fatal ("too many fixups");
2178           fixups[fc].exp = ex;
2179           fixups[fc].opindex = 0;
2180           fixups[fc].reloc = reloc;
2181           ++fc;
2182         }
2183 #endif /* OBJ_ELF */
2184       else
2185         {
2186           /* We need to generate a fixup for this expression.  */
2187           /* Typically, the expression will just be a symbol ...
2188                printf ("insn %s needs fixup for %s \n",
2189                     opcode->name, ex.X_add_symbol->bsym->name);  */
2190
2191           if (fc >= MAX_INSN_FIXUPS)
2192             as_fatal ("too many fixups");
2193           fixups[fc].exp = ex;
2194           fixups[fc].opindex = *opindex_ptr;
2195           fixups[fc].reloc = BFD_RELOC_UNUSED;
2196           ++fc;
2197         }
2198
2199       /* Skip over delimiter (close paren, or comma).  */
2200       if ((')' == *str) && (',' == *(str+1)))
2201         ++str;
2202       if (*str != '\0')
2203         ++str;
2204     }
2205
2206   while (ISSPACE (*str))
2207     ++str;
2208
2209   if (*str != '\0')
2210     as_bad ("junk at end of line: `%s'", str);
2211
2212   /* Write out the instruction.  */
2213   f = frag_more (opcode->len);
2214   if (4 >= opcode->len)
2215     md_number_to_chars (f, insn.i[0], opcode->len);
2216   else
2217     {
2218       md_number_to_chars (f, insn.i[0], 4);
2219
2220       if (6 == opcode->len)
2221         md_number_to_chars ((f + 4), ((insn.i[1])>>16), 2);
2222       else
2223         {
2224           /* Not used --- don't have any 8 byte instructions.  */
2225           as_bad ("Internal Error: bad instruction length");
2226           md_number_to_chars ((f + 4), insn.i[1], opcode->len -4);
2227         }
2228     }
2229
2230   /* Create any fixups.  At this point we do not use a
2231      bfd_reloc_code_real_type, but instead just use the
2232      BFD_RELOC_UNUSED plus the operand index.  This lets us easily
2233      handle fixups for any operand type, although that is admittedly
2234      not a very exciting feature.  We pick a BFD reloc type in
2235      md_apply_fix.  */
2236   for (i = 0; i < fc; i++)
2237     {
2238       const struct i370_operand *operand;
2239
2240       operand = &i370_operands[fixups[i].opindex];
2241       if (fixups[i].reloc != BFD_RELOC_UNUSED)
2242         {
2243           reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
2244           int size;
2245           fixS *fixP;
2246
2247           if (!reloc_howto)
2248             abort ();
2249
2250           size = bfd_get_reloc_size (reloc_howto);
2251
2252           if (size < 1 || size > 4)
2253             abort ();
2254
2255           printf (" gwana doo fixup %d \n", i);
2256           fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
2257                               &fixups[i].exp, reloc_howto->pc_relative,
2258                               fixups[i].reloc);
2259
2260           /* Turn off complaints that the addend is too large for things like
2261              foo+100000@ha.  */
2262           switch (fixups[i].reloc)
2263             {
2264             case BFD_RELOC_16_GOTOFF:
2265             case BFD_RELOC_LO16:
2266             case BFD_RELOC_HI16:
2267             case BFD_RELOC_HI16_S:
2268               fixP->fx_no_overflow = 1;
2269               break;
2270             default:
2271               break;
2272             }
2273         }
2274       else
2275         {
2276           fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->len,
2277                        &fixups[i].exp,
2278                        (operand->flags & I370_OPERAND_RELATIVE) != 0,
2279                        ((bfd_reloc_code_real_type)
2280                         (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2281         }
2282     }
2283 }
2284
2285 \f
2286 /* Pseudo-op handling.  */
2287
2288 /* The .byte pseudo-op.  This is similar to the normal .byte
2289    pseudo-op, but it can also take a single ASCII string.  */
2290
2291 static void
2292 i370_byte (int ignore ATTRIBUTE_UNUSED)
2293 {
2294   if (*input_line_pointer != '\"')
2295     {
2296       cons (1);
2297       return;
2298     }
2299
2300   /* Gather characters.  A real double quote is doubled.  Unusual
2301      characters are not permitted.  */
2302   ++input_line_pointer;
2303   while (1)
2304     {
2305       char c;
2306
2307       c = *input_line_pointer++;
2308
2309       if (c == '\"')
2310         {
2311         if (*input_line_pointer != '\"')
2312             break;
2313           ++input_line_pointer;
2314         }
2315
2316       FRAG_APPEND_1_CHAR (c);
2317     }
2318
2319   demand_empty_rest_of_line ();
2320 }
2321 \f
2322 /* The .tc pseudo-op.  This is used when generating XCOFF and ELF.
2323    This takes two or more arguments.
2324
2325    When generating XCOFF output, the first argument is the name to
2326    give to this location in the toc; this will be a symbol with class
2327    TC.  The rest of the arguments are 4 byte values to actually put at
2328    this location in the TOC; often there is just one more argument, a
2329    relocatable symbol reference.
2330
2331    When not generating XCOFF output, the arguments are the same, but
2332    the first argument is simply ignored.  */
2333
2334 static void
2335 i370_tc (int ignore ATTRIBUTE_UNUSED)
2336 {
2337
2338   /* Skip the TOC symbol name.  */
2339   while (is_part_of_name (*input_line_pointer)
2340          || *input_line_pointer == '['
2341          || *input_line_pointer == ']'
2342          || *input_line_pointer == '{'
2343          || *input_line_pointer == '}')
2344     ++input_line_pointer;
2345
2346   /* Align to a four byte boundary.  */
2347   frag_align (2, 0, 0);
2348   record_alignment (now_seg, 2);
2349
2350   if (*input_line_pointer != ',')
2351     demand_empty_rest_of_line ();
2352   else
2353     {
2354       ++input_line_pointer;
2355       cons (4);
2356     }
2357 }
2358 \f
2359 char *
2360 md_atof (int type, char *litp, int *sizep)
2361 {
2362   /* 360/370/390 have two float formats: an old, funky 360 single-precision
2363      format, and the ieee format.  Support only the ieee format.  */
2364   return ieee_md_atof (type, litp, sizep, TRUE);
2365 }
2366
2367 /* Write a value out to the object file, using the appropriate
2368    endianness.  */
2369
2370 void
2371 md_number_to_chars (char *buf, valueT val, int n)
2372 {
2373   number_to_chars_bigendian (buf, val, n);
2374 }
2375
2376 /* Align a section (I don't know why this is machine dependent).  */
2377
2378 valueT
2379 md_section_align (asection *seg, valueT addr)
2380 {
2381   int align = bfd_get_section_alignment (stdoutput, seg);
2382
2383   return (addr + (1 << align) - 1) & (-1 << align);
2384 }
2385
2386 /* We don't have any form of relaxing.  */
2387
2388 int
2389 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
2390                                asection *seg ATTRIBUTE_UNUSED)
2391 {
2392   abort ();
2393   return 0;
2394 }
2395
2396 /* Convert a machine dependent frag.  We never generate these.  */
2397
2398 void
2399 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2400                  asection *sec ATTRIBUTE_UNUSED,
2401                  fragS *fragp ATTRIBUTE_UNUSED)
2402 {
2403   abort ();
2404 }
2405
2406 /* We have no need to default values of symbols.  */
2407
2408 symbolS *
2409 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2410 {
2411   return 0;
2412 }
2413 \f
2414 /* Functions concerning relocs.  */
2415
2416 /* The location from which a PC relative jump should be calculated,
2417    given a PC relative reloc.  */
2418
2419 long
2420 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
2421 {
2422   return fixp->fx_frag->fr_address + fixp->fx_where;
2423 }
2424
2425 /* Apply a fixup to the object code.  This is called for all the
2426    fixups we generated by the call to fix_new_exp, above.  In the call
2427    above we used a reloc code which was the largest legal reloc code
2428    plus the operand index.  Here we undo that to recover the operand
2429    index.  At this point all symbol values should be fully resolved,
2430    and we attempt to completely resolve the reloc.  If we can not do
2431    that, we determine the correct reloc code and put it back in the
2432    fixup.
2433
2434    See gas/cgen.c for more sample code and explanations of what's
2435    going on here.  */
2436
2437 void
2438 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
2439 {
2440   valueT value = * valP;
2441
2442   if (fixP->fx_addsy != NULL)
2443     {
2444 #ifdef DEBUG
2445       printf ("\nmd_apply_fix: symbol %s at 0x%x (%s:%d) val=0x%x addend=0x%x\n",
2446               S_GET_NAME (fixP->fx_addsy),
2447               fixP->fx_frag->fr_address + fixP->fx_where,
2448               fixP->fx_file, fixP->fx_line,
2449               S_GET_VALUE (fixP->fx_addsy), value);
2450 #endif
2451     }
2452   else
2453     fixP->fx_done = 1;
2454
2455   /* Apply fixups to operands.  Note that there should be no relocations
2456      for any operands, since no instruction ever takes an operand
2457      that requires reloc.  */
2458   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2459     {
2460       int opindex;
2461       const struct i370_operand *operand;
2462       char *where;
2463       i370_insn_t insn;
2464
2465       opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2466
2467       operand = &i370_operands[opindex];
2468
2469 #ifdef DEBUG
2470       printf ("\nmd_apply_fix: fixup operand %s at 0x%x in %s:%d addend=0x%x\n",
2471               operand->name,
2472               fixP->fx_frag->fr_address + fixP->fx_where,
2473               fixP->fx_file, fixP->fx_line,
2474               value);
2475 #endif
2476       /* Fetch the instruction, insert the fully resolved operand
2477          value, and stuff the instruction back again.
2478          fisxp->fx_size is the length of the instruction.  */
2479       where = fixP->fx_frag->fr_literal + fixP->fx_where;
2480       insn.i[0] = bfd_getb32 ((unsigned char *) where);
2481
2482       if (6 <= fixP->fx_size)
2483         /* Deal with 48-bit insn's.  */
2484         insn.i[1] = bfd_getb32 (((unsigned char *) where)+4);
2485
2486       insn = i370_insert_operand (insn, operand, (offsetT) value);
2487       bfd_putb32 ((bfd_vma) insn.i[0], (unsigned char *) where);
2488
2489       if (6 <= fixP->fx_size)
2490         /* Deal with 48-bit insn's.  */
2491         bfd_putb32 ((bfd_vma) insn.i[1], (((unsigned char *) where)+4));
2492
2493       /* We are done, right? right !!  */
2494       fixP->fx_done = 1;
2495       if (fixP->fx_done)
2496         /* Nothing else to do here.  */
2497         return;
2498
2499       /* Determine a BFD reloc value based on the operand information.
2500          We are only prepared to turn a few of the operands into
2501          relocs.  In fact, we support *zero* operand relocations ...
2502          Why?  Because we are not expecting the compiler to generate
2503          any operands that need relocation.  Due to the 12-bit naturew of
2504          i370 addressing, this would be unusual.  */
2505         {
2506           char *sfile;
2507           unsigned int sline;
2508
2509           /* Use expr_symbol_where to see if this is an expression
2510              symbol.  */
2511           if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
2512             as_bad_where (fixP->fx_file, fixP->fx_line,
2513                           "unresolved expression that must be resolved");
2514           else
2515             as_bad_where (fixP->fx_file, fixP->fx_line,
2516                           "unsupported relocation type");
2517           fixP->fx_done = 1;
2518           return;
2519         }
2520     }
2521   else
2522     {
2523       /* We branch to here if the fixup is not to a symbol that
2524          appears in an instruction operand, but is rather some
2525          declared storage.  */
2526 #ifdef OBJ_ELF
2527       i370_elf_validate_fix (fixP, seg);
2528 #endif
2529 #ifdef DEBUG
2530       printf ("md_apply_fix: reloc case %d in segment  %s %s:%d\n",
2531               fixP->fx_r_type, segment_name (seg), fixP->fx_file, fixP->fx_line);
2532       printf ("\tcurrent fixup value is 0x%x \n", value);
2533 #endif
2534       switch (fixP->fx_r_type)
2535         {
2536         case BFD_RELOC_32:
2537         case BFD_RELOC_CTOR:
2538           if (fixP->fx_pcrel)
2539             fixP->fx_r_type = BFD_RELOC_32_PCREL;
2540           /* Fall through.  */
2541
2542         case BFD_RELOC_RVA:
2543         case BFD_RELOC_32_PCREL:
2544         case BFD_RELOC_32_BASEREL:
2545 #ifdef DEBUG
2546           printf ("\t32 bit relocation at 0x%x\n",
2547                   fixP->fx_frag->fr_address + fixP->fx_where);
2548 #endif
2549           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2550                               value, 4);
2551           break;
2552
2553         case BFD_RELOC_LO16:
2554         case BFD_RELOC_16:
2555           if (fixP->fx_pcrel)
2556             as_bad_where (fixP->fx_file, fixP->fx_line,
2557                           "cannot emit PC relative %s relocation%s%s",
2558                           bfd_get_reloc_code_name (fixP->fx_r_type),
2559                           fixP->fx_addsy != NULL ? " against " : "",
2560                           (fixP->fx_addsy != NULL
2561                            ? S_GET_NAME (fixP->fx_addsy)
2562                            : ""));
2563
2564           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2565                               value, 2);
2566           break;
2567
2568           /* This case happens when you write, for example,
2569              lis %r3,(L1-L2)@ha
2570              where L1 and L2 are defined later.  */
2571         case BFD_RELOC_HI16:
2572           if (fixP->fx_pcrel)
2573             abort ();
2574           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2575                               value >> 16, 2);
2576           break;
2577         case BFD_RELOC_HI16_S:
2578           if (fixP->fx_pcrel)
2579             abort ();
2580           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2581                               (value + 0x8000) >> 16, 2);
2582           break;
2583
2584         case BFD_RELOC_8:
2585           if (fixP->fx_pcrel)
2586             abort ();
2587
2588           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2589                               value, 1);
2590           break;
2591
2592         default:
2593           fprintf (stderr,
2594                   "Gas failure, reloc value %d\n", fixP->fx_r_type);
2595           fflush (stderr);
2596           abort ();
2597         }
2598     }
2599
2600   fixP->fx_addnumber = value;
2601 }
2602
2603 /* Generate a reloc for a fixup.  */
2604
2605 arelent *
2606 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
2607 {
2608   arelent *reloc;
2609
2610   reloc = xmalloc (sizeof (arelent));
2611
2612   reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2613   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2614   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2615   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2616   if (reloc->howto == (reloc_howto_type *) NULL)
2617     {
2618       as_bad_where (fixp->fx_file, fixp->fx_line,
2619                     "reloc %d not supported by object file format", (int)fixp->fx_r_type);
2620       return NULL;
2621     }
2622   reloc->addend = fixp->fx_addnumber;
2623
2624 #ifdef DEBUG
2625   printf ("\ngen_reloc(): sym %s (%s:%d) at addr 0x%x addend=0x%x\n",
2626           fixp->fx_addsy->bsym->name,
2627           fixp->fx_file, fixp->fx_line,
2628           reloc->address, reloc->addend);
2629 #endif
2630
2631   return reloc;
2632 }
2633
2634 /* The target specific pseudo-ops which we support.  */
2635
2636 const pseudo_typeS md_pseudo_table[] =
2637 {
2638   /* Pseudo-ops which must be overridden.  */
2639   { "byte",     i370_byte,      0 },
2640
2641   { "dc",       i370_dc,        0 },
2642   { "ds",       i370_ds,        0 },
2643   { "rmode",    i370_rmode,     0 },
2644   { "csect",    i370_csect,     0 },
2645   { "dsect",    i370_dsect,     0 },
2646
2647   /* enable ebcdic strings e.g. for 3270 support */
2648   { "ebcdic",   i370_ebcdic,    0 },
2649
2650 #ifdef OBJ_ELF
2651   { "long",     i370_elf_cons,  4 },
2652   { "word",     i370_elf_cons,  4 },
2653   { "short",    i370_elf_cons,  2 },
2654   { "rdata",    i370_elf_rdata, 0 },
2655   { "rodata",   i370_elf_rdata, 0 },
2656   { "lcomm",    i370_elf_lcomm, 0 },
2657 #endif
2658
2659   /* This pseudo-op is used even when not generating XCOFF output.  */
2660   { "tc",       i370_tc,        0 },
2661
2662   /* dump the literal pool */
2663   { "ltorg",    i370_ltorg,     0 },
2664
2665   /* support the hlasm-style USING directive */
2666   { "using",    i370_using,     0 },
2667   { "drop",     i370_drop,      0 },
2668
2669   { NULL,       NULL,           0 }
2670 };
2671