bfd/vms-tir.c

   1 /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
   2    EVAX (openVMS/Alpha) files.
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    TIR record handling functions
   7    ETIR record handling functions
   8
   9    go and read the openVMS linker manual (esp. appendix B)
  10    if you don't know what's going on here :-)
  11
  12    Written by Klaus K"ampf (kkaempf@rmi.de)
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 2 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  27
  28 /* The following type abbreviations are used:
  29
  30         cs      counted string (ascii string with length byte)
  31         by      byte (1 byte)
  32         sh      short (2 byte, 16 bit)
  33         lw      longword (4 byte, 32 bit)
  34         qw      quadword (8 byte, 64 bit)
  35         da      data stream  */
  36
  37 #include "bfd.h"
  38 #include "sysdep.h"
  39 #include "bfdlink.h"
  40 #include "libbfd.h"
  41
  42 #include "vms.h"
  43
  44 static void image_set_ptr
  45   PARAMS ((bfd *abfd, int psect, uquad offset));
  46 static void image_inc_ptr
  47   PARAMS ((bfd *abfd, uquad offset));
  48 static void image_dump
  49   PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset));
  50 static void image_write_b
  51   PARAMS ((bfd *abfd, unsigned int value));
  52 static void image_write_w
  53   PARAMS ((bfd *abfd, unsigned int value));
  54 static void image_write_l
  55   PARAMS ((bfd *abfd, unsigned long value));
  56 static void image_write_q
  57   PARAMS ((bfd *abfd, uquad value));
  58 static int check_section
  59   PARAMS ((bfd *, int));
  60 static bfd_boolean etir_sta
  61   PARAMS ((bfd *, int, unsigned char *));
  62 static bfd_boolean etir_sto
  63   PARAMS ((bfd *, int, unsigned char *));
  64 static bfd_boolean etir_opr
  65   PARAMS ((bfd *, int, unsigned char *));
  66 static bfd_boolean etir_ctl
  67   PARAMS ((bfd *, int, unsigned char *));
  68 static bfd_boolean etir_stc
  69   PARAMS ((bfd *, int, unsigned char *));
  70 static asection *new_section
  71   PARAMS ((bfd *, int));
  72 static int alloc_section
  73   PARAMS ((bfd *, unsigned int));
  74 static int etir_cmd
  75   PARAMS ((bfd *, int, unsigned char *));
  76 static int analyze_tir
  77   PARAMS ((bfd *, unsigned char *, unsigned int));
  78 static int analyze_etir
  79   PARAMS ((bfd *, unsigned char *, unsigned int));
  80 static unsigned char * tir_opr
  81   PARAMS ((bfd *, unsigned char *));
  82 static const char * tir_cmd_name
  83   PARAMS ((int));
  84 static const char * cmd_name
  85   PARAMS ((int));
  86
  87 \f
  88 static int
  89 check_section (abfd, size)
  90      bfd *abfd;
  91      int size;
  92 {
  93   bfd_size_type offset;
  94
  95   offset = PRIV (image_ptr) - PRIV (image_section)->contents;
  96   if (offset + size > PRIV (image_section)->_raw_size)
  97     {
  98       PRIV (image_section)->contents
  99         = bfd_realloc (PRIV (image_section)->contents, offset + size);
 100       if (PRIV (image_section)->contents == 0)
 101         {
 102           (*_bfd_error_handler) (_("No Mem !"));
 103           return -1;
 104         }
 105       PRIV (image_section)->_raw_size = offset + size;
 106       PRIV (image_ptr) = PRIV (image_section)->contents + offset;
 107     }
 108
 109   return 0;
 110 }
 111
 112 /* Routines to fill sections contents during tir/etir read.  */
 113
 114 /* Initialize image buffer pointer to be filled.  */
 115
 116 static void
 117 image_set_ptr (abfd, psect, offset)
 118      bfd *abfd;
 119      int psect;
 120      uquad offset;
 121 {
 122 #if VMS_DEBUG
 123   _bfd_vms_debug (4, "image_set_ptr (%d=%s, %d)\n",
 124                   psect, PRIV (sections)[psect]->name, offset);
 125 #endif
 126
 127   PRIV (image_ptr) = PRIV (sections)[psect]->contents + offset;
 128   PRIV (image_section) = PRIV (sections)[psect];
 129   return;
 130 }
 131
 132 /* Increment image buffer pointer by offset.  */
 133
 134 static void
 135 image_inc_ptr (abfd, offset)
 136      bfd *abfd;
 137      uquad offset;
 138 {
 139 #if VMS_DEBUG
 140   _bfd_vms_debug (4, "image_inc_ptr (%d)\n", offset);
 141 #endif
 142
 143   PRIV (image_ptr) += offset;
 144
 145   return;
 146 }
 147
 148 /* Dump multiple bytes to section image.  */
 149
 150 static void
 151 image_dump (abfd, ptr, size, offset)
 152     bfd *abfd;
 153     unsigned char *ptr;
 154     int size;
 155     int offset ATTRIBUTE_UNUSED;
 156 {
 157 #if VMS_DEBUG
 158   _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size,
 159                   PRIV (image_ptr));
 160   _bfd_hexdump (9, ptr, size, offset);
 161 #endif
 162
 163   if (PRIV (is_vax) && check_section (abfd, size))
 164     return;
 165
 166   while (size-- > 0)
 167     *PRIV (image_ptr)++ = *ptr++;
 168   return;
 169 }
 170
 171 /* Write byte to section image.  */
 172
 173 static void
 174 image_write_b (abfd, value)
 175      bfd *abfd;
 176      unsigned int value;
 177 {
 178 #if VMS_DEBUG
 179   _bfd_vms_debug (6, "image_write_b(%02x)\n", (int) value);
 180 #endif
 181
 182   if (PRIV (is_vax) && check_section (abfd, 1))
 183     return;
 184
 185   *PRIV (image_ptr)++ = (value & 0xff);
 186   return;
 187 }
 188
 189 /* Write 2-byte word to image.  */
 190
 191 static void
 192 image_write_w (abfd, value)
 193      bfd *abfd;
 194      unsigned int value;
 195 {
 196 #if VMS_DEBUG
 197   _bfd_vms_debug (6, "image_write_w(%04x)\n", (int) value);
 198 #endif
 199
 200   if (PRIV (is_vax) && check_section (abfd, 2))
 201     return;
 202
 203   bfd_putl16 ((bfd_vma) value, PRIV (image_ptr));
 204   PRIV (image_ptr) += 2;
 205
 206   return;
 207 }
 208
 209 /* Write 4-byte long to image.  */
 210
 211 static void
 212 image_write_l (abfd, value)
 213      bfd *abfd;
 214      unsigned long value;
 215 {
 216 #if VMS_DEBUG
 217   _bfd_vms_debug (6, "image_write_l (%08lx)\n", value);
 218 #endif
 219
 220   if (PRIV (is_vax) && check_section (abfd, 4))
 221     return;
 222
 223   bfd_putl32 ((bfd_vma) value, PRIV (image_ptr));
 224   PRIV (image_ptr) += 4;
 225
 226   return;
 227 }
 228
 229 /* Write 8-byte quad to image.  */
 230
 231 static void
 232 image_write_q (abfd, value)
 233      bfd *abfd;
 234      uquad value;
 235 {
 236 #if VMS_DEBUG
 237   _bfd_vms_debug (6, "image_write_q (%016lx)\n", value);
 238 #endif
 239
 240   if (PRIV (is_vax) && check_section (abfd, 8))
 241     return;
 242
 243   bfd_putl64 (value, PRIV (image_ptr));
 244   PRIV (image_ptr) += 8;
 245
 246   return;
 247 }
 248 \f
 249 static const char *
 250 cmd_name (cmd)
 251      int cmd;
 252 {
 253   switch (cmd)
 254     {
 255     case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL";
 256     case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ";
 257     case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI";
 258     case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD";
 259     case ETIR_S_C_STA_CKARG: return "ETIR_S_C_STA_CKARG";
 260     case ETIR_S_C_STO_B: return "ETIR_S_C_STO_B";
 261     case ETIR_S_C_STO_W: return "ETIR_S_C_STO_W";
 262     case ETIR_S_C_STO_GBL: return "ETIR_S_C_STO_GBL";
 263     case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA";
 264     case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB";
 265     case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB";
 266     case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW";
 267     case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB";
 268     case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL";
 269     case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS";
 270     case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV";
 271     case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH";
 272     case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT";
 273     case ETIR_S_C_OPR_REDEF: return "ETIR_S_C_OPR_REDEF";
 274     case ETIR_S_C_OPR_DFLIT: return "ETIR_S_C_OPR_DFLIT";
 275     case ETIR_S_C_STC_LP: return "ETIR_S_C_STC_LP";
 276     case ETIR_S_C_STC_GBL: return "ETIR_S_C_STC_GBL";
 277     case ETIR_S_C_STC_GCA: return "ETIR_S_C_STC_GCA";
 278     case ETIR_S_C_STC_PS: return "ETIR_S_C_STC_PS";
 279     case ETIR_S_C_STC_NBH_PS: return "ETIR_S_C_STC_NBH_PS";
 280     case ETIR_S_C_STC_NOP_GBL: return "ETIR_S_C_STC_NOP_GBL";
 281     case ETIR_S_C_STC_NOP_PS: return "ETIR_S_C_STC_NOP_PS";
 282     case ETIR_S_C_STC_BSR_GBL: return "ETIR_S_C_STC_BSR_GBL";
 283     case ETIR_S_C_STC_BSR_PS: return "ETIR_S_C_STC_BSR_PS";
 284     case ETIR_S_C_STC_LDA_GBL: return "ETIR_S_C_STC_LDA_GBL";
 285     case ETIR_S_C_STC_LDA_PS: return "ETIR_S_C_STC_LDA_PS";
 286     case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL";
 287     case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS";
 288     case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL";
 289
 290     default:
 291       /* These names have not yet been added to this switch statement.  */
 292       abort ();
 293     }
 294 }
 295 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
 296
 297 /* etir_sta
 298
 299    vms stack commands
 300
 301    handle sta_xxx commands in etir section
 302    ptr points to data area in record
 303
 304    see table B-8 of the openVMS linker manual.  */
 305
 306 static bfd_boolean
 307 etir_sta (abfd, cmd, ptr)
 308      bfd *abfd;
 309      int cmd;
 310      unsigned char *ptr;
 311 {
 312
 313 #if VMS_DEBUG
 314   _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
 315   _bfd_hexdump (8, ptr, 16, (int) ptr);
 316 #endif
 317
 318   switch (cmd)
 319     {
 320       /* stack */
 321
 322       /* stack global
 323          arg: cs        symbol name
 324
 325          stack 32 bit value of symbol (high bits set to 0)  */
 326
 327     case ETIR_S_C_STA_GBL:
 328       {
 329         char *name;
 330         vms_symbol_entry *entry;
 331
 332         name = _bfd_vms_save_counted_string (ptr);
 333         entry = (vms_symbol_entry *)
 334           bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
 335         if (entry == (vms_symbol_entry *) NULL)
 336           {
 337 #if VMS_DEBUG
 338             _bfd_vms_debug (3, "%s: no symbol \"%s\"\n",
 339                             cmd_name (cmd), name);
 340 #endif
 341             _bfd_vms_push (abfd, (uquad) 0, -1);
 342           }
 343         else
 344           {
 345             _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
 346           }
 347       }
 348       break;
 349
 350       /* stack longword
 351          arg: lw        value
 352
 353          stack 32 bit value, sign extend to 64 bit  */
 354
 355     case ETIR_S_C_STA_LW:
 356       _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
 357       break;
 358
 359       /* stack global
 360          arg: qw        value
 361
 362          stack 64 bit value of symbol    */
 363
 364     case ETIR_S_C_STA_QW:
 365       _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1);
 366       break;
 367
 368       /* stack psect base plus quadword offset
 369          arg: lw        section index
 370          qw     signed quadword offset (low 32 bits)
 371
 372          stack qw argument and section index
 373          (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB)  */
 374
 375     case ETIR_S_C_STA_PQ:
 376       {
 377         uquad dummy;
 378         unsigned int psect;
 379
 380         psect = bfd_getl32 (ptr);
 381         if (psect >= PRIV (section_count))
 382           {
 383             (*_bfd_error_handler) (_("bad section index in %s"),
 384                                    cmd_name (cmd));
 385             bfd_set_error (bfd_error_bad_value);
 386             return FALSE;
 387           }
 388         dummy = bfd_getl64 (ptr+4);
 389         _bfd_vms_push (abfd, dummy, (int) psect);
 390       }
 391       break;
 392
 393     case ETIR_S_C_STA_LI:
 394     case ETIR_S_C_STA_MOD:
 395     case ETIR_S_C_STA_CKARG:
 396       (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd));
 397       return FALSE;
 398       break;
 399
 400     default:
 401       (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd);
 402       return FALSE;
 403       break;
 404     }
 405 #if VMS_DEBUG
 406   _bfd_vms_debug (5, "etir_sta true\n");
 407 #endif
 408   return TRUE;
 409 }
 410
 411 /*
 412    etir_sto
 413
 414    vms store commands
 415
 416    handle sto_xxx commands in etir section
 417    ptr points to data area in record
 418
 419    see table B-9 of the openVMS linker manual.  */
 420
 421 static bfd_boolean
 422 etir_sto (abfd, cmd, ptr)
 423      bfd *abfd;
 424      int cmd;
 425      unsigned char *ptr;
 426 {
 427   uquad dummy;
 428   int psect;
 429
 430 #if VMS_DEBUG
 431   _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
 432   _bfd_hexdump (8, ptr, 16, (int) ptr);
 433 #endif
 434
 435   switch (cmd)
 436     {
 437       /* store byte: pop stack, write byte
 438          arg: -  */
 439
 440     case ETIR_S_C_STO_B:
 441       dummy = _bfd_vms_pop (abfd, &psect);
 442 #if 0
 443       if (is_share)             /* FIXME */
 444         (*_bfd_error_handler) ("%s: byte fixups not supported",
 445                                cmd_name (cmd));
 446 #endif
 447       /* FIXME: check top bits */
 448       image_write_b (abfd, (unsigned int) dummy & 0xff);
 449       break;
 450
 451       /* store word: pop stack, write word
 452          arg: -  */
 453
 454     case ETIR_S_C_STO_W:
 455       dummy = _bfd_vms_pop (abfd, &psect);
 456 #if 0
 457       if (is_share)             /* FIXME */
 458         (*_bfd_error_handler) ("%s: word fixups not supported",
 459                                cmd_name (cmd));
 460 #endif
 461       /* FIXME: check top bits */
 462       image_write_w (abfd, (unsigned int) dummy & 0xffff);
 463       break;
 464
 465       /* store longword: pop stack, write longword
 466          arg: -  */
 467
 468     case ETIR_S_C_STO_LW:
 469       dummy = _bfd_vms_pop (abfd, &psect);
 470       dummy += (PRIV (sections)[psect])->vma;
 471       /* FIXME: check top bits.  */
 472       image_write_l (abfd, (unsigned int) dummy & 0xffffffff);
 473       break;
 474
 475       /* store quadword: pop stack, write quadword
 476          arg: -  */
 477
 478     case ETIR_S_C_STO_QW:
 479       dummy = _bfd_vms_pop (abfd, &psect);
 480       dummy += (PRIV (sections)[psect])->vma;
 481       image_write_q (abfd, dummy);              /* FIXME: check top bits */
 482       break;
 483
 484       /* store immediate repeated: pop stack for repeat count
 485          arg: lw        byte count
 486          da     data  */
 487
 488     case ETIR_S_C_STO_IMMR:
 489       {
 490         int size;
 491
 492         size = bfd_getl32 (ptr);
 493         dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
 494         while (dummy-- > 0)
 495           image_dump (abfd, ptr+4, size, 0);
 496       }
 497       break;
 498
 499       /* store global: write symbol value
 500          arg: cs        global symbol name.  */
 501
 502     case ETIR_S_C_STO_GBL:
 503       {
 504         vms_symbol_entry *entry;
 505         char *name;
 506
 507         name = _bfd_vms_save_counted_string (ptr);
 508         entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 509                                                       name, FALSE, FALSE);
 510         if (entry == (vms_symbol_entry *) NULL)
 511           {
 512             (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
 513                                    cmd_name (cmd), name);
 514             return FALSE;
 515           }
 516         else
 517           /* FIXME, reloc.  */
 518           image_write_q (abfd, (uquad) (entry->symbol->value));
 519       }
 520       break;
 521
 522       /* store code address: write address of entry point
 523          arg: cs        global symbol name (procedure).  */
 524
 525     case ETIR_S_C_STO_CA:
 526       {
 527         vms_symbol_entry *entry;
 528         char *name;
 529
 530         name = _bfd_vms_save_counted_string (ptr);
 531         entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 532                                                       name, FALSE, FALSE);
 533         if (entry == (vms_symbol_entry *) NULL)
 534           {
 535             (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
 536                                    cmd_name (cmd), name);
 537             return FALSE;
 538           }
 539         else
 540           image_write_q (abfd, (uquad) (entry->symbol->value)); /* FIXME, reloc */
 541       }
 542       break;
 543
 544       /* Store offset to psect: pop stack, add low 32 bits to base of psect
 545          arg: none.  */
 546
 547     case ETIR_S_C_STO_OFF:
 548       {
 549         uquad q;
 550         int psect1;
 551
 552         q = _bfd_vms_pop (abfd, &psect1);
 553         q += (PRIV (sections)[psect1])->vma;
 554         image_write_q (abfd, q);
 555       }
 556       break;
 557
 558       /* Store immediate
 559          arg: lw        count of bytes
 560               da        data.  */
 561
 562     case ETIR_S_C_STO_IMM:
 563       {
 564         int size;
 565
 566         size = bfd_getl32 (ptr);
 567         image_dump (abfd, ptr+4, size, 0);
 568       }
 569       break;
 570
 571       /* This code is 'reserved to digital' according to the openVMS
 572          linker manual, however it is generated by the DEC C compiler
 573          and defined in the include file.
 574          FIXME, since the following is just a guess
 575          store global longword: store 32bit value of symbol
 576          arg: cs        symbol name.  */
 577
 578     case ETIR_S_C_STO_GBL_LW:
 579       {
 580         vms_symbol_entry *entry;
 581         char *name;
 582
 583         name = _bfd_vms_save_counted_string (ptr);
 584         entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 585                                                       name, FALSE, FALSE);
 586         if (entry == (vms_symbol_entry *) NULL)
 587           {
 588 #if VMS_DEBUG
 589             _bfd_vms_debug (3, "%s: no symbol \"%s\"\n", cmd_name (cmd), name);
 590 #endif
 591             image_write_l (abfd, (unsigned long) 0);    /* FIXME, reloc */
 592           }
 593         else
 594           /* FIXME, reloc.  */
 595           image_write_l (abfd, (unsigned long) (entry->symbol->value));
 596       }
 597       break;
 598
 599     case ETIR_S_C_STO_RB:
 600     case ETIR_S_C_STO_AB:
 601     case ETIR_S_C_STO_LP_PSB:
 602       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
 603       break;
 604
 605     case ETIR_S_C_STO_HINT_GBL:
 606     case ETIR_S_C_STO_HINT_PS:
 607       (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd));
 608       break;
 609
 610     default:
 611       (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd);
 612       break;
 613     }
 614
 615   return TRUE;
 616 }
 617
 618 /* Stack operator commands
 619    all 32 bit signed arithmetic
 620    all word just like a stack calculator
 621    arguments are popped from stack, results are pushed on stack
 622
 623    see table B-10 of the openVMS linker manual.  */
 624
 625 static bfd_boolean
 626 etir_opr (abfd, cmd, ptr)
 627      bfd *abfd;
 628      int cmd;
 629      unsigned char *ptr ATTRIBUTE_UNUSED;
 630 {
 631   long op1, op2;
 632
 633 #if VMS_DEBUG
 634   _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
 635   _bfd_hexdump (8, ptr, 16, (int) ptr);
 636 #endif
 637
 638   switch (cmd)
 639     {
 640     case ETIR_S_C_OPR_NOP:      /* no-op  */
 641       break;
 642
 643     case ETIR_S_C_OPR_ADD:      /* add  */
 644       op1 = (long) _bfd_vms_pop (abfd, NULL);
 645       op2 = (long) _bfd_vms_pop (abfd, NULL);
 646       _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
 647       break;
 648
 649     case ETIR_S_C_OPR_SUB:      /* subtract  */
 650       op1 = (long) _bfd_vms_pop (abfd, NULL);
 651       op2 = (long) _bfd_vms_pop (abfd, NULL);
 652       _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
 653       break;
 654
 655     case ETIR_S_C_OPR_MUL:      /* multiply  */
 656       op1 = (long) _bfd_vms_pop (abfd, NULL);
 657       op2 = (long) _bfd_vms_pop (abfd, NULL);
 658       _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
 659       break;
 660
 661     case ETIR_S_C_OPR_DIV:      /* divide  */
 662       op1 = (long) _bfd_vms_pop (abfd, NULL);
 663       op2 = (long) _bfd_vms_pop (abfd, NULL);
 664       if (op2 == 0)
 665         _bfd_vms_push (abfd, (uquad) 0, -1);
 666       else
 667         _bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
 668       break;
 669
 670     case ETIR_S_C_OPR_AND:      /* logical and  */
 671       op1 = (long) _bfd_vms_pop (abfd, NULL);
 672       op2 = (long) _bfd_vms_pop (abfd, NULL);
 673       _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
 674       break;
 675
 676     case ETIR_S_C_OPR_IOR:      /* logical inclusive or  */
 677       op1 = (long) _bfd_vms_pop (abfd, NULL);
 678       op2 = (long) _bfd_vms_pop (abfd, NULL);
 679       _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
 680       break;
 681
 682     case ETIR_S_C_OPR_EOR:      /* logical exclusive or  */
 683       op1 = (long) _bfd_vms_pop (abfd, NULL);
 684       op2 = (long) _bfd_vms_pop (abfd, NULL);
 685       _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
 686       break;
 687
 688     case ETIR_S_C_OPR_NEG:      /* negate  */
 689       op1 = (long) _bfd_vms_pop (abfd, NULL);
 690       _bfd_vms_push (abfd, (uquad) (-op1), -1);
 691       break;
 692
 693     case ETIR_S_C_OPR_COM:      /* complement  */
 694       op1 = (long) _bfd_vms_pop (abfd, NULL);
 695       _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
 696       break;
 697
 698     case ETIR_S_C_OPR_ASH:      /* arithmetic shift  */
 699       op1 = (long) _bfd_vms_pop (abfd, NULL);
 700       op2 = (long) _bfd_vms_pop (abfd, NULL);
 701       if (op2 < 0)              /* shift right */
 702         op1 >>= -op2;
 703       else                      /* shift left */
 704         op1 <<= op2;
 705       _bfd_vms_push (abfd, (uquad) op1, -1);
 706       break;
 707
 708     case ETIR_S_C_OPR_INSV:      /* insert field  */
 709       (void) _bfd_vms_pop (abfd, NULL);
 710     case ETIR_S_C_OPR_USH:       /* unsigned shift  */
 711     case ETIR_S_C_OPR_ROT:       /* rotate  */
 712     case ETIR_S_C_OPR_REDEF:     /* Redefine symbol to current location.  */
 713     case ETIR_S_C_OPR_DFLIT:     /* Define a literal.  */
 714       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
 715       break;
 716
 717     case ETIR_S_C_OPR_SEL:      /* select  */
 718       if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
 719         (void) _bfd_vms_pop (abfd, NULL);
 720       else
 721         {
 722           op1 = (long) _bfd_vms_pop (abfd, NULL);
 723           (void) _bfd_vms_pop (abfd, NULL);
 724           _bfd_vms_push (abfd, (uquad) op1, -1);
 725         }
 726       break;
 727
 728     default:
 729       (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd);
 730       break;
 731     }
 732
 733   return TRUE;
 734 }
 735
 736 /* Control commands.
 737
 738    See table B-11 of the openVMS linker manual.  */
 739
 740 static bfd_boolean
 741 etir_ctl (abfd, cmd, ptr)
 742      bfd *abfd;
 743      int cmd;
 744      unsigned char *ptr;
 745 {
 746   uquad  dummy;
 747   int psect;
 748
 749 #if VMS_DEBUG
 750   _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
 751   _bfd_hexdump (8, ptr, 16, (int) ptr);
 752 #endif
 753
 754   switch (cmd)
 755     {
 756       /* set relocation base: pop stack, set image location counter
 757          arg: none.  */
 758
 759     case ETIR_S_C_CTL_SETRB:
 760       dummy = _bfd_vms_pop (abfd, &psect);
 761       image_set_ptr (abfd, psect, dummy);
 762       break;
 763
 764       /* augment relocation base: increment image location counter by offset
 765          arg: lw        offset value  */
 766
 767     case ETIR_S_C_CTL_AUGRB:
 768       dummy = bfd_getl32 (ptr);
 769       image_inc_ptr (abfd, dummy);
 770       break;
 771
 772       /* define location: pop index, save location counter under index
 773          arg: none.  */
 774
 775     case ETIR_S_C_CTL_DFLOC:
 776       dummy = _bfd_vms_pop (abfd, NULL);
 777       /* FIXME */
 778       break;
 779
 780       /* set location: pop index, restore location counter from index
 781          arg: none.  */
 782
 783     case ETIR_S_C_CTL_STLOC:
 784       dummy = _bfd_vms_pop (abfd, &psect);
 785       /* FIXME */
 786       break;
 787
 788       /* stack defined location: pop index, push location counter from index
 789          arg: none.  */
 790
 791     case ETIR_S_C_CTL_STKDL:
 792       dummy = _bfd_vms_pop (abfd, &psect);
 793       /* FIXME */
 794       break;
 795
 796     default:
 797       (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd);
 798       break;
 799     }
 800   return TRUE;
 801 }
 802
 803 /* store conditional commands
 804
 805    See table B-12 and B-13 of the openVMS linker manual.  */
 806
 807 static bfd_boolean
 808 etir_stc (abfd, cmd, ptr)
 809      bfd *abfd;
 810      int cmd;
 811      unsigned char *ptr ATTRIBUTE_UNUSED;
 812 {
 813 #if VMS_DEBUG
 814   _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
 815   _bfd_hexdump (8, ptr, 16, (int) ptr);
 816 #endif
 817
 818   switch (cmd)
 819     {
 820       /* 200 Store-conditional Linkage Pair
 821          arg: none.  */
 822
 823     case ETIR_S_C_STC_LP:
 824       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
 825       break;
 826
 827       /* 201 Store-conditional Linkage Pair with Procedure Signature
 828          arg:   lw      linkage index
 829                 cs      procedure name
 830                 by      signature length
 831                 da      signature.  */
 832
 833     case ETIR_S_C_STC_LP_PSB:
 834       image_inc_ptr (abfd, (uquad) 16); /* skip entry,procval */
 835       break;
 836
 837       /* 202 Store-conditional Address at global address
 838          arg:   lw      linkage index
 839                 cs      global name.  */
 840
 841     case ETIR_S_C_STC_GBL:
 842       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
 843       break;
 844
 845       /* 203 Store-conditional Code Address at global address
 846          arg:   lw      linkage index
 847                 cs      procedure name.  */
 848
 849     case ETIR_S_C_STC_GCA:
 850       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
 851       break;
 852
 853       /* 204 Store-conditional Address at psect + offset
 854          arg:   lw      linkage index
 855                 lw      psect index
 856                 qw      offset.  */
 857
 858     case ETIR_S_C_STC_PS:
 859       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
 860       break;
 861
 862       /* 205 Store-conditional NOP at address of global
 863          arg: none.  */
 864
 865     case ETIR_S_C_STC_NOP_GBL:
 866
 867       /* 206 Store-conditional NOP at pect + offset
 868          arg: none.  */
 869
 870     case ETIR_S_C_STC_NOP_PS:
 871
 872       /* 207 Store-conditional BSR at global address
 873          arg: none.  */
 874
 875     case ETIR_S_C_STC_BSR_GBL:
 876
 877       /* 208 Store-conditional BSR at pect + offset
 878          arg: none.  */
 879
 880     case ETIR_S_C_STC_BSR_PS:
 881
 882       /* 209 Store-conditional LDA at global address
 883          arg: none.  */
 884
 885     case ETIR_S_C_STC_LDA_GBL:
 886
 887       /* 210 Store-conditional LDA at psect + offset
 888          arg: none.  */
 889
 890     case ETIR_S_C_STC_LDA_PS:
 891
 892       /* 211 Store-conditional BSR or Hint at global address
 893          arg: none.  */
 894
 895     case ETIR_S_C_STC_BOH_GBL:
 896
 897       /* 212 Store-conditional BSR or Hint at pect + offset
 898          arg: none.  */
 899
 900     case ETIR_S_C_STC_BOH_PS:
 901
 902       /* 213 Store-conditional NOP,BSR or HINT at global address
 903          arg: none.  */
 904
 905     case ETIR_S_C_STC_NBH_GBL:
 906
 907       /* 214 Store-conditional NOP,BSR or HINT at psect + offset
 908          arg: none.  */
 909
 910     case ETIR_S_C_STC_NBH_PS:
 911       /* FIXME */
 912 #if 0
 913       (*_bfd_error_handler) ("%s: not supported", cmd_name (cmd));
 914 #endif
 915       break;
 916
 917     default:
 918 #if VMS_DEBUG
 919       _bfd_vms_debug (3,  "reserved STC cmd %d", cmd);
 920 #endif
 921       break;
 922     }
 923   return TRUE;
 924 }
 925
 926 static asection *
 927 new_section (abfd, idx)
 928      bfd *abfd ATTRIBUTE_UNUSED;
 929      int idx;
 930 {
 931   asection *section;
 932   char sname[16];
 933   char *name;
 934
 935 #if VMS_DEBUG
 936   _bfd_vms_debug (5, "new_section %d\n", idx);
 937 #endif
 938   sprintf (sname, SECTION_NAME_TEMPLATE, idx);
 939
 940   name = bfd_malloc ((bfd_size_type) strlen (sname) + 1);
 941   if (name == 0)
 942     return 0;
 943   strcpy (name, sname);
 944
 945   section = bfd_malloc ((bfd_size_type) sizeof (asection));
 946   if (section == 0)
 947     {
 948 #if VMS_DEBUG
 949       _bfd_vms_debug (6,  "bfd_make_section (%s) failed", name);
 950 #endif
 951       return 0;
 952     }
 953
 954   section->_raw_size = 0;
 955   section->vma = 0;
 956   section->contents = 0;
 957   section->_cooked_size = 0;
 958   section->name = name;
 959   section->index = idx;
 960
 961   return section;
 962 }
 963
 964 static int
 965 alloc_section (abfd, idx)
 966      bfd *abfd;
 967      unsigned int idx;
 968 {
 969   bfd_size_type amt;
 970
 971 #if VMS_DEBUG
 972   _bfd_vms_debug (4, "alloc_section %d\n", idx);
 973 #endif
 974
 975   amt = idx + 1;
 976   amt *= sizeof (asection *);
 977   PRIV (sections) = (asection **) bfd_realloc (PRIV (sections), amt);
 978   if (PRIV (sections) == 0)
 979     return -1;
 980
 981   while (PRIV (section_count) <= idx)
 982     {
 983       PRIV (sections)[PRIV (section_count)]
 984         = new_section (abfd, (int) PRIV (section_count));
 985       if (PRIV (sections)[PRIV (section_count)] == 0)
 986         return -1;
 987       PRIV (section_count)++;
 988     }
 989
 990   return 0;
 991 }
 992
 993 /* tir_sta
 994
 995    vax stack commands
 996
 997    Handle sta_xxx commands in tir section
 998    ptr points to data area in record
 999
1000    See table 7-3 of the VAX/VMS linker manual.  */
1001
1002 static unsigned char *
1003 tir_sta (bfd *abfd, unsigned char *ptr)
1004 {
1005   int cmd = *ptr++;
1006
1007 #if VMS_DEBUG
1008   _bfd_vms_debug (5, "tir_sta %d\n", cmd);
1009 #endif
1010
1011   switch (cmd)
1012     {
1013       /* stack */
1014     case TIR_S_C_STA_GBL:
1015       /* stack global
1016          arg: cs        symbol name
1017
1018          stack 32 bit value of symbol (high bits set to 0).  */
1019       {
1020         char *name;
1021         vms_symbol_entry *entry;
1022
1023         name = _bfd_vms_save_counted_string (ptr);
1024
1025         entry = _bfd_vms_enter_symbol (abfd, name);
1026         if (entry == (vms_symbol_entry *) NULL)
1027           return 0;
1028
1029         _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
1030         ptr += *ptr + 1;
1031       }
1032       break;
1033
1034     case TIR_S_C_STA_SB:
1035       /* stack signed byte
1036          arg: by        value
1037
1038          stack byte value, sign extend to 32 bit.  */
1039       _bfd_vms_push (abfd, (uquad) *ptr++, -1);
1040       break;
1041
1042     case TIR_S_C_STA_SW:
1043       /* stack signed short word
1044          arg: sh        value
1045
1046          stack 16 bit value, sign extend to 32 bit.  */
1047       _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
1048       ptr += 2;
1049       break;
1050
1051     case TIR_S_C_STA_LW:
1052       /* stack signed longword
1053          arg: lw        value
1054
1055          stack 32 bit value.  */
1056       _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
1057       ptr += 4;
1058       break;
1059
1060     case TIR_S_C_STA_PB:
1061     case TIR_S_C_STA_WPB:
1062       /* stack psect base plus byte offset (word index)
1063          arg: by        section index
1064                 (sh     section index)
1065                 by      signed byte offset.  */
1066       {
1067         unsigned long dummy;
1068         unsigned int psect;
1069
1070         if (cmd == TIR_S_C_STA_PB)
1071           psect = *ptr++;
1072         else
1073           {
1074             psect = bfd_getl16 (ptr);
1075             ptr += 2;
1076           }
1077
1078         if (psect >= PRIV (section_count))
1079           alloc_section (abfd, psect);
1080
1081         dummy = (long) *ptr++;
1082         dummy += (PRIV (sections)[psect])->vma;
1083         _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
1084       }
1085       break;
1086
1087     case TIR_S_C_STA_PW:
1088     case TIR_S_C_STA_WPW:
1089       /* stack psect base plus word offset (word index)
1090          arg: by        section index
1091                 (sh     section index)
1092                 sh      signed short offset.  */
1093       {
1094         unsigned long dummy;
1095         unsigned int psect;
1096
1097         if (cmd == TIR_S_C_STA_PW)
1098           psect = *ptr++;
1099         else
1100           {
1101             psect = bfd_getl16 (ptr);
1102             ptr += 2;
1103           }
1104
1105         if (psect >= PRIV (section_count))
1106           alloc_section (abfd, psect);
1107
1108         dummy = bfd_getl16 (ptr); ptr+=2;
1109         dummy += (PRIV (sections)[psect])->vma;
1110         _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
1111       }
1112       break;
1113
1114     case TIR_S_C_STA_PL:
1115     case TIR_S_C_STA_WPL:
1116       /* stack psect base plus long offset (word index)
1117          arg: by        section index
1118                 (sh     section index)
1119                 lw      signed longword offset.  */
1120       {
1121         unsigned long dummy;
1122         unsigned int psect;
1123
1124         if (cmd == TIR_S_C_STA_PL)
1125           psect = *ptr++;
1126         else
1127           {
1128             psect = bfd_getl16 (ptr);
1129             ptr += 2;
1130           }
1131
1132         if (psect >= PRIV (section_count))
1133           alloc_section (abfd, psect);
1134
1135         dummy = bfd_getl32 (ptr); ptr += 4;
1136         dummy += (PRIV (sections)[psect])->vma;
1137         _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
1138       }
1139       break;
1140
1141     case TIR_S_C_STA_UB:
1142       /* stack unsigned byte
1143          arg: by        value
1144
1145          stack byte value.  */
1146       _bfd_vms_push (abfd, (uquad) *ptr++, -1);
1147       break;
1148
1149     case TIR_S_C_STA_UW:
1150       /* stack unsigned short word
1151          arg: sh        value
1152
1153          stack 16 bit value.  */
1154       _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
1155       ptr += 2;
1156       break;
1157
1158     case TIR_S_C_STA_BFI:
1159       /* stack byte from image
1160          arg: none.  */
1161       /* FALLTHRU  */
1162     case TIR_S_C_STA_WFI:
1163       /* stack byte from image
1164          arg: none.  */
1165       /* FALLTHRU */
1166     case TIR_S_C_STA_LFI:
1167       /* stack byte from image
1168          arg: none.  */
1169       (*_bfd_error_handler) (_("stack-from-image not implemented"));
1170       return NULL;
1171
1172     case TIR_S_C_STA_EPM:
1173       /* stack entry point mask
1174          arg: cs        symbol name
1175
1176          stack (unsigned) entry point mask of symbol
1177          err if symbol is no entry point.  */
1178       {
1179         char *name;
1180         vms_symbol_entry *entry;
1181
1182         name = _bfd_vms_save_counted_string (ptr);
1183         entry = _bfd_vms_enter_symbol (abfd, name);
1184         if (entry == (vms_symbol_entry *) NULL)
1185           return 0;
1186
1187         (*_bfd_error_handler) (_("stack-entry-mask not fully implemented"));
1188         _bfd_vms_push (abfd, (uquad) 0, -1);
1189         ptr += *ptr + 1;
1190       }
1191       break;
1192
1193     case TIR_S_C_STA_CKARG:
1194       /* compare procedure argument
1195          arg: cs        symbol name
1196                 by      argument index
1197                 da      argument descriptor
1198
1199          compare argument descriptor with symbol argument (ARG$V_PASSMECH)
1200          and stack TRUE (args match) or FALSE (args dont match) value.  */
1201       (*_bfd_error_handler) (_("PASSMECH not fully implemented"));
1202       _bfd_vms_push (abfd, (uquad) 1, -1);
1203       break;
1204
1205     case TIR_S_C_STA_LSY:
1206       /* stack local symbol value
1207          arg:   sh      environment index
1208                 cs      symbol name.  */
1209       {
1210         int envidx;
1211         char *name;
1212         vms_symbol_entry *entry;
1213
1214         envidx = bfd_getl16 (ptr);
1215         ptr += 2;
1216         name = _bfd_vms_save_counted_string (ptr);
1217         entry = _bfd_vms_enter_symbol (abfd, name);
1218         if (entry == (vms_symbol_entry *) NULL)
1219           return 0;
1220         (*_bfd_error_handler) (_("stack-local-symbol not fully implemented"));
1221         _bfd_vms_push (abfd, (uquad) 0, -1);
1222         ptr += *ptr + 1;
1223       }
1224       break;
1225
1226     case TIR_S_C_STA_LIT:
1227       /* stack literal
1228          arg:   by      literal index
1229
1230          stack literal.  */
1231       ptr++;
1232       _bfd_vms_push (abfd, (uquad) 0, -1);
1233       (*_bfd_error_handler) (_("stack-literal not fully implemented"));
1234       break;
1235
1236     case TIR_S_C_STA_LEPM:
1237       /* stack local symbol entry point mask
1238          arg:   sh      environment index
1239                 cs      symbol name
1240
1241          stack (unsigned) entry point mask of symbol
1242          err if symbol is no entry point.  */
1243       {
1244         int envidx;
1245         char *name;
1246         vms_symbol_entry *entry;
1247
1248         envidx = bfd_getl16 (ptr);
1249         ptr += 2;
1250         name = _bfd_vms_save_counted_string (ptr);
1251         entry = _bfd_vms_enter_symbol (abfd, name);
1252         if (entry == (vms_symbol_entry *) NULL)
1253           return 0;
1254         (*_bfd_error_handler) (_("stack-local-symbol-entry-point-mask not fully implemented"));
1255         _bfd_vms_push (abfd, (uquad) 0, -1);
1256         ptr += *ptr + 1;
1257       }
1258       break;
1259
1260     default:
1261       (*_bfd_error_handler) (_("reserved STA cmd %d"), ptr[-1]);
1262       return NULL;
1263       break;
1264     }
1265
1266   return ptr;
1267 }
1268
1269 static const char *
1270 tir_cmd_name (cmd)
1271      int cmd;
1272 {
1273   switch (cmd)
1274     {
1275     case TIR_S_C_STO_RSB: return "TIR_S_C_STO_RSB";
1276     case TIR_S_C_STO_RSW: return "TIR_S_C_STO_RSW";
1277     case TIR_S_C_STO_RL: return "TIR_S_C_STO_RL";
1278     case TIR_S_C_STO_VPS: return "TIR_S_C_STO_VPS";
1279     case TIR_S_C_STO_USB: return "TIR_S_C_STO_USB";
1280     case TIR_S_C_STO_USW: return "TIR_S_C_STO_USW";
1281     case TIR_S_C_STO_RUB: return "TIR_S_C_STO_RUB";
1282     case TIR_S_C_STO_RUW: return "TIR_S_C_STO_RUW";
1283     case TIR_S_C_STO_PIRR: return "TIR_S_C_STO_PIRR";
1284     case TIR_S_C_OPR_INSV: return "TIR_S_C_OPR_INSV";
1285     case TIR_S_C_OPR_DFLIT: return "TIR_S_C_OPR_DFLIT";
1286     case TIR_S_C_OPR_REDEF: return "TIR_S_C_OPR_REDEF";
1287     case TIR_S_C_OPR_ROT: return "TIR_S_C_OPR_ROT";
1288     case TIR_S_C_OPR_USH: return "TIR_S_C_OPR_USH";
1289     case TIR_S_C_OPR_ASH: return "TIR_S_C_OPR_ASH";
1290     case TIR_S_C_CTL_DFLOC: return "TIR_S_C_CTL_DFLOC";
1291     case TIR_S_C_CTL_STLOC: return "TIR_S_C_CTL_STLOC";
1292     case TIR_S_C_CTL_STKDL: return "TIR_S_C_CTL_STKDL";
1293
1294     default:
1295       /* These strings have not been added yet.  */
1296       abort ();
1297     }
1298 }
1299
1300 /* tir_sto
1301
1302    vax store commands
1303
1304    handle sto_xxx commands in tir section
1305    ptr points to data area in record
1306
1307    See table 7-4 of the VAX/VMS linker manual.  */
1308
1309 static unsigned char *
1310 tir_sto (bfd *abfd, unsigned char *ptr)
1311 {
1312   unsigned long dummy;
1313   int size;
1314   int psect;
1315
1316 #if VMS_DEBUG
1317   _bfd_vms_debug (5, "tir_sto %d\n", *ptr);
1318 #endif
1319
1320   switch (*ptr++)
1321     {
1322     case TIR_S_C_STO_SB:
1323       /* store signed byte: pop stack, write byte
1324          arg: none.  */
1325       dummy = _bfd_vms_pop (abfd, &psect);
1326       image_write_b (abfd, dummy & 0xff);       /* FIXME: check top bits */
1327       break;
1328
1329     case TIR_S_C_STO_SW:
1330       /* store signed word: pop stack, write word
1331          arg: none.  */
1332       dummy = _bfd_vms_pop (abfd, &psect);
1333       image_write_w (abfd, dummy & 0xffff);     /* FIXME: check top bits */
1334       break;
1335
1336     case TIR_S_C_STO_LW:
1337       /* store longword: pop stack, write longword
1338          arg: none.  */
1339       dummy = _bfd_vms_pop (abfd, &psect);
1340       image_write_l (abfd, dummy & 0xffffffff); /* FIXME: check top bits */
1341       break;
1342
1343     case TIR_S_C_STO_BD:
1344       /* store byte displaced: pop stack, sub lc+1, write byte
1345          arg: none.  */
1346       dummy = _bfd_vms_pop (abfd, &psect);
1347       dummy -= ((PRIV (sections)[psect])->vma + 1);
1348       image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
1349       break;
1350
1351     case TIR_S_C_STO_WD:
1352       /* store word displaced: pop stack, sub lc+2, write word
1353          arg: none.  */
1354       dummy = _bfd_vms_pop (abfd, &psect);
1355       dummy -= ((PRIV (sections)[psect])->vma + 2);
1356       image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */
1357       break;
1358
1359     case TIR_S_C_STO_LD:
1360       /* store long displaced: pop stack, sub lc+4, write long
1361          arg: none.  */
1362       dummy = _bfd_vms_pop (abfd, &psect);
1363       dummy -= ((PRIV (sections)[psect])->vma + 4);
1364       image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
1365       break;
1366
1367     case TIR_S_C_STO_LI:
1368       /* store short literal: pop stack, write byte
1369          arg: none.  */
1370       dummy = _bfd_vms_pop (abfd, &psect);
1371       image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
1372       break;
1373
1374     case TIR_S_C_STO_PIDR:
1375       /* store position independent data reference: pop stack, write longword
1376          arg: none.
1377          FIXME: incomplete !  */
1378       dummy = _bfd_vms_pop (abfd, &psect);
1379       image_write_l (abfd, dummy & 0xffffffff);
1380       break;
1381
1382     case TIR_S_C_STO_PICR:
1383       /* store position independent code reference: pop stack, write longword
1384          arg: none.
1385          FIXME: incomplete !  */
1386       dummy = _bfd_vms_pop (abfd, &psect);
1387       image_write_b (abfd, 0x9f);
1388       image_write_l (abfd, dummy & 0xffffffff);
1389       break;
1390
1391     case TIR_S_C_STO_RIVB:
1392       /* store repeated immediate variable bytes
1393          1-byte count n field followed by n bytes of data
1394          pop stack, write n bytes <stack> times.  */
1395       size = *ptr++;
1396       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1397       while (dummy-- > 0L)
1398         image_dump (abfd, ptr, size, 0);
1399       ptr += size;
1400       break;
1401
1402     case TIR_S_C_STO_B:
1403       /* store byte from top longword.  */
1404       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1405       image_write_b (abfd, dummy & 0xff);
1406       break;
1407
1408     case TIR_S_C_STO_W:
1409       /* store word from top longword.  */
1410       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1411       image_write_w (abfd, dummy & 0xffff);
1412       break;
1413
1414     case TIR_S_C_STO_RB:
1415       /* store repeated byte from top longword.  */
1416       size = (unsigned long) _bfd_vms_pop (abfd, NULL);
1417       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1418       while (size-- > 0)
1419         image_write_b (abfd, dummy & 0xff);
1420       break;
1421
1422     case TIR_S_C_STO_RW:
1423       /* store repeated word from top longword.  */
1424       size = (unsigned long) _bfd_vms_pop (abfd, NULL);
1425       dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1426       while (size-- > 0)
1427         image_write_w (abfd, dummy & 0xffff);
1428       break;
1429
1430     case TIR_S_C_STO_RSB:
1431     case TIR_S_C_STO_RSW:
1432     case TIR_S_C_STO_RL:
1433     case TIR_S_C_STO_VPS:
1434     case TIR_S_C_STO_USB:
1435     case TIR_S_C_STO_USW:
1436     case TIR_S_C_STO_RUB:
1437     case TIR_S_C_STO_RUW:
1438     case TIR_S_C_STO_PIRR:
1439       (*_bfd_error_handler) (_("%s: not implemented"), tir_cmd_name (ptr[-1]));
1440       break;
1441
1442     default:
1443       (*_bfd_error_handler) (_("reserved STO cmd %d"), ptr[-1]);
1444       break;
1445     }
1446
1447   return ptr;
1448 }
1449
1450 /* stack operator commands
1451    all 32 bit signed arithmetic
1452    all word just like a stack calculator
1453    arguments are popped from stack, results are pushed on stack
1454
1455    See table 7-5 of the VAX/VMS linker manual.  */
1456
1457 static unsigned char *
1458 tir_opr (abfd, ptr)
1459      bfd *abfd;
1460      unsigned char *ptr;
1461 {
1462   long op1, op2;
1463
1464 #if VMS_DEBUG
1465   _bfd_vms_debug (5, "tir_opr %d\n", *ptr);
1466 #endif
1467
1468   switch (*ptr++)
1469     {
1470       /* operation */
1471     case TIR_S_C_OPR_NOP: /* no-op */
1472       break;
1473
1474     case TIR_S_C_OPR_ADD: /* add */
1475       op1 = (long) _bfd_vms_pop (abfd, NULL);
1476       op2 = (long) _bfd_vms_pop (abfd, NULL);
1477       _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
1478       break;
1479
1480     case TIR_S_C_OPR_SUB: /* subtract */
1481       op1 = (long) _bfd_vms_pop (abfd, NULL);
1482       op2 = (long) _bfd_vms_pop (abfd, NULL);
1483       _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
1484       break;
1485
1486     case TIR_S_C_OPR_MUL: /* multiply */
1487       op1 = (long) _bfd_vms_pop (abfd, NULL);
1488       op2 = (long) _bfd_vms_pop (abfd, NULL);
1489       _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
1490       break;
1491
1492     case TIR_S_C_OPR_DIV: /* divide */
1493       op1 = (long) _bfd_vms_pop (abfd, NULL);
1494       op2 = (long) _bfd_vms_pop (abfd, NULL);
1495       if (op2 == 0)
1496         _bfd_vms_push (abfd, (uquad) 0, -1);
1497       else
1498         _bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
1499       break;
1500
1501     case TIR_S_C_OPR_AND: /* logical and */
1502       op1 = (long) _bfd_vms_pop (abfd, NULL);
1503       op2 = (long) _bfd_vms_pop (abfd, NULL);
1504       _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
1505       break;
1506
1507     case TIR_S_C_OPR_IOR: /* logical inclusive or */
1508       op1 = (long) _bfd_vms_pop (abfd, NULL);
1509       op2 = (long) _bfd_vms_pop (abfd, NULL);
1510       _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
1511       break;
1512
1513     case TIR_S_C_OPR_EOR: /* logical exclusive or */
1514       op1 = (long) _bfd_vms_pop (abfd, NULL);
1515       op2 = (long) _bfd_vms_pop (abfd, NULL);
1516       _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
1517       break;
1518
1519     case TIR_S_C_OPR_NEG: /* negate */
1520       op1 = (long) _bfd_vms_pop (abfd, NULL);
1521       _bfd_vms_push (abfd, (uquad) (-op1), -1);
1522       break;
1523
1524     case TIR_S_C_OPR_COM: /* complement */
1525       op1 = (long) _bfd_vms_pop (abfd, NULL);
1526       _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
1527       break;
1528
1529     case TIR_S_C_OPR_INSV: /* insert field */
1530       (void) _bfd_vms_pop (abfd, NULL);
1531       (*_bfd_error_handler)  (_("%s: not fully implemented"),
1532                               tir_cmd_name (ptr[-1]));
1533       break;
1534
1535     case TIR_S_C_OPR_ASH: /* arithmetic shift */
1536       op1 = (long) _bfd_vms_pop (abfd, NULL);
1537       op2 = (long) _bfd_vms_pop (abfd, NULL);
1538       if (HIGHBIT (op1))        /* shift right */
1539         op2 >>= op1;
1540       else                      /* shift left */
1541         op2 <<= op1;
1542       _bfd_vms_push (abfd, (uquad) op2, -1);
1543       (*_bfd_error_handler)  (_("%s: not fully implemented"),
1544                               tir_cmd_name (ptr[-1]));
1545       break;
1546
1547     case TIR_S_C_OPR_USH: /* unsigned shift */
1548       op1 = (long) _bfd_vms_pop (abfd, NULL);
1549       op2 = (long) _bfd_vms_pop (abfd, NULL);
1550       if (HIGHBIT (op1))        /* shift right */
1551         op2 >>= op1;
1552       else                      /* shift left */
1553         op2 <<= op1;
1554       _bfd_vms_push (abfd, (uquad) op2, -1);
1555       (*_bfd_error_handler)  (_("%s: not fully implemented"),
1556                               tir_cmd_name (ptr[-1]));
1557       break;
1558
1559     case TIR_S_C_OPR_ROT: /* rotate */
1560       op1 = (long) _bfd_vms_pop (abfd, NULL);
1561       op2 = (long) _bfd_vms_pop (abfd, NULL);
1562       if (HIGHBIT (0))  /* shift right */
1563         op2 >>= op1;
1564       else              /* shift left */
1565         op2 <<= op1;
1566       _bfd_vms_push (abfd, (uquad) op2, -1);
1567       (*_bfd_error_handler)  (_("%s: not fully implemented"),
1568                               tir_cmd_name (ptr[-1]));
1569       break;
1570
1571     case TIR_S_C_OPR_SEL: /* select */
1572       if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
1573         (void) _bfd_vms_pop (abfd, NULL);
1574       else
1575         {
1576           op1 = (long) _bfd_vms_pop (abfd, NULL);
1577           (void) _bfd_vms_pop (abfd, NULL);
1578           _bfd_vms_push (abfd, (uquad) op1, -1);
1579         }
1580       break;
1581
1582     case TIR_S_C_OPR_REDEF: /* Redefine symbol to current location.  */
1583     case TIR_S_C_OPR_DFLIT: /* Define a literal.  */
1584       (*_bfd_error_handler) (_("%s: not supported"),
1585                              tir_cmd_name (ptr[-1]));
1586       break;
1587
1588     default:
1589       (*_bfd_error_handler) (_("reserved OPR cmd %d"), ptr[-1]);
1590       break;
1591     }
1592
1593   return ptr;
1594 }
1595
1596 /* control commands
1597
1598    See table 7-6 of the VAX/VMS linker manual.  */
1599
1600 static unsigned char *
1601 tir_ctl (bfd *abfd, unsigned char *ptr)
1602 {
1603   unsigned long dummy;
1604   unsigned int psect;
1605
1606 #if VMS_DEBUG
1607   _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
1608 #endif
1609
1610   switch (*ptr++)
1611     {
1612     case TIR_S_C_CTL_SETRB:
1613       /* Set relocation base: pop stack, set image location counter
1614          arg: none.  */
1615       dummy = _bfd_vms_pop (abfd, &psect);
1616       if (psect >= PRIV (section_count))
1617         alloc_section (abfd, psect);
1618       image_set_ptr (abfd, (int) psect, (uquad) dummy);
1619       break;
1620
1621     case TIR_S_C_CTL_AUGRB:
1622       /* Augment relocation base: increment image location counter by offset
1623          arg: lw        offset value.  */
1624       dummy = bfd_getl32 (ptr);
1625       image_inc_ptr (abfd, (uquad) dummy);
1626       break;
1627
1628     case TIR_S_C_CTL_DFLOC:
1629       /* Define location: pop index, save location counter under index
1630          arg: none.  */
1631       dummy = _bfd_vms_pop (abfd, NULL);
1632       (*_bfd_error_handler) (_("%s: not fully implemented"),
1633                              tir_cmd_name (ptr[-1]));
1634       break;
1635
1636     case TIR_S_C_CTL_STLOC:
1637       /* Set location: pop index, restore location counter from index
1638          arg: none.  */
1639       dummy = _bfd_vms_pop (abfd, &psect);
1640       (*_bfd_error_handler) (_("%s: not fully implemented"),
1641                              tir_cmd_name (ptr[-1]));
1642       break;
1643
1644     case TIR_S_C_CTL_STKDL:
1645       /* Stack defined location: pop index, push location counter from index
1646          arg: none.  */
1647       dummy = _bfd_vms_pop (abfd, &psect);
1648       (*_bfd_error_handler) (_("%s: not fully implemented"),
1649                              tir_cmd_name (ptr[-1]));
1650       break;
1651
1652     default:
1653       (*_bfd_error_handler) (_("reserved CTL cmd %d"), ptr[-1]);
1654       break;
1655     }
1656   return ptr;
1657 }
1658
1659 /* Handle command from TIR section.  */
1660
1661 static unsigned char *
1662 tir_cmd (bfd *abfd, unsigned char *ptr)
1663 {
1664   struct
1665   {
1666     int mincod;
1667     int maxcod;
1668     unsigned char * (*explain) (bfd *, unsigned char *);
1669   }
1670   tir_table[] =
1671   {
1672     { 0,                 TIR_S_C_MAXSTACOD, tir_sta },
1673     { TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto },
1674     { TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr },
1675     { TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl },
1676     { -1, -1, NULL }
1677   };
1678   int i = 0;
1679
1680 #if VMS_DEBUG
1681   _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
1682   _bfd_hexdump (8, ptr, 16, (int) ptr);
1683 #endif
1684
1685   if (*ptr & 0x80)                              /* store immediate */
1686     {
1687       i = 128 - (*ptr++ & 0x7f);
1688       image_dump (abfd, ptr, i, 0);
1689       ptr += i;
1690     }
1691   else
1692     {
1693       while (tir_table[i].mincod >= 0)
1694         {
1695           if ( (tir_table[i].mincod <= *ptr)
1696                && (*ptr <= tir_table[i].maxcod))
1697             {
1698               ptr = tir_table[i].explain (abfd, ptr);
1699               break;
1700             }
1701           i++;
1702         }
1703       if (tir_table[i].mincod < 0)
1704         {
1705           (*_bfd_error_handler) (_("obj code %d not found"), *ptr);
1706           ptr = 0;
1707         }
1708     }
1709
1710   return ptr;
1711 }
1712
1713 /* Handle command from ETIR section.  */
1714
1715 static int
1716 etir_cmd (abfd, cmd, ptr)
1717      bfd *abfd;
1718      int cmd;
1719      unsigned char *ptr;
1720 {
1721   static struct
1722   {
1723     int mincod;
1724     int maxcod;
1725     bfd_boolean (*explain) PARAMS ((bfd *, int, unsigned char *));
1726   }
1727   etir_table[] =
1728   {
1729     { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta },
1730     { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto },
1731     { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr },
1732     { ETIR_S_C_MINCTLCOD, ETIR_S_C_MAXCTLCOD, etir_ctl },
1733     { ETIR_S_C_MINSTCCOD, ETIR_S_C_MAXSTCCOD, etir_stc },
1734     { -1, -1, NULL }
1735   };
1736
1737   int i = 0;
1738
1739 #if VMS_DEBUG
1740   _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd);
1741   _bfd_hexdump (8, ptr, 16, (int) ptr);
1742 #endif
1743
1744   while (etir_table[i].mincod >= 0)
1745     {
1746       if ( (etir_table[i].mincod <= cmd)
1747            && (cmd <= etir_table[i].maxcod))
1748         {
1749           if (!etir_table[i].explain (abfd, cmd, ptr))
1750             return -1;
1751           break;
1752         }
1753       i++;
1754     }
1755
1756 #if VMS_DEBUG
1757   _bfd_vms_debug (4, "etir_cmd: = 0\n");
1758 #endif
1759   return 0;
1760 }
1761
1762 /* Text Information and Relocation Records (OBJ$C_TIR)
1763    handle tir record.  */
1764
1765 static int
1766 analyze_tir (abfd, ptr, length)
1767      bfd *abfd;
1768      unsigned char *ptr;
1769      unsigned int length;
1770 {
1771   unsigned char *maxptr;
1772
1773 #if VMS_DEBUG
1774   _bfd_vms_debug (3, "analyze_tir: %d bytes\n", length);
1775 #endif
1776
1777   maxptr = ptr + length;
1778
1779   while (ptr < maxptr)
1780     {
1781       ptr = tir_cmd (abfd, ptr);
1782       if (ptr == 0)
1783         return -1;
1784     }
1785
1786   return 0;
1787 }
1788
1789 /* Text Information and Relocation Records (EOBJ$C_ETIR)
1790    handle etir record.  */
1791
1792 static int
1793 analyze_etir (abfd, ptr, length)
1794      bfd *abfd;
1795      unsigned char *ptr;
1796      unsigned int length;
1797 {
1798   int cmd;
1799   unsigned char *maxptr;
1800   int result = 0;
1801
1802 #if VMS_DEBUG
1803   _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
1804 #endif
1805
1806   maxptr = ptr + length;
1807
1808   while (ptr < maxptr)
1809     {
1810       cmd = bfd_getl16 (ptr);
1811       length = bfd_getl16 (ptr + 2);
1812       result = etir_cmd (abfd, cmd, ptr+4);
1813       if (result != 0)
1814         break;
1815       ptr += length;
1816     }
1817
1818 #if VMS_DEBUG
1819   _bfd_vms_debug (3, "analyze_etir: = %d\n", result);
1820 #endif
1821
1822   return result;
1823 }
1824
1825 /* Process ETIR record
1826    Return 0 on success, -1 on error.  */
1827
1828 int
1829 _bfd_vms_slurp_tir (abfd, objtype)
1830      bfd *abfd;
1831      int objtype;
1832 {
1833   int result;
1834
1835 #if VMS_DEBUG
1836   _bfd_vms_debug (2, "TIR/ETIR\n");
1837 #endif
1838
1839   switch (objtype)
1840     {
1841     case EOBJ_S_C_ETIR:
1842       PRIV (vms_rec) += 4;      /* skip type, size */
1843       PRIV (rec_size) -= 4;
1844       result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
1845       break;
1846     case OBJ_S_C_TIR:
1847       PRIV (vms_rec) += 1;      /* skip type */
1848       PRIV (rec_size) -= 1;
1849       result = analyze_tir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
1850       break;
1851     default:
1852       result = -1;
1853       break;
1854     }
1855
1856   return result;
1857 }
1858
1859 /* Process EDBG record
1860    Return 0 on success, -1 on error
1861
1862    Not implemented yet.  */
1863
1864 int
1865 _bfd_vms_slurp_dbg (abfd, objtype)
1866      bfd *abfd;
1867      int objtype ATTRIBUTE_UNUSED;
1868 {
1869 #if VMS_DEBUG
1870   _bfd_vms_debug (2, "DBG/EDBG\n");
1871 #endif
1872
1873   abfd->flags |= (HAS_DEBUG | HAS_LINENO);
1874   return 0;
1875 }
1876
1877 /* Process ETBT record
1878    Return 0 on success, -1 on error
1879
1880    Not implemented yet.  */
1881
1882 int
1883 _bfd_vms_slurp_tbt (abfd, objtype)
1884      bfd *abfd ATTRIBUTE_UNUSED;
1885      int objtype ATTRIBUTE_UNUSED;
1886 {
1887 #if VMS_DEBUG
1888   _bfd_vms_debug (2, "TBT/ETBT\n");
1889 #endif
1890
1891   return 0;
1892 }
1893
1894 /* Process LNK record
1895    Return 0 on success, -1 on error
1896
1897    Not implemented yet.  */
1898
1899 int
1900 _bfd_vms_slurp_lnk (abfd, objtype)
1901      bfd *abfd ATTRIBUTE_UNUSED;
1902      int objtype ATTRIBUTE_UNUSED;
1903 {
1904 #if VMS_DEBUG
1905   _bfd_vms_debug (2, "LNK\n");
1906 #endif
1907
1908   return 0;
1909 }
1910 \f
1911 /* WRITE ETIR SECTION
1912
1913    This is still under construction and therefore not documented.  */
1914
1915 static void start_etir_record
1916   PARAMS ((bfd *abfd, int index, uquad offset, bfd_boolean justoffset));
1917 static void sto_imm
1918   PARAMS ((bfd *abfd, vms_section *sptr, bfd_vma vaddr, int index));
1919 static void end_etir_record
1920   PARAMS ((bfd *abfd));
1921
1922 static void
1923 sto_imm (abfd, sptr, vaddr, index)
1924      bfd *abfd;
1925      vms_section *sptr;
1926      bfd_vma vaddr;
1927      int index;
1928 {
1929   int size;
1930   int ssize;
1931   unsigned char *cptr;
1932
1933 #if VMS_DEBUG
1934   _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size);
1935   _bfd_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr);
1936 #endif
1937
1938   ssize = sptr->size;
1939   cptr = sptr->contents;
1940
1941   while (ssize > 0)
1942     {
1943       size = ssize;                             /* try all the rest */
1944
1945       if (_bfd_vms_output_check (abfd, size) < 0)
1946         {                                       /* doesn't fit, split ! */
1947           end_etir_record (abfd);
1948           start_etir_record (abfd, index, vaddr, FALSE);
1949           size = _bfd_vms_output_check (abfd, 0);       /* get max size */
1950           if (size > ssize)                     /* more than what's left ? */
1951             size = ssize;
1952         }
1953
1954       _bfd_vms_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
1955       _bfd_vms_output_long (abfd, (unsigned long) (size));
1956       _bfd_vms_output_dump (abfd, cptr, size);
1957       _bfd_vms_output_flush (abfd);
1958
1959 #if VMS_DEBUG
1960       _bfd_vms_debug (10, "dumped %d bytes\n", size);
1961       _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
1962 #endif
1963
1964       vaddr += size;
1965       ssize -= size;
1966       cptr += size;
1967     }
1968 }
1969
1970 /* Start ETIR record for section #index at virtual addr offset.  */
1971
1972 static void
1973 start_etir_record (abfd, index, offset, justoffset)
1974     bfd *abfd;
1975     int index;
1976     uquad offset;
1977     bfd_boolean justoffset;
1978 {
1979   if (!justoffset)
1980     {
1981       _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1);  /* one ETIR per section */
1982       _bfd_vms_output_push (abfd);
1983     }
1984
1985   _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);    /* push start offset */
1986   _bfd_vms_output_long (abfd, (unsigned long) index);
1987   _bfd_vms_output_quad (abfd, (uquad) offset);
1988   _bfd_vms_output_flush (abfd);
1989
1990   _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1); /* start = pop () */
1991   _bfd_vms_output_flush (abfd);
1992 }
1993
1994 /* End etir record.  */
1995
1996 static void
1997 end_etir_record (abfd)
1998     bfd *abfd;
1999 {
2000   _bfd_vms_output_pop (abfd);
2001   _bfd_vms_output_end (abfd);
2002 }
2003
2004 /* Write section contents for bfd abfd.  */
2005
2006 int
2007 _bfd_vms_write_tir (abfd, objtype)
2008      bfd *abfd;
2009      int objtype ATTRIBUTE_UNUSED;
2010 {
2011   asection *section;
2012   vms_section *sptr;
2013   int nextoffset;
2014
2015 #if VMS_DEBUG
2016   _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
2017 #endif
2018
2019   _bfd_vms_output_alignment (abfd, 4);
2020
2021   nextoffset = 0;
2022   PRIV (vms_linkage_index) = 1;
2023
2024   /* Dump all other sections.  */
2025
2026   section = abfd->sections;
2027
2028   while (section != NULL)
2029     {
2030
2031 #if VMS_DEBUG
2032       _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n",
2033                       section->index, section->name,
2034                       (int) (section->_raw_size));
2035 #endif
2036
2037       if (section->flags & SEC_RELOC)
2038         {
2039           int i;
2040
2041           if ((i = section->reloc_count) <= 0)
2042             {
2043               (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"),
2044                                      section->name);
2045             }
2046 #if VMS_DEBUG
2047           else
2048             {
2049               arelent **rptr;
2050               _bfd_vms_debug (4, "%d relocations:\n", i);
2051               rptr = section->orelocation;
2052               while (i-- > 0)
2053                 {
2054                   _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n",
2055                                   (*(*rptr)->sym_ptr_ptr)->name,
2056                                   (*(*rptr)->sym_ptr_ptr)->section->name,
2057                                   (long) (*(*rptr)->sym_ptr_ptr)->value,
2058                                   (*rptr)->address, (*rptr)->addend,
2059                                   bfd_get_reloc_size ((*rptr)->howto),
2060                                   (*rptr)->howto->name);
2061                   rptr++;
2062                 }
2063             }
2064 #endif
2065         }
2066
2067       if ((section->flags & SEC_HAS_CONTENTS)
2068           && (! bfd_is_com_section (section)))
2069         {
2070           bfd_vma vaddr;                /* Virtual addr in section.  */
2071
2072           sptr = _bfd_get_vms_section (abfd, section->index);
2073           if (sptr == NULL)
2074             {
2075               bfd_set_error (bfd_error_no_contents);
2076               return -1;
2077             }
2078
2079           vaddr = (bfd_vma) (sptr->offset);
2080
2081           start_etir_record (abfd, section->index, (uquad) sptr->offset,
2082                              FALSE);
2083
2084           while (sptr != NULL)  /* one STA_PQ, CTL_SETRB per vms_section */
2085             {
2086
2087               if (section->flags & SEC_RELOC)   /* check for relocs */
2088                 {
2089                   arelent **rptr = section->orelocation;
2090                   int i = section->reloc_count;
2091
2092                   for (;;)
2093                     {
2094                       bfd_size_type addr = (*rptr)->address;
2095                       bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto);
2096                       if (sptr->offset < addr)  /* sptr starts before reloc */
2097                         {
2098                           bfd_size_type before = addr - sptr->offset;
2099                           if (sptr->size <= before)     /* complete before */
2100                             {
2101                               sto_imm (abfd, sptr, vaddr, section->index);
2102                               vaddr += sptr->size;
2103                               break;
2104                             }
2105                           else                          /* partly before */
2106                             {
2107                               int after = sptr->size - before;
2108                               sptr->size = before;
2109                               sto_imm (abfd, sptr, vaddr, section->index);
2110                               vaddr += sptr->size;
2111                               sptr->contents += before;
2112                               sptr->offset += before;
2113                               sptr->size = after;
2114                             }
2115                         }
2116                       else if (sptr->offset == addr) /* sptr starts at reloc */
2117                         {
2118                           asymbol *sym = *(*rptr)->sym_ptr_ptr;
2119                           asection *sec = sym->section;
2120
2121                           switch ((*rptr)->howto->type)
2122                             {
2123                             case ALPHA_R_IGNORE:
2124                               break;
2125
2126                             case ALPHA_R_REFLONG:
2127                               {
2128                                 if (bfd_is_und_section (sym->section))
2129                                   {
2130                                     int slen = strlen ((char *) sym->name);
2131                                     char *hash;
2132
2133                                     if (_bfd_vms_output_check (abfd, slen) < 0)
2134                                       {
2135                                         end_etir_record (abfd);
2136                                         start_etir_record (abfd,
2137                                                            section->index,
2138                                                            vaddr, FALSE);
2139                                       }
2140                                     _bfd_vms_output_begin (abfd,
2141                                                            ETIR_S_C_STO_GBL_LW,
2142                                                            -1);
2143                                     hash = (_bfd_vms_length_hash_symbol
2144                                             (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2145                                     _bfd_vms_output_counted (abfd, hash);
2146                                     _bfd_vms_output_flush (abfd);
2147                                   }
2148                                 else if (bfd_is_abs_section (sym->section))
2149                                   {
2150                                     if (_bfd_vms_output_check (abfd, 16) < 0)
2151                                       {
2152                                         end_etir_record (abfd);
2153                                         start_etir_record (abfd,
2154                                                            section->index,
2155                                                            vaddr, FALSE);
2156                                       }
2157                                     _bfd_vms_output_begin (abfd,
2158                                                            ETIR_S_C_STA_LW,
2159                                                            -1);
2160                                     _bfd_vms_output_quad (abfd,
2161                                                           (uquad) sym->value);
2162                                     _bfd_vms_output_flush (abfd);
2163                                     _bfd_vms_output_begin (abfd,
2164                                                            ETIR_S_C_STO_LW,
2165                                                            -1);
2166                                     _bfd_vms_output_flush (abfd);
2167                                   }
2168                                 else
2169                                   {
2170                                     if (_bfd_vms_output_check (abfd, 32) < 0)
2171                                       {
2172                                         end_etir_record (abfd);
2173                                         start_etir_record (abfd,
2174                                                            section->index,
2175                                                            vaddr, FALSE);
2176                                       }
2177                                     _bfd_vms_output_begin (abfd,
2178                                                            ETIR_S_C_STA_PQ,
2179                                                            -1);
2180                                     _bfd_vms_output_long (abfd,
2181                                                           (unsigned long) (sec->index));
2182                                     _bfd_vms_output_quad (abfd,
2183                                                           ((uquad) (*rptr)->addend
2184                                                            + (uquad) sym->value));
2185                                     _bfd_vms_output_flush (abfd);
2186                                     _bfd_vms_output_begin (abfd,
2187                                                            ETIR_S_C_STO_LW,
2188                                                            -1);
2189                                     _bfd_vms_output_flush (abfd);
2190                                   }
2191                               }
2192                               break;
2193
2194                             case ALPHA_R_REFQUAD:
2195                               {
2196                                 if (bfd_is_und_section (sym->section))
2197                                   {
2198                                     int slen = strlen ((char *) sym->name);
2199                                     char *hash;
2200                                     if (_bfd_vms_output_check (abfd, slen) < 0)
2201                                       {
2202                                         end_etir_record (abfd);
2203                                         start_etir_record (abfd,
2204                                                            section->index,
2205                                                            vaddr, FALSE);
2206                                       }
2207                                     _bfd_vms_output_begin (abfd,
2208                                                            ETIR_S_C_STO_GBL,
2209                                                            -1);
2210                                     hash = (_bfd_vms_length_hash_symbol
2211                                             (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2212                                     _bfd_vms_output_counted (abfd, hash);
2213                                     _bfd_vms_output_flush (abfd);
2214                                   }
2215                                 else if (bfd_is_abs_section (sym->section))
2216                                   {
2217                                     if (_bfd_vms_output_check (abfd, 16) < 0)
2218                                       {
2219                                         end_etir_record (abfd);
2220                                         start_etir_record (abfd,
2221                                                            section->index,
2222                                                            vaddr, FALSE);
2223                                       }
2224                                     _bfd_vms_output_begin (abfd,
2225                                                            ETIR_S_C_STA_QW,
2226                                                            -1);
2227                                     _bfd_vms_output_quad (abfd,
2228                                                           (uquad) sym->value);
2229                                     _bfd_vms_output_flush (abfd);
2230                                     _bfd_vms_output_begin (abfd,
2231                                                            ETIR_S_C_STO_QW,
2232                                                            -1);
2233                                     _bfd_vms_output_flush (abfd);
2234                                   }
2235                                 else
2236                                   {
2237                                     if (_bfd_vms_output_check (abfd, 32) < 0)
2238                                       {
2239                                         end_etir_record (abfd);
2240                                         start_etir_record (abfd,
2241                                                            section->index,
2242                                                            vaddr, FALSE);
2243                                       }
2244                                     _bfd_vms_output_begin (abfd,
2245                                                            ETIR_S_C_STA_PQ,
2246                                                            -1);
2247                                     _bfd_vms_output_long (abfd,
2248                                                           (unsigned long) (sec->index));
2249                                     _bfd_vms_output_quad (abfd,
2250                                                           ((uquad) (*rptr)->addend
2251                                                            + (uquad) sym->value));
2252                                     _bfd_vms_output_flush (abfd);
2253                                     _bfd_vms_output_begin (abfd,
2254                                                            ETIR_S_C_STO_OFF,
2255                                                            -1);
2256                                     _bfd_vms_output_flush (abfd);
2257                                   }
2258                               }
2259                               break;
2260
2261                             case ALPHA_R_HINT:
2262                               {
2263                                 int hint_size;
2264                                 char *hash ATTRIBUTE_UNUSED;
2265
2266                                 hint_size = sptr->size;
2267                                 sptr->size = len;
2268                                 sto_imm (abfd, sptr, vaddr, section->index);
2269                                 sptr->size = hint_size;
2270 #if 0
2271                                 vms_output_begin (abfd,
2272                                                   ETIR_S_C_STO_HINT_GBL, -1);
2273                                 vms_output_long (abfd,
2274                                                  (unsigned long) (sec->index));
2275                                 vms_output_quad (abfd, (uquad) addr);
2276
2277                                 hash = (_bfd_vms_length_hash_symbol
2278                                         (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2279                                 vms_output_counted (abfd, hash);
2280
2281                                 vms_output_flush (abfd);
2282 #endif
2283                               }
2284                               break;
2285                             case ALPHA_R_LINKAGE:
2286                               {
2287                                 char *hash;
2288
2289                                 if (_bfd_vms_output_check (abfd, 64) < 0)
2290                                   {
2291                                     end_etir_record (abfd);
2292                                     start_etir_record (abfd, section->index,
2293                                                        vaddr, FALSE);
2294                                   }
2295                                 _bfd_vms_output_begin (abfd,
2296                                                        ETIR_S_C_STC_LP_PSB,
2297                                                        -1);
2298                                 _bfd_vms_output_long (abfd,
2299                                                       (unsigned long) PRIV (vms_linkage_index));
2300                                 PRIV (vms_linkage_index) += 2;
2301                                 hash = (_bfd_vms_length_hash_symbol
2302                                         (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2303                                 _bfd_vms_output_counted (abfd, hash);
2304                                 _bfd_vms_output_byte (abfd, 0);
2305                                 _bfd_vms_output_flush (abfd);
2306                               }
2307                               break;
2308
2309                             case ALPHA_R_CODEADDR:
2310                               {
2311                                 int slen = strlen ((char *) sym->name);
2312                                 char *hash;
2313                                 if (_bfd_vms_output_check (abfd, slen) < 0)
2314                                   {
2315                                     end_etir_record (abfd);
2316                                     start_etir_record (abfd,
2317                                                        section->index,
2318                                                        vaddr, FALSE);
2319                                   }
2320                                 _bfd_vms_output_begin (abfd,
2321                                                        ETIR_S_C_STO_CA,
2322                                                        -1);
2323                                 hash = (_bfd_vms_length_hash_symbol
2324                                         (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2325                                 _bfd_vms_output_counted (abfd, hash);
2326                                 _bfd_vms_output_flush (abfd);
2327                               }
2328                               break;
2329
2330                             default:
2331                               (*_bfd_error_handler) (_("Unhandled relocation %s"),
2332                                                      (*rptr)->howto->name);
2333                               break;
2334                             }
2335
2336                           vaddr += len;
2337
2338                           if (len == sptr->size)
2339                             {
2340                               break;
2341                             }
2342                           else
2343                             {
2344                               sptr->contents += len;
2345                               sptr->offset += len;
2346                               sptr->size -= len;
2347                               i--;
2348                               rptr++;
2349                             }
2350                         }
2351                       else                      /* sptr starts after reloc */
2352                         {
2353                           i--;                  /* check next reloc */
2354                           rptr++;
2355                         }
2356
2357                       if (i==0)                 /* all reloc checked */
2358                         {
2359                           if (sptr->size > 0)
2360                             {
2361                               /* dump rest */
2362                               sto_imm (abfd, sptr, vaddr, section->index);
2363                               vaddr += sptr->size;
2364                             }
2365                           break;
2366                         }
2367                     } /* for (;;) */
2368                 } /* if SEC_RELOC */
2369               else                              /* no relocs, just dump */
2370                 {
2371                   sto_imm (abfd, sptr, vaddr, section->index);
2372                   vaddr += sptr->size;
2373                 }
2374
2375               sptr = sptr->next;
2376
2377             } /* while (sptr != 0) */
2378
2379           end_etir_record (abfd);
2380
2381         } /* has_contents */
2382
2383       section = section->next;
2384     }
2385
2386   _bfd_vms_output_alignment (abfd, 2);
2387   return 0;
2388 }
2389
2390 /* Write traceback data for bfd abfd.  */
2391
2392 int
2393 _bfd_vms_write_tbt (abfd, objtype)
2394      bfd *abfd ATTRIBUTE_UNUSED;
2395      int objtype ATTRIBUTE_UNUSED;
2396 {
2397 #if VMS_DEBUG
2398   _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
2399 #endif
2400
2401   return 0;
2402 }
2403
2404 /* Write debug info for bfd abfd.  */
2405
2406 int
2407 _bfd_vms_write_dbg (abfd, objtype)
2408      bfd *abfd ATTRIBUTE_UNUSED;
2409      int objtype ATTRIBUTE_UNUSED;
2410 {
2411 #if VMS_DEBUG
2412   _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
2413 #endif
2414
2415   return 0;
2416 }