bfd/vms-alpha.c

   1 /* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
   2    Copyright (C) 1996-2014 Free Software Foundation, Inc.
   3
   4    Initial version written by Klaus Kaempf (kkaempf@rmi.de)
   5    Major rewrite by Adacore.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 /* TODO:
  23    o  overlayed sections
  24    o  PIC
  25    o  Generation of shared image
  26    o  Relocation optimizations
  27    o  EISD for the stack
  28    o  Vectors isect
  29    o  64 bits sections
  30    o  Entry point
  31    o  LIB$INITIALIZE
  32    o  protected sections (for messages)
  33    ...
  34 */
  35
  36 #include "sysdep.h"
  37 #include "bfd.h"
  38 #include "bfdlink.h"
  39 #include "libbfd.h"
  40 #include "bfdver.h"
  41
  42 #include "vms.h"
  43 #include "vms/eihd.h"
  44 #include "vms/eiha.h"
  45 #include "vms/eihi.h"
  46 #include "vms/eihs.h"
  47 #include "vms/eisd.h"
  48 #include "vms/dmt.h"
  49 #include "vms/dst.h"
  50 #include "vms/eihvn.h"
  51 #include "vms/eobjrec.h"
  52 #include "vms/egsd.h"
  53 #include "vms/egps.h"
  54 #include "vms/esgps.h"
  55 #include "vms/eeom.h"
  56 #include "vms/emh.h"
  57 #include "vms/eiaf.h"
  58 #include "vms/shl.h"
  59 #include "vms/eicp.h"
  60 #include "vms/etir.h"
  61 #include "vms/egsy.h"
  62 #include "vms/esdf.h"
  63 #include "vms/esdfm.h"
  64 #include "vms/esdfv.h"
  65 #include "vms/esrf.h"
  66 #include "vms/egst.h"
  67 #include "vms/eidc.h"
  68 #include "vms/dsc.h"
  69 #include "vms/prt.h"
  70 #include "vms/internal.h"
  71 \f
  72
  73 #define MIN(a,b) ((a) < (b) ? (a) : (b))
  74
  75 /* The r_type field in a reloc is one of the following values.  */
  76 #define ALPHA_R_IGNORE          0
  77 #define ALPHA_R_REFQUAD         1
  78 #define ALPHA_R_BRADDR          2
  79 #define ALPHA_R_HINT            3
  80 #define ALPHA_R_SREL16          4
  81 #define ALPHA_R_SREL32          5
  82 #define ALPHA_R_SREL64          6
  83 #define ALPHA_R_OP_PUSH         7
  84 #define ALPHA_R_OP_STORE        8
  85 #define ALPHA_R_OP_PSUB         9
  86 #define ALPHA_R_OP_PRSHIFT      10
  87 #define ALPHA_R_LINKAGE         11
  88 #define ALPHA_R_REFLONG         12
  89 #define ALPHA_R_CODEADDR        13
  90 #define ALPHA_R_NOP             14
  91 #define ALPHA_R_BSR             15
  92 #define ALPHA_R_LDA             16
  93 #define ALPHA_R_BOH             17
  94
  95 /* These are used with DST_S_C_LINE_NUM.  */
  96 #define DST_S_C_LINE_NUM_HEADER_SIZE 4
  97
  98 /* These are used with DST_S_C_SOURCE */
  99
 100 #define DST_S_B_PCLINE_UNSBYTE   1
 101 #define DST_S_W_PCLINE_UNSWORD   1
 102 #define DST_S_L_PCLINE_UNSLONG   1
 103
 104 #define DST_S_B_MODBEG_NAME     14
 105 #define DST_S_L_RTNBEG_ADDRESS   5
 106 #define DST_S_B_RTNBEG_NAME     13
 107 #define DST_S_L_RTNEND_SIZE      5
 108
 109 /* These are used with DST_S_C_SOURCE.  */
 110 #define DST_S_C_SOURCE_HEADER_SIZE 4
 111
 112 #define DST_S_B_SRC_DF_LENGTH     1
 113 #define DST_S_W_SRC_DF_FILEID     3
 114 #define DST_S_B_SRC_DF_FILENAME  20
 115 #define DST_S_B_SRC_UNSBYTE       1
 116 #define DST_S_W_SRC_UNSWORD       1
 117 #define DST_S_L_SRC_UNSLONG       1
 118
 119 /* Debugger symbol definitions.  */
 120
 121 #define DBG_S_L_DMT_MODBEG       0
 122 #define DBG_S_L_DST_SIZE         4
 123 #define DBG_S_W_DMT_PSECT_COUNT  8
 124 #define DBG_S_C_DMT_HEADER_SIZE 12
 125
 126 #define DBG_S_L_DMT_PSECT_START  0
 127 #define DBG_S_L_DMT_PSECT_LENGTH 4
 128 #define DBG_S_C_DMT_PSECT_SIZE   8
 129
 130 /* VMS module header.  */
 131
 132 struct hdr_struct
 133 {
 134   char hdr_b_strlvl;
 135   int hdr_l_arch1;
 136   int hdr_l_arch2;
 137   int hdr_l_recsiz;
 138   char *hdr_t_name;
 139   char *hdr_t_version;
 140   char *hdr_t_date;
 141   char *hdr_c_lnm;
 142   char *hdr_c_src;
 143   char *hdr_c_ttl;
 144 };
 145
 146 #define EMH_DATE_LENGTH  17
 147
 148 /* VMS End-Of-Module records (EOM/EEOM).  */
 149
 150 struct eom_struct
 151 {
 152   unsigned int eom_l_total_lps;
 153   unsigned short eom_w_comcod;
 154   bfd_boolean eom_has_transfer;
 155   unsigned char eom_b_tfrflg;
 156   unsigned int eom_l_psindx;
 157   unsigned int eom_l_tfradr;
 158 };
 159
 160 struct vms_symbol_entry
 161 {
 162   bfd *owner;
 163
 164   /* Common fields.  */
 165   unsigned char typ;
 166   unsigned char data_type;
 167   unsigned short flags;
 168
 169   /* Section and offset/value of the symbol.  */
 170   unsigned int value;
 171   asection *section;
 172
 173   /* Section and offset/value for the entry point (only for subprg).  */
 174   asection *code_section;
 175   unsigned int code_value;
 176
 177   /* Symbol vector offset.  */
 178   unsigned int symbol_vector;
 179
 180   /* Length of the name.  */
 181   unsigned char namelen;
 182
 183   char name[1];
 184 };
 185
 186 /* Stack value for push/pop commands.  */
 187
 188 struct stack_struct
 189 {
 190   bfd_vma value;
 191   unsigned int reloc;
 192 };
 193
 194 #define STACKSIZE 128
 195
 196 /* A minimal decoding of DST compilation units.  We only decode
 197    what's needed to get to the line number information.  */
 198
 199 struct fileinfo
 200 {
 201   char *name;
 202   unsigned int srec;
 203 };
 204
 205 struct srecinfo
 206 {
 207   struct srecinfo *next;
 208   unsigned int line;
 209   unsigned int sfile;
 210   unsigned int srec;
 211 };
 212
 213 struct lineinfo
 214 {
 215   struct lineinfo *next;
 216   bfd_vma address;
 217   unsigned int line;
 218 };
 219
 220 struct funcinfo
 221 {
 222   struct funcinfo *next;
 223   char *name;
 224   bfd_vma low;
 225   bfd_vma high;
 226 };
 227
 228 struct module
 229 {
 230   /* Chain the previously read compilation unit.  */
 231   struct module *next;
 232
 233   /* The module name.  */
 234   char *name;
 235
 236   /* The start offset and size of debug info in the DST section.  */
 237   unsigned int modbeg;
 238   unsigned int size;
 239
 240   /* The lowest and highest addresses contained in this compilation
 241      unit as specified in the compilation unit header.  */
 242   bfd_vma low;
 243   bfd_vma high;
 244
 245   /* The listing line table.  */
 246   struct lineinfo *line_table;
 247
 248   /* The source record table.  */
 249   struct srecinfo *srec_table;
 250
 251   /* A list of the functions found in this module.  */
 252   struct funcinfo *func_table;
 253
 254   /* Current allocation of file_table.  */
 255   unsigned int file_table_count;
 256
 257   /* An array of the files making up this module.  */
 258   struct fileinfo *file_table;
 259 };
 260
 261 /* BFD private data for alpha-vms.  */
 262
 263 struct vms_private_data_struct
 264 {
 265   /* If true, relocs have been read.  */
 266   bfd_boolean reloc_done;
 267
 268   /* Record input buffer.  */
 269   struct vms_rec_rd recrd;
 270   struct vms_rec_wr recwr;
 271
 272   struct hdr_struct hdr_data;           /* data from HDR/EMH record  */
 273   struct eom_struct eom_data;           /* data from EOM/EEOM record  */
 274
 275   /* Transfer addresses (entry points).  */
 276   bfd_vma transfer_address[4];
 277
 278   /* Array of GSD sections to get the correspond BFD one.  */
 279   unsigned int section_max;             /* Size of the sections array.  */
 280   unsigned int section_count;           /* Number of GSD sections.  */
 281   asection **sections;
 282
 283   /* Array of raw symbols.  */
 284   struct vms_symbol_entry **syms;
 285
 286   /* Canonicalized symbols.  */
 287   asymbol **csymbols;
 288
 289   /* Number of symbols.  */
 290   unsigned int gsd_sym_count;
 291   /* Size of the syms array.  */
 292   unsigned int max_sym_count;
 293   /* Number of procedure symbols.  */
 294   unsigned int norm_sym_count;
 295
 296   /* Stack used to evaluate TIR/ETIR commands.  */
 297   struct stack_struct *stack;
 298   int stackptr;
 299
 300   /* Content reading.  */
 301   asection *image_section;              /* section for image_ptr  */
 302   file_ptr image_offset;                /* Offset for image_ptr.  */
 303
 304   struct module *modules;               /* list of all compilation units */
 305
 306   /* The DST section.  */
 307   asection *dst_section;
 308
 309   unsigned int dst_ptr_offsets_count;   /* # of offsets in following array  */
 310   unsigned int *dst_ptr_offsets;        /* array of saved image_ptr offsets */
 311
 312   /* Shared library support */
 313   bfd_vma symvva; /* relative virtual address of symbol vector */
 314   unsigned int ident;
 315   unsigned char matchctl;
 316
 317   /* Shared library index.  This is used for input bfd while linking.  */
 318   unsigned int shr_index;
 319
 320   /* Used to place structures in the file.  */
 321   file_ptr file_pos;
 322
 323   /* Simply linked list of eisd.  */
 324   struct vms_internal_eisd_map *eisd_head;
 325   struct vms_internal_eisd_map *eisd_tail;
 326
 327   /* Simply linked list of eisd for shared libraries.  */
 328   struct vms_internal_eisd_map *gbl_eisd_head;
 329   struct vms_internal_eisd_map *gbl_eisd_tail;
 330
 331   /* linkage index counter used by conditional store commands */
 332   unsigned int vms_linkage_index;
 333 };
 334
 335 #define PRIV2(abfd, name) \
 336   (((struct vms_private_data_struct *)(abfd)->tdata.any)->name)
 337 #define PRIV(name) PRIV2(abfd,name)
 338
 339
 340 /* Used to keep extra VMS specific information for a given section.
 341
 342    reloc_size holds the size of the relocation stream, note this
 343    is very different from the number of relocations as VMS relocations
 344    are variable length.
 345
 346    reloc_stream is the actual stream of relocation entries.  */
 347
 348 struct vms_section_data_struct
 349 {
 350   /* Maximnum number of entries in sec->relocation.  */
 351   unsigned reloc_max;
 352
 353   /* Corresponding eisd.  Used only while generating executables.  */
 354   struct vms_internal_eisd_map *eisd;
 355
 356   /* PSC flags to be clear.  */
 357   flagword no_flags;
 358
 359   /* PSC flags to be set.  */
 360   flagword flags;
 361 };
 362
 363 #define vms_section_data(sec) \
 364   ((struct vms_section_data_struct *)sec->used_by_bfd)
 365
 366 /* To be called from the debugger.  */
 367 struct vms_private_data_struct *bfd_vms_get_data (bfd *abfd);
 368
 369 static int vms_get_remaining_object_record (bfd *abfd, int read_so_far);
 370 static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);
 371 static void alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);
 372 static void alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);
 373 static void alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,
 374                                     bfd_vma);
 375 static void alpha_vms_add_fixup_lr (struct bfd_link_info *, unsigned int,
 376                                     bfd_vma);
 377 static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);
 378 static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);
 379
 380 struct vector_type
 381 {
 382   unsigned int max_el;
 383   unsigned int nbr_el;
 384   void *els;
 385 };
 386
 387 /* Number of elements in VEC.  */
 388
 389 #define VEC_COUNT(VEC) ((VEC).nbr_el)
 390
 391 /* Get the address of the Nth element.  */
 392
 393 #define VEC_EL(VEC, TYPE, N) (((TYPE *)((VEC).els))[N])
 394
 395 #define VEC_INIT(VEC)                           \
 396   do {                                          \
 397     (VEC).max_el = 0;                           \
 398     (VEC).nbr_el = 0;                           \
 399     (VEC).els = NULL;                           \
 400   } while (0)
 401
 402 /* Be sure there is room for a new element.  */
 403
 404 static void vector_grow1 (struct vector_type *vec, size_t elsz);
 405
 406 /* Allocate room for a new element and return its address.  */
 407
 408 #define VEC_APPEND(VEC, TYPE)                                   \
 409   (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))
 410
 411 /* Append an element.  */
 412
 413 #define VEC_APPEND_EL(VEC, TYPE, EL)            \
 414   (*(VEC_APPEND (VEC, TYPE)) = EL)
 415
 416 struct alpha_vms_vma_ref
 417 {
 418   bfd_vma vma;  /* Vma in the output.  */
 419   bfd_vma ref;  /* Reference in the input.  */
 420 };
 421
 422 struct alpha_vms_shlib_el
 423 {
 424   bfd *abfd;
 425   bfd_boolean has_fixups;
 426
 427   struct vector_type lp;        /* Vector of bfd_vma.  */
 428   struct vector_type ca;        /* Vector of bfd_vma.  */
 429   struct vector_type qr;        /* Vector of struct alpha_vms_vma_ref.  */
 430 };
 431
 432 /* Alpha VMS linker hash table.  */
 433
 434 struct alpha_vms_link_hash_table
 435 {
 436   struct bfd_link_hash_table root;
 437
 438   /* Vector of shared libraries.  */
 439   struct vector_type shrlibs;
 440
 441   /* Fixup section.  */
 442   asection *fixup;
 443
 444   /* Base address.  Used by fixups.  */
 445   bfd_vma base_addr;
 446 };
 447
 448 #define alpha_vms_link_hash(INFO) \
 449   ((struct alpha_vms_link_hash_table *)(INFO->hash))
 450
 451 /* Alpha VMS linker hash table entry.  */
 452
 453 struct alpha_vms_link_hash_entry
 454 {
 455   struct bfd_link_hash_entry root;
 456
 457   /* Pointer to the original vms symbol.  */
 458   struct vms_symbol_entry *sym;
 459 };
 460 \f
 461 /* Image reading.  */
 462
 463 /* Read & process EIHD record.
 464    Return TRUE on success, FALSE on error.  */
 465
 466 static bfd_boolean
 467 _bfd_vms_slurp_eihd (bfd *abfd, unsigned int *eisd_offset,
 468                      unsigned int *eihs_offset)
 469 {
 470   unsigned int imgtype, size;
 471   bfd_vma symvva;
 472   struct vms_eihd *eihd = (struct vms_eihd *)PRIV (recrd.rec);
 473
 474   vms_debug2 ((8, "_bfd_vms_slurp_eihd\n"));
 475
 476   size = bfd_getl32 (eihd->size);
 477   imgtype = bfd_getl32 (eihd->imgtype);
 478
 479   if (imgtype == EIHD__K_EXE || imgtype == EIHD__K_LIM)
 480     abfd->flags |= EXEC_P;
 481
 482   symvva = bfd_getl64 (eihd->symvva);
 483   if (symvva != 0)
 484     {
 485       PRIV (symvva) = symvva;
 486       abfd->flags |= DYNAMIC;
 487     }
 488
 489   PRIV (ident) = bfd_getl32 (eihd->ident);
 490   PRIV (matchctl) = eihd->matchctl;
 491
 492   *eisd_offset = bfd_getl32 (eihd->isdoff);
 493   *eihs_offset = bfd_getl32 (eihd->symdbgoff);
 494
 495   vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",
 496                size, imgtype, (unsigned long)symvva,
 497                *eisd_offset, *eihs_offset));
 498
 499   return TRUE;
 500 }
 501
 502 /* Read & process EISD record.
 503    Return TRUE on success, FALSE on error.  */
 504
 505 static bfd_boolean
 506 _bfd_vms_slurp_eisd (bfd *abfd, unsigned int offset)
 507 {
 508   int section_count = 0;
 509
 510   vms_debug2 ((8, "_bfd_vms_slurp_eisd\n"));
 511
 512   while (1)
 513     {
 514       struct vms_eisd *eisd;
 515       unsigned int rec_size;
 516       unsigned int size;
 517       unsigned long long vaddr;
 518       unsigned int flags;
 519       unsigned int vbn;
 520       char *name = NULL;
 521       asection *section;
 522       flagword bfd_flags;
 523
 524       eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
 525       rec_size = bfd_getl32 (eisd->eisdsize);
 526
 527       if (rec_size == 0)
 528         break;
 529
 530       /* Skip to next block if pad.  */
 531       if (rec_size == 0xffffffff)
 532         {
 533           offset = (offset + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
 534           continue;
 535         }
 536       else
 537         offset += rec_size;
 538
 539       size = bfd_getl32 (eisd->secsize);
 540       vaddr = bfd_getl64 (eisd->virt_addr);
 541       flags = bfd_getl32 (eisd->flags);
 542       vbn = bfd_getl32 (eisd->vbn);
 543
 544       vms_debug2 ((4, "EISD at 0x%x size 0x%x addr 0x%lx flags 0x%x blk %d\n",
 545                    offset, size, (unsigned long)vaddr, flags, vbn));
 546
 547       /* VMS combines psects from .obj files into isects in the .exe.  This
 548          process doesn't preserve enough information to reliably determine
 549          what's in each section without examining the data.  This is
 550          especially true of DWARF debug sections.  */
 551       bfd_flags = SEC_ALLOC;
 552       if (vbn != 0)
 553         bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
 554
 555       if (flags & EISD__M_EXE)
 556         bfd_flags |= SEC_CODE;
 557
 558       if (flags & EISD__M_NONSHRADR)
 559         bfd_flags |= SEC_DATA;
 560
 561       if (!(flags & EISD__M_WRT))
 562         bfd_flags |= SEC_READONLY;
 563
 564       if (flags & EISD__M_DZRO)
 565         bfd_flags |= SEC_DATA;
 566
 567       if (flags & EISD__M_FIXUPVEC)
 568         bfd_flags |= SEC_DATA;
 569
 570       if (flags & EISD__M_CRF)
 571         bfd_flags |= SEC_DATA;
 572
 573       if (flags & EISD__M_GBL)
 574         {
 575           name = _bfd_vms_save_counted_string (eisd->gblnam);
 576           bfd_flags |= SEC_COFF_SHARED_LIBRARY;
 577           bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
 578         }
 579       else if (flags & EISD__M_FIXUPVEC)
 580         name = "$FIXUPVEC$";
 581       else if (eisd->type == EISD__K_USRSTACK)
 582         name = "$STACK$";
 583       else
 584         {
 585           const char *pfx;
 586
 587           name = (char*) bfd_alloc (abfd, 32);
 588           if (flags & EISD__M_DZRO)
 589             pfx = "BSS";
 590           else if (flags & EISD__M_EXE)
 591             pfx = "CODE";
 592           else if (!(flags & EISD__M_WRT))
 593             pfx = "RO";
 594           else
 595             pfx = "LOCAL";
 596           BFD_ASSERT (section_count < 999);
 597           sprintf (name, "$%s_%03d$", pfx, section_count++);
 598         }
 599
 600       section = bfd_make_section (abfd, name);
 601
 602       if (!section)
 603         return FALSE;
 604
 605       section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : 0;
 606       section->size = size;
 607       section->vma = vaddr;
 608
 609       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 610         return FALSE;
 611     }
 612
 613   return TRUE;
 614 }
 615
 616 /* Read & process EIHS record.
 617    Return TRUE on success, FALSE on error.  */
 618
 619 static bfd_boolean
 620 _bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)
 621 {
 622   unsigned char *p = PRIV (recrd.rec) + offset;
 623   unsigned int gstvbn = bfd_getl32 (p + EIHS__L_GSTVBN);
 624   unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS__L_GSTSIZE);
 625   unsigned int dstvbn = bfd_getl32 (p + EIHS__L_DSTVBN);
 626   unsigned int dstsize = bfd_getl32 (p + EIHS__L_DSTSIZE);
 627   unsigned int dmtvbn = bfd_getl32 (p + EIHS__L_DMTVBN);
 628   unsigned int dmtbytes = bfd_getl32 (p + EIHS__L_DMTBYTES);
 629   asection *section;
 630
 631 #if VMS_DEBUG
 632   vms_debug (8, "_bfd_vms_slurp_ihs\n");
 633   vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
 634              gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
 635 #endif
 636
 637   if (dstvbn)
 638     {
 639       flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
 640
 641       section = bfd_make_section (abfd, "$DST$");
 642       if (!section)
 643         return FALSE;
 644
 645       section->size = dstsize;
 646       section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
 647
 648       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 649         return FALSE;
 650
 651       PRIV (dst_section) = section;
 652       abfd->flags |= (HAS_DEBUG | HAS_LINENO);
 653     }
 654
 655   if (dmtvbn)
 656     {
 657       flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
 658
 659       section = bfd_make_section (abfd, "$DMT$");
 660       if (!section)
 661         return FALSE;
 662
 663       section->size = dmtbytes;
 664       section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
 665
 666       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 667         return FALSE;
 668     }
 669
 670   if (gstvbn)
 671     {
 672       if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
 673         {
 674           bfd_set_error (bfd_error_file_truncated);
 675           return FALSE;
 676         }
 677
 678       if (_bfd_vms_slurp_object_records (abfd) != TRUE)
 679         return FALSE;
 680
 681       abfd->flags |= HAS_SYMS;
 682     }
 683
 684   return TRUE;
 685 }
 686 \f
 687 /* Object file reading.  */
 688
 689 /* Object file input functions.  */
 690
 691 /* Get next record from object file to vms_buf.
 692    Set PRIV(buf_size) and return it
 693
 694    This is a little tricky since it should be portable.
 695
 696    The openVMS object file has 'variable length' which means that
 697    read() returns data in chunks of (hopefully) correct and expected
 698    size.  The linker (and other tools on VMS) depend on that. Unix
 699    doesn't know about 'formatted' files, so reading and writing such
 700    an object file in a Unix environment is not trivial.
 701
 702    With the tool 'file' (available on all VMS FTP sites), one
 703    can view and change the attributes of a file.  Changing from
 704    'variable length' to 'fixed length, 512 bytes' reveals the
 705    record size at the first 2 bytes of every record.  The same
 706    may happen during the transfer of object files from VMS to Unix,
 707    at least with UCX, the DEC implementation of TCP/IP.
 708
 709    The VMS format repeats the size at bytes 2 & 3 of every record.
 710
 711    On the first call (file_format == FF_UNKNOWN) we check if
 712    the first and the third byte pair (!) of the record match.
 713    If they do it's an object file in an Unix environment or with
 714    wrong attributes (FF_FOREIGN), else we should be in a VMS
 715    environment where read() returns the record size (FF_NATIVE).
 716
 717    Reading is always done in 2 steps:
 718     1. first just the record header is read and the size extracted,
 719     2. then the read buffer is adjusted and the remaining bytes are
 720        read in.
 721
 722    All file I/O is done on even file positions.  */
 723
 724 #define VMS_OBJECT_ADJUSTMENT  2
 725
 726 static void
 727 maybe_adjust_record_pointer_for_object (bfd *abfd)
 728 {
 729   /* Set the file format once for all on the first invocation.  */
 730   if (PRIV (recrd.file_format) == FF_UNKNOWN)
 731     {
 732       if (PRIV (recrd.rec)[0] == PRIV (recrd.rec)[4]
 733           && PRIV (recrd.rec)[1] == PRIV (recrd.rec)[5])
 734         PRIV (recrd.file_format) = FF_FOREIGN;
 735       else
 736         PRIV (recrd.file_format) = FF_NATIVE;
 737     }
 738
 739   /* The adjustment is needed only in an Unix environment.  */
 740   if (PRIV (recrd.file_format) == FF_FOREIGN)
 741     PRIV (recrd.rec) += VMS_OBJECT_ADJUSTMENT;
 742 }
 743
 744 /* Implement step #1 of the object record reading procedure.
 745    Return the record type or -1 on failure.  */
 746
 747 static int
 748 _bfd_vms_get_object_record (bfd *abfd)
 749 {
 750   unsigned int test_len = 6;
 751   int type;
 752
 753   vms_debug2 ((8, "_bfd_vms_get_obj_record\n"));
 754
 755   /* Skip alignment byte if the current position is odd.  */
 756   if (PRIV (recrd.file_format) == FF_FOREIGN && (bfd_tell (abfd) & 1))
 757     {
 758       if (bfd_bread (PRIV (recrd.buf), 1, abfd) != 1)
 759         {
 760           bfd_set_error (bfd_error_file_truncated);
 761           return -1;
 762         }
 763     }
 764
 765   /* Read the record header  */
 766   if (bfd_bread (PRIV (recrd.buf), test_len, abfd) != test_len)
 767     {
 768       bfd_set_error (bfd_error_file_truncated);
 769       return -1;
 770     }
 771
 772   /* Reset the record pointer.  */
 773   PRIV (recrd.rec) = PRIV (recrd.buf);
 774   maybe_adjust_record_pointer_for_object (abfd);
 775
 776   if (vms_get_remaining_object_record (abfd, test_len) <= 0)
 777     return -1;
 778
 779   type = bfd_getl16 (PRIV (recrd.rec));
 780
 781   vms_debug2 ((8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",
 782                PRIV (recrd.rec), PRIV (recrd.rec_size), type));
 783
 784   return type;
 785 }
 786
 787 /* Implement step #2 of the object record reading procedure.
 788    Return the size of the record or 0 on failure.  */
 789
 790 static int
 791 vms_get_remaining_object_record (bfd *abfd, int read_so_far)
 792 {
 793   unsigned int to_read;
 794
 795   vms_debug2 ((8, "vms_get_remaining_obj_record\n"));
 796
 797   /* Extract record size.  */
 798   PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);
 799
 800   if (PRIV (recrd.rec_size) == 0)
 801     {
 802       bfd_set_error (bfd_error_file_truncated);
 803       return 0;
 804     }
 805
 806   /* That's what the linker manual says.  */
 807   if (PRIV (recrd.rec_size) > EOBJ__C_MAXRECSIZ)
 808     {
 809       bfd_set_error (bfd_error_file_truncated);
 810       return 0;
 811     }
 812
 813   /* Take into account object adjustment.  */
 814   to_read = PRIV (recrd.rec_size);
 815   if (PRIV (recrd.file_format) == FF_FOREIGN)
 816     to_read += VMS_OBJECT_ADJUSTMENT;
 817
 818   /* Adjust the buffer.  */
 819   if (to_read > PRIV (recrd.buf_size))
 820     {
 821       PRIV (recrd.buf)
 822         = (unsigned char *) bfd_realloc (PRIV (recrd.buf), to_read);
 823       if (PRIV (recrd.buf) == NULL)
 824         return 0;
 825       PRIV (recrd.buf_size) = to_read;
 826     }
 827
 828   /* Read the remaining record.  */
 829   to_read -= read_so_far;
 830
 831   vms_debug2 ((8, "vms_get_remaining_obj_record: to_read %d\n", to_read));
 832
 833   if (bfd_bread (PRIV (recrd.buf) + read_so_far, to_read, abfd) != to_read)
 834     {
 835       bfd_set_error (bfd_error_file_truncated);
 836       return 0;
 837     }
 838
 839   /* Reset the record pointer.  */
 840   PRIV (recrd.rec) = PRIV (recrd.buf);
 841   maybe_adjust_record_pointer_for_object (abfd);
 842
 843   vms_debug2 ((8, "vms_get_remaining_obj_record: size %d\n",
 844                PRIV (recrd.rec_size)));
 845
 846   return PRIV (recrd.rec_size);
 847 }
 848
 849 /* Read and process emh record.
 850    Return TRUE on success, FALSE on error.  */
 851
 852 static bfd_boolean
 853 _bfd_vms_slurp_ehdr (bfd *abfd)
 854 {
 855   unsigned char *ptr;
 856   unsigned char *vms_rec;
 857   int subtype;
 858
 859   vms_rec = PRIV (recrd.rec);
 860
 861   vms_debug2 ((2, "HDR/EMH\n"));
 862
 863   subtype = bfd_getl16 (vms_rec + 4);
 864
 865   vms_debug2 ((3, "subtype %d\n", subtype));
 866
 867   switch (subtype)
 868     {
 869     case EMH__C_MHD:
 870       /* Module header.  */
 871       PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
 872       PRIV (hdr_data).hdr_l_arch1  = bfd_getl32 (vms_rec + 8);
 873       PRIV (hdr_data).hdr_l_arch2  = bfd_getl32 (vms_rec + 12);
 874       PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
 875       PRIV (hdr_data).hdr_t_name   = _bfd_vms_save_counted_string (vms_rec + 20);
 876       ptr = vms_rec + 20 + vms_rec[20] + 1;
 877       PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
 878       ptr += *ptr + 1;
 879       PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
 880       break;
 881
 882     case EMH__C_LNM:
 883       PRIV (hdr_data).hdr_c_lnm =
 884         _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
 885       break;
 886
 887     case EMH__C_SRC:
 888       PRIV (hdr_data).hdr_c_src =
 889         _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
 890       break;
 891
 892     case EMH__C_TTL:
 893       PRIV (hdr_data).hdr_c_ttl =
 894         _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
 895       break;
 896
 897     case EMH__C_CPR:
 898     case EMH__C_MTC:
 899     case EMH__C_GTX:
 900       break;
 901
 902     default:
 903       bfd_set_error (bfd_error_wrong_format);
 904       return FALSE;
 905     }
 906
 907   return TRUE;
 908 }
 909
 910 /* Typical sections for evax object files.  */
 911
 912 #define EVAX_ABS_NAME           "$ABS$"
 913 #define EVAX_CODE_NAME          "$CODE$"
 914 #define EVAX_LINK_NAME          "$LINK$"
 915 #define EVAX_DATA_NAME          "$DATA$"
 916 #define EVAX_BSS_NAME           "$BSS$"
 917 #define EVAX_READONLYADDR_NAME  "$READONLY_ADDR$"
 918 #define EVAX_READONLY_NAME      "$READONLY$"
 919 #define EVAX_LITERAL_NAME       "$LITERAL$"
 920 #define EVAX_LITERALS_NAME      "$LITERALS"
 921 #define EVAX_COMMON_NAME        "$COMMON$"
 922 #define EVAX_LOCAL_NAME         "$LOCAL$"
 923
 924 struct sec_flags_struct
 925 {
 926   const char *name;             /* Name of section.  */
 927   int vflags_always;
 928   flagword flags_always;        /* Flags we set always.  */
 929   int vflags_hassize;
 930   flagword flags_hassize;       /* Flags we set if the section has a size > 0.  */
 931 };
 932
 933 /* These flags are deccrtl/vaxcrtl (openVMS 6.2 Alpha) compatible.  */
 934
 935 static const struct sec_flags_struct evax_section_flags[] =
 936   {
 937     { EVAX_ABS_NAME,
 938       EGPS__V_SHR,
 939       0,
 940       EGPS__V_SHR,
 941       0 },
 942     { EVAX_CODE_NAME,
 943       EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE,
 944       SEC_CODE | SEC_READONLY,
 945       EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE,
 946       SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 947     { EVAX_LITERAL_NAME,
 948       EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD,
 949       SEC_DATA | SEC_READONLY,
 950       EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD,
 951       SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 952     { EVAX_LINK_NAME,
 953       EGPS__V_REL | EGPS__V_RD,
 954       SEC_DATA | SEC_READONLY,
 955       EGPS__V_REL | EGPS__V_RD,
 956       SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 957     { EVAX_DATA_NAME,
 958       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
 959       SEC_DATA,
 960       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
 961       SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 962     { EVAX_BSS_NAME,
 963       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
 964       SEC_NO_FLAGS,
 965       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
 966       SEC_ALLOC },
 967     { EVAX_READONLYADDR_NAME,
 968       EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD,
 969       SEC_DATA | SEC_READONLY,
 970       EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD,
 971       SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 972     { EVAX_READONLY_NAME,
 973       EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD,
 974       SEC_DATA | SEC_READONLY,
 975       EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD,
 976       SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 977     { EVAX_LOCAL_NAME,
 978       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
 979       SEC_DATA,
 980       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
 981       SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 982     { EVAX_LITERALS_NAME,
 983       EGPS__V_PIC | EGPS__V_OVR,
 984       SEC_DATA | SEC_READONLY,
 985       EGPS__V_PIC | EGPS__V_OVR,
 986       SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
 987     { NULL,
 988       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
 989       SEC_DATA,
 990       EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
 991       SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD }
 992   };
 993
 994 /* Retrieve BFD section flags by name and size.  */
 995
 996 static flagword
 997 vms_secflag_by_name (const struct sec_flags_struct *section_flags,
 998                      const char *name,
 999                      int hassize)
1000 {
1001   int i = 0;
1002
1003   while (section_flags[i].name != NULL)
1004     {
1005       if (strcmp (name, section_flags[i].name) == 0)
1006         {
1007           if (hassize)
1008             return section_flags[i].flags_hassize;
1009           else
1010             return section_flags[i].flags_always;
1011         }
1012       i++;
1013     }
1014   if (hassize)
1015     return section_flags[i].flags_hassize;
1016   return section_flags[i].flags_always;
1017 }
1018
1019 /* Retrieve VMS section flags by name and size.  */
1020
1021 static flagword
1022 vms_esecflag_by_name (const struct sec_flags_struct *section_flags,
1023                       const char *name,
1024                       int hassize)
1025 {
1026   int i = 0;
1027
1028   while (section_flags[i].name != NULL)
1029     {
1030       if (strcmp (name, section_flags[i].name) == 0)
1031         {
1032           if (hassize)
1033             return section_flags[i].vflags_hassize;
1034           else
1035             return section_flags[i].vflags_always;
1036         }
1037       i++;
1038     }
1039   if (hassize)
1040     return section_flags[i].vflags_hassize;
1041   return section_flags[i].vflags_always;
1042 }
1043
1044 /* Add SYM to the symbol table of ABFD.
1045    Return FALSE in case of error.  */
1046
1047 static bfd_boolean
1048 add_symbol_entry (bfd *abfd, struct vms_symbol_entry *sym)
1049 {
1050   if (PRIV (gsd_sym_count) >= PRIV (max_sym_count))
1051     {
1052       if (PRIV (max_sym_count) == 0)
1053         {
1054           PRIV (max_sym_count) = 128;
1055           PRIV (syms) = bfd_malloc
1056             (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *));
1057         }
1058       else
1059         {
1060           PRIV (max_sym_count) *= 2;
1061           PRIV (syms) = bfd_realloc
1062             (PRIV (syms),
1063              (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *)));
1064         }
1065       if (PRIV (syms) == NULL)
1066         return FALSE;
1067     }
1068
1069   PRIV (syms)[PRIV (gsd_sym_count)++] = sym;
1070   return TRUE;
1071 }
1072
1073 /* Create a symbol whose name is ASCIC and add it to ABFD.
1074    Return NULL in case of error.  */
1075
1076 static struct vms_symbol_entry *
1077 add_symbol (bfd *abfd, const unsigned char *ascic)
1078 {
1079   struct vms_symbol_entry *entry;
1080   int len;
1081
1082   len = *ascic++;
1083   entry = (struct vms_symbol_entry *)bfd_zalloc (abfd, sizeof (*entry) + len);
1084   if (entry == NULL)
1085     return NULL;
1086   entry->namelen = len;
1087   memcpy (entry->name, ascic, len);
1088   entry->name[len] = 0;
1089   entry->owner = abfd;
1090
1091   if (!add_symbol_entry (abfd, entry))
1092     return NULL;
1093   return entry;
1094 }
1095
1096 /* Read and process EGSD.  Return FALSE on failure.  */
1097
1098 static bfd_boolean
1099 _bfd_vms_slurp_egsd (bfd *abfd)
1100 {
1101   int gsd_type, gsd_size;
1102   unsigned char *vms_rec;
1103   unsigned long base_addr;
1104
1105   vms_debug2 ((2, "EGSD\n"));
1106
1107   PRIV (recrd.rec) += 8;        /* Skip type, size, align pad.  */
1108   PRIV (recrd.rec_size) -= 8;
1109
1110   /* Calculate base address for each section.  */
1111   base_addr = 0L;
1112
1113   while (PRIV (recrd.rec_size) > 0)
1114     {
1115       vms_rec = PRIV (recrd.rec);
1116
1117       gsd_type = bfd_getl16 (vms_rec);
1118       gsd_size = bfd_getl16 (vms_rec + 2);
1119
1120       vms_debug2 ((3, "egsd_type %d\n", gsd_type));
1121
1122       switch (gsd_type)
1123         {
1124         case EGSD__C_PSC:
1125           /* Program section definition.  */
1126           {
1127             struct vms_egps *egps = (struct vms_egps *)vms_rec;
1128             flagword new_flags, vms_flags;
1129             asection *section;
1130
1131             vms_flags = bfd_getl16 (egps->flags);
1132
1133             if ((vms_flags & EGPS__V_REL) == 0)
1134               {
1135                 /* Use the global absolute section for all
1136                    absolute sections.  */
1137                 section = bfd_abs_section_ptr;
1138               }
1139             else
1140               {
1141                 char *name;
1142                 unsigned long align_addr;
1143
1144                 name = _bfd_vms_save_counted_string (&egps->namlng);
1145
1146                 section = bfd_make_section (abfd, name);
1147                 if (!section)
1148                   return FALSE;
1149
1150                 section->filepos = 0;
1151                 section->size = bfd_getl32 (egps->alloc);
1152                 section->alignment_power = egps->align;
1153
1154                 vms_section_data (section)->flags = vms_flags;
1155                 vms_section_data (section)->no_flags = 0;
1156
1157                 new_flags = vms_secflag_by_name (evax_section_flags, name,
1158                                                  section->size > 0);
1159                 if (section->size > 0)
1160                   new_flags |= SEC_LOAD;
1161                 if (!(vms_flags & EGPS__V_NOMOD) && section->size > 0)
1162                   {
1163                     /* Set RELOC and HAS_CONTENTS if the section is not
1164                        demand-zero and not empty.  */
1165                     new_flags |= SEC_HAS_CONTENTS;
1166                     if (vms_flags & EGPS__V_REL)
1167                       new_flags |= SEC_RELOC;
1168                   }
1169                 if (vms_flags & EGPS__V_EXE)
1170                   {
1171                     /* Set CODE if section is executable.  */
1172                     new_flags |= SEC_CODE;
1173                     new_flags &= ~SEC_DATA;
1174                   }
1175                 if (!bfd_set_section_flags (abfd, section, new_flags))
1176                   return FALSE;
1177
1178                 /* Give a non-overlapping vma to non absolute sections.  */
1179                 align_addr = (1 << section->alignment_power);
1180                 if ((base_addr % align_addr) != 0)
1181                   base_addr += (align_addr - (base_addr % align_addr));
1182                 section->vma = (bfd_vma)base_addr;
1183                 base_addr += section->size;
1184               }
1185
1186             /* Append it to the section array.  */
1187             if (PRIV (section_count) >= PRIV (section_max))
1188               {
1189                 if (PRIV (section_max) == 0)
1190                   PRIV (section_max) = 16;
1191                 else
1192                   PRIV (section_max) *= 2;
1193                 PRIV (sections) = bfd_realloc_or_free
1194                   (PRIV (sections), PRIV (section_max) * sizeof (asection *));
1195                 if (PRIV (sections) == NULL)
1196                   return FALSE;
1197               }
1198
1199             PRIV (sections)[PRIV (section_count)] = section;
1200             PRIV (section_count)++;
1201           }
1202           break;
1203
1204         case EGSD__C_SYM:
1205           {
1206             int nameoff;
1207             struct vms_symbol_entry *entry;
1208             struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
1209             flagword old_flags;
1210
1211             old_flags = bfd_getl16 (egsy->flags);
1212             if (old_flags & EGSY__V_DEF)
1213               nameoff = ESDF__B_NAMLNG;
1214             else
1215               nameoff = ESRF__B_NAMLNG;
1216
1217             entry = add_symbol (abfd, vms_rec + nameoff);
1218             if (entry == NULL)
1219               return FALSE;
1220
1221             /* Allow only duplicate reference.  */
1222             if ((entry->flags & EGSY__V_DEF) && (old_flags & EGSY__V_DEF))
1223               abort ();
1224
1225             if (entry->typ == 0)
1226               {
1227                 entry->typ = gsd_type;
1228                 entry->data_type = egsy->datyp;
1229                 entry->flags = old_flags;
1230               }
1231
1232             if (old_flags & EGSY__V_DEF)
1233               {
1234                 struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
1235
1236                 entry->value = bfd_getl64 (esdf->value);
1237                 entry->section = PRIV (sections)[bfd_getl32 (esdf->psindx)];
1238
1239                 if (old_flags & EGSY__V_NORM)
1240                   {
1241                     PRIV (norm_sym_count)++;
1242
1243                     entry->code_value = bfd_getl64 (esdf->code_address);
1244                     entry->code_section =
1245                       PRIV (sections)[bfd_getl32 (esdf->ca_psindx)];
1246                   }
1247               }
1248           }
1249           break;
1250
1251         case EGSD__C_SYMG:
1252           {
1253             struct vms_symbol_entry *entry;
1254             struct vms_egst *egst = (struct vms_egst *)vms_rec;
1255             flagword old_flags;
1256
1257             old_flags = bfd_getl16 (egst->header.flags);
1258
1259             entry = add_symbol (abfd, &egst->namlng);
1260
1261             if (entry == NULL)
1262               return FALSE;
1263
1264             entry->typ = gsd_type;
1265             entry->data_type = egst->header.datyp;
1266             entry->flags = old_flags;
1267
1268             entry->symbol_vector = bfd_getl32 (egst->value);
1269
1270             if (old_flags & EGSY__V_REL)
1271               entry->section = PRIV (sections)[bfd_getl32 (egst->psindx)];
1272             else
1273               entry->section = bfd_abs_section_ptr;
1274
1275             entry->value = bfd_getl64 (egst->lp_2);
1276
1277             if (old_flags & EGSY__V_NORM)
1278               {
1279                 PRIV (norm_sym_count)++;
1280
1281                 entry->code_value = bfd_getl64 (egst->lp_1);
1282                 entry->code_section = bfd_abs_section_ptr;
1283               }
1284           }
1285           break;
1286
1287         case EGSD__C_SPSC:
1288         case EGSD__C_IDC:
1289           /* Currently ignored.  */
1290           break;
1291         case EGSD__C_SYMM:
1292         case EGSD__C_SYMV:
1293         default:
1294           (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
1295           bfd_set_error (bfd_error_bad_value);
1296           return FALSE;
1297         }
1298
1299       PRIV (recrd.rec_size) -= gsd_size;
1300       PRIV (recrd.rec) += gsd_size;
1301     }
1302
1303   if (PRIV (gsd_sym_count) > 0)
1304     abfd->flags |= HAS_SYMS;
1305
1306   return TRUE;
1307 }
1308
1309 /* Stack routines for vms ETIR commands.  */
1310
1311 /* Push value and section index.  */
1312
1313 static void
1314 _bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
1315 {
1316   vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
1317                (unsigned long)val, reloc, PRIV (stackptr)));
1318
1319   PRIV (stack[PRIV (stackptr)]).value = val;
1320   PRIV (stack[PRIV (stackptr)]).reloc = reloc;
1321   PRIV (stackptr)++;
1322   if (PRIV (stackptr) >= STACKSIZE)
1323     {
1324       bfd_set_error (bfd_error_bad_value);
1325       (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
1326       exit (1);
1327     }
1328 }
1329
1330 /* Pop value and section index.  */
1331
1332 static void
1333 _bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
1334 {
1335   if (PRIV (stackptr) == 0)
1336     {
1337       bfd_set_error (bfd_error_bad_value);
1338       (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
1339       exit (1);
1340     }
1341   PRIV (stackptr)--;
1342   *val = PRIV (stack[PRIV (stackptr)]).value;
1343   *rel = PRIV (stack[PRIV (stackptr)]).reloc;
1344
1345   vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
1346 }
1347
1348 /* Routines to fill sections contents during tir/etir read.  */
1349
1350 /* Initialize image buffer pointer to be filled.  */
1351
1352 static void
1353 image_set_ptr (bfd *abfd, bfd_vma vma, int sect, struct bfd_link_info *info)
1354 {
1355   asection *sec;
1356
1357   vms_debug2 ((4, "image_set_ptr (0x%08x, sect=%d)\n", (unsigned)vma, sect));
1358
1359   sec = PRIV (sections)[sect];
1360
1361   if (info)
1362     {
1363       /* Reading contents to an output bfd.  */
1364
1365       if (sec->output_section == NULL)
1366         {
1367           /* Section discarded.  */
1368           vms_debug2 ((5, " section %s discarded\n", sec->name));
1369
1370           /* This is not used.  */
1371           PRIV (image_section) = NULL;
1372           PRIV (image_offset) = 0;
1373           return;
1374         }
1375       PRIV (image_offset) = sec->output_offset + vma;
1376       PRIV (image_section) = sec->output_section;
1377     }
1378   else
1379     {
1380       PRIV (image_offset) = vma;
1381       PRIV (image_section) = sec;
1382     }
1383 }
1384
1385 /* Increment image buffer pointer by offset.  */
1386
1387 static void
1388 image_inc_ptr (bfd *abfd, bfd_vma offset)
1389 {
1390   vms_debug2 ((4, "image_inc_ptr (%u)\n", (unsigned)offset));
1391
1392   PRIV (image_offset) += offset;
1393 }
1394
1395 /* Save current DST location counter under specified index.  */
1396
1397 static void
1398 dst_define_location (bfd *abfd, unsigned int loc)
1399 {
1400   vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
1401
1402   /* Grow the ptr offset table if necessary.  */
1403   if (loc + 1 > PRIV (dst_ptr_offsets_count))
1404     {
1405       PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
1406                                            (loc + 1) * sizeof (unsigned int));
1407       PRIV (dst_ptr_offsets_count) = loc + 1;
1408     }
1409
1410   PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
1411 }
1412
1413 /* Restore saved DST location counter from specified index.  */
1414
1415 static void
1416 dst_restore_location (bfd *abfd, unsigned int loc)
1417 {
1418   vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
1419
1420   PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
1421 }
1422
1423 /* Retrieve saved DST location counter from specified index.  */
1424
1425 static unsigned int
1426 dst_retrieve_location (bfd *abfd, unsigned int loc)
1427 {
1428   vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
1429
1430   return PRIV (dst_ptr_offsets)[loc];
1431 }
1432
1433 /* Write multiple bytes to section image.  */
1434
1435 static bfd_boolean
1436 image_write (bfd *abfd, unsigned char *ptr, int size)
1437 {
1438 #if VMS_DEBUG
1439   _bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
1440                   (long)PRIV (image_offset));
1441   _bfd_hexdump (9, ptr, size, 0);
1442 #endif
1443
1444   if (PRIV (image_section)->contents != NULL)
1445     {
1446       asection *sec = PRIV (image_section);
1447       file_ptr off = PRIV (image_offset);
1448
1449       /* Check bounds.  */
1450       if (off > (file_ptr)sec->size
1451           || size > (file_ptr)sec->size
1452           || off + size > (file_ptr)sec->size)
1453         {
1454           bfd_set_error (bfd_error_bad_value);
1455           return FALSE;
1456         }
1457
1458       memcpy (sec->contents + off, ptr, size);
1459     }
1460
1461   PRIV (image_offset) += size;
1462   return TRUE;
1463 }
1464
1465 /* Write byte to section image.  */
1466
1467 static bfd_boolean
1468 image_write_b (bfd * abfd, unsigned int value)
1469 {
1470   unsigned char data[1];
1471
1472   vms_debug2 ((6, "image_write_b (%02x)\n", (int) value));
1473
1474   *data = value;
1475
1476   return image_write (abfd, data, sizeof (data));
1477 }
1478
1479 /* Write 2-byte word to image.  */
1480
1481 static bfd_boolean
1482 image_write_w (bfd * abfd, unsigned int value)
1483 {
1484   unsigned char data[2];
1485
1486   vms_debug2 ((6, "image_write_w (%04x)\n", (int) value));
1487
1488   bfd_putl16 (value, data);
1489   return image_write (abfd, data, sizeof (data));
1490 }
1491
1492 /* Write 4-byte long to image.  */
1493
1494 static bfd_boolean
1495 image_write_l (bfd * abfd, unsigned long value)
1496 {
1497   unsigned char data[4];
1498
1499   vms_debug2 ((6, "image_write_l (%08lx)\n", value));
1500
1501   bfd_putl32 (value, data);
1502   return image_write (abfd, data, sizeof (data));
1503 }
1504
1505 /* Write 8-byte quad to image.  */
1506
1507 static bfd_boolean
1508 image_write_q (bfd * abfd, bfd_vma value)
1509 {
1510   unsigned char data[8];
1511
1512   vms_debug2 ((6, "image_write_q (%08lx)\n", (unsigned long)value));
1513
1514   bfd_putl64 (value, data);
1515   return image_write (abfd, data, sizeof (data));
1516 }
1517 \f
1518 static const char *
1519 _bfd_vms_etir_name (int cmd)
1520 {
1521   switch (cmd)
1522     {
1523     case ETIR__C_STA_GBL: return "ETIR__C_STA_GBL";
1524     case ETIR__C_STA_LW: return "ETIR__C_STA_LW";
1525     case ETIR__C_STA_QW: return "ETIR__C_STA_QW";
1526     case ETIR__C_STA_PQ: return "ETIR__C_STA_PQ";
1527     case ETIR__C_STA_LI: return "ETIR__C_STA_LI";
1528     case ETIR__C_STA_MOD: return "ETIR__C_STA_MOD";
1529     case ETIR__C_STA_CKARG: return "ETIR__C_STA_CKARG";
1530     case ETIR__C_STO_B: return "ETIR__C_STO_B";
1531     case ETIR__C_STO_W: return "ETIR__C_STO_W";
1532     case ETIR__C_STO_GBL: return "ETIR__C_STO_GBL";
1533     case ETIR__C_STO_CA: return "ETIR__C_STO_CA";
1534     case ETIR__C_STO_RB: return "ETIR__C_STO_RB";
1535     case ETIR__C_STO_AB: return "ETIR__C_STO_AB";
1536     case ETIR__C_STO_OFF: return "ETIR__C_STO_OFF";
1537     case ETIR__C_STO_IMM: return "ETIR__C_STO_IMM";
1538     case ETIR__C_STO_IMMR: return "ETIR__C_STO_IMMR";
1539     case ETIR__C_STO_LW: return "ETIR__C_STO_LW";
1540     case ETIR__C_STO_QW: return "ETIR__C_STO_QW";
1541     case ETIR__C_STO_GBL_LW: return "ETIR__C_STO_GBL_LW";
1542     case ETIR__C_STO_LP_PSB: return "ETIR__C_STO_LP_PSB";
1543     case ETIR__C_STO_HINT_GBL: return "ETIR__C_STO_HINT_GBL";
1544     case ETIR__C_STO_HINT_PS: return "ETIR__C_STO_HINT_PS";
1545     case ETIR__C_OPR_ADD: return "ETIR__C_OPR_ADD";
1546     case ETIR__C_OPR_SUB: return "ETIR__C_OPR_SUB";
1547     case ETIR__C_OPR_INSV: return "ETIR__C_OPR_INSV";
1548     case ETIR__C_OPR_USH: return "ETIR__C_OPR_USH";
1549     case ETIR__C_OPR_ROT: return "ETIR__C_OPR_ROT";
1550     case ETIR__C_OPR_REDEF: return "ETIR__C_OPR_REDEF";
1551     case ETIR__C_OPR_DFLIT: return "ETIR__C_OPR_DFLIT";
1552     case ETIR__C_STC_LP: return "ETIR__C_STC_LP";
1553     case ETIR__C_STC_GBL: return "ETIR__C_STC_GBL";
1554     case ETIR__C_STC_GCA: return "ETIR__C_STC_GCA";
1555     case ETIR__C_STC_PS: return "ETIR__C_STC_PS";
1556     case ETIR__C_STC_NBH_PS: return "ETIR__C_STC_NBH_PS";
1557     case ETIR__C_STC_NOP_GBL: return "ETIR__C_STC_NOP_GBL";
1558     case ETIR__C_STC_NOP_PS: return "ETIR__C_STC_NOP_PS";
1559     case ETIR__C_STC_BSR_GBL: return "ETIR__C_STC_BSR_GBL";
1560     case ETIR__C_STC_BSR_PS: return "ETIR__C_STC_BSR_PS";
1561     case ETIR__C_STC_LDA_GBL: return "ETIR__C_STC_LDA_GBL";
1562     case ETIR__C_STC_LDA_PS: return "ETIR__C_STC_LDA_PS";
1563     case ETIR__C_STC_BOH_GBL: return "ETIR__C_STC_BOH_GBL";
1564     case ETIR__C_STC_BOH_PS: return "ETIR__C_STC_BOH_PS";
1565     case ETIR__C_STC_NBH_GBL: return "ETIR__C_STC_NBH_GBL";
1566     case ETIR__C_STC_LP_PSB: return "ETIR__C_STC_LP_PSB";
1567     case ETIR__C_CTL_SETRB: return "ETIR__C_CTL_SETRB";
1568     case ETIR__C_CTL_AUGRB: return "ETIR__C_CTL_AUGRB";
1569     case ETIR__C_CTL_DFLOC: return "ETIR__C_CTL_DFLOC";
1570     case ETIR__C_CTL_STLOC: return "ETIR__C_CTL_STLOC";
1571     case ETIR__C_CTL_STKDL: return "ETIR__C_CTL_STKDL";
1572
1573     default:
1574       /* These names have not yet been added to this switch statement.  */
1575       (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
1576     }
1577
1578   return NULL;
1579 }
1580 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
1581
1582 static void
1583 _bfd_vms_get_value (bfd *abfd, const unsigned char *ascic,
1584                     struct bfd_link_info *info,
1585                     bfd_vma *vma,
1586                     struct alpha_vms_link_hash_entry **hp)
1587 {
1588   char name[257];
1589   int len;
1590   int i;
1591   struct alpha_vms_link_hash_entry *h;
1592
1593   /* Not linking.  Do not try to resolve the symbol.  */
1594   if (info == NULL)
1595     {
1596       *vma = 0;
1597       *hp = NULL;
1598       return;
1599     }
1600
1601   len = *ascic;
1602   for (i = 0; i < len; i++)
1603     name[i] = ascic[i + 1];
1604   name[i] = 0;
1605
1606   h = (struct alpha_vms_link_hash_entry *)
1607     bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
1608
1609   *hp = h;
1610
1611   if (h != NULL
1612       && (h->root.type == bfd_link_hash_defined
1613           || h->root.type == bfd_link_hash_defweak))
1614     *vma = h->root.u.def.value
1615       + h->root.u.def.section->output_offset
1616       + h->root.u.def.section->output_section->vma;
1617   else if (h && h->root.type == bfd_link_hash_undefweak)
1618     *vma = 0;
1619   else
1620     {
1621       if (!(*info->callbacks->undefined_symbol)
1622           (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
1623         abort ();
1624       *vma = 0;
1625     }
1626 }
1627
1628 #define RELC_NONE 0
1629 #define RELC_REL  1
1630 #define RELC_SHR_BASE 0x10000
1631 #define RELC_SEC_BASE 0x20000
1632 #define RELC_MASK     0x0ffff
1633
1634 static unsigned int
1635 alpha_vms_sym_to_ctxt (struct alpha_vms_link_hash_entry *h)
1636 {
1637   /* Handle undefined symbols.  */
1638   if (h == NULL || h->sym == NULL)
1639     return RELC_NONE;
1640
1641   if (h->sym->typ == EGSD__C_SYMG)
1642     {
1643       if (h->sym->flags & EGSY__V_REL)
1644         return RELC_SHR_BASE + PRIV2 (h->sym->owner, shr_index);
1645       else
1646         {
1647           /* Can this happen (non-relocatable symg) ?  I'd like to see
1648              an example.  */
1649           abort ();
1650         }
1651     }
1652   if (h->sym->typ == EGSD__C_SYM)
1653     {
1654       if (h->sym->flags & EGSY__V_REL)
1655         return RELC_REL;
1656       else
1657         return RELC_NONE;
1658     }
1659   abort ();
1660 }
1661
1662 static bfd_vma
1663 alpha_vms_get_sym_value (asection *sect, bfd_vma addr)
1664 {
1665   return sect->output_section->vma + sect->output_offset + addr;
1666 }
1667
1668 static bfd_vma
1669 alpha_vms_fix_sec_rel (bfd *abfd, struct bfd_link_info *info,
1670                        unsigned int rel, bfd_vma vma)
1671 {
1672   asection *sec = PRIV (sections)[rel & RELC_MASK];
1673
1674   if (info)
1675     {
1676       if (sec->output_section == NULL)
1677         abort ();
1678       return vma + sec->output_section->vma + sec->output_offset;
1679     }
1680   else
1681     return vma + sec->vma;
1682 }
1683
1684 /* Read an ETIR record from ABFD.  If INFO is not null, put the content into
1685    the output section (used during linking).
1686    Return FALSE in case of error.  */
1687
1688 static bfd_boolean
1689 _bfd_vms_slurp_etir (bfd *abfd, struct bfd_link_info *info)
1690 {
1691   unsigned char *ptr;
1692   unsigned int length;
1693   unsigned char *maxptr;
1694   bfd_vma op1;
1695   bfd_vma op2;
1696   unsigned int rel1;
1697   unsigned int rel2;
1698   struct alpha_vms_link_hash_entry *h;
1699
1700   PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
1701   PRIV (recrd.rec_size) -= ETIR__C_HEADER_SIZE;
1702
1703   ptr = PRIV (recrd.rec);
1704   length = PRIV (recrd.rec_size);
1705   maxptr = ptr + length;
1706
1707   vms_debug2 ((2, "ETIR: %d bytes\n", length));
1708
1709   while (ptr < maxptr)
1710     {
1711       int cmd = bfd_getl16 (ptr);
1712       int cmd_length = bfd_getl16 (ptr + 2);
1713
1714       ptr += 4;
1715
1716 #if VMS_DEBUG
1717       _bfd_vms_debug (4, "etir: %s(%d)\n",
1718                       _bfd_vms_etir_name (cmd), cmd);
1719       _bfd_hexdump (8, ptr, cmd_length - 4, 0);
1720 #endif
1721
1722       switch (cmd)
1723         {
1724           /* Stack global
1725              arg: cs    symbol name
1726
1727              stack 32 bit value of symbol (high bits set to 0).  */
1728         case ETIR__C_STA_GBL:
1729           _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1730           _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
1731           break;
1732
1733           /* Stack longword
1734              arg: lw    value
1735
1736              stack 32 bit value, sign extend to 64 bit.  */
1737         case ETIR__C_STA_LW:
1738           _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
1739           break;
1740
1741           /* Stack quadword
1742              arg: qw    value
1743
1744              stack 64 bit value of symbol.  */
1745         case ETIR__C_STA_QW:
1746           _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
1747           break;
1748
1749           /* Stack psect base plus quadword offset
1750              arg: lw    section index
1751              qw signed quadword offset (low 32 bits)
1752
1753              Stack qw argument and section index
1754              (see ETIR__C_STO_OFF, ETIR__C_CTL_SETRB).  */
1755         case ETIR__C_STA_PQ:
1756           {
1757             int psect;
1758
1759             psect = bfd_getl32 (ptr);
1760             if ((unsigned int) psect >= PRIV (section_count))
1761               {
1762                 (*_bfd_error_handler) (_("bad section index in %s"),
1763                                        _bfd_vms_etir_name (cmd));
1764                 bfd_set_error (bfd_error_bad_value);
1765                 return FALSE;
1766               }
1767             op1 = bfd_getl64 (ptr + 4);
1768             _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
1769           }
1770           break;
1771
1772         case ETIR__C_STA_LI:
1773         case ETIR__C_STA_MOD:
1774         case ETIR__C_STA_CKARG:
1775           (*_bfd_error_handler) (_("unsupported STA cmd %s"),
1776                                  _bfd_vms_etir_name (cmd));
1777           return FALSE;
1778           break;
1779
1780           /* Store byte: pop stack, write byte
1781              arg: -.  */
1782         case ETIR__C_STO_B:
1783           _bfd_vms_pop (abfd, &op1, &rel1);
1784           if (rel1 != RELC_NONE)
1785             goto bad_context;
1786           image_write_b (abfd, (unsigned int) op1 & 0xff);
1787           break;
1788
1789           /* Store word: pop stack, write word
1790              arg: -.  */
1791         case ETIR__C_STO_W:
1792           _bfd_vms_pop (abfd, &op1, &rel1);
1793           if (rel1 != RELC_NONE)
1794             goto bad_context;
1795           image_write_w (abfd, (unsigned int) op1 & 0xffff);
1796           break;
1797
1798           /* Store longword: pop stack, write longword
1799              arg: -.  */
1800         case ETIR__C_STO_LW:
1801           _bfd_vms_pop (abfd, &op1, &rel1);
1802           if (rel1 & RELC_SEC_BASE)
1803             {
1804               op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1805               rel1 = RELC_REL;
1806             }
1807           else if (rel1 & RELC_SHR_BASE)
1808             {
1809               alpha_vms_add_fixup_lr (info, rel1 & RELC_MASK, op1);
1810               rel1 = RELC_NONE;
1811             }
1812           if (rel1 != RELC_NONE)
1813             {
1814               if (rel1 != RELC_REL)
1815                 abort ();
1816               alpha_vms_add_lw_reloc (info);
1817             }
1818           image_write_l (abfd, op1);
1819           break;
1820
1821           /* Store quadword: pop stack, write quadword
1822              arg: -.  */
1823         case ETIR__C_STO_QW:
1824           _bfd_vms_pop (abfd, &op1, &rel1);
1825           if (rel1 & RELC_SEC_BASE)
1826             {
1827               op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1828               rel1 = RELC_REL;
1829             }
1830           else if (rel1 & RELC_SHR_BASE)
1831             abort ();
1832           if (rel1 != RELC_NONE)
1833             {
1834               if (rel1 != RELC_REL)
1835                 abort ();
1836               alpha_vms_add_qw_reloc (info);
1837             }
1838           image_write_q (abfd, op1);
1839           break;
1840
1841           /* Store immediate repeated: pop stack for repeat count
1842              arg: lw    byte count
1843              da data.  */
1844         case ETIR__C_STO_IMMR:
1845           {
1846             int size;
1847
1848             size = bfd_getl32 (ptr);
1849             _bfd_vms_pop (abfd, &op1, &rel1);
1850             if (rel1 != RELC_NONE)
1851               goto bad_context;
1852             while (op1-- > 0)
1853               image_write (abfd, ptr + 4, size);
1854           }
1855           break;
1856
1857           /* Store global: write symbol value
1858              arg: cs    global symbol name.  */
1859         case ETIR__C_STO_GBL:
1860           _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1861           if (h && h->sym)
1862             {
1863               if (h->sym->typ == EGSD__C_SYMG)
1864                 {
1865                   alpha_vms_add_fixup_qr
1866                     (info, abfd, h->sym->owner, h->sym->symbol_vector);
1867                   op1 = 0;
1868                 }
1869               else
1870                 {
1871                   op1 = alpha_vms_get_sym_value (h->sym->section,
1872                                                  h->sym->value);
1873                   alpha_vms_add_qw_reloc (info);
1874                 }
1875             }
1876           image_write_q (abfd, op1);
1877           break;
1878
1879           /* Store code address: write address of entry point
1880              arg: cs    global symbol name (procedure).  */
1881         case ETIR__C_STO_CA:
1882           _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1883           if (h && h->sym)
1884             {
1885               if (h->sym->flags & EGSY__V_NORM)
1886                 {
1887                   /* That's really a procedure.  */
1888                   if (h->sym->typ == EGSD__C_SYMG)
1889                     {
1890                       alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
1891                       op1 = h->sym->symbol_vector;
1892                     }
1893                   else
1894                     {
1895                       op1 = alpha_vms_get_sym_value (h->sym->code_section,
1896                                                      h->sym->code_value);
1897                       alpha_vms_add_qw_reloc (info);
1898                     }
1899                 }
1900               else
1901                 {
1902                   /* Symbol is not a procedure.  */
1903                   abort ();
1904                 }
1905             }
1906           image_write_q (abfd, op1);
1907           break;
1908
1909           /* Store offset to psect: pop stack, add low 32 bits to base of psect
1910              arg: none.  */
1911         case ETIR__C_STO_OFF:
1912           _bfd_vms_pop (abfd, &op1, &rel1);
1913
1914           if (!(rel1 & RELC_SEC_BASE))
1915             abort ();
1916
1917           op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1918           rel1 = RELC_REL;
1919           image_write_q (abfd, op1);
1920           break;
1921
1922           /* Store immediate
1923              arg: lw    count of bytes
1924              da data.  */
1925         case ETIR__C_STO_IMM:
1926           {
1927             int size;
1928
1929             size = bfd_getl32 (ptr);
1930             image_write (abfd, ptr + 4, size);
1931           }
1932           break;
1933
1934           /* This code is 'reserved to digital' according to the openVMS
1935              linker manual, however it is generated by the DEC C compiler
1936              and defined in the include file.
1937              FIXME, since the following is just a guess
1938              store global longword: store 32bit value of symbol
1939              arg: cs    symbol name.  */
1940         case ETIR__C_STO_GBL_LW:
1941           _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1942 #if 0
1943           abort ();
1944 #endif
1945           image_write_l (abfd, op1);
1946           break;
1947
1948         case ETIR__C_STO_RB:
1949         case ETIR__C_STO_AB:
1950         case ETIR__C_STO_LP_PSB:
1951           (*_bfd_error_handler) (_("%s: not supported"),
1952                                  _bfd_vms_etir_name (cmd));
1953           return FALSE;
1954           break;
1955         case ETIR__C_STO_HINT_GBL:
1956         case ETIR__C_STO_HINT_PS:
1957           (*_bfd_error_handler) (_("%s: not implemented"),
1958                                  _bfd_vms_etir_name (cmd));
1959           return FALSE;
1960           break;
1961
1962           /* 200 Store-conditional Linkage Pair
1963              arg: none.  */
1964         case ETIR__C_STC_LP:
1965
1966           /* 202 Store-conditional Address at global address
1967              lw linkage index
1968              cs global name.  */
1969
1970         case ETIR__C_STC_GBL:
1971
1972           /* 203 Store-conditional Code Address at global address
1973              lw linkage index
1974              cs procedure name.  */
1975         case ETIR__C_STC_GCA:
1976
1977           /* 204 Store-conditional Address at psect + offset
1978              lw linkage index
1979              lw psect index
1980              qw offset.  */
1981         case ETIR__C_STC_PS:
1982           (*_bfd_error_handler) (_("%s: not supported"),
1983                                  _bfd_vms_etir_name (cmd));
1984           return FALSE;
1985           break;
1986
1987           /* 201 Store-conditional Linkage Pair with Procedure Signature
1988              lw linkage index
1989              cs procedure name
1990              by signature length
1991              da signature.  */
1992
1993         case ETIR__C_STC_LP_PSB:
1994           _bfd_vms_get_value (abfd, ptr + 4, info, &op1, &h);
1995           if (h && h->sym)
1996             {
1997               if (h->sym->typ == EGSD__C_SYMG)
1998                 {
1999                   alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
2000                   op1 = h->sym->symbol_vector;
2001                   op2 = 0;
2002                 }
2003               else
2004                 {
2005                   op1 = alpha_vms_get_sym_value (h->sym->code_section,
2006                                                  h->sym->code_value);
2007                   op2 = alpha_vms_get_sym_value (h->sym->section,
2008                                                 h->sym->value);
2009                 }
2010             }
2011           else
2012             {
2013               /* Undefined symbol.  */
2014               op1 = 0;
2015               op2 = 0;
2016             }
2017           image_write_q (abfd, op1);
2018           image_write_q (abfd, op2);
2019           break;
2020
2021           /* 205 Store-conditional NOP at address of global
2022              arg: none.  */
2023         case ETIR__C_STC_NOP_GBL:
2024           /* ALPHA_R_NOP */
2025
2026           /* 207 Store-conditional BSR at global address
2027              arg: none.  */
2028
2029         case ETIR__C_STC_BSR_GBL:
2030           /* ALPHA_R_BSR */
2031
2032           /* 209 Store-conditional LDA at global address
2033              arg: none.  */
2034
2035         case ETIR__C_STC_LDA_GBL:
2036           /* ALPHA_R_LDA */
2037
2038           /* 211 Store-conditional BSR or Hint at global address
2039              arg: none.  */
2040
2041         case ETIR__C_STC_BOH_GBL:
2042           /* Currentl ignored.  */
2043           break;
2044
2045           /* 213 Store-conditional NOP,BSR or HINT at global address
2046              arg: none.  */
2047
2048         case ETIR__C_STC_NBH_GBL:
2049
2050           /* 206 Store-conditional NOP at pect + offset
2051              arg: none.  */
2052
2053         case ETIR__C_STC_NOP_PS:
2054
2055           /* 208 Store-conditional BSR at pect + offset
2056              arg: none.  */
2057
2058         case ETIR__C_STC_BSR_PS:
2059
2060           /* 210 Store-conditional LDA at psect + offset
2061              arg: none.  */
2062
2063         case ETIR__C_STC_LDA_PS:
2064
2065           /* 212 Store-conditional BSR or Hint at pect + offset
2066              arg: none.  */
2067
2068         case ETIR__C_STC_BOH_PS:
2069
2070           /* 214 Store-conditional NOP, BSR or HINT at psect + offset
2071              arg: none.  */
2072         case ETIR__C_STC_NBH_PS:
2073           (*_bfd_error_handler) ("%s: not supported",
2074                                  _bfd_vms_etir_name (cmd));
2075           return FALSE;
2076           break;
2077
2078           /* Det relocation base: pop stack, set image location counter
2079              arg: none.  */
2080         case ETIR__C_CTL_SETRB:
2081           _bfd_vms_pop (abfd, &op1, &rel1);
2082           if (!(rel1 & RELC_SEC_BASE))
2083             abort ();
2084           image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
2085           break;
2086
2087           /* Augment relocation base: increment image location counter by offset
2088              arg: lw    offset value.  */
2089         case ETIR__C_CTL_AUGRB:
2090           op1 = bfd_getl32 (ptr);
2091           image_inc_ptr (abfd, op1);
2092           break;
2093
2094           /* Define location: pop index, save location counter under index
2095              arg: none.  */
2096         case ETIR__C_CTL_DFLOC:
2097           _bfd_vms_pop (abfd, &op1, &rel1);
2098           if (rel1 != RELC_NONE)
2099             goto bad_context;
2100           dst_define_location (abfd, op1);
2101           break;
2102
2103           /* Set location: pop index, restore location counter from index
2104              arg: none.  */
2105         case ETIR__C_CTL_STLOC:
2106           _bfd_vms_pop (abfd, &op1, &rel1);
2107           if (rel1 != RELC_NONE)
2108             goto bad_context;
2109           dst_restore_location (abfd, op1);
2110           break;
2111
2112           /* Stack defined location: pop index, push location counter from index
2113              arg: none.  */
2114         case ETIR__C_CTL_STKDL:
2115           _bfd_vms_pop (abfd, &op1, &rel1);
2116           if (rel1 != RELC_NONE)
2117             goto bad_context;
2118           _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
2119           break;
2120
2121         case ETIR__C_OPR_NOP:      /* No-op.  */
2122           break;
2123
2124         case ETIR__C_OPR_ADD:      /* Add.  */
2125           _bfd_vms_pop (abfd, &op1, &rel1);
2126           _bfd_vms_pop (abfd, &op2, &rel2);
2127           if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2128             rel1 = rel2;
2129           else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2130             goto bad_context;
2131           _bfd_vms_push (abfd, op1 + op2, rel1);
2132           break;
2133
2134         case ETIR__C_OPR_SUB:      /* Subtract.  */
2135           _bfd_vms_pop (abfd, &op1, &rel1);
2136           _bfd_vms_pop (abfd, &op2, &rel2);
2137           if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2138             rel1 = rel2;
2139           else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
2140             {
2141               op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
2142               op2 = alpha_vms_fix_sec_rel (abfd, info, rel2, op2);
2143               rel1 = RELC_NONE;
2144             }
2145           else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2146             goto bad_context;
2147           _bfd_vms_push (abfd, op2 - op1, rel1);
2148           break;
2149
2150         case ETIR__C_OPR_MUL:      /* Multiply.  */
2151           _bfd_vms_pop (abfd, &op1, &rel1);
2152           _bfd_vms_pop (abfd, &op2, &rel2);
2153           if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2154             goto bad_context;
2155           _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
2156           break;
2157
2158         case ETIR__C_OPR_DIV:      /* Divide.  */
2159           _bfd_vms_pop (abfd, &op1, &rel1);
2160           _bfd_vms_pop (abfd, &op2, &rel2);
2161           if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2162             goto bad_context;
2163           if (op2 == 0)
2164             _bfd_vms_push (abfd, 0, RELC_NONE);
2165           else
2166             _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
2167           break;
2168
2169         case ETIR__C_OPR_AND:      /* Logical AND.  */
2170           _bfd_vms_pop (abfd, &op1, &rel1);
2171           _bfd_vms_pop (abfd, &op2, &rel2);
2172           if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2173             goto bad_context;
2174           _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
2175           break;
2176
2177         case ETIR__C_OPR_IOR:      /* Logical inclusive OR.  */
2178           _bfd_vms_pop (abfd, &op1, &rel1);
2179           _bfd_vms_pop (abfd, &op2, &rel2);
2180           if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2181             goto bad_context;
2182           _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
2183           break;
2184
2185         case ETIR__C_OPR_EOR:      /* Logical exclusive OR.  */
2186           _bfd_vms_pop (abfd, &op1, &rel1);
2187           _bfd_vms_pop (abfd, &op2, &rel2);
2188           if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2189             goto bad_context;
2190           _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
2191           break;
2192
2193         case ETIR__C_OPR_NEG:      /* Negate.  */
2194           _bfd_vms_pop (abfd, &op1, &rel1);
2195           if (rel1 != RELC_NONE)
2196             goto bad_context;
2197           _bfd_vms_push (abfd, -op1, RELC_NONE);
2198           break;
2199
2200         case ETIR__C_OPR_COM:      /* Complement.  */
2201           _bfd_vms_pop (abfd, &op1, &rel1);
2202           if (rel1 != RELC_NONE)
2203             goto bad_context;
2204           _bfd_vms_push (abfd, ~op1, RELC_NONE);
2205           break;
2206
2207         case ETIR__C_OPR_ASH:      /* Arithmetic shift.  */
2208           _bfd_vms_pop (abfd, &op1, &rel1);
2209           _bfd_vms_pop (abfd, &op2, &rel2);
2210           if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2211             {
2212             bad_context:
2213               (*_bfd_error_handler) (_("invalid use of %s with contexts"),
2214                                      _bfd_vms_etir_name (cmd));
2215               return FALSE;
2216             }
2217           if ((int)op2 < 0)             /* Shift right.  */
2218             op1 >>= -(int)op2;
2219           else                  /* Shift left.  */
2220             op1 <<= (int)op2;
2221           _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym.  */
2222           break;
2223
2224         case ETIR__C_OPR_INSV:      /* Insert field.   */
2225         case ETIR__C_OPR_USH:       /* Unsigned shift.   */
2226         case ETIR__C_OPR_ROT:       /* Rotate.  */
2227         case ETIR__C_OPR_REDEF:     /* Redefine symbol to current location.  */
2228         case ETIR__C_OPR_DFLIT:     /* Define a literal.  */
2229           (*_bfd_error_handler) (_("%s: not supported"),
2230                                  _bfd_vms_etir_name (cmd));
2231           return FALSE;
2232           break;
2233
2234         case ETIR__C_OPR_SEL:      /* Select.  */
2235           _bfd_vms_pop (abfd, &op1, &rel1);
2236           if (op1 & 0x01L)
2237             _bfd_vms_pop (abfd, &op1, &rel1);
2238           else
2239             {
2240               _bfd_vms_pop (abfd, &op1, &rel1);
2241               _bfd_vms_pop (abfd, &op2, &rel2);
2242               _bfd_vms_push (abfd, op1, rel1);
2243             }
2244           break;
2245
2246         default:
2247           (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
2248           return FALSE;
2249           break;
2250         }
2251
2252       ptr += cmd_length - 4;
2253     }
2254
2255   return TRUE;
2256 }
2257
2258 /* Process EDBG/ETBT record.
2259    Return TRUE on success, FALSE on error  */
2260
2261 static bfd_boolean
2262 vms_slurp_debug (bfd *abfd)
2263 {
2264   asection *section = PRIV (dst_section);
2265
2266   if (section == NULL)
2267     {
2268       /* We have no way to find out beforehand how much debug info there
2269          is in an object file, so pick an initial amount and grow it as
2270          needed later.  */
2271       flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC
2272         | SEC_IN_MEMORY;
2273
2274       section = bfd_make_section (abfd, "$DST$");
2275       if (!section)
2276         return FALSE;
2277       if (!bfd_set_section_flags (abfd, section, flags))
2278         return FALSE;
2279       PRIV (dst_section) = section;
2280     }
2281
2282   PRIV (image_section) = section;
2283   PRIV (image_offset) = section->size;
2284
2285   if (!_bfd_vms_slurp_etir (abfd, NULL))
2286     return FALSE;
2287
2288   section->size = PRIV (image_offset);
2289   return TRUE;
2290 }
2291
2292 /* Process EDBG record.
2293    Return TRUE on success, FALSE on error.  */
2294
2295 static bfd_boolean
2296 _bfd_vms_slurp_edbg (bfd *abfd)
2297 {
2298   vms_debug2 ((2, "EDBG\n"));
2299
2300   abfd->flags |= HAS_DEBUG | HAS_LINENO;
2301
2302   return vms_slurp_debug (abfd);
2303 }
2304
2305 /* Process ETBT record.
2306    Return TRUE on success, FALSE on error.  */
2307
2308 static bfd_boolean
2309 _bfd_vms_slurp_etbt (bfd *abfd)
2310 {
2311   vms_debug2 ((2, "ETBT\n"));
2312
2313   abfd->flags |= HAS_LINENO;
2314
2315   return vms_slurp_debug (abfd);
2316 }
2317
2318 /* Process EEOM record.
2319    Return TRUE on success, FALSE on error.  */
2320
2321 static bfd_boolean
2322 _bfd_vms_slurp_eeom (bfd *abfd)
2323 {
2324   struct vms_eeom *eeom = (struct vms_eeom *) PRIV (recrd.rec);
2325
2326   vms_debug2 ((2, "EEOM\n"));
2327
2328   PRIV (eom_data).eom_l_total_lps = bfd_getl32 (eeom->total_lps);
2329   PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
2330   if (PRIV (eom_data).eom_w_comcod > 1)
2331     {
2332       (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
2333       bfd_set_error (bfd_error_bad_value);
2334       return FALSE;
2335     }
2336
2337   PRIV (eom_data).eom_has_transfer = FALSE;
2338   if (PRIV (recrd.rec_size) > 10)
2339     {
2340       PRIV (eom_data).eom_has_transfer = TRUE;
2341       PRIV (eom_data).eom_b_tfrflg = eeom->tfrflg;
2342       PRIV (eom_data).eom_l_psindx = bfd_getl32 (eeom->psindx);
2343       PRIV (eom_data).eom_l_tfradr = bfd_getl32 (eeom->tfradr);
2344
2345       abfd->start_address = PRIV (eom_data).eom_l_tfradr;
2346     }
2347   return TRUE;
2348 }
2349
2350 /* Slurp an ordered set of VMS object records.  Return FALSE on error.  */
2351
2352 static bfd_boolean
2353 _bfd_vms_slurp_object_records (bfd * abfd)
2354 {
2355   bfd_boolean err;
2356   int type;
2357
2358   do
2359     {
2360       vms_debug2 ((7, "reading at %08lx\n", (unsigned long)bfd_tell (abfd)));
2361
2362       type = _bfd_vms_get_object_record (abfd);
2363       if (type < 0)
2364         {
2365           vms_debug2 ((2, "next_record failed\n"));
2366           return FALSE;
2367         }
2368
2369       switch (type)
2370         {
2371         case EOBJ__C_EMH:
2372           err = _bfd_vms_slurp_ehdr (abfd);
2373           break;
2374         case EOBJ__C_EEOM:
2375           err = _bfd_vms_slurp_eeom (abfd);
2376           break;
2377         case EOBJ__C_EGSD:
2378           err = _bfd_vms_slurp_egsd (abfd);
2379           break;
2380         case EOBJ__C_ETIR:
2381           err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
2382           break;
2383         case EOBJ__C_EDBG:
2384           err = _bfd_vms_slurp_edbg (abfd);
2385           break;
2386         case EOBJ__C_ETBT:
2387           err = _bfd_vms_slurp_etbt (abfd);
2388           break;
2389         default:
2390           err = FALSE;
2391         }
2392       if (err != TRUE)
2393         {
2394           vms_debug2 ((2, "slurp type %d failed\n", type));
2395           return FALSE;
2396         }
2397     }
2398   while (type != EOBJ__C_EEOM);
2399
2400   return TRUE;
2401 }
2402
2403 /* Initialize private data  */
2404 static bfd_boolean
2405 vms_initialize (bfd * abfd)
2406 {
2407   bfd_size_type amt;
2408
2409   amt = sizeof (struct vms_private_data_struct);
2410   abfd->tdata.any = bfd_zalloc (abfd, amt);
2411   if (abfd->tdata.any == NULL)
2412     return FALSE;
2413
2414   PRIV (recrd.file_format) = FF_UNKNOWN;
2415
2416   amt = sizeof (struct stack_struct) * STACKSIZE;
2417   PRIV (stack) = bfd_alloc (abfd, amt);
2418   if (PRIV (stack) == NULL)
2419     goto error_ret1;
2420
2421   return TRUE;
2422
2423  error_ret1:
2424   bfd_release (abfd, abfd->tdata.any);
2425   abfd->tdata.any = NULL;
2426   return FALSE;
2427 }
2428
2429 /* Check the format for a file being read.
2430    Return a (bfd_target *) if it's an object file or zero if not.  */
2431
2432 static const struct bfd_target *
2433 alpha_vms_object_p (bfd *abfd)
2434 {
2435   void *tdata_save = abfd->tdata.any;
2436   unsigned int test_len;
2437   unsigned char *buf;
2438
2439   vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
2440
2441   /* Allocate alpha-vms specific data.  */
2442   if (!vms_initialize (abfd))
2443     goto error_ret;
2444
2445   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
2446     goto err_wrong_format;
2447
2448   /* The first challenge with VMS is to discover the kind of the file.
2449
2450      Image files (executable or shared images) are stored as a raw
2451      stream of bytes (like on UNIX), but there is no magic number.
2452
2453      Object files are written with RMS (record management service), ie
2454      each records are preceeded by its length (on a word - 2 bytes), and
2455      padded for word-alignment.  That would be simple but when files
2456      are transfered to a UNIX filesystem (using ftp), records are lost.
2457      Only the raw content of the records are transfered.  Fortunately,
2458      the Alpha Object file format also store the length of the record
2459      in the records.  Is that clear ?  */
2460
2461   /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
2462      2 bytes size repeated) and 12 bytes for images (4 bytes major id,
2463      4 bytes minor id, 4 bytes length).  */
2464   test_len = 12;
2465
2466   /* Size the main buffer.  */
2467   buf = (unsigned char *) bfd_malloc (test_len);
2468   if (buf == NULL)
2469     goto error_ret;
2470   PRIV (recrd.buf) = buf;
2471   PRIV (recrd.buf_size) = test_len;
2472
2473   /* Initialize the record pointer.  */
2474   PRIV (recrd.rec) = buf;
2475
2476   if (bfd_bread (buf, test_len, abfd) != test_len)
2477     goto err_wrong_format;
2478
2479   /* Is it an image?  */
2480   if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
2481       && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
2482     {
2483       unsigned int to_read;
2484       unsigned int read_so_far;
2485       unsigned int remaining;
2486       unsigned int eisd_offset, eihs_offset;
2487
2488       /* Extract the header size.  */
2489       PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
2490
2491       /* The header size is 0 for DSF files.  */
2492       if (PRIV (recrd.rec_size) == 0)
2493         PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
2494
2495       if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
2496         {
2497           buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
2498
2499           if (buf == NULL)
2500             {
2501               PRIV (recrd.buf) = NULL;
2502               goto error_ret;
2503             }
2504           PRIV (recrd.buf) = buf;
2505           PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
2506         }
2507
2508       /* Read the remaining record.  */
2509       remaining = PRIV (recrd.rec_size) - test_len;
2510       to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
2511       read_so_far = test_len;
2512
2513       while (remaining > 0)
2514         {
2515           if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
2516             goto err_wrong_format;
2517
2518           read_so_far += to_read;
2519           remaining -= to_read;
2520
2521           to_read = MIN (VMS_BLOCK_SIZE, remaining);
2522         }
2523
2524       /* Reset the record pointer.  */
2525       PRIV (recrd.rec) = buf;
2526
2527       vms_debug2 ((2, "file type is image\n"));
2528
2529       if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
2530         goto err_wrong_format;
2531
2532       if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
2533         goto err_wrong_format;
2534
2535       /* EIHS is optional.  */
2536       if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
2537         goto err_wrong_format;
2538     }
2539   else
2540     {
2541       int type;
2542
2543       /* Assume it's a module and adjust record pointer if necessary.  */
2544       maybe_adjust_record_pointer_for_object (abfd);
2545
2546       /* But is it really a module?  */
2547       if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
2548           && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
2549         {
2550           if (vms_get_remaining_object_record (abfd, test_len) <= 0)
2551             goto err_wrong_format;
2552
2553           vms_debug2 ((2, "file type is module\n"));
2554
2555           type = bfd_getl16 (PRIV (recrd.rec));
2556           if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
2557             goto err_wrong_format;
2558
2559           if (_bfd_vms_slurp_object_records (abfd) != TRUE)
2560             goto err_wrong_format;
2561         }
2562       else
2563         goto err_wrong_format;
2564     }
2565
2566   /* Set arch_info to alpha.   */
2567
2568   if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
2569     goto err_wrong_format;
2570
2571   return abfd->xvec;
2572
2573  err_wrong_format:
2574   bfd_set_error (bfd_error_wrong_format);
2575
2576  error_ret:
2577   if (PRIV (recrd.buf))
2578     free (PRIV (recrd.buf));
2579   if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
2580     bfd_release (abfd, abfd->tdata.any);
2581   abfd->tdata.any = tdata_save;
2582   return NULL;
2583 }
2584 \f
2585 /* Image write.  */
2586
2587 /* Write an EMH/MHD record.  */
2588
2589 static void
2590 _bfd_vms_write_emh (bfd *abfd)
2591 {
2592   struct vms_rec_wr *recwr = &PRIV (recwr);
2593
2594   _bfd_vms_output_alignment (recwr, 2);
2595
2596   /* EMH.  */
2597   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2598   _bfd_vms_output_short (recwr, EMH__C_MHD);
2599   _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
2600   _bfd_vms_output_long (recwr, 0);
2601   _bfd_vms_output_long (recwr, 0);
2602   _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
2603
2604   /* Create module name from filename.  */
2605   if (bfd_get_filename (abfd) != 0)
2606     {
2607       char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2608       _bfd_vms_output_counted (recwr, module);
2609       free (module);
2610     }
2611   else
2612     _bfd_vms_output_counted (recwr, "NONAME");
2613
2614   _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
2615   _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
2616   _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
2617   _bfd_vms_output_end (abfd, recwr);
2618 }
2619
2620 /* Write an EMH/LMN record.  */
2621
2622 static void
2623 _bfd_vms_write_lmn (bfd *abfd, const char *name)
2624 {
2625   char version [64];
2626   struct vms_rec_wr *recwr = &PRIV (recwr);
2627   unsigned int ver = BFD_VERSION / 10000;
2628
2629   /* LMN.  */
2630   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2631   _bfd_vms_output_short (recwr, EMH__C_LNM);
2632   snprintf (version, sizeof (version), "%s %d.%d.%d", name,
2633             ver / 10000, (ver / 100) % 100, ver % 100);
2634   _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
2635   _bfd_vms_output_end (abfd, recwr);
2636 }
2637
2638
2639 /* Write eom record for bfd abfd.  Return FALSE on error.  */
2640
2641 static bfd_boolean
2642 _bfd_vms_write_eeom (bfd *abfd)
2643 {
2644   struct vms_rec_wr *recwr = &PRIV (recwr);
2645
2646   vms_debug2 ((2, "vms_write_eeom\n"));
2647
2648   _bfd_vms_output_alignment (recwr, 2);
2649
2650   _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
2651   _bfd_vms_output_long (recwr, PRIV (vms_linkage_index + 1) >> 1);
2652   _bfd_vms_output_byte (recwr, 0);      /* Completion code.  */
2653   _bfd_vms_output_byte (recwr, 0);      /* Fill byte.  */
2654
2655   if ((abfd->flags & EXEC_P) == 0
2656       && bfd_get_start_address (abfd) != (bfd_vma)-1)
2657     {
2658       asection *section;
2659
2660       section = bfd_get_section_by_name (abfd, ".link");
2661       if (section == 0)
2662         {
2663           bfd_set_error (bfd_error_nonrepresentable_section);
2664           return FALSE;
2665         }
2666       _bfd_vms_output_short (recwr, 0);
2667       _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
2668       _bfd_vms_output_long (recwr,
2669                              (unsigned long) bfd_get_start_address (abfd));
2670       _bfd_vms_output_long (recwr, 0);
2671     }
2672
2673   _bfd_vms_output_end (abfd, recwr);
2674   return TRUE;
2675 }
2676
2677 static void
2678 vector_grow1 (struct vector_type *vec, size_t elsz)
2679 {
2680   if (vec->nbr_el + 1 < vec->max_el)
2681     return;
2682
2683   if (vec->max_el == 0)
2684     {
2685       vec->max_el = 16;
2686       vec->els = bfd_malloc2 (vec->max_el, elsz);
2687     }
2688   else
2689     {
2690       vec->max_el *= 2;
2691       vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
2692     }
2693 }
2694
2695 /* Bump ABFD file position to next block.  */
2696
2697 static void
2698 alpha_vms_file_position_block (bfd *abfd)
2699 {
2700   /* Next block.  */
2701   PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
2702   PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
2703 }
2704
2705 /* Convert from internal structure SRC to external structure DST.  */
2706
2707 static void
2708 alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
2709                          struct vms_eisd *dst)
2710 {
2711   bfd_putl32 (src->u.eisd.majorid, dst->majorid);
2712   bfd_putl32 (src->u.eisd.minorid, dst->minorid);
2713   bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
2714   if (src->u.eisd.eisdsize <= EISD__K_LENEND)
2715     return;
2716   bfd_putl32 (src->u.eisd.secsize, dst->secsize);
2717   bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
2718   bfd_putl32 (src->u.eisd.flags, dst->flags);
2719   bfd_putl32 (src->u.eisd.vbn, dst->vbn);
2720   dst->pfc = src->u.eisd.pfc;
2721   dst->matchctl = src->u.eisd.matchctl;
2722   dst->type = src->u.eisd.type;
2723   dst->fill_1 = 0;
2724   if (src->u.eisd.flags & EISD__M_GBL)
2725     {
2726       bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
2727       memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
2728               src->u.gbl_eisd.gblnam[0] + 1);
2729     }
2730 }
2731
2732 /* Append EISD to the list of extra eisd for ABFD.  */
2733
2734 static void
2735 alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
2736 {
2737   eisd->next = NULL;
2738   if (PRIV (gbl_eisd_head) == NULL)
2739     PRIV (gbl_eisd_head) = eisd;
2740   else
2741     PRIV (gbl_eisd_tail)->next = eisd;
2742   PRIV (gbl_eisd_tail) = eisd;
2743 }
2744
2745 /* Create an EISD for shared image SHRIMG.
2746    Return FALSE in case of error.  */
2747
2748 static bfd_boolean
2749 alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
2750 {
2751   struct vms_internal_eisd_map *eisd;
2752   int namlen;
2753
2754   namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
2755   if (namlen + 5 > EISD__K_GBLNAMLEN)
2756     {
2757       /* Won't fit.  */
2758       return FALSE;
2759     }
2760
2761   eisd = bfd_alloc (abfd, sizeof (*eisd));
2762   if (eisd == NULL)
2763     return FALSE;
2764
2765   /* Fill the fields.  */
2766   eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
2767   eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
2768   eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
2769   eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE;     /* Must not be 0.  */
2770   eisd->u.gbl_eisd.common.virt_addr = 0;
2771   eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
2772   eisd->u.gbl_eisd.common.vbn = 0;
2773   eisd->u.gbl_eisd.common.pfc = 0;
2774   eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
2775   eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
2776
2777   eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
2778   eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
2779   memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
2780           namlen);
2781   memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
2782
2783   /* Append it to the list.  */
2784   alpha_vms_append_extra_eisd (abfd, eisd);
2785
2786   return TRUE;
2787 }
2788
2789 /* Create an EISD for section SEC.
2790    Return FALSE in case of failure.  */
2791
2792 static bfd_boolean
2793 alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
2794 {
2795   struct vms_internal_eisd_map *eisd;
2796
2797   /* Only for allocating section.  */
2798   if (!(sec->flags & SEC_ALLOC))
2799     return TRUE;
2800
2801   BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
2802   eisd = bfd_alloc (abfd, sizeof (*eisd));
2803   if (eisd == NULL)
2804     return FALSE;
2805   vms_section_data (sec)->eisd = eisd;
2806
2807   /* Fill the fields.  */
2808   eisd->u.eisd.majorid = EISD__K_MAJORID;
2809   eisd->u.eisd.minorid = EISD__K_MINORID;
2810   eisd->u.eisd.eisdsize = EISD__K_LEN;
2811   eisd->u.eisd.secsize =
2812     (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
2813   eisd->u.eisd.virt_addr = sec->vma;
2814   eisd->u.eisd.flags = 0;
2815   eisd->u.eisd.vbn = 0; /* To be later defined.  */
2816   eisd->u.eisd.pfc = 0; /* Default.  */
2817   eisd->u.eisd.matchctl = EISD__K_MATALL;
2818   eisd->u.eisd.type = EISD__K_NORMAL;
2819
2820   if (sec->flags & SEC_CODE)
2821     eisd->u.eisd.flags |= EISD__M_EXE;
2822   if (!(sec->flags & SEC_READONLY))
2823     eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2824
2825   /* If relocations or fixup will be applied, make this isect writeable.  */
2826   if (sec->flags & SEC_RELOC)
2827     eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2828
2829   if (!(sec->flags & SEC_HAS_CONTENTS))
2830     {
2831       eisd->u.eisd.flags |= EISD__M_DZRO;
2832       eisd->u.eisd.flags &= ~EISD__M_CRF;
2833     }
2834   if (sec->flags & SEC_LINKER_CREATED)
2835     {
2836       if (strcmp (sec->name, "$FIXUP$") == 0)
2837         eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
2838     }
2839
2840   /* Append it to the list.  */
2841   eisd->next = NULL;
2842   if (PRIV (eisd_head) == NULL)
2843     PRIV (eisd_head) = eisd;
2844   else
2845     PRIV (eisd_tail)->next = eisd;
2846   PRIV (eisd_tail) = eisd;
2847
2848   return TRUE;
2849 }
2850
2851 /* Layout executable ABFD and write it to the disk.
2852    Return FALSE in case of failure.  */
2853
2854 static bfd_boolean
2855 alpha_vms_write_exec (bfd *abfd)
2856 {
2857   struct vms_eihd eihd;
2858   struct vms_eiha *eiha;
2859   struct vms_eihi *eihi;
2860   struct vms_eihs *eihs = NULL;
2861   asection *sec;
2862   struct vms_internal_eisd_map *first_eisd;
2863   struct vms_internal_eisd_map *eisd;
2864   asection *dst;
2865   asection *dmt;
2866   file_ptr gst_filepos = 0;
2867   unsigned int lnkflags = 0;
2868
2869   /* Build the EIHD.  */
2870   PRIV (file_pos) = EIHD__C_LENGTH;
2871
2872   memset (&eihd, 0, sizeof (eihd));
2873   memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
2874
2875   bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
2876   bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
2877
2878   bfd_putl32 (sizeof (eihd), eihd.size);
2879   bfd_putl32 (0, eihd.isdoff);
2880   bfd_putl32 (0, eihd.activoff);
2881   bfd_putl32 (0, eihd.symdbgoff);
2882   bfd_putl32 (0, eihd.imgidoff);
2883   bfd_putl32 (0, eihd.patchoff);
2884   bfd_putl64 (0, eihd.iafva);
2885   bfd_putl32 (0, eihd.version_array_off);
2886
2887   bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
2888   bfd_putl32 (0, eihd.subtype);
2889
2890   bfd_putl32 (0, eihd.imgiocnt);
2891   bfd_putl32 (-1, eihd.privreqs);
2892   bfd_putl32 (-1, eihd.privreqs + 4);
2893
2894   bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
2895               eihd.hdrblkcnt);
2896   bfd_putl32 (0, eihd.ident);
2897   bfd_putl32 (0, eihd.sysver);
2898
2899   eihd.matchctl = 0;
2900   bfd_putl32 (0, eihd.symvect_size);
2901   bfd_putl32 (16, eihd.virt_mem_block_size);
2902   bfd_putl32 (0, eihd.ext_fixup_off);
2903   bfd_putl32 (0, eihd.noopt_psect_off);
2904   bfd_putl32 (-1, eihd.alias);
2905
2906   /* Alloc EIHA.  */
2907   eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
2908   bfd_putl32 (PRIV (file_pos), eihd.activoff);
2909   PRIV (file_pos) += sizeof (struct vms_eiha);
2910
2911   bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
2912   bfd_putl32 (0, eiha->spare);
2913   bfd_putl64 (PRIV (transfer_address[0]), eiha->tfradr1);
2914   bfd_putl64 (PRIV (transfer_address[1]), eiha->tfradr2);
2915   bfd_putl64 (PRIV (transfer_address[2]), eiha->tfradr3);
2916   bfd_putl64 (PRIV (transfer_address[3]), eiha->tfradr4);
2917   bfd_putl64 (0, eiha->inishr);
2918
2919   /* Alloc EIHI.  */
2920   eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
2921   bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
2922   PRIV (file_pos) += sizeof (struct vms_eihi);
2923
2924   bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
2925   bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
2926   {
2927     char *module;
2928     unsigned int len;
2929
2930     /* Set module name.  */
2931     module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2932     len = strlen (module);
2933     if (len > sizeof (eihi->imgnam) - 1)
2934       len = sizeof (eihi->imgnam) - 1;
2935     eihi->imgnam[0] = len;
2936     memcpy (eihi->imgnam + 1, module, len);
2937     free (module);
2938   }
2939   {
2940     unsigned int lo;
2941     unsigned int hi;
2942
2943     /* Set time.  */
2944     vms_get_time (&hi, &lo);
2945     bfd_putl32 (lo, eihi->linktime + 0);
2946     bfd_putl32 (hi, eihi->linktime + 4);
2947   }
2948   eihi->imgid[0] = 0;
2949   eihi->linkid[0] = 0;
2950   eihi->imgbid[0] = 0;
2951
2952   /* Alloc EIHS.  */
2953   dst = PRIV (dst_section);
2954   dmt = bfd_get_section_by_name (abfd, "$DMT$");
2955   if (dst != NULL && dst->size != 0)
2956     {
2957       eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
2958       bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
2959       PRIV (file_pos) += sizeof (struct vms_eihs);
2960
2961       bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
2962       bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
2963       bfd_putl32 (0, eihs->dstvbn);
2964       bfd_putl32 (0, eihs->dstsize);
2965       bfd_putl32 (0, eihs->gstvbn);
2966       bfd_putl32 (0, eihs->gstsize);
2967       bfd_putl32 (0, eihs->dmtvbn);
2968       bfd_putl32 (0, eihs->dmtsize);
2969     }
2970
2971   /* One EISD per section.  */
2972   for (sec = abfd->sections; sec; sec = sec->next)
2973     {
2974       if (!alpha_vms_create_eisd_for_section (abfd, sec))
2975         return FALSE;
2976     }
2977
2978   /* Merge section EIDS which extra ones.  */
2979   if (PRIV (eisd_tail))
2980     PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
2981   else
2982     PRIV (eisd_head) = PRIV (gbl_eisd_head);
2983   if (PRIV (gbl_eisd_tail))
2984     PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
2985
2986   first_eisd = PRIV (eisd_head);
2987
2988   /* Add end of eisd.  */
2989   if (first_eisd)
2990     {
2991       eisd = bfd_zalloc (abfd, sizeof (*eisd));
2992       if (eisd == NULL)
2993         return FALSE;
2994       eisd->u.eisd.majorid = 0;
2995       eisd->u.eisd.minorid = 0;
2996       eisd->u.eisd.eisdsize = 0;
2997       alpha_vms_append_extra_eisd (abfd, eisd);
2998     }
2999
3000   /* Place EISD in the file.  */
3001   for (eisd = first_eisd; eisd; eisd = eisd->next)
3002     {
3003       file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
3004
3005       /* First block is a little bit special: there is a word at the end.  */
3006       if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
3007         room -= 2;
3008       if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
3009         alpha_vms_file_position_block (abfd);
3010
3011       eisd->file_pos = PRIV (file_pos);
3012       PRIV (file_pos) += eisd->u.eisd.eisdsize;
3013
3014       if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
3015         bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
3016     }
3017
3018   if (first_eisd != NULL)
3019     {
3020       bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
3021       /* Real size of end of eisd marker.  */
3022       PRIV (file_pos) += EISD__K_LENEND;
3023     }
3024
3025   bfd_putl32 (PRIV (file_pos), eihd.size);
3026   bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
3027               eihd.hdrblkcnt);
3028
3029   /* Place sections.  */
3030   for (sec = abfd->sections; sec; sec = sec->next)
3031     {
3032       if (!(sec->flags & SEC_HAS_CONTENTS))
3033         continue;
3034
3035       eisd = vms_section_data (sec)->eisd;
3036
3037       /* Align on a block.  */
3038       alpha_vms_file_position_block (abfd);
3039       sec->filepos = PRIV (file_pos);
3040
3041       if (eisd != NULL)
3042         eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
3043
3044       PRIV (file_pos) += sec->size;
3045     }
3046
3047   /* Update EIHS.  */
3048   if (eihs != NULL && dst != NULL)
3049     {
3050       bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
3051       bfd_putl32 (dst->size, eihs->dstsize);
3052
3053       if (dmt != NULL)
3054         {
3055           lnkflags |= EIHD__M_DBGDMT;
3056           bfd_putl32 ((dmt->filepos / VMS_BLOCK_SIZE) + 1, eihs->dmtvbn);
3057           bfd_putl32 (dmt->size, eihs->dmtsize);
3058         }
3059       if (PRIV (gsd_sym_count) != 0)
3060         {
3061           alpha_vms_file_position_block (abfd);
3062           gst_filepos = PRIV (file_pos);
3063           bfd_putl32 ((gst_filepos / VMS_BLOCK_SIZE) + 1, eihs->gstvbn);
3064           bfd_putl32 ((PRIV (gsd_sym_count) + 4) / 5 + 4, eihs->gstsize);
3065         }
3066     }
3067
3068   /* Write EISD in hdr.  */
3069   for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
3070        eisd = eisd->next)
3071     alpha_vms_swap_eisd_out
3072       (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
3073
3074   /* Write first block.  */
3075   bfd_putl32 (lnkflags, eihd.lnkflags);
3076   if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
3077     return FALSE;
3078
3079   /* Write remaining eisd.  */
3080   if (eisd != NULL)
3081     {
3082       unsigned char blk[VMS_BLOCK_SIZE];
3083       struct vms_internal_eisd_map *next_eisd;
3084
3085       memset (blk, 0xff, sizeof (blk));
3086       while (eisd != NULL)
3087         {
3088           alpha_vms_swap_eisd_out
3089             (eisd,
3090              (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
3091
3092           next_eisd = eisd->next;
3093           if (next_eisd == NULL
3094               || (next_eisd->file_pos / VMS_BLOCK_SIZE
3095                   != eisd->file_pos / VMS_BLOCK_SIZE))
3096             {
3097               if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
3098                 return FALSE;
3099
3100               memset (blk, 0xff, sizeof (blk));
3101             }
3102           eisd = next_eisd;
3103         }
3104     }
3105
3106   /* Write sections.  */
3107   for (sec = abfd->sections; sec; sec = sec->next)
3108     {
3109       unsigned char blk[VMS_BLOCK_SIZE];
3110       bfd_size_type len;
3111
3112       if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
3113         continue;
3114       if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
3115         return FALSE;
3116
3117       /* Pad.  */
3118       len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
3119       if (len != VMS_BLOCK_SIZE)
3120         {
3121           memset (blk, 0, len);
3122           if (bfd_bwrite (blk, len, abfd) != len)
3123             return FALSE;
3124         }
3125     }
3126
3127   /* Write GST.  */
3128   if (gst_filepos != 0)
3129     {
3130       struct vms_rec_wr *recwr = &PRIV (recwr);
3131       unsigned int i;
3132
3133       _bfd_vms_write_emh (abfd);
3134       _bfd_vms_write_lmn (abfd, "GNU LD");
3135
3136       /* PSC for the absolute section.  */
3137       _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3138       _bfd_vms_output_long (recwr, 0);
3139       _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3140       _bfd_vms_output_short (recwr, 0);
3141       _bfd_vms_output_short (recwr, EGPS__V_PIC | EGPS__V_LIB | EGPS__V_RD);
3142       _bfd_vms_output_long (recwr, 0);
3143       _bfd_vms_output_counted (recwr, ".$$ABS$$.");
3144       _bfd_vms_output_end_subrec (recwr);
3145       _bfd_vms_output_end (abfd, recwr);
3146
3147       for (i = 0; i < PRIV (gsd_sym_count); i++)
3148         {
3149           struct vms_symbol_entry *sym = PRIV (syms)[i];
3150           bfd_vma val;
3151           bfd_vma ep;
3152
3153           if ((i % 5) == 0)
3154             {
3155               _bfd_vms_output_alignment (recwr, 8);
3156               _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3157               _bfd_vms_output_long (recwr, 0);
3158             }
3159           _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYMG);
3160           _bfd_vms_output_short (recwr, 0); /* Data type, alignment.  */
3161           _bfd_vms_output_short (recwr, sym->flags);
3162
3163           if (sym->code_section)
3164             ep = alpha_vms_get_sym_value (sym->code_section, sym->code_value);
3165           else
3166             {
3167               BFD_ASSERT (sym->code_value == 0);
3168               ep = 0;
3169             }
3170           val = alpha_vms_get_sym_value (sym->section, sym->value);
3171           _bfd_vms_output_quad
3172             (recwr, sym->typ == EGSD__C_SYMG ? sym->symbol_vector : val);
3173           _bfd_vms_output_quad (recwr, ep);
3174           _bfd_vms_output_quad (recwr, val);
3175           _bfd_vms_output_long (recwr, 0);
3176           _bfd_vms_output_counted (recwr, sym->name);
3177           _bfd_vms_output_end_subrec (recwr);
3178           if ((i % 5) == 4)
3179             _bfd_vms_output_end (abfd, recwr);
3180         }
3181       if ((i % 5) != 0)
3182         _bfd_vms_output_end (abfd, recwr);
3183
3184       if (!_bfd_vms_write_eeom (abfd))
3185         return FALSE;
3186     }
3187   return TRUE;
3188 }
3189 \f
3190 /* Object write.  */
3191
3192 /* Write section and symbol directory of bfd abfd.  Return FALSE on error.  */
3193
3194 static bfd_boolean
3195 _bfd_vms_write_egsd (bfd *abfd)
3196 {
3197   asection *section;
3198   asymbol *symbol;
3199   unsigned int symnum;
3200   const char *sname;
3201   flagword new_flags, old_flags;
3202   int abs_section_index = -1;
3203   unsigned int target_index = 0;
3204   struct vms_rec_wr *recwr = &PRIV (recwr);
3205
3206   vms_debug2 ((2, "vms_write_egsd\n"));
3207
3208   /* Egsd is quadword aligned.  */
3209   _bfd_vms_output_alignment (recwr, 8);
3210
3211   _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3212   _bfd_vms_output_long (recwr, 0);
3213
3214   /* Number sections.  */
3215   for (section = abfd->sections; section != NULL; section = section->next)
3216     {
3217       if (section->flags & SEC_DEBUGGING)
3218         continue;
3219       if (!strcmp (section->name, ".vmsdebug"))
3220         {
3221           section->flags |= SEC_DEBUGGING;
3222           continue;
3223         }
3224       section->target_index = target_index++;
3225     }
3226
3227   for (section = abfd->sections; section != NULL; section = section->next)
3228     {
3229       vms_debug2 ((3, "Section #%d %s, %d bytes\n",
3230                    section->target_index, section->name, (int)section->size));
3231
3232       /* Don't write out the VMS debug info section since it is in the
3233          ETBT and EDBG sections in etir. */
3234       if (section->flags & SEC_DEBUGGING)
3235         continue;
3236
3237       /* 13 bytes egsd, max 31 chars name -> should be 44 bytes.  */
3238       if (_bfd_vms_output_check (recwr, 64) < 0)
3239         {
3240           _bfd_vms_output_end (abfd, recwr);
3241           _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3242           _bfd_vms_output_long (recwr, 0);
3243         }
3244
3245       /* Don't know if this is necessary for the linker but for now it keeps
3246          vms_slurp_gsd happy.  */
3247       sname = section->name;
3248       if (*sname == '.')
3249         {
3250           /* Remove leading dot.  */
3251           sname++;
3252           if ((*sname == 't') && (strcmp (sname, "text") == 0))
3253             sname = EVAX_CODE_NAME;
3254           else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
3255             sname = EVAX_DATA_NAME;
3256           else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
3257             sname = EVAX_BSS_NAME;
3258           else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
3259             sname = EVAX_LINK_NAME;
3260           else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
3261             sname = EVAX_READONLY_NAME;
3262           else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
3263             sname = EVAX_LITERAL_NAME;
3264           else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
3265             sname = EVAX_LITERALS_NAME;
3266           else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
3267             sname = EVAX_COMMON_NAME;
3268           else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
3269             sname = EVAX_LOCAL_NAME;
3270         }
3271
3272       if (bfd_is_com_section (section))
3273         new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
3274                      | EGPS__V_WRT | EGPS__V_NOMOD | EGPS__V_COM);
3275       else
3276         new_flags = vms_esecflag_by_name (evax_section_flags, sname,
3277                                           section->size > 0);
3278
3279       /* Modify them as directed.  */
3280       if (section->flags & SEC_READONLY)
3281         new_flags &= ~EGPS__V_WRT;
3282
3283       new_flags &= ~vms_section_data (section)->no_flags;
3284       new_flags |= vms_section_data (section)->flags;
3285
3286       vms_debug2 ((3, "sec flags %x\n", section->flags));
3287       vms_debug2 ((3, "new_flags %x, _raw_size %lu\n",
3288                    new_flags, (unsigned long)section->size));
3289
3290       _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3291       _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
3292       _bfd_vms_output_short (recwr, new_flags);
3293       _bfd_vms_output_long (recwr, (unsigned long) section->size);
3294       _bfd_vms_output_counted (recwr, sname);
3295       _bfd_vms_output_end_subrec (recwr);
3296
3297       /* If the section is an obsolute one, remind its index as it will be
3298          used later for absolute symbols.  */
3299       if ((new_flags & EGPS__V_REL) == 0 && abs_section_index < 0)
3300         abs_section_index = section->target_index;
3301     }
3302
3303   /* Output symbols.  */
3304   vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
3305
3306   bfd_set_start_address (abfd, (bfd_vma) -1);
3307
3308   for (symnum = 0; symnum < abfd->symcount; symnum++)
3309     {
3310       symbol = abfd->outsymbols[symnum];
3311       old_flags = symbol->flags;
3312
3313       /* Work-around a missing feature:  consider __main as the main entry
3314          point.  */
3315       if (symbol->name[0] == '_' && strcmp (symbol->name, "__main") == 0)
3316         bfd_set_start_address (abfd, (bfd_vma)symbol->value);
3317
3318       /* Only put in the GSD the global and the undefined symbols.  */
3319       if (old_flags & BSF_FILE)
3320         continue;
3321
3322       if ((old_flags & BSF_GLOBAL) == 0 && !bfd_is_und_section (symbol->section))
3323         {
3324           /* If the LIB$INITIIALIZE section is present, add a reference to
3325              LIB$INITIALIZE symbol.  FIXME: this should be done explicitely
3326              in the assembly file.  */
3327           if (!((old_flags & BSF_SECTION_SYM) != 0
3328                 && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
3329             continue;
3330         }
3331
3332       /* 13 bytes egsd, max 64 chars name -> should be 77 bytes.  Add 16 more
3333          bytes for a possible ABS section.  */
3334       if (_bfd_vms_output_check (recwr, 80 + 16) < 0)
3335         {
3336           _bfd_vms_output_end (abfd, recwr);
3337           _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3338           _bfd_vms_output_long (recwr, 0);
3339         }
3340
3341       if ((old_flags & BSF_GLOBAL) != 0
3342           && bfd_is_abs_section (symbol->section)
3343           && abs_section_index <= 0)
3344         {
3345           /* Create an absolute section if none was defined.  It is highly
3346              unlikely that the name $ABS$ clashes with a user defined
3347              non-absolute section name.  */
3348           _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3349           _bfd_vms_output_short (recwr, 4);
3350           _bfd_vms_output_short (recwr, EGPS__V_SHR);
3351           _bfd_vms_output_long (recwr, 0);
3352           _bfd_vms_output_counted (recwr, "$ABS$");
3353           _bfd_vms_output_end_subrec (recwr);
3354
3355           abs_section_index = target_index++;
3356         }
3357
3358       _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
3359
3360       /* Data type, alignment.  */
3361       _bfd_vms_output_short (recwr, 0);
3362
3363       new_flags = 0;
3364
3365       if (old_flags & BSF_WEAK)
3366         new_flags |= EGSY__V_WEAK;
3367       if (bfd_is_com_section (symbol->section))         /* .comm  */
3368         new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
3369
3370       if (old_flags & BSF_FUNCTION)
3371         {
3372           new_flags |= EGSY__V_NORM;
3373           new_flags |= EGSY__V_REL;
3374         }
3375       if (old_flags & BSF_GLOBAL)
3376         {
3377           new_flags |= EGSY__V_DEF;
3378           if (!bfd_is_abs_section (symbol->section))
3379             new_flags |= EGSY__V_REL;
3380         }
3381       _bfd_vms_output_short (recwr, new_flags);
3382
3383       if (old_flags & BSF_GLOBAL)
3384         {
3385           /* Symbol definition.  */
3386           bfd_vma code_address = 0;
3387           unsigned long ca_psindx = 0;
3388           unsigned long psindx;
3389
3390           if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
3391             {
3392               asymbol *sym;
3393
3394               sym =
3395                 ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
3396               code_address = sym->value;
3397               ca_psindx = sym->section->target_index;
3398             }
3399           if (bfd_is_abs_section (symbol->section))
3400             psindx = abs_section_index;
3401           else
3402             psindx = symbol->section->target_index;
3403
3404           _bfd_vms_output_quad (recwr, symbol->value);
3405           _bfd_vms_output_quad (recwr, code_address);
3406           _bfd_vms_output_long (recwr, ca_psindx);
3407           _bfd_vms_output_long (recwr, psindx);
3408         }
3409       _bfd_vms_output_counted (recwr, symbol->name);
3410
3411       _bfd_vms_output_end_subrec (recwr);
3412     }
3413
3414   _bfd_vms_output_alignment (recwr, 8);
3415   _bfd_vms_output_end (abfd, recwr);
3416
3417   return TRUE;
3418 }
3419
3420 /* Write object header for bfd abfd.  Return FALSE on error.  */
3421
3422 static bfd_boolean
3423 _bfd_vms_write_ehdr (bfd *abfd)
3424 {
3425   asymbol *symbol;
3426   unsigned int symnum;
3427   struct vms_rec_wr *recwr = &PRIV (recwr);
3428
3429   vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
3430
3431   _bfd_vms_output_alignment (recwr, 2);
3432
3433   _bfd_vms_write_emh (abfd);
3434   _bfd_vms_write_lmn (abfd, "GNU AS");
3435
3436   /* SRC.  */
3437   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3438   _bfd_vms_output_short (recwr, EMH__C_SRC);
3439
3440   for (symnum = 0; symnum < abfd->symcount; symnum++)
3441     {
3442       symbol = abfd->outsymbols[symnum];
3443
3444       if (symbol->flags & BSF_FILE)
3445         {
3446           _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
3447                                 (int) strlen (symbol->name));
3448           break;
3449         }
3450     }
3451
3452   if (symnum == abfd->symcount)
3453     _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
3454
3455   _bfd_vms_output_end (abfd, recwr);
3456
3457   /* TTL.  */
3458   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3459   _bfd_vms_output_short (recwr, EMH__C_TTL);
3460   _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
3461   _bfd_vms_output_end (abfd, recwr);
3462
3463   /* CPR.  */
3464   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3465   _bfd_vms_output_short (recwr, EMH__C_CPR);
3466   _bfd_vms_output_dump (recwr,
3467                         (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
3468                          39);
3469   _bfd_vms_output_end (abfd, recwr);
3470
3471   return TRUE;
3472 }
3473
3474 /* Part 4.6, relocations.  */
3475
3476 \f
3477 /* WRITE ETIR SECTION
3478
3479    This is still under construction and therefore not documented.  */
3480
3481 /* Close the etir/etbt record.  */
3482
3483 static void
3484 end_etir_record (bfd * abfd)
3485 {
3486   struct vms_rec_wr *recwr = &PRIV (recwr);
3487
3488   _bfd_vms_output_end (abfd, recwr);
3489 }
3490
3491 static void
3492 start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
3493 {
3494   struct vms_rec_wr *recwr = &PRIV (recwr);
3495
3496   if (section->flags & SEC_DEBUGGING)
3497     {
3498       _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
3499
3500       if (offset == 0)
3501         {
3502           /* Push start offset.  */
3503           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3504           _bfd_vms_output_long (recwr, (unsigned long) 0);
3505           _bfd_vms_output_end_subrec (recwr);
3506
3507           /* Set location.  */
3508           _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
3509           _bfd_vms_output_end_subrec (recwr);
3510         }
3511     }
3512   else
3513     {
3514       _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
3515
3516       if (offset == 0)
3517         {
3518           /* Push start offset.  */
3519           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3520           _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
3521           _bfd_vms_output_quad (recwr, offset);
3522           _bfd_vms_output_end_subrec (recwr);
3523
3524           /* Start = pop ().  */
3525           _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
3526           _bfd_vms_output_end_subrec (recwr);
3527         }
3528     }
3529 }
3530
3531 /* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
3532    address VADDR in section specified by SEC_INDEX and NAME.  */
3533
3534 static void
3535 sto_imm (bfd *abfd, asection *section,
3536          bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
3537 {
3538   bfd_size_type size;
3539   struct vms_rec_wr *recwr = &PRIV (recwr);
3540
3541 #if VMS_DEBUG
3542   _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
3543   _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
3544 #endif
3545
3546   while (ssize > 0)
3547     {
3548       /* Try all the rest.  */
3549       size = ssize;
3550
3551       if (_bfd_vms_output_check (recwr, size) < 0)
3552         {
3553           /* Doesn't fit, split !  */
3554           end_etir_record (abfd);
3555
3556           start_etir_or_etbt_record (abfd, section, vaddr);
3557
3558           size = _bfd_vms_output_check (recwr, 0);      /* get max size */
3559           if (size > ssize)                     /* more than what's left ? */
3560             size = ssize;
3561         }
3562
3563       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
3564       _bfd_vms_output_long (recwr, (unsigned long) (size));
3565       _bfd_vms_output_dump (recwr, cptr, size);
3566       _bfd_vms_output_end_subrec (recwr);
3567
3568 #if VMS_DEBUG
3569       _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
3570       _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
3571 #endif
3572
3573       vaddr += size;
3574       cptr += size;
3575       ssize -= size;
3576     }
3577 }
3578
3579 static void
3580 etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
3581 {
3582   if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
3583     {
3584       /* Not enough room in this record.  Close it and open a new one.  */
3585       end_etir_record (abfd);
3586       start_etir_or_etbt_record (abfd, section, vaddr);
3587     }
3588 }
3589
3590 /* Return whether RELOC must be deferred till the end.  */
3591
3592 static bfd_boolean
3593 defer_reloc_p (arelent *reloc)
3594 {
3595   switch (reloc->howto->type)
3596     {
3597     case ALPHA_R_NOP:
3598     case ALPHA_R_LDA:
3599     case ALPHA_R_BSR:
3600     case ALPHA_R_BOH:
3601       return TRUE;
3602
3603     default:
3604       return FALSE;
3605     }
3606 }
3607
3608 /* Write section contents for bfd abfd.  Return FALSE on error.  */
3609
3610 static bfd_boolean
3611 _bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
3612 {
3613   asection *section;
3614   struct vms_rec_wr *recwr = &PRIV (recwr);
3615
3616   vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
3617
3618   _bfd_vms_output_alignment (recwr, 4);
3619
3620   PRIV (vms_linkage_index) = 0;
3621
3622   for (section = abfd->sections; section; section = section->next)
3623     {
3624       vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
3625                    section->target_index, section->name, (int) (section->size)));
3626
3627       if (!(section->flags & SEC_HAS_CONTENTS)
3628           || bfd_is_com_section (section))
3629         continue;
3630
3631       if (!section->contents)
3632         {
3633           bfd_set_error (bfd_error_no_contents);
3634           return FALSE;
3635         }
3636
3637       start_etir_or_etbt_record (abfd, section, 0);
3638
3639       if (section->flags & SEC_RELOC)
3640         {
3641           bfd_vma curr_addr = 0;
3642           unsigned char *curr_data = section->contents;
3643           bfd_size_type size;
3644           int pass2_needed = 0;
3645           int pass2_in_progress = 0;
3646           unsigned int irel;
3647
3648           if (section->reloc_count == 0)
3649             (*_bfd_error_handler)
3650               (_("SEC_RELOC with no relocs in section %s"), section->name);
3651
3652 #if VMS_DEBUG
3653           else
3654             {
3655               int i = section->reloc_count;
3656               arelent **rptr = section->orelocation;
3657               _bfd_vms_debug (4, "%d relocations:\n", i);
3658               while (i-- > 0)
3659                 {
3660                   _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
3661                                      "addr %08lx, off %08lx, len %d: %s\n",
3662                                   (*(*rptr)->sym_ptr_ptr)->name,
3663                                   (*(*rptr)->sym_ptr_ptr)->section->name,
3664                                   (long) (*(*rptr)->sym_ptr_ptr)->value,
3665                                   (unsigned long)(*rptr)->address,
3666                                   (unsigned long)(*rptr)->addend,
3667                                   bfd_get_reloc_size ((*rptr)->howto),
3668                                   ( *rptr)->howto->name);
3669                   rptr++;
3670                 }
3671             }
3672 #endif
3673
3674         new_pass:
3675           for (irel = 0; irel < section->reloc_count; irel++)
3676             {
3677               struct evax_private_udata_struct *udata;
3678               arelent *rptr = section->orelocation [irel];
3679               bfd_vma addr = rptr->address;
3680               asymbol *sym = *rptr->sym_ptr_ptr;
3681               asection *sec = sym->section;
3682               bfd_boolean defer = defer_reloc_p (rptr);
3683               unsigned int slen;
3684
3685               if (pass2_in_progress)
3686                 {
3687                   /* Non-deferred relocs have already been output.  */
3688                   if (!defer)
3689                     continue;
3690                 }
3691               else
3692                 {
3693                   /* Deferred relocs must be output at the very end.  */
3694                   if (defer)
3695                     {
3696                       pass2_needed = 1;
3697                       continue;
3698                     }
3699
3700                   /* Regular relocs are intertwined with binary data.  */
3701                   if (curr_addr > addr)
3702                     (*_bfd_error_handler) (_("Size error in section %s"),
3703                                            section->name);
3704                   size = addr - curr_addr;
3705                   sto_imm (abfd, section, size, curr_data, curr_addr);
3706                   curr_data += size;
3707                   curr_addr += size;
3708                 }
3709
3710               size = bfd_get_reloc_size (rptr->howto);
3711
3712               switch (rptr->howto->type)
3713                 {
3714                 case ALPHA_R_IGNORE:
3715                   break;
3716
3717                 case ALPHA_R_REFLONG:
3718                   if (bfd_is_und_section (sym->section))
3719                     {
3720                       bfd_vma addend = rptr->addend;
3721                       slen = strlen ((char *) sym->name);
3722                       etir_output_check (abfd, section, curr_addr, slen);
3723                       if (addend)
3724                         {
3725                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3726                           _bfd_vms_output_counted (recwr, sym->name);
3727                           _bfd_vms_output_end_subrec (recwr);
3728                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3729                           _bfd_vms_output_long (recwr, (unsigned long) addend);
3730                           _bfd_vms_output_end_subrec (recwr);
3731                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3732                           _bfd_vms_output_end_subrec (recwr);
3733                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3734                           _bfd_vms_output_end_subrec (recwr);
3735                         }
3736                       else
3737                         {
3738                           _bfd_vms_output_begin_subrec
3739                             (recwr, ETIR__C_STO_GBL_LW);
3740                           _bfd_vms_output_counted (recwr, sym->name);
3741                           _bfd_vms_output_end_subrec (recwr);
3742                         }
3743                     }
3744                   else if (bfd_is_abs_section (sym->section))
3745                     {
3746                       etir_output_check (abfd, section, curr_addr, 16);
3747                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3748                       _bfd_vms_output_long (recwr, (unsigned long) sym->value);
3749                       _bfd_vms_output_end_subrec (recwr);
3750                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3751                       _bfd_vms_output_end_subrec (recwr);
3752                     }
3753                   else
3754                     {
3755                       etir_output_check (abfd, section, curr_addr, 32);
3756                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3757                       _bfd_vms_output_long (recwr,
3758                                             (unsigned long) sec->target_index);
3759                       _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3760                       _bfd_vms_output_end_subrec (recwr);
3761                       /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
3762                          says that we should have a ETIR__C_STO_OFF here.
3763                          But the relocation would not be BFD_RELOC_32 then.
3764                          This case is very likely unreachable.  */
3765                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3766                       _bfd_vms_output_end_subrec (recwr);
3767                     }
3768                   break;
3769
3770                 case ALPHA_R_REFQUAD:
3771                   if (bfd_is_und_section (sym->section))
3772                     {
3773                       bfd_vma addend = rptr->addend;
3774                       slen = strlen ((char *) sym->name);
3775                       etir_output_check (abfd, section, curr_addr, slen);
3776                       if (addend)
3777                         {
3778                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3779                           _bfd_vms_output_counted (recwr, sym->name);
3780                           _bfd_vms_output_end_subrec (recwr);
3781                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3782                           _bfd_vms_output_quad (recwr, addend);
3783                           _bfd_vms_output_end_subrec (recwr);
3784                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3785                           _bfd_vms_output_end_subrec (recwr);
3786                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3787                           _bfd_vms_output_end_subrec (recwr);
3788                         }
3789                       else
3790                         {
3791                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
3792                           _bfd_vms_output_counted (recwr, sym->name);
3793                           _bfd_vms_output_end_subrec (recwr);
3794                         }
3795                     }
3796                   else if (bfd_is_abs_section (sym->section))
3797                     {
3798                       etir_output_check (abfd, section, curr_addr, 16);
3799                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3800                       _bfd_vms_output_quad (recwr, sym->value);
3801                       _bfd_vms_output_end_subrec (recwr);
3802                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3803                       _bfd_vms_output_end_subrec (recwr);
3804                     }
3805                   else
3806                     {
3807                       etir_output_check (abfd, section, curr_addr, 32);
3808                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3809                       _bfd_vms_output_long (recwr,
3810                                             (unsigned long) sec->target_index);
3811                       _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3812                       _bfd_vms_output_end_subrec (recwr);
3813                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
3814                       _bfd_vms_output_end_subrec (recwr);
3815                     }
3816                   break;
3817
3818                 case ALPHA_R_HINT:
3819                   sto_imm (abfd, section, size, curr_data, curr_addr);
3820                   break;
3821
3822                 case ALPHA_R_LINKAGE:
3823                   etir_output_check (abfd, section, curr_addr, 64);
3824                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
3825                   _bfd_vms_output_long
3826                     (recwr, (unsigned long) rptr->addend);
3827                   if (rptr->addend > PRIV (vms_linkage_index))
3828                     PRIV (vms_linkage_index) = rptr->addend;
3829                   _bfd_vms_output_counted (recwr, sym->name);
3830                   _bfd_vms_output_byte (recwr, 0);
3831                   _bfd_vms_output_end_subrec (recwr);
3832                   break;
3833
3834                 case ALPHA_R_CODEADDR:
3835                   slen = strlen ((char *) sym->name);
3836                   etir_output_check (abfd, section, curr_addr, slen);
3837                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
3838                   _bfd_vms_output_counted (recwr, sym->name);
3839                   _bfd_vms_output_end_subrec (recwr);
3840                   break;
3841
3842                 case ALPHA_R_NOP:
3843                   udata
3844                     = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3845                   etir_output_check (abfd, section, curr_addr,
3846                                      32 + 1 + strlen (udata->origname));
3847                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
3848                   _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3849                   _bfd_vms_output_long
3850                     (recwr, (unsigned long) section->target_index);
3851                   _bfd_vms_output_quad (recwr, rptr->address);
3852                   _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3853                   _bfd_vms_output_long
3854                     (recwr, (unsigned long) section->target_index);
3855                   _bfd_vms_output_quad (recwr, rptr->addend);
3856                   _bfd_vms_output_counted (recwr, udata->origname);
3857                   _bfd_vms_output_end_subrec (recwr);
3858                   break;
3859
3860                 case ALPHA_R_BSR:
3861                   (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3862                   break;
3863
3864                 case ALPHA_R_LDA:
3865                   udata
3866                     = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3867                   etir_output_check (abfd, section, curr_addr,
3868                                      32 + 1 + strlen (udata->origname));
3869                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
3870                   _bfd_vms_output_long
3871                     (recwr, (unsigned long) udata->lkindex + 1);
3872                   _bfd_vms_output_long
3873                     (recwr, (unsigned long) section->target_index);
3874                   _bfd_vms_output_quad (recwr, rptr->address);
3875                   _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
3876                   _bfd_vms_output_long
3877                     (recwr, (unsigned long) udata->bsym->section->target_index);
3878                   _bfd_vms_output_quad (recwr, rptr->addend);
3879                   _bfd_vms_output_counted (recwr, udata->origname);
3880                   _bfd_vms_output_end_subrec (recwr);
3881                   break;
3882
3883                 case ALPHA_R_BOH:
3884                   udata
3885                     = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3886                   etir_output_check (abfd, section, curr_addr,
3887                                        32 + 1 + strlen (udata->origname));
3888                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
3889                   _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3890                   _bfd_vms_output_long
3891                     (recwr, (unsigned long) section->target_index);
3892                   _bfd_vms_output_quad (recwr, rptr->address);
3893                   _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
3894                   _bfd_vms_output_long
3895                     (recwr, (unsigned long) section->target_index);
3896                   _bfd_vms_output_quad (recwr, rptr->addend);
3897                   _bfd_vms_output_counted (recwr, udata->origname);
3898                   _bfd_vms_output_end_subrec (recwr);
3899                   break;
3900
3901                 default:
3902                   (*_bfd_error_handler) (_("Unhandled relocation %s"),
3903                                          rptr->howto->name);
3904                   break;
3905                 }
3906
3907               curr_data += size;
3908               curr_addr += size;
3909             } /* End of relocs loop.  */
3910
3911           if (!pass2_in_progress)
3912             {
3913               /* Output rest of section.  */
3914               if (curr_addr > section->size)
3915                 (*_bfd_error_handler) (_("Size error in section %s"),
3916                                        section->name);
3917               size = section->size - curr_addr;
3918               sto_imm (abfd, section, size, curr_data, curr_addr);
3919               curr_data += size;
3920               curr_addr += size;
3921
3922               if (pass2_needed)
3923                 {
3924                   pass2_in_progress = 1;
3925                   goto new_pass;
3926                 }
3927             }
3928         }
3929
3930       else /* (section->flags & SEC_RELOC) */
3931         sto_imm (abfd, section, section->size, section->contents, 0);
3932
3933       end_etir_record (abfd);
3934     }
3935
3936   _bfd_vms_output_alignment (recwr, 2);
3937   return TRUE;
3938 }
3939
3940 /* Write cached information into a file being written, at bfd_close.  */
3941
3942 static bfd_boolean
3943 alpha_vms_write_object_contents (bfd *abfd)
3944 {
3945   vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
3946
3947   if (abfd->flags & (EXEC_P | DYNAMIC))
3948     {
3949       return alpha_vms_write_exec (abfd);
3950     }
3951   else
3952     {
3953       if (abfd->section_count > 0)                      /* we have sections */
3954         {
3955           if (_bfd_vms_write_ehdr (abfd) != TRUE)
3956             return FALSE;
3957           if (_bfd_vms_write_egsd (abfd) != TRUE)
3958             return FALSE;
3959           if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
3960             return FALSE;
3961           if (_bfd_vms_write_eeom (abfd) != TRUE)
3962             return FALSE;
3963         }
3964     }
3965   return TRUE;
3966 }
3967 \f
3968 /* Debug stuff: nearest line.  */
3969
3970 #define SET_MODULE_PARSED(m) \
3971   do { if ((m)->name == NULL) (m)->name = ""; } while (0)
3972 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
3973
3974 /* Build a new module for the specified BFD.  */
3975
3976 static struct module *
3977 new_module (bfd *abfd)
3978 {
3979   struct module *module
3980     = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
3981   module->file_table_count = 16; /* Arbitrary.  */
3982   module->file_table
3983     = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
3984   return module;
3985 }
3986
3987 /* Parse debug info for a module and internalize it.  */
3988
3989 static void
3990 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
3991               int length)
3992 {
3993   unsigned char *maxptr = ptr + length;
3994   unsigned char *src_ptr, *pcl_ptr;
3995   unsigned int prev_linum = 0, curr_linenum = 0;
3996   bfd_vma prev_pc = 0, curr_pc = 0;
3997   struct srecinfo *curr_srec, *srec;
3998   struct lineinfo *curr_line, *line;
3999   struct funcinfo *funcinfo;
4000
4001   /* Initialize tables with zero element.  */
4002   curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4003   module->srec_table = curr_srec;
4004
4005   curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4006   module->line_table = curr_line;
4007
4008   while (length == -1 || ptr < maxptr)
4009     {
4010       /* The first byte is not counted in the recorded length.  */
4011       int rec_length = bfd_getl16 (ptr) + 1;
4012       int rec_type = bfd_getl16 (ptr + 2);
4013
4014       vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4015
4016       if (length == -1 && rec_type == DST__K_MODEND)
4017         break;
4018
4019       switch (rec_type)
4020         {
4021         case DST__K_MODBEG:
4022           module->name
4023             = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4024
4025           curr_pc = 0;
4026           prev_pc = 0;
4027           curr_linenum = 0;
4028           prev_linum = 0;
4029
4030           vms_debug2 ((3, "module: %s\n", module->name));
4031           break;
4032
4033         case DST__K_MODEND:
4034           break;
4035
4036         case DST__K_RTNBEG:
4037           funcinfo = (struct funcinfo *)
4038             bfd_zalloc (abfd, sizeof (struct funcinfo));
4039           funcinfo->name
4040             = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4041           funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4042           funcinfo->next = module->func_table;
4043           module->func_table = funcinfo;
4044
4045           vms_debug2 ((3, "routine: %s at 0x%lx\n",
4046                        funcinfo->name, (unsigned long) funcinfo->low));
4047           break;
4048
4049         case DST__K_RTNEND:
4050           module->func_table->high = module->func_table->low
4051             + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4052
4053           if (module->func_table->high > module->high)
4054             module->high = module->func_table->high;
4055
4056           vms_debug2 ((3, "end routine\n"));
4057           break;
4058
4059         case DST__K_PROLOG:
4060           vms_debug2 ((3, "prologue\n"));
4061           break;
4062
4063         case DST__K_EPILOG:
4064           vms_debug2 ((3, "epilog\n"));
4065           break;
4066
4067         case DST__K_BLKBEG:
4068           vms_debug2 ((3, "block\n"));
4069           break;
4070
4071         case DST__K_BLKEND:
4072           vms_debug2 ((3, "end block\n"));
4073           break;
4074
4075         case DST__K_SOURCE:
4076           src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4077
4078           vms_debug2 ((3, "source info\n"));
4079
4080           while (src_ptr < ptr + rec_length)
4081             {
4082               int cmd = src_ptr[0], cmd_length, data;
4083
4084               switch (cmd)
4085                 {
4086                 case DST__K_SRC_DECLFILE:
4087                   {
4088                     unsigned int fileid
4089                       = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4090                     char *filename
4091                       = _bfd_vms_save_counted_string (src_ptr
4092                           + DST_S_B_SRC_DF_FILENAME);
4093
4094                     while (fileid >= module->file_table_count)
4095                       {
4096                         module->file_table_count *= 2;
4097                         module->file_table
4098                           = bfd_realloc (module->file_table,
4099                                          module->file_table_count
4100                                            * sizeof (struct fileinfo));
4101                       }
4102
4103                     module->file_table [fileid].name = filename;
4104                     module->file_table [fileid].srec = 1;
4105                     cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4106                     vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4107                                  fileid, module->file_table [fileid].name));
4108                   }
4109                   break;
4110
4111                 case DST__K_SRC_DEFLINES_B:
4112                   /* Perform the association and set the next higher index
4113                      to the limit.  */
4114                   data = src_ptr[DST_S_B_SRC_UNSBYTE];
4115                   srec = (struct srecinfo *)
4116                     bfd_zalloc (abfd, sizeof (struct srecinfo));
4117                   srec->line = curr_srec->line + data;
4118                   srec->srec = curr_srec->srec + data;
4119                   srec->sfile = curr_srec->sfile;
4120                   curr_srec->next = srec;
4121                   curr_srec = srec;
4122                   cmd_length = 2;
4123                   vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4124                   break;
4125
4126                 case DST__K_SRC_DEFLINES_W:
4127                   /* Perform the association and set the next higher index
4128                      to the limit.  */
4129                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4130                   srec = (struct srecinfo *)
4131                     bfd_zalloc (abfd, sizeof (struct srecinfo));
4132                   srec->line = curr_srec->line + data;
4133                   srec->srec = curr_srec->srec + data,
4134                   srec->sfile = curr_srec->sfile;
4135                   curr_srec->next = srec;
4136                   curr_srec = srec;
4137                   cmd_length = 3;
4138                   vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4139                   break;
4140
4141                 case DST__K_SRC_INCRLNUM_B:
4142                   data = src_ptr[DST_S_B_SRC_UNSBYTE];
4143                   curr_srec->line += data;
4144                   cmd_length = 2;
4145                   vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4146                   break;
4147
4148                 case DST__K_SRC_SETFILE:
4149                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4150                   curr_srec->sfile = data;
4151                   curr_srec->srec = module->file_table[data].srec;
4152                   cmd_length = 3;
4153                   vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4154                   break;
4155
4156                 case DST__K_SRC_SETLNUM_L:
4157                   data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4158                   curr_srec->line = data;
4159                   cmd_length = 5;
4160                   vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4161                   break;
4162
4163                 case DST__K_SRC_SETLNUM_W:
4164                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4165                   curr_srec->line = data;
4166                   cmd_length = 3;
4167                   vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4168                   break;
4169
4170                 case DST__K_SRC_SETREC_L:
4171                   data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4172                   curr_srec->srec = data;
4173                   module->file_table[curr_srec->sfile].srec = data;
4174                   cmd_length = 5;
4175                   vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4176                   break;
4177
4178                 case DST__K_SRC_SETREC_W:
4179                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4180                   curr_srec->srec = data;
4181                   module->file_table[curr_srec->sfile].srec = data;
4182                   cmd_length = 3;
4183                   vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4184                   break;
4185
4186                 case DST__K_SRC_FORMFEED:
4187                   cmd_length = 1;
4188                   vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4189                   break;
4190
4191                 default:
4192                   (*_bfd_error_handler) (_("unknown source command %d"),
4193                                          cmd);
4194                   cmd_length = 2;
4195                   break;
4196                 }
4197
4198               src_ptr += cmd_length;
4199             }
4200           break;
4201
4202         case DST__K_LINE_NUM:
4203           pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4204
4205           vms_debug2 ((3, "line info\n"));
4206
4207           while (pcl_ptr < ptr + rec_length)
4208             {
4209               /* The command byte is signed so we must sign-extend it.  */
4210               int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4211
4212               switch (cmd)
4213                 {
4214                 case DST__K_DELTA_PC_W:
4215                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4216                   curr_pc += data;
4217                   curr_linenum += 1;
4218                   cmd_length = 3;
4219                   vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4220                   break;
4221
4222                 case DST__K_DELTA_PC_L:
4223                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4224                   curr_pc += data;
4225                   curr_linenum += 1;
4226                   cmd_length = 5;
4227                   vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4228                   break;
4229
4230                 case DST__K_INCR_LINUM:
4231                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4232                   curr_linenum += data;
4233                   cmd_length = 2;
4234                   vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4235                   break;
4236
4237                 case DST__K_INCR_LINUM_W:
4238                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4239                   curr_linenum += data;
4240                   cmd_length = 3;
4241                   vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4242                   break;
4243
4244                 case DST__K_INCR_LINUM_L:
4245                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4246                   curr_linenum += data;
4247                   cmd_length = 5;
4248                   vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4249                   break;
4250
4251                 case DST__K_SET_LINUM_INCR:
4252                   (*_bfd_error_handler)
4253                     (_("DST__K_SET_LINUM_INCR not implemented"));
4254                   cmd_length = 2;
4255                   break;
4256
4257                 case DST__K_SET_LINUM_INCR_W:
4258                   (*_bfd_error_handler)
4259                     (_("DST__K_SET_LINUM_INCR_W not implemented"));
4260                   cmd_length = 3;
4261                   break;
4262
4263                 case DST__K_RESET_LINUM_INCR:
4264                   (*_bfd_error_handler)
4265                     (_("DST__K_RESET_LINUM_INCR not implemented"));
4266                   cmd_length = 1;
4267                   break;
4268
4269                 case DST__K_BEG_STMT_MODE:
4270                   (*_bfd_error_handler)
4271                     (_("DST__K_BEG_STMT_MODE not implemented"));
4272                   cmd_length = 1;
4273                   break;
4274
4275                 case DST__K_END_STMT_MODE:
4276                   (*_bfd_error_handler)
4277                     (_("DST__K_END_STMT_MODE not implemented"));
4278                   cmd_length = 1;
4279                   break;
4280
4281                 case DST__K_SET_LINUM_B:
4282                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4283                   curr_linenum = data;
4284                   cmd_length = 2;
4285                   vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4286                   break;
4287
4288                 case DST__K_SET_LINUM:
4289                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4290                   curr_linenum = data;
4291                   cmd_length = 3;
4292                   vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4293                   break;
4294
4295                 case DST__K_SET_LINUM_L:
4296                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4297                   curr_linenum = data;
4298                   cmd_length = 5;
4299                   vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4300                   break;
4301
4302                 case DST__K_SET_PC:
4303                   (*_bfd_error_handler)
4304                     (_("DST__K_SET_PC not implemented"));
4305                   cmd_length = 2;
4306                   break;
4307
4308                 case DST__K_SET_PC_W:
4309                   (*_bfd_error_handler)
4310                     (_("DST__K_SET_PC_W not implemented"));
4311                   cmd_length = 3;
4312                   break;
4313
4314                 case DST__K_SET_PC_L:
4315                   (*_bfd_error_handler)
4316                     (_("DST__K_SET_PC_L not implemented"));
4317                   cmd_length = 5;
4318                   break;
4319
4320                 case DST__K_SET_STMTNUM:
4321                   (*_bfd_error_handler)
4322                     (_("DST__K_SET_STMTNUM not implemented"));
4323                   cmd_length = 2;
4324                   break;
4325
4326                 case DST__K_TERM:
4327                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4328                   curr_pc += data;
4329                   cmd_length = 2;
4330                   vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4331                   break;
4332
4333                 case DST__K_TERM_W:
4334                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4335                   curr_pc += data;
4336                   cmd_length = 3;
4337                   vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4338                   break;
4339
4340                 case DST__K_TERM_L:
4341                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4342                   curr_pc += data;
4343                   cmd_length = 5;
4344                   vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
4345                   break;
4346
4347                 case DST__K_SET_ABS_PC:
4348                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4349                   curr_pc = data;
4350                   cmd_length = 5;
4351                   vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4352                   break;
4353
4354                 default:
4355                   if (cmd <= 0)
4356                     {
4357                       curr_pc -= cmd;
4358                       curr_linenum += 1;
4359                       cmd_length = 1;
4360                       vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4361                                    (unsigned long)curr_pc, curr_linenum));
4362                     }
4363                   else
4364                     {
4365                       (*_bfd_error_handler) (_("unknown line command %d"),
4366                                              cmd);
4367                       cmd_length = 2;
4368                     }
4369                   break;
4370                 }
4371
4372               if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4373                   || cmd <= 0
4374                   || cmd == DST__K_DELTA_PC_L
4375                   || cmd == DST__K_DELTA_PC_W)
4376                 {
4377                   line = (struct lineinfo *)
4378                     bfd_zalloc (abfd, sizeof (struct lineinfo));
4379                   line->address = curr_pc;
4380                   line->line = curr_linenum;
4381
4382                   curr_line->next = line;
4383                   curr_line = line;
4384
4385                   prev_linum = curr_linenum;
4386                   prev_pc = curr_pc;
4387                   vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4388                                (unsigned long)curr_pc, curr_linenum));
4389                 }
4390
4391               pcl_ptr += cmd_length;
4392             }
4393           break;
4394
4395         case 0x17: /* Undocumented type used by DEC C to declare equates.  */
4396           vms_debug2 ((3, "undocumented type 0x17\n"));
4397           break;
4398
4399         default:
4400           vms_debug2 ((3, "ignoring record\n"));
4401           break;
4402
4403         }
4404
4405       ptr += rec_length;
4406     }
4407
4408   /* Finalize tables with EOL marker.  */
4409   srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4410   srec->line = (unsigned int) -1;
4411   srec->srec = (unsigned int) -1;
4412   curr_srec->next = srec;
4413
4414   line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4415   line->line = (unsigned int) -1;
4416   line->address = (bfd_vma) -1;
4417   curr_line->next = line;
4418
4419   /* Advertise that this module has been parsed.  This is needed
4420      because parsing can be either performed at module creation
4421      or deferred until debug info is consumed.  */
4422   SET_MODULE_PARSED (module);
4423 }
4424
4425 /* Build the list of modules for the specified BFD.  */
4426
4427 static struct module *
4428 build_module_list (bfd *abfd)
4429 {
4430   struct module *module, *list = NULL;
4431   asection *dmt;
4432
4433   if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4434     {
4435       /* We have a DMT section so this must be an image.  Parse the
4436          section and build the list of modules.  This is sufficient
4437          since we can compute the start address and the end address
4438          of every module from the section contents.  */
4439       bfd_size_type size = bfd_get_section_size (dmt);
4440       unsigned char *ptr, *end;
4441
4442       ptr = (unsigned char *) bfd_alloc (abfd, size);
4443       if (! ptr)
4444         return NULL;
4445
4446       if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4447         return NULL;
4448
4449       vms_debug2 ((2, "DMT\n"));
4450
4451       end = ptr + size;
4452
4453       while (ptr < end)
4454         {
4455           /* Each header declares a module with its start offset and size
4456              of debug info in the DST section, as well as the count of
4457              program sections (i.e. address spans) it contains.  */
4458           int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4459           int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4460           int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4461           ptr += DBG_S_C_DMT_HEADER_SIZE;
4462
4463           vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4464                        modbeg, msize, count));
4465
4466           /* We create a 'module' structure for each program section since
4467              we only support contiguous addresses in a 'module' structure.
4468              As a consequence, the actual debug info in the DST section is
4469              shared and can be parsed multiple times; that doesn't seem to
4470              cause problems in practice.  */
4471           while (count-- > 0)
4472             {
4473               int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4474               int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4475               module = new_module (abfd);
4476               module->modbeg = modbeg;
4477               module->size = msize;
4478               module->low = start;
4479               module->high = start + length;
4480               module->next = list;
4481               list = module;
4482               ptr += DBG_S_C_DMT_PSECT_SIZE;
4483
4484               vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4485                            start, length));
4486             }
4487         }
4488     }
4489   else
4490     {
4491       /* We don't have a DMT section so this must be an object.  Parse
4492          the module right now in order to compute its start address and
4493          end address.  */
4494       void *dst = PRIV (dst_section)->contents;
4495
4496       if (dst == NULL)
4497         return NULL;
4498
4499       module = new_module (abfd);
4500       parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4501       list = module;
4502     }
4503
4504   return list;
4505 }
4506
4507 /* Calculate and return the name of the source file and the line nearest
4508    to the wanted location in the specified module.  */
4509
4510 static bfd_boolean
4511 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4512                           const char **file, const char **func,
4513                           unsigned int *line)
4514 {
4515   struct funcinfo *funcinfo;
4516   struct lineinfo *lineinfo;
4517   struct srecinfo *srecinfo;
4518   bfd_boolean ret = FALSE;
4519
4520   /* Parse this module if that was not done at module creation.  */
4521   if (! IS_MODULE_PARSED (module))
4522     {
4523       unsigned int size = module->size;
4524       unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4525       unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4526
4527       if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4528           || bfd_bread (buffer, size, abfd) != size)
4529         {
4530           bfd_set_error (bfd_error_no_debug_section);
4531           return FALSE;
4532         }
4533
4534       parse_module (abfd, module, buffer, size);
4535       free (buffer);
4536     }
4537
4538   /* Find out the function (if any) that contains the address.  */
4539   for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4540     if (addr >= funcinfo->low && addr <= funcinfo->high)
4541       {
4542         *func = funcinfo->name;
4543         ret = TRUE;
4544         break;
4545       }
4546
4547   /* Find out the source file and the line nearest to the address.  */
4548   for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4549     if (lineinfo->next && addr < lineinfo->next->address)
4550       {
4551         for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4552           if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4553             {
4554               if (srecinfo->sfile > 0)
4555                 {
4556                   *file = module->file_table[srecinfo->sfile].name;
4557                   *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4558                 }
4559               else
4560                 {
4561                   *file = module->name;
4562                   *line = lineinfo->line;
4563                 }
4564               return TRUE;
4565             }
4566
4567         break;
4568       }
4569
4570   return ret;
4571 }
4572
4573 /* Provided a BFD, a section and an offset into the section, calculate and
4574    return the name of the source file and the line nearest to the wanted
4575    location.  */
4576
4577 static bfd_boolean
4578 _bfd_vms_find_nearest_line (bfd *abfd,
4579                             asymbol **symbols ATTRIBUTE_UNUSED,
4580                             asection *section,
4581                             bfd_vma offset,
4582                             const char **file,
4583                             const char **func,
4584                             unsigned int *line,
4585                             unsigned int *discriminator)
4586 {
4587   struct module *module;
4588
4589   /* What address are we looking for?  */
4590   bfd_vma addr = section->vma + offset;
4591
4592   *file = NULL;
4593   *func = NULL;
4594   *line = 0;
4595   if (discriminator)
4596     *discriminator = 0;
4597
4598   /* We can't do anything if there is no DST (debug symbol table).  */
4599   if (PRIV (dst_section) == NULL)
4600     return FALSE;
4601
4602   /* Create the module list - if not already done.  */
4603   if (PRIV (modules) == NULL)
4604     {
4605       PRIV (modules) = build_module_list (abfd);
4606       if (PRIV (modules) == NULL)
4607         return FALSE;
4608     }
4609
4610   for (module = PRIV (modules); module; module = module->next)
4611     if (addr >= module->low && addr <= module->high)
4612       return module_find_nearest_line (abfd, module, addr, file, func, line);
4613
4614   return FALSE;
4615 }
4616 \f
4617 /* Canonicalizations.  */
4618 /* Set name, value, section and flags of SYM from E.  */
4619
4620 static bfd_boolean
4621 alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4622 {
4623   flagword flags;
4624   symvalue value;
4625   asection *sec;
4626   const char *name;
4627
4628   name = e->name;
4629   value = 0;
4630   flags = BSF_NO_FLAGS;
4631   sec = NULL;
4632
4633   switch (e->typ)
4634     {
4635     case EGSD__C_SYM:
4636       if (e->flags & EGSY__V_WEAK)
4637         flags |= BSF_WEAK;
4638
4639       if (e->flags & EGSY__V_DEF)
4640         {
4641           /* Symbol definition.  */
4642           flags |= BSF_GLOBAL;
4643           if (e->flags & EGSY__V_NORM)
4644             flags |= BSF_FUNCTION;
4645           value = e->value;
4646           sec = e->section;
4647         }
4648       else
4649         {
4650           /* Symbol reference.  */
4651           sec = bfd_und_section_ptr;
4652         }
4653       break;
4654
4655     case EGSD__C_SYMG:
4656       /* A universal symbol is by definition global...  */
4657       flags |= BSF_GLOBAL;
4658
4659       /* ...and dynamic in shared libraries.  */
4660       if (abfd->flags & DYNAMIC)
4661         flags |= BSF_DYNAMIC;
4662
4663       if (e->flags & EGSY__V_WEAK)
4664         flags |= BSF_WEAK;
4665
4666       if (!(e->flags & EGSY__V_DEF))
4667         abort ();
4668
4669       if (e->flags & EGSY__V_NORM)
4670         flags |= BSF_FUNCTION;
4671
4672       value = e->value;
4673       /* sec = e->section; */
4674       sec = bfd_abs_section_ptr;
4675       break;
4676
4677     default:
4678       return FALSE;
4679     }
4680
4681   sym->name = name;
4682   sym->section = sec;
4683   sym->flags = flags;
4684   sym->value = value;
4685   return TRUE;
4686 }
4687
4688
4689 /* Return the number of bytes required to store a vector of pointers
4690    to asymbols for all the symbols in the BFD abfd, including a
4691    terminal NULL pointer. If there are no symbols in the BFD,
4692    then return 0.  If an error occurs, return -1.  */
4693
4694 static long
4695 alpha_vms_get_symtab_upper_bound (bfd *abfd)
4696 {
4697   vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4698                abfd, PRIV (gsd_sym_count)));
4699
4700   return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4701 }
4702
4703 /* Read the symbols from the BFD abfd, and fills in the vector
4704    location with pointers to the symbols and a trailing NULL.
4705
4706    Return number of symbols read.   */
4707
4708 static long
4709 alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4710 {
4711   unsigned int i;
4712
4713   vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4714
4715   if (PRIV (csymbols) == NULL)
4716     {
4717       PRIV (csymbols) = (asymbol **) bfd_alloc
4718         (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4719
4720       /* Traverse table and fill symbols vector.  */
4721       for (i = 0; i < PRIV (gsd_sym_count); i++)
4722         {
4723           struct vms_symbol_entry *e = PRIV (syms)[i];
4724           asymbol *sym;
4725
4726           sym = bfd_make_empty_symbol (abfd);
4727           if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4728             {
4729               bfd_release (abfd, PRIV (csymbols));
4730               PRIV (csymbols) = NULL;
4731               return -1;
4732             }
4733
4734           PRIV (csymbols)[i] = sym;
4735         }
4736     }
4737
4738   if (symbols != NULL)
4739     {
4740       for (i = 0; i < PRIV (gsd_sym_count); i++)
4741         symbols[i] = PRIV (csymbols)[i];
4742       symbols[i] = NULL;
4743     }
4744
4745   return PRIV (gsd_sym_count);
4746 }
4747
4748 /* Read and convert relocations from ETIR.  We do it once for all sections.  */
4749
4750 static bfd_boolean
4751 alpha_vms_slurp_relocs (bfd *abfd)
4752 {
4753   int cur_psect = -1;
4754
4755   vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4756
4757   /* We slurp relocs only once, for all sections.  */
4758   if (PRIV (reloc_done))
4759       return TRUE;
4760   PRIV (reloc_done) = TRUE;
4761
4762   if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4763     return FALSE;
4764
4765   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4766     return FALSE;
4767
4768   while (1)
4769     {
4770       unsigned char *begin;
4771       unsigned char *end;
4772       unsigned char *ptr;
4773       bfd_reloc_code_real_type reloc_code;
4774       int type;
4775       bfd_vma vaddr = 0;
4776
4777       int length;
4778
4779       bfd_vma cur_address;
4780       int cur_psidx = -1;
4781       unsigned char *cur_sym = NULL;
4782       int prev_cmd = -1;
4783       bfd_vma cur_addend = 0;
4784
4785       /* Skip non-ETIR records.  */
4786       type = _bfd_vms_get_object_record (abfd);
4787       if (type == EOBJ__C_EEOM)
4788         break;
4789       if (type != EOBJ__C_ETIR)
4790         continue;
4791
4792       begin = PRIV (recrd.rec) + 4;
4793       end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4794
4795       for (ptr = begin; ptr < end; ptr += length)
4796         {
4797           int cmd;
4798
4799           cmd = bfd_getl16 (ptr);
4800           length = bfd_getl16 (ptr + 2);
4801
4802           cur_address = vaddr;
4803
4804           vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4805                        _bfd_vms_etir_name (cmd)));
4806
4807           switch (cmd)
4808             {
4809             case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4810                                   /* ALPHA_R_REFQUAD und_section, step 1 */
4811               cur_sym = ptr + 4;
4812               prev_cmd = cmd;
4813               continue;
4814
4815             case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4816               cur_psidx = bfd_getl32 (ptr + 4);
4817               cur_addend = bfd_getl64 (ptr + 8);
4818               prev_cmd = cmd;
4819               continue;
4820
4821             case ETIR__C_CTL_SETRB:
4822               if (prev_cmd != ETIR__C_STA_PQ)
4823                 {
4824                   (*_bfd_error_handler)
4825                     (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4826                      _bfd_vms_etir_name (cmd));
4827                   return FALSE;
4828                 }
4829               cur_psect = cur_psidx;
4830               vaddr = cur_addend;
4831               cur_psidx = -1;
4832               cur_addend = 0;
4833               continue;
4834
4835             case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4836                                  /* ALPHA_R_REFLONG und_section, step 2 */
4837               if (prev_cmd != -1)
4838                 {
4839                   if (prev_cmd != ETIR__C_STA_GBL)
4840                     {
4841                       (*_bfd_error_handler)
4842                         (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4843                          _bfd_vms_etir_name (ETIR__C_STA_LW));
4844                       return FALSE;
4845                     }
4846                 }
4847               cur_addend = bfd_getl32 (ptr + 4);
4848               prev_cmd = cmd;
4849               continue;
4850
4851             case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4852                                  /* ALPHA_R_REFQUAD und_section, step 2 */
4853               if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4854                 {
4855                   (*_bfd_error_handler)
4856                     (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4857                      _bfd_vms_etir_name (ETIR__C_STA_QW));
4858                   return FALSE;
4859                 }
4860               cur_addend = bfd_getl64 (ptr + 4);
4861               prev_cmd = cmd;
4862               continue;
4863
4864             case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4865                                  /* ALPHA_R_REFLONG abs_section, step 2 */
4866                                  /* ALPHA_R_REFLONG others, step 2 */
4867               if (prev_cmd != ETIR__C_OPR_ADD
4868                   && prev_cmd != ETIR__C_STA_LW
4869                   && prev_cmd != ETIR__C_STA_PQ)
4870                 {
4871                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4872                                          _bfd_vms_etir_name (prev_cmd),
4873                                          _bfd_vms_etir_name (ETIR__C_STO_LW));
4874                   return FALSE;
4875                 }
4876               reloc_code = BFD_RELOC_32;
4877               break;
4878
4879             case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
4880                                  /* ALPHA_R_REFQUAD abs_section, step 2 */
4881               if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
4882                 {
4883                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4884                                          _bfd_vms_etir_name (prev_cmd),
4885                                          _bfd_vms_etir_name (ETIR__C_STO_QW));
4886                   return FALSE;
4887                 }
4888               reloc_code = BFD_RELOC_64;
4889               break;
4890
4891             case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
4892               if (prev_cmd != ETIR__C_STA_PQ)
4893                 {
4894                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4895                                          _bfd_vms_etir_name (prev_cmd),
4896                                          _bfd_vms_etir_name (ETIR__C_STO_OFF));
4897                   return FALSE;
4898                 }
4899               reloc_code = BFD_RELOC_64;
4900               break;
4901
4902             case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
4903                                   /* ALPHA_R_REFQUAD und_section, step 3 */
4904               if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
4905                 {
4906                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4907                                          _bfd_vms_etir_name (prev_cmd),
4908                                          _bfd_vms_etir_name (ETIR__C_OPR_ADD));
4909                   return FALSE;
4910                 }
4911               prev_cmd = ETIR__C_OPR_ADD;
4912               continue;
4913
4914             case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
4915               reloc_code = BFD_RELOC_ALPHA_CODEADDR;
4916               cur_sym = ptr + 4;
4917               break;
4918
4919             case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
4920               reloc_code = BFD_RELOC_64;
4921               cur_sym = ptr + 4;
4922               break;
4923
4924             case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
4925               reloc_code = BFD_RELOC_32;
4926               cur_sym = ptr + 4;
4927               break;
4928
4929             case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
4930               reloc_code = BFD_RELOC_ALPHA_LINKAGE;
4931               cur_sym = ptr + 8;
4932               break;
4933
4934             case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
4935               reloc_code = BFD_RELOC_ALPHA_NOP;
4936               goto call_reloc;
4937
4938             case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
4939               reloc_code = BFD_RELOC_ALPHA_BSR;
4940               goto call_reloc;
4941
4942             case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
4943               reloc_code = BFD_RELOC_ALPHA_LDA;
4944               goto call_reloc;
4945
4946             case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
4947               reloc_code = BFD_RELOC_ALPHA_BOH;
4948               goto call_reloc;
4949
4950             call_reloc:
4951               cur_sym = ptr + 4 + 32;
4952               cur_address = bfd_getl64 (ptr + 4 + 8);
4953               cur_addend = bfd_getl64 (ptr + 4 + 24);
4954               break;
4955
4956             case ETIR__C_STO_IMM:
4957               vaddr += bfd_getl32 (ptr + 4);
4958               continue;
4959
4960             default:
4961               (*_bfd_error_handler) (_("Unknown reloc %s"),
4962                                      _bfd_vms_etir_name (cmd));
4963               return FALSE;
4964             }
4965
4966           {
4967             asection *sec;
4968             struct vms_section_data_struct *vms_sec;
4969             arelent *reloc;
4970
4971             /* Get section to which the relocation applies.  */
4972             if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
4973               {
4974                 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
4975                 return FALSE;
4976               }
4977
4978             sec = PRIV (sections)[cur_psect];
4979             if (sec == bfd_abs_section_ptr)
4980               {
4981                 (*_bfd_error_handler) (_("Relocation for non-REL psect"));
4982                 return FALSE;
4983               }
4984
4985             vms_sec = vms_section_data (sec);
4986
4987             /* Allocate a reloc entry.  */
4988             if (sec->reloc_count >= vms_sec->reloc_max)
4989               {
4990                 if (vms_sec->reloc_max == 0)
4991                   {
4992                     vms_sec->reloc_max = 64;
4993                     sec->relocation = bfd_zmalloc
4994                       (vms_sec->reloc_max * sizeof (arelent));
4995                   }
4996                 else
4997                   {
4998                     vms_sec->reloc_max *= 2;
4999                     sec->relocation = bfd_realloc
5000                       (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5001                   }
5002               }
5003             reloc = &sec->relocation[sec->reloc_count];
5004             sec->reloc_count++;
5005
5006             reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5007
5008             if (cur_sym != NULL)
5009               {
5010                 unsigned int j;
5011                 unsigned int symlen = *cur_sym;
5012                 asymbol **sym;
5013
5014                 /* Linear search.  */
5015                 symlen = *cur_sym;
5016                 cur_sym++;
5017                 sym = NULL;
5018
5019                 for (j = 0; j < PRIV (gsd_sym_count); j++)
5020                   if (PRIV (syms)[j]->namelen == symlen
5021                       && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5022                     {
5023                       sym = &PRIV (csymbols)[j];
5024                       break;
5025                     }
5026                 if (sym == NULL)
5027                   {
5028                     (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5029                                            _bfd_vms_etir_name (cmd));
5030                     reloc->sym_ptr_ptr = NULL;
5031                   }
5032                 else
5033                   reloc->sym_ptr_ptr = sym;
5034               }
5035             else if (cur_psidx >= 0)
5036               reloc->sym_ptr_ptr =
5037                 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5038             else
5039               reloc->sym_ptr_ptr = NULL;
5040
5041             reloc->address = cur_address;
5042             reloc->addend = cur_addend;
5043
5044             vaddr += bfd_get_reloc_size (reloc->howto);
5045           }
5046
5047           cur_addend = 0;
5048           prev_cmd = -1;
5049           cur_sym = NULL;
5050           cur_psidx = -1;
5051         }
5052     }
5053   vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5054
5055   return TRUE;
5056 }
5057
5058 /* Return the number of bytes required to store the relocation
5059    information associated with the given section.  */
5060
5061 static long
5062 alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5063 {
5064   alpha_vms_slurp_relocs (abfd);
5065
5066   return (section->reloc_count + 1) * sizeof (arelent *);
5067 }
5068
5069 /* Convert relocations from VMS (external) form into BFD internal
5070    form.  Return the number of relocations.  */
5071
5072 static long
5073 alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5074                               asymbol **symbols ATTRIBUTE_UNUSED)
5075 {
5076   arelent *tblptr;
5077   int count;
5078
5079   if (!alpha_vms_slurp_relocs (abfd))
5080     return -1;
5081
5082   count = section->reloc_count;
5083   tblptr = section->relocation;
5084
5085   while (count--)
5086     *relptr++ = tblptr++;
5087
5088   *relptr = (arelent *) NULL;
5089   return section->reloc_count;
5090 }
5091 \f
5092 /* This is just copied from ecoff-alpha, needs to be fixed probably.  */
5093
5094 /* How to process the various reloc types.  */
5095
5096 static bfd_reloc_status_type
5097 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5098            arelent *reloc ATTRIBUTE_UNUSED,
5099            asymbol *sym ATTRIBUTE_UNUSED,
5100            void * data ATTRIBUTE_UNUSED,
5101            asection *sec ATTRIBUTE_UNUSED,
5102            bfd *output_bfd ATTRIBUTE_UNUSED,
5103            char **error_message ATTRIBUTE_UNUSED)
5104 {
5105 #if VMS_DEBUG
5106   vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5107   vms_debug (2, "In section %s, symbol %s\n",
5108         sec->name, sym->name);
5109   vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5110                 reloc->sym_ptr_ptr[0]->name,
5111                 (unsigned long)reloc->address,
5112                 (unsigned long)reloc->addend, reloc->howto->name);
5113   vms_debug (2, "data at %p\n", data);
5114   /*  _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5115 #endif
5116
5117   return bfd_reloc_ok;
5118 }
5119
5120 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5121    from smaller values.  Start with zero, widen, *then* decrement.  */
5122 #define MINUS_ONE       (((bfd_vma)0) - 1)
5123
5124 static reloc_howto_type alpha_howto_table[] =
5125 {
5126   HOWTO (ALPHA_R_IGNORE,        /* Type.  */
5127          0,                     /* Rightshift.  */
5128          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5129          8,                     /* Bitsize.  */
5130          TRUE,                  /* PC relative.  */
5131          0,                     /* Bitpos.  */
5132          complain_overflow_dont,/* Complain_on_overflow.  */
5133          reloc_nil,             /* Special_function.  */
5134          "IGNORE",              /* Name.  */
5135          TRUE,                  /* Partial_inplace.  */
5136          0,                     /* Source mask */
5137          0,                     /* Dest mask.  */
5138          TRUE),                 /* PC rel offset.  */
5139
5140   /* A 64 bit reference to a symbol.  */
5141   HOWTO (ALPHA_R_REFQUAD,       /* Type.  */
5142          0,                     /* Rightshift.  */
5143          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5144          64,                    /* Bitsize.  */
5145          FALSE,                 /* PC relative.  */
5146          0,                     /* Bitpos.  */
5147          complain_overflow_bitfield, /* Complain_on_overflow.  */
5148          reloc_nil,             /* Special_function.  */
5149          "REFQUAD",             /* Name.  */
5150          TRUE,                  /* Partial_inplace.  */
5151          MINUS_ONE,             /* Source mask.  */
5152          MINUS_ONE,             /* Dest mask.  */
5153          FALSE),                /* PC rel offset.  */
5154
5155   /* A 21 bit branch.  The native assembler generates these for
5156      branches within the text segment, and also fills in the PC
5157      relative offset in the instruction.  */
5158   HOWTO (ALPHA_R_BRADDR,        /* Type.  */
5159          2,                     /* Rightshift.  */
5160          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5161          21,                    /* Bitsize.  */
5162          TRUE,                  /* PC relative.  */
5163          0,                     /* Bitpos.  */
5164          complain_overflow_signed, /* Complain_on_overflow.  */
5165          reloc_nil,             /* Special_function.  */
5166          "BRADDR",              /* Name.  */
5167          TRUE,                  /* Partial_inplace.  */
5168          0x1fffff,              /* Source mask.  */
5169          0x1fffff,              /* Dest mask.  */
5170          FALSE),                /* PC rel offset.  */
5171
5172   /* A hint for a jump to a register.  */
5173   HOWTO (ALPHA_R_HINT,          /* Type.  */
5174          2,                     /* Rightshift.  */
5175          1,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5176          14,                    /* Bitsize.  */
5177          TRUE,                  /* PC relative.  */
5178          0,                     /* Bitpos.  */
5179          complain_overflow_dont,/* Complain_on_overflow.  */
5180          reloc_nil,             /* Special_function.  */
5181          "HINT",                /* Name.  */
5182          TRUE,                  /* Partial_inplace.  */
5183          0x3fff,                /* Source mask.  */
5184          0x3fff,                /* Dest mask.  */
5185          FALSE),                /* PC rel offset.  */
5186
5187   /* 16 bit PC relative offset.  */
5188   HOWTO (ALPHA_R_SREL16,        /* Type.  */
5189          0,                     /* Rightshift.  */
5190          1,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5191          16,                    /* Bitsize.  */
5192          TRUE,                  /* PC relative.  */
5193          0,                     /* Bitpos.  */
5194          complain_overflow_signed, /* Complain_on_overflow.  */
5195          reloc_nil,             /* Special_function.  */
5196          "SREL16",              /* Name.  */
5197          TRUE,                  /* Partial_inplace.  */
5198          0xffff,                /* Source mask.  */
5199          0xffff,                /* Dest mask.  */
5200          FALSE),                /* PC rel offset.  */
5201
5202   /* 32 bit PC relative offset.  */
5203   HOWTO (ALPHA_R_SREL32,        /* Type.  */
5204          0,                     /* Rightshift.  */
5205          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5206          32,                    /* Bitsize.  */
5207          TRUE,                  /* PC relative.  */
5208          0,                     /* Bitpos.  */
5209          complain_overflow_signed, /* Complain_on_overflow.  */
5210          reloc_nil,             /* Special_function.  */
5211          "SREL32",              /* Name.  */
5212          TRUE,                  /* Partial_inplace.  */
5213          0xffffffff,            /* Source mask.  */
5214          0xffffffff,            /* Dest mask.  */
5215          FALSE),                /* PC rel offset.  */
5216
5217   /* A 64 bit PC relative offset.  */
5218   HOWTO (ALPHA_R_SREL64,        /* Type.  */
5219          0,                     /* Rightshift.  */
5220          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5221          64,                    /* Bitsize.  */
5222          TRUE,                  /* PC relative.  */
5223          0,                     /* Bitpos.  */
5224          complain_overflow_signed, /* Complain_on_overflow.  */
5225          reloc_nil,             /* Special_function.  */
5226          "SREL64",              /* Name.  */
5227          TRUE,                  /* Partial_inplace.  */
5228          MINUS_ONE,             /* Source mask.  */
5229          MINUS_ONE,             /* Dest mask.  */
5230          FALSE),                /* PC rel offset.  */
5231
5232   /* Push a value on the reloc evaluation stack.  */
5233   HOWTO (ALPHA_R_OP_PUSH,       /* Type.  */
5234          0,                     /* Rightshift.  */
5235          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5236          0,                     /* Bitsize.  */
5237          FALSE,                 /* PC relative.  */
5238          0,                     /* Bitpos.  */
5239          complain_overflow_dont,/* Complain_on_overflow.  */
5240          reloc_nil,             /* Special_function.  */
5241          "OP_PUSH",             /* Name.  */
5242          FALSE,                 /* Partial_inplace.  */
5243          0,                     /* Source mask.  */
5244          0,                     /* Dest mask.  */
5245          FALSE),                /* PC rel offset.  */
5246
5247   /* Store the value from the stack at the given address.  Store it in
5248      a bitfield of size r_size starting at bit position r_offset.  */
5249   HOWTO (ALPHA_R_OP_STORE,      /* Type.  */
5250          0,                     /* Rightshift.  */
5251          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5252          64,                    /* Bitsize.  */
5253          FALSE,                 /* PC relative.  */
5254          0,                     /* Bitpos.  */
5255          complain_overflow_dont,/* Complain_on_overflow.  */
5256          reloc_nil,             /* Special_function.  */
5257          "OP_STORE",            /* Name.  */
5258          FALSE,                 /* Partial_inplace.  */
5259          0,                     /* Source mask.  */
5260          MINUS_ONE,             /* Dest mask.  */
5261          FALSE),                /* PC rel offset.  */
5262
5263   /* Subtract the reloc address from the value on the top of the
5264      relocation stack.  */
5265   HOWTO (ALPHA_R_OP_PSUB,       /* Type.  */
5266          0,                     /* Rightshift.  */
5267          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5268          0,                     /* Bitsize.  */
5269          FALSE,                 /* PC relative.  */
5270          0,                     /* Bitpos.  */
5271          complain_overflow_dont,/* Complain_on_overflow.  */
5272          reloc_nil,             /* Special_function.  */
5273          "OP_PSUB",             /* Name.  */
5274          FALSE,                 /* Partial_inplace.  */
5275          0,                     /* Source mask.  */
5276          0,                     /* Dest mask.  */
5277          FALSE),                /* PC rel offset.  */
5278
5279   /* Shift the value on the top of the relocation stack right by the
5280      given value.  */
5281   HOWTO (ALPHA_R_OP_PRSHIFT,    /* Type.  */
5282          0,                     /* Rightshift.  */
5283          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5284          0,                     /* Bitsize.  */
5285          FALSE,                 /* PC relative.  */
5286          0,                     /* Bitpos.  */
5287          complain_overflow_dont,/* Complain_on_overflow.  */
5288          reloc_nil,             /* Special_function.  */
5289          "OP_PRSHIFT",          /* Name.  */
5290          FALSE,                 /* Partial_inplace.  */
5291          0,                     /* Source mask.  */
5292          0,                     /* Dest mask.  */
5293          FALSE),                /* PC rel offset.  */
5294
5295   /* Hack. Linkage is done by linker.  */
5296   HOWTO (ALPHA_R_LINKAGE,       /* Type.  */
5297          0,                     /* Rightshift.  */
5298          8,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5299          256,                   /* Bitsize.  */
5300          FALSE,                 /* PC relative.  */
5301          0,                     /* Bitpos.  */
5302          complain_overflow_dont,/* Complain_on_overflow.  */
5303          reloc_nil,             /* Special_function.  */
5304          "LINKAGE",             /* Name.  */
5305          FALSE,                 /* Partial_inplace.  */
5306          0,                     /* Source mask.  */
5307          0,                     /* Dest mask.  */
5308          FALSE),                /* PC rel offset.  */
5309
5310   /* A 32 bit reference to a symbol.  */
5311   HOWTO (ALPHA_R_REFLONG,       /* Type.  */
5312          0,                     /* Rightshift.  */
5313          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5314          32,                    /* Bitsize.  */
5315          FALSE,                 /* PC relative.  */
5316          0,                     /* Bitpos.  */
5317          complain_overflow_bitfield, /* Complain_on_overflow.  */
5318          reloc_nil,             /* Special_function.  */
5319          "REFLONG",             /* Name.  */
5320          TRUE,                  /* Partial_inplace.  */
5321          0xffffffff,            /* Source mask.  */
5322          0xffffffff,            /* Dest mask.  */
5323          FALSE),                /* PC rel offset.  */
5324
5325   /* A 64 bit reference to a procedure, written as 32 bit value.  */
5326   HOWTO (ALPHA_R_CODEADDR,      /* Type.  */
5327          0,                     /* Rightshift.  */
5328          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5329          64,                    /* Bitsize.  */
5330          FALSE,                 /* PC relative.  */
5331          0,                     /* Bitpos.  */
5332          complain_overflow_signed,/* Complain_on_overflow.  */
5333          reloc_nil,             /* Special_function.  */
5334          "CODEADDR",            /* Name.  */
5335          FALSE,                 /* Partial_inplace.  */
5336          0xffffffff,            /* Source mask.  */
5337          0xffffffff,            /* Dest mask.  */
5338          FALSE),                /* PC rel offset.  */
5339
5340   HOWTO (ALPHA_R_NOP,           /* Type.  */
5341          0,                     /* Rightshift.  */
5342          3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5343          0,                     /* Bitsize.  */
5344          /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5345             because the calculations for the 3 relocations are the same.
5346             See B.4.5.2 of the OpenVMS Linker Utility Manual.  */
5347          TRUE,                  /* PC relative.  */
5348          0,                     /* Bitpos.   */
5349          complain_overflow_dont,/* Complain_on_overflow.  */
5350          reloc_nil,             /* Special_function.  */
5351          "NOP",                 /* Name.  */
5352          FALSE,                 /* Partial_inplace.  */
5353          0xffffffff,            /* Source mask.  */
5354          0xffffffff,            /* Dest mask.  */
5355          FALSE),                /* PC rel offset.  */
5356
5357   HOWTO (ALPHA_R_BSR,           /* Type.  */
5358          0,                     /* Rightshift.  */
5359          3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5360          0,                     /* Bitsize.  */
5361          TRUE,                  /* PC relative.  */
5362          0,                     /* Bitpos.  */
5363          complain_overflow_dont,/* Complain_on_overflow.  */
5364          reloc_nil,             /* Special_function.  */
5365          "BSR",                 /* Name.  */
5366          FALSE,                 /* Partial_inplace.  */
5367          0xffffffff,            /* Source mask.  */
5368          0xffffffff,            /* Dest mask.  */
5369          FALSE),                /* PC rel offset.  */
5370
5371   HOWTO (ALPHA_R_LDA,           /* Type.  */
5372          0,                     /* Rightshift.  */
5373          3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5374          0,                     /* Bitsize.  */
5375          FALSE,                 /* PC relative.  */
5376          0,                     /* Bitpos.  */
5377          complain_overflow_dont,/* Complain_on_overflow.  */
5378          reloc_nil,             /* Special_function.  */
5379          "LDA",                 /* Name.  */
5380          FALSE,                 /* Partial_inplace.  */
5381          0xffffffff,            /* Source mask.  */
5382          0xffffffff,            /* Dest mask.  */
5383          FALSE),                /* PC rel offset.  */
5384
5385   HOWTO (ALPHA_R_BOH,           /* Type.  */
5386          0,                     /* Rightshift.  */
5387          3,                     /* Size (0 = byte, 1 = short, 2 = long, 3 = nil).  */
5388          0,                     /* Bitsize.  */
5389          TRUE,                  /* PC relative.  */
5390          0,                     /* Bitpos.  */
5391          complain_overflow_dont,/* Complain_on_overflow.  */
5392          reloc_nil,             /* Special_function.  */
5393          "BOH",                 /* Name.  */
5394          FALSE,                 /* Partial_inplace.  */
5395          0xffffffff,            /* Source mask.  */
5396          0xffffffff,            /* Dest mask.  */
5397          FALSE),                /* PC rel offset.  */
5398 };
5399
5400 /* Return a pointer to a howto structure which, when invoked, will perform
5401    the relocation code on data from the architecture noted.  */
5402
5403 static const struct reloc_howto_struct *
5404 alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5405                                  bfd_reloc_code_real_type code)
5406 {
5407   int alpha_type;
5408
5409   vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5410
5411   switch (code)
5412     {
5413       case BFD_RELOC_16:                alpha_type = ALPHA_R_SREL16;    break;
5414       case BFD_RELOC_32:                alpha_type = ALPHA_R_REFLONG;   break;
5415       case BFD_RELOC_64:                alpha_type = ALPHA_R_REFQUAD;   break;
5416       case BFD_RELOC_CTOR:              alpha_type = ALPHA_R_REFQUAD;   break;
5417       case BFD_RELOC_23_PCREL_S2:       alpha_type = ALPHA_R_BRADDR;    break;
5418       case BFD_RELOC_ALPHA_HINT:        alpha_type = ALPHA_R_HINT;      break;
5419       case BFD_RELOC_16_PCREL:          alpha_type = ALPHA_R_SREL16;    break;
5420       case BFD_RELOC_32_PCREL:          alpha_type = ALPHA_R_SREL32;    break;
5421       case BFD_RELOC_64_PCREL:          alpha_type = ALPHA_R_SREL64;    break;
5422       case BFD_RELOC_ALPHA_LINKAGE:     alpha_type = ALPHA_R_LINKAGE;   break;
5423       case BFD_RELOC_ALPHA_CODEADDR:    alpha_type = ALPHA_R_CODEADDR;  break;
5424       case BFD_RELOC_ALPHA_NOP:         alpha_type = ALPHA_R_NOP;       break;
5425       case BFD_RELOC_ALPHA_BSR:         alpha_type = ALPHA_R_BSR;       break;
5426       case BFD_RELOC_ALPHA_LDA:         alpha_type = ALPHA_R_LDA;       break;
5427       case BFD_RELOC_ALPHA_BOH:         alpha_type = ALPHA_R_BOH;       break;
5428       default:
5429         (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5430         return NULL;
5431     }
5432   vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5433   return & alpha_howto_table[alpha_type];
5434 }
5435
5436 static reloc_howto_type *
5437 alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5438                                  const char *r_name)
5439 {
5440   unsigned int i;
5441
5442   for (i = 0;
5443        i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5444        i++)
5445     if (alpha_howto_table[i].name != NULL
5446         && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5447       return &alpha_howto_table[i];
5448
5449   return NULL;
5450 }
5451 \f
5452 static long
5453 alpha_vms_get_synthetic_symtab (bfd *abfd,
5454                                 long symcount ATTRIBUTE_UNUSED,
5455                                 asymbol **usyms ATTRIBUTE_UNUSED,
5456                                 long dynsymcount ATTRIBUTE_UNUSED,
5457                                 asymbol **dynsyms ATTRIBUTE_UNUSED,
5458                                 asymbol **ret)
5459 {
5460   asymbol *syms;
5461   unsigned int i;
5462   unsigned int n = 0;
5463
5464   syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5465   *ret = syms;
5466   if (syms == NULL)
5467     return -1;
5468
5469   for (i = 0; i < PRIV (gsd_sym_count); i++)
5470     {
5471       struct vms_symbol_entry *e = PRIV (syms)[i];
5472       asymbol *sym;
5473       flagword flags;
5474       symvalue value;
5475       asection *sec;
5476       const char *name;
5477       char *sname;
5478       int l;
5479
5480       name = e->name;
5481       value = 0;
5482       flags = BSF_LOCAL | BSF_SYNTHETIC;
5483       sec = NULL;
5484
5485       switch (e->typ)
5486         {
5487         case EGSD__C_SYM:
5488         case EGSD__C_SYMG:
5489           if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5490             {
5491               value = e->code_value;
5492               sec = e->code_section;
5493             }
5494           else
5495             continue;
5496           break;
5497
5498         default:
5499           continue;
5500         }
5501
5502       l = strlen (name);
5503       sname = bfd_alloc (abfd, l + 5);
5504       if (sname == NULL)
5505         return FALSE;
5506       memcpy (sname, name, l);
5507       memcpy (sname + l, "..en", 5);
5508
5509       sym = &syms[n++];
5510       sym->name = sname;
5511       sym->section = sec;
5512       sym->flags = flags;
5513       sym->value = value;
5514       sym->udata.p = NULL;
5515     }
5516
5517   return n;
5518 }
5519 \f
5520 /* Private dump.  */
5521
5522 static const char *
5523 vms_time_to_str (unsigned char *buf)
5524 {
5525   time_t t = vms_rawtime_to_time_t (buf);
5526   char *res = ctime (&t);
5527
5528   if (!res)
5529     res = "*invalid time*";
5530   else
5531     res[24] = 0;
5532   return res;
5533 }
5534
5535 static void
5536 evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5537 {
5538   struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5539   unsigned int subtype;
5540
5541   subtype = (unsigned)bfd_getl16 (emh->subtyp);
5542
5543   fprintf (file, _("  EMH %u (len=%u): "), subtype, rec_len);
5544
5545   switch (subtype)
5546     {
5547     case EMH__C_MHD:
5548       {
5549         struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5550         const char *name;
5551
5552         fprintf (file, _("Module header\n"));
5553         fprintf (file, _("   structure level: %u\n"), mhd->strlvl);
5554         fprintf (file, _("   max record size: %u\n"),
5555                  (unsigned)bfd_getl32 (mhd->recsiz));
5556         name = (char *)(mhd + 1);
5557         fprintf (file, _("   module name    : %.*s\n"), name[0], name + 1);
5558         name += name[0] + 1;
5559         fprintf (file, _("   module version : %.*s\n"), name[0], name + 1);
5560         name += name[0] + 1;
5561         fprintf (file, _("   compile date   : %.17s\n"), name);
5562       }
5563       break;
5564     case EMH__C_LNM:
5565       {
5566         fprintf (file, _("Language Processor Name\n"));
5567         fprintf (file, _("   language name: %.*s\n"),
5568                  (int)(rec_len - sizeof (struct vms_emh_common)),
5569                  (char *)rec + sizeof (struct vms_emh_common));
5570       }
5571       break;
5572     case EMH__C_SRC:
5573       {
5574         fprintf (file, _("Source Files Header\n"));
5575         fprintf (file, _("   file: %.*s\n"),
5576                  (int)(rec_len - sizeof (struct vms_emh_common)),
5577                  (char *)rec + sizeof (struct vms_emh_common));
5578       }
5579       break;
5580     case EMH__C_TTL:
5581       {
5582         fprintf (file, _("Title Text Header\n"));
5583         fprintf (file, _("   title: %.*s\n"),
5584                  (int)(rec_len - sizeof (struct vms_emh_common)),
5585                  (char *)rec + sizeof (struct vms_emh_common));
5586       }
5587       break;
5588     case EMH__C_CPR:
5589       {
5590         fprintf (file, _("Copyright Header\n"));
5591         fprintf (file, _("   copyright: %.*s\n"),
5592                  (int)(rec_len - sizeof (struct vms_emh_common)),
5593                  (char *)rec + sizeof (struct vms_emh_common));
5594       }
5595       break;
5596     default:
5597       fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5598       break;
5599     }
5600 }
5601
5602 static void
5603 evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5604 {
5605   struct vms_eeom *eeom = (struct vms_eeom *)rec;
5606
5607   fprintf (file, _("  EEOM (len=%u):\n"), rec_len);
5608   fprintf (file, _("   number of cond linkage pairs: %u\n"),
5609            (unsigned)bfd_getl32 (eeom->total_lps));
5610   fprintf (file, _("   completion code: %u\n"),
5611            (unsigned)bfd_getl16 (eeom->comcod));
5612   if (rec_len > 10)
5613     {
5614       fprintf (file, _("   transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5615       fprintf (file, _("   transfer addr psect: %u\n"),
5616                (unsigned)bfd_getl32 (eeom->psindx));
5617       fprintf (file, _("   transfer address   : 0x%08x\n"),
5618                (unsigned)bfd_getl32 (eeom->tfradr));
5619     }
5620 }
5621
5622 static void
5623 exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5624 {
5625   if (flags & EGSY__V_WEAK)
5626     fputs (_(" WEAK"), file);
5627   if (flags & EGSY__V_DEF)
5628     fputs (_(" DEF"), file);
5629   if (flags & EGSY__V_UNI)
5630     fputs (_(" UNI"), file);
5631   if (flags & EGSY__V_REL)
5632     fputs (_(" REL"), file);
5633   if (flags & EGSY__V_COMM)
5634     fputs (_(" COMM"), file);
5635   if (flags & EGSY__V_VECEP)
5636     fputs (_(" VECEP"), file);
5637   if (flags & EGSY__V_NORM)
5638     fputs (_(" NORM"), file);
5639   if (flags & EGSY__V_QUAD_VAL)
5640     fputs (_(" QVAL"), file);
5641 }
5642
5643 static void
5644 evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5645 {
5646   if (flags & EGPS__V_PIC)
5647     fputs (_(" PIC"), file);
5648   if (flags & EGPS__V_LIB)
5649     fputs (_(" LIB"), file);
5650   if (flags & EGPS__V_OVR)
5651     fputs (_(" OVR"), file);
5652   if (flags & EGPS__V_REL)
5653     fputs (_(" REL"), file);
5654   if (flags & EGPS__V_GBL)
5655     fputs (_(" GBL"), file);
5656   if (flags & EGPS__V_SHR)
5657     fputs (_(" SHR"), file);
5658   if (flags & EGPS__V_EXE)
5659     fputs (_(" EXE"), file);
5660   if (flags & EGPS__V_RD)
5661     fputs (_(" RD"), file);
5662   if (flags & EGPS__V_WRT)
5663     fputs (_(" WRT"), file);
5664   if (flags & EGPS__V_VEC)
5665     fputs (_(" VEC"), file);
5666   if (flags & EGPS__V_NOMOD)
5667     fputs (_(" NOMOD"), file);
5668   if (flags & EGPS__V_COM)
5669     fputs (_(" COM"), file);
5670   if (flags & EGPS__V_ALLOC_64BIT)
5671     fputs (_(" 64B"), file);
5672 }
5673
5674 static void
5675 evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5676 {
5677   unsigned int off = sizeof (struct vms_egsd);
5678   unsigned int n;
5679
5680   fprintf (file, _("  EGSD (len=%u):\n"), rec_len);
5681
5682   n = 0;
5683   for (off = sizeof (struct vms_egsd); off < rec_len; )
5684     {
5685       struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5686       unsigned int type;
5687       unsigned int len;
5688
5689       type = (unsigned)bfd_getl16 (e->gsdtyp);
5690       len = (unsigned)bfd_getl16 (e->gsdsiz);
5691
5692       fprintf (file, _("  EGSD entry %2u (type: %u, len: %u): "),
5693                n, type, len);
5694       n++;
5695
5696       switch (type)
5697         {
5698         case EGSD__C_PSC:
5699           {
5700             struct vms_egps *egps = (struct vms_egps *)e;
5701             unsigned int flags = bfd_getl16 (egps->flags);
5702             unsigned int l;
5703
5704             fprintf (file, _("PSC - Program section definition\n"));
5705             fprintf (file, _("   alignment  : 2**%u\n"), egps->align);
5706             fprintf (file, _("   flags      : 0x%04x"), flags);
5707             evax_bfd_print_egsd_flags (file, flags);
5708             fputc ('\n', file);
5709             l = bfd_getl32 (egps->alloc);
5710             fprintf (file, _("   alloc (len): %u (0x%08x)\n"), l, l);
5711             fprintf (file, _("   name       : %.*s\n"),
5712                      egps->namlng, egps->name);
5713           }
5714           break;
5715         case EGSD__C_SPSC:
5716           {
5717             struct vms_esgps *esgps = (struct vms_esgps *)e;
5718             unsigned int flags = bfd_getl16 (esgps->flags);
5719             unsigned int l;
5720
5721             fprintf (file, _("SPSC - Shared Image Program section def\n"));
5722             fprintf (file, _("   alignment  : 2**%u\n"), esgps->align);
5723             fprintf (file, _("   flags      : 0x%04x"), flags);
5724             evax_bfd_print_egsd_flags (file, flags);
5725             fputc ('\n', file);
5726             l = bfd_getl32 (esgps->alloc);
5727             fprintf (file, _("   alloc (len)   : %u (0x%08x)\n"), l, l);
5728             fprintf (file, _("   image offset  : 0x%08x\n"),
5729                      (unsigned int)bfd_getl32 (esgps->base));
5730             fprintf (file, _("   symvec offset : 0x%08x\n"),
5731                      (unsigned int)bfd_getl32 (esgps->value));
5732             fprintf (file, _("   name          : %.*s\n"),
5733                      esgps->namlng, esgps->name);
5734           }
5735           break;
5736         case EGSD__C_SYM:
5737           {
5738             struct vms_egsy *egsy = (struct vms_egsy *)e;
5739             unsigned int flags = bfd_getl16 (egsy->flags);
5740
5741             if (flags & EGSY__V_DEF)
5742               {
5743                 struct vms_esdf *esdf = (struct vms_esdf *)e;
5744
5745                 fprintf (file, _("SYM - Global symbol definition\n"));
5746                 fprintf (file, _("   flags: 0x%04x"), flags);
5747                 exav_bfd_print_egsy_flags (flags, file);
5748                 fputc ('\n', file);
5749                 fprintf (file, _("   psect offset: 0x%08x\n"),
5750                          (unsigned)bfd_getl32 (esdf->value));
5751                 if (flags & EGSY__V_NORM)
5752                   {
5753                     fprintf (file, _("   code address: 0x%08x\n"),
5754                              (unsigned)bfd_getl32 (esdf->code_address));
5755                     fprintf (file, _("   psect index for entry point : %u\n"),
5756                              (unsigned)bfd_getl32 (esdf->ca_psindx));
5757                   }
5758                 fprintf (file, _("   psect index : %u\n"),
5759                          (unsigned)bfd_getl32 (esdf->psindx));
5760                 fprintf (file, _("   name        : %.*s\n"),
5761                          esdf->namlng, esdf->name);
5762               }
5763             else
5764               {
5765                 struct vms_esrf *esrf = (struct vms_esrf *)e;
5766
5767                 fprintf (file, _("SYM - Global symbol reference\n"));
5768                 fprintf (file, _("   name       : %.*s\n"),
5769                          esrf->namlng, esrf->name);
5770               }
5771           }
5772           break;
5773         case EGSD__C_IDC:
5774           {
5775             struct vms_eidc *eidc = (struct vms_eidc *)e;
5776             unsigned int flags = bfd_getl32 (eidc->flags);
5777             unsigned char *p;
5778
5779             fprintf (file, _("IDC - Ident Consistency check\n"));
5780             fprintf (file, _("   flags         : 0x%08x"), flags);
5781             if (flags & EIDC__V_BINIDENT)
5782               fputs (" BINDENT", file);
5783             fputc ('\n', file);
5784             fprintf (file, _("   id match      : %x\n"),
5785                      (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5786             fprintf (file, _("   error severity: %x\n"),
5787                      (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5788             p = eidc->name;
5789             fprintf (file, _("   entity name   : %.*s\n"), p[0], p + 1);
5790             p += 1 + p[0];
5791             fprintf (file, _("   object name   : %.*s\n"), p[0], p + 1);
5792             p += 1 + p[0];
5793             if (flags & EIDC__V_BINIDENT)
5794               fprintf (file, _("   binary ident  : 0x%08x\n"),
5795                        (unsigned)bfd_getl32 (p + 1));
5796             else
5797               fprintf (file, _("   ascii ident   : %.*s\n"), p[0], p + 1);
5798           }
5799           break;
5800         case EGSD__C_SYMG:
5801           {
5802             struct vms_egst *egst = (struct vms_egst *)e;
5803             unsigned int flags = bfd_getl16 (egst->header.flags);
5804
5805             fprintf (file, _("SYMG - Universal symbol definition\n"));
5806             fprintf (file, _("   flags: 0x%04x"), flags);
5807             exav_bfd_print_egsy_flags (flags, file);
5808             fputc ('\n', file);
5809             fprintf (file, _("   symbol vector offset: 0x%08x\n"),
5810                      (unsigned)bfd_getl32 (egst->value));
5811             fprintf (file, _("   entry point: 0x%08x\n"),
5812                      (unsigned)bfd_getl32 (egst->lp_1));
5813             fprintf (file, _("   proc descr : 0x%08x\n"),
5814                      (unsigned)bfd_getl32 (egst->lp_2));
5815             fprintf (file, _("   psect index: %u\n"),
5816                      (unsigned)bfd_getl32 (egst->psindx));
5817             fprintf (file, _("   name       : %.*s\n"),
5818                      egst->namlng, egst->name);
5819           }
5820           break;
5821         case EGSD__C_SYMV:
5822           {
5823             struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5824             unsigned int flags = bfd_getl16 (esdfv->flags);
5825
5826             fprintf (file, _("SYMV - Vectored symbol definition\n"));
5827             fprintf (file, _("   flags: 0x%04x"), flags);
5828             exav_bfd_print_egsy_flags (flags, file);
5829             fputc ('\n', file);
5830             fprintf (file, _("   vector      : 0x%08x\n"),
5831                      (unsigned)bfd_getl32 (esdfv->vector));
5832             fprintf (file, _("   psect offset: %u\n"),
5833                      (unsigned)bfd_getl32 (esdfv->value));
5834             fprintf (file, _("   psect index : %u\n"),
5835                      (unsigned)bfd_getl32 (esdfv->psindx));
5836             fprintf (file, _("   name        : %.*s\n"),
5837                      esdfv->namlng, esdfv->name);
5838           }
5839           break;
5840         case EGSD__C_SYMM:
5841           {
5842             struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5843             unsigned int flags = bfd_getl16 (esdfm->flags);
5844
5845             fprintf (file, _("SYMM - Global symbol definition with version\n"));
5846             fprintf (file, _("   flags: 0x%04x"), flags);
5847             exav_bfd_print_egsy_flags (flags, file);
5848             fputc ('\n', file);
5849             fprintf (file, _("   version mask: 0x%08x\n"),
5850                      (unsigned)bfd_getl32 (esdfm->version_mask));
5851             fprintf (file, _("   psect offset: %u\n"),
5852                      (unsigned)bfd_getl32 (esdfm->value));
5853             fprintf (file, _("   psect index : %u\n"),
5854                      (unsigned)bfd_getl32 (esdfm->psindx));
5855             fprintf (file, _("   name        : %.*s\n"),
5856                      esdfm->namlng, esdfm->name);
5857           }
5858           break;
5859         default:
5860           fprintf (file, _("unhandled egsd entry type %u\n"), type);
5861           break;
5862         }
5863       off += len;
5864     }
5865 }
5866
5867 static void
5868 evax_bfd_print_hex (FILE *file, const char *pfx,
5869                     const unsigned char *buf, unsigned int len)
5870 {
5871   unsigned int i;
5872   unsigned int n;
5873
5874   n = 0;
5875   for (i = 0; i < len; i++)
5876     {
5877       if (n == 0)
5878         fputs (pfx, file);
5879       fprintf (file, " %02x", buf[i]);
5880       n++;
5881       if (n == 16)
5882         {
5883           n = 0;
5884           fputc ('\n', file);
5885         }
5886     }
5887   if (n != 0)
5888     fputc ('\n', file);
5889 }
5890
5891 static void
5892 evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
5893 {
5894   fprintf (file, _("    linkage index: %u, replacement insn: 0x%08x\n"),
5895            (unsigned)bfd_getl32 (buf),
5896            (unsigned)bfd_getl32 (buf + 16));
5897   fprintf (file, _("    psect idx 1: %u, offset 1: 0x%08x %08x\n"),
5898            (unsigned)bfd_getl32 (buf + 4),
5899            (unsigned)bfd_getl32 (buf + 12),
5900            (unsigned)bfd_getl32 (buf + 8));
5901   fprintf (file, _("    psect idx 2: %u, offset 2: 0x%08x %08x\n"),
5902            (unsigned)bfd_getl32 (buf + 20),
5903            (unsigned)bfd_getl32 (buf + 28),
5904            (unsigned)bfd_getl32 (buf + 24));
5905   if (is_ps)
5906     fprintf (file, _("    psect idx 3: %u, offset 3: 0x%08x %08x\n"),
5907              (unsigned)bfd_getl32 (buf + 32),
5908              (unsigned)bfd_getl32 (buf + 40),
5909              (unsigned)bfd_getl32 (buf + 36));
5910   else
5911     fprintf (file, _("    global name: %.*s\n"), buf[32], buf + 33);
5912 }
5913
5914 static void
5915 evax_bfd_print_etir (FILE *file, const char *name,
5916                      unsigned char *rec, unsigned int rec_len)
5917 {
5918   unsigned int off = sizeof (struct vms_egsd);
5919   unsigned int sec_len = 0;
5920
5921   fprintf (file, _("  %s (len=%u+%u):\n"), name,
5922            (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
5923            (unsigned)sizeof (struct vms_eobjrec));
5924
5925   for (off = sizeof (struct vms_eobjrec); off < rec_len; )
5926     {
5927       struct vms_etir *etir = (struct vms_etir *)(rec + off);
5928       unsigned char *buf;
5929       unsigned int type;
5930       unsigned int size;
5931
5932       type = bfd_getl16 (etir->rectyp);
5933       size = bfd_getl16 (etir->size);
5934       buf = rec + off + sizeof (struct vms_etir);
5935
5936       fprintf (file, _("   (type: %3u, size: 4+%3u): "), type, size - 4);
5937       switch (type)
5938         {
5939         case ETIR__C_STA_GBL:
5940           fprintf (file, _("STA_GBL (stack global) %.*s\n"),
5941                    buf[0], buf + 1);
5942           break;
5943         case ETIR__C_STA_LW:
5944           fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
5945                    (unsigned)bfd_getl32 (buf));
5946           break;
5947         case ETIR__C_STA_QW:
5948           fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
5949                    (unsigned)bfd_getl32 (buf + 4),
5950                    (unsigned)bfd_getl32 (buf + 0));
5951           break;
5952         case ETIR__C_STA_PQ:
5953           fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
5954           fprintf (file, _("    psect: %u, offset: 0x%08x %08x\n"),
5955                    (unsigned)bfd_getl32 (buf + 0),
5956                    (unsigned)bfd_getl32 (buf + 8),
5957                    (unsigned)bfd_getl32 (buf + 4));
5958           break;
5959         case ETIR__C_STA_LI:
5960           fprintf (file, _("STA_LI (stack literal)\n"));
5961           break;
5962         case ETIR__C_STA_MOD:
5963           fprintf (file, _("STA_MOD (stack module)\n"));
5964           break;
5965         case ETIR__C_STA_CKARG:
5966           fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
5967           break;
5968
5969         case ETIR__C_STO_B:
5970           fprintf (file, _("STO_B (store byte)\n"));
5971           break;
5972         case ETIR__C_STO_W:
5973           fprintf (file, _("STO_W (store word)\n"));
5974           break;
5975         case ETIR__C_STO_LW:
5976           fprintf (file, _("STO_LW (store longword)\n"));
5977           break;
5978         case ETIR__C_STO_QW:
5979           fprintf (file, _("STO_QW (store quadword)\n"));
5980           break;
5981         case ETIR__C_STO_IMMR:
5982           {
5983             unsigned int len = bfd_getl32 (buf);
5984             fprintf (file,
5985                      _("STO_IMMR (store immediate repeat) %u bytes\n"),
5986                      len);
5987             evax_bfd_print_hex (file, "   ", buf + 4, len);
5988             sec_len += len;
5989           }
5990           break;
5991         case ETIR__C_STO_GBL:
5992           fprintf (file, _("STO_GBL (store global) %.*s\n"),
5993                    buf[0], buf + 1);
5994           break;
5995         case ETIR__C_STO_CA:
5996           fprintf (file, _("STO_CA (store code address) %.*s\n"),
5997                    buf[0], buf + 1);
5998           break;
5999         case ETIR__C_STO_RB:
6000           fprintf (file, _("STO_RB (store relative branch)\n"));
6001           break;
6002         case ETIR__C_STO_AB:
6003           fprintf (file, _("STO_AB (store absolute branch)\n"));
6004           break;
6005         case ETIR__C_STO_OFF:
6006           fprintf (file, _("STO_OFF (store offset to psect)\n"));
6007           break;
6008         case ETIR__C_STO_IMM:
6009           {
6010             unsigned int len = bfd_getl32 (buf);
6011             fprintf (file,
6012                      _("STO_IMM (store immediate) %u bytes\n"),
6013                      len);
6014             evax_bfd_print_hex (file, "   ", buf + 4, len);
6015             sec_len += len;
6016           }
6017           break;
6018         case ETIR__C_STO_GBL_LW:
6019           fprintf (file, _("STO_GBL_LW (store global longword) %.*s\n"),
6020                    buf[0], buf + 1);
6021           break;
6022         case ETIR__C_STO_LP_PSB:
6023           fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6024           break;
6025         case ETIR__C_STO_HINT_GBL:
6026           fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6027           break;
6028         case ETIR__C_STO_HINT_PS:
6029           fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6030           break;
6031
6032         case ETIR__C_OPR_NOP:
6033           fprintf (file, _("OPR_NOP (no-operation)\n"));
6034           break;
6035         case ETIR__C_OPR_ADD:
6036           fprintf (file, _("OPR_ADD (add)\n"));
6037           break;
6038         case ETIR__C_OPR_SUB:
6039           fprintf (file, _("OPR_SUB (substract)\n"));
6040           break;
6041         case ETIR__C_OPR_MUL:
6042           fprintf (file, _("OPR_MUL (multiply)\n"));
6043           break;
6044         case ETIR__C_OPR_DIV:
6045           fprintf (file, _("OPR_DIV (divide)\n"));
6046           break;
6047         case ETIR__C_OPR_AND:
6048           fprintf (file, _("OPR_AND (logical and)\n"));
6049           break;
6050         case ETIR__C_OPR_IOR:
6051           fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6052           break;
6053         case ETIR__C_OPR_EOR:
6054           fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6055           break;
6056         case ETIR__C_OPR_NEG:
6057           fprintf (file, _("OPR_NEG (negate)\n"));
6058           break;
6059         case ETIR__C_OPR_COM:
6060           fprintf (file, _("OPR_COM (complement)\n"));
6061           break;
6062         case ETIR__C_OPR_INSV:
6063           fprintf (file, _("OPR_INSV (insert field)\n"));
6064           break;
6065         case ETIR__C_OPR_ASH:
6066           fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6067           break;
6068         case ETIR__C_OPR_USH:
6069           fprintf (file, _("OPR_USH (unsigned shift)\n"));
6070           break;
6071         case ETIR__C_OPR_ROT:
6072           fprintf (file, _("OPR_ROT (rotate)\n"));
6073           break;
6074         case ETIR__C_OPR_SEL:
6075           fprintf (file, _("OPR_SEL (select)\n"));
6076           break;
6077         case ETIR__C_OPR_REDEF:
6078           fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6079           break;
6080         case ETIR__C_OPR_DFLIT:
6081           fprintf (file, _("OPR_REDEF (define a literal)\n"));
6082           break;
6083
6084         case ETIR__C_STC_LP:
6085           fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6086           break;
6087         case ETIR__C_STC_LP_PSB:
6088           fprintf (file,
6089                    _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6090           fprintf (file, _("   linkage index: %u, procedure: %.*s\n"),
6091                    (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6092           buf += 4 + 1 + buf[4];
6093           fprintf (file, _("   signature: %.*s\n"), buf[0], buf + 1);
6094           break;
6095         case ETIR__C_STC_GBL:
6096           fprintf (file, _("STC_GBL (store cond global)\n"));
6097           fprintf (file, _("   linkage index: %u, global: %.*s\n"),
6098                    (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6099           break;
6100         case ETIR__C_STC_GCA:
6101           fprintf (file, _("STC_GCA (store cond code address)\n"));
6102           fprintf (file, _("   linkage index: %u, procedure name: %.*s\n"),
6103                    (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6104           break;
6105         case ETIR__C_STC_PS:
6106           fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6107           fprintf (file,
6108                    _("   linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6109                    (unsigned)bfd_getl32 (buf),
6110                    (unsigned)bfd_getl32 (buf + 4),
6111                    (unsigned)bfd_getl32 (buf + 12),
6112                    (unsigned)bfd_getl32 (buf + 8));
6113           break;
6114         case ETIR__C_STC_NOP_GBL:
6115           fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6116           evax_bfd_print_etir_stc_ir (file, buf, 0);
6117           break;
6118         case ETIR__C_STC_NOP_PS:
6119           fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6120           evax_bfd_print_etir_stc_ir (file, buf, 1);
6121           break;
6122         case ETIR__C_STC_BSR_GBL:
6123           fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6124           evax_bfd_print_etir_stc_ir (file, buf, 0);
6125           break;
6126         case ETIR__C_STC_BSR_PS:
6127           fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6128           evax_bfd_print_etir_stc_ir (file, buf, 1);
6129           break;
6130         case ETIR__C_STC_LDA_GBL:
6131           fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6132           evax_bfd_print_etir_stc_ir (file, buf, 0);
6133           break;
6134         case ETIR__C_STC_LDA_PS:
6135           fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6136           evax_bfd_print_etir_stc_ir (file, buf, 1);
6137           break;
6138         case ETIR__C_STC_BOH_GBL:
6139           fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6140           evax_bfd_print_etir_stc_ir (file, buf, 0);
6141           break;
6142         case ETIR__C_STC_BOH_PS:
6143           fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6144           evax_bfd_print_etir_stc_ir (file, buf, 1);
6145           break;
6146         case ETIR__C_STC_NBH_GBL:
6147           fprintf (file,
6148                    _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6149           break;
6150         case ETIR__C_STC_NBH_PS:
6151           fprintf (file,
6152                    _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6153           break;
6154
6155         case ETIR__C_CTL_SETRB:
6156           fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6157           sec_len += 4;
6158           break;
6159         case ETIR__C_CTL_AUGRB:
6160           {
6161             unsigned int val = bfd_getl32 (buf);
6162             fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6163           }
6164           break;
6165         case ETIR__C_CTL_DFLOC:
6166           fprintf (file, _("CTL_DFLOC (define location)\n"));
6167           break;
6168         case ETIR__C_CTL_STLOC:
6169           fprintf (file, _("CTL_STLOC (set location)\n"));
6170           break;
6171         case ETIR__C_CTL_STKDL:
6172           fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6173           break;
6174         default:
6175           fprintf (file, _("*unhandled*\n"));
6176           break;
6177         }
6178       off += size;
6179     }
6180 }
6181
6182 static void
6183 evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6184 {
6185   bfd_boolean is_first = TRUE;
6186   bfd_boolean has_records = FALSE;
6187
6188   while (1)
6189     {
6190       unsigned int rec_len;
6191       unsigned int pad_len;
6192       unsigned char *rec;
6193       unsigned int hdr_size;
6194       unsigned int type;
6195
6196       if (is_first)
6197         {
6198           unsigned char buf[6];
6199
6200           is_first = FALSE;
6201
6202           /* Read 6 bytes.  */
6203           if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6204             {
6205               fprintf (file, _("cannot read GST record length\n"));
6206               return;
6207             }
6208           rec_len = bfd_getl16 (buf + 0);
6209           if (rec_len == bfd_getl16 (buf + 4)
6210               && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6211             {
6212               /* The format is raw: record-size, type, record-size.  */
6213               has_records = TRUE;
6214               pad_len = (rec_len + 1) & ~1U;
6215               hdr_size = 4;
6216             }
6217           else if (rec_len == EOBJ__C_EMH)
6218             {
6219               has_records = FALSE;
6220               pad_len = bfd_getl16 (buf + 2);
6221               hdr_size = 6;
6222             }
6223           else
6224             {
6225               /* Ill-formed.  */
6226               fprintf (file, _("cannot find EMH in first GST record\n"));
6227               return;
6228             }
6229           rec = bfd_malloc (pad_len);
6230           memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6231         }
6232       else
6233         {
6234           unsigned int rec_len2 = 0;
6235           unsigned char hdr[4];
6236
6237           if (has_records)
6238             {
6239               unsigned char buf_len[2];
6240
6241               if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6242                   != sizeof (buf_len))
6243                 {
6244                   fprintf (file, _("cannot read GST record length\n"));
6245                   return;
6246                 }
6247               rec_len2 = (unsigned)bfd_getl16 (buf_len);
6248             }
6249
6250           if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6251             {
6252               fprintf (file, _("cannot read GST record header\n"));
6253               return;
6254             }
6255           rec_len = (unsigned)bfd_getl16 (hdr + 2);
6256           if (has_records)
6257             pad_len = (rec_len + 1) & ~1U;
6258           else
6259             pad_len = rec_len;
6260           rec = bfd_malloc (pad_len);
6261           memcpy (rec, hdr, sizeof (hdr));
6262           hdr_size = sizeof (hdr);
6263           if (has_records && rec_len2 != rec_len)
6264             {
6265               fprintf (file, _(" corrupted GST\n"));
6266               break;
6267             }
6268         }
6269
6270       if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6271           != pad_len - hdr_size)
6272         {
6273           fprintf (file, _("cannot read GST record\n"));
6274           return;
6275         }
6276
6277       type = (unsigned)bfd_getl16 (rec);
6278
6279       switch (type)
6280         {
6281         case EOBJ__C_EMH:
6282           evax_bfd_print_emh (file, rec, rec_len);
6283           break;
6284         case EOBJ__C_EGSD:
6285           evax_bfd_print_egsd (file, rec, rec_len);
6286           break;
6287         case EOBJ__C_EEOM:
6288           evax_bfd_print_eeom (file, rec, rec_len);
6289           free (rec);
6290           return;
6291           break;
6292         case EOBJ__C_ETIR:
6293           evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6294           break;
6295         case EOBJ__C_EDBG:
6296           evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6297           break;
6298         case EOBJ__C_ETBT:
6299           evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6300           break;
6301         default:
6302           fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6303           break;
6304         }
6305       free (rec);
6306     }
6307 }
6308
6309 static void
6310 evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6311                                    unsigned int stride)
6312 {
6313   while (1)
6314     {
6315       unsigned int base;
6316       unsigned int count;
6317       unsigned int j;
6318
6319       count = bfd_getl32 (rel + 0);
6320
6321       if (count == 0)
6322         break;
6323       base = bfd_getl32 (rel + 4);
6324
6325       fprintf (file, _("  bitcount: %u, base addr: 0x%08x\n"),
6326                count, base);
6327
6328       rel += 8;
6329       for (j = 0; count > 0; j += 4, count -= 32)
6330         {
6331           unsigned int k;
6332           unsigned int n = 0;
6333           unsigned int val;
6334
6335           val = bfd_getl32 (rel);
6336           rel += 4;
6337
6338           fprintf (file, _("   bitmap: 0x%08x (count: %u):\n"), val, count);
6339
6340           for (k = 0; k < 32; k++)
6341             if (val & (1 << k))
6342               {
6343                 if (n == 0)
6344                   fputs ("   ", file);
6345                 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6346                 n++;
6347                 if (n == 8)
6348                   {
6349                     fputs ("\n", file);
6350                     n = 0;
6351                   }
6352               }
6353           if (n)
6354             fputs ("\n", file);
6355         }
6356     }
6357 }
6358
6359 static void
6360 evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6361 {
6362   while (1)
6363     {
6364       unsigned int j;
6365       unsigned int count;
6366
6367       count = bfd_getl32 (rel + 0);
6368       if (count == 0)
6369         return;
6370       fprintf (file, _("  image %u (%u entries)\n"),
6371                (unsigned)bfd_getl32 (rel + 4), count);
6372       rel += 8;
6373       for (j = 0; j < count; j++)
6374         {
6375           fprintf (file, _("   offset: 0x%08x, val: 0x%08x\n"),
6376                    (unsigned)bfd_getl32 (rel + 0),
6377                    (unsigned)bfd_getl32 (rel + 4));
6378           rel += 8;
6379         }
6380     }
6381 }
6382
6383 static void
6384 evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6385 {
6386   unsigned int count;
6387
6388   while (1)
6389     {
6390       unsigned int j;
6391       unsigned int n = 0;
6392
6393       count = bfd_getl32 (rel + 0);
6394       if (count == 0)
6395         break;
6396       fprintf (file, _("  image %u (%u entries), offsets:\n"),
6397                (unsigned)bfd_getl32 (rel + 4), count);
6398       rel += 8;
6399       for (j = 0; j < count; j++)
6400         {
6401           if (n == 0)
6402             fputs ("   ", file);
6403           fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6404           n++;
6405           if (n == 7)
6406             {
6407               fputs ("\n", file);
6408               n = 0;
6409             }
6410           rel += 4;
6411         }
6412       if (n)
6413         fputs ("\n", file);
6414     }
6415 }
6416
6417 static void
6418 evax_bfd_print_indent (int indent, FILE *file)
6419 {
6420   for (; indent; indent--)
6421     fputc (' ', file);
6422 }
6423
6424 static const char *
6425 evax_bfd_get_dsc_name (unsigned int v)
6426 {
6427   switch (v)
6428     {
6429     case DSC__K_DTYPE_Z:
6430       return "Z (Unspecified)";
6431     case DSC__K_DTYPE_V:
6432       return "V (Bit)";
6433     case DSC__K_DTYPE_BU:
6434       return "BU (Byte logical)";
6435     case DSC__K_DTYPE_WU:
6436       return "WU (Word logical)";
6437     case DSC__K_DTYPE_LU:
6438       return "LU (Longword logical)";
6439     case DSC__K_DTYPE_QU:
6440       return "QU (Quadword logical)";
6441     case DSC__K_DTYPE_B:
6442       return "B (Byte integer)";
6443     case DSC__K_DTYPE_W:
6444       return "W (Word integer)";
6445     case DSC__K_DTYPE_L:
6446       return "L (Longword integer)";
6447     case DSC__K_DTYPE_Q:
6448       return "Q (Quadword integer)";
6449     case DSC__K_DTYPE_F:
6450       return "F (Single-precision floating)";
6451     case DSC__K_DTYPE_D:
6452       return "D (Double-precision floating)";
6453     case DSC__K_DTYPE_FC:
6454       return "FC (Complex)";
6455     case DSC__K_DTYPE_DC:
6456       return "DC (Double-precision Complex)";
6457     case DSC__K_DTYPE_T:
6458       return "T (ASCII text string)";
6459     case DSC__K_DTYPE_NU:
6460       return "NU (Numeric string, unsigned)";
6461     case DSC__K_DTYPE_NL:
6462       return "NL (Numeric string, left separate sign)";
6463     case DSC__K_DTYPE_NLO:
6464       return "NLO (Numeric string, left overpunched sign)";
6465     case DSC__K_DTYPE_NR:
6466       return "NR (Numeric string, right separate sign)";
6467     case DSC__K_DTYPE_NRO:
6468       return "NRO (Numeric string, right overpunched sig)";
6469     case DSC__K_DTYPE_NZ:
6470       return "NZ (Numeric string, zoned sign)";
6471     case DSC__K_DTYPE_P:
6472       return "P (Packed decimal string)";
6473     case DSC__K_DTYPE_ZI:
6474       return "ZI (Sequence of instructions)";
6475     case DSC__K_DTYPE_ZEM:
6476       return "ZEM (Procedure entry mask)";
6477     case DSC__K_DTYPE_DSC:
6478       return "DSC (Descriptor, used for arrays of dyn strings)";
6479     case DSC__K_DTYPE_OU:
6480       return "OU (Octaword logical)";
6481     case DSC__K_DTYPE_O:
6482       return "O (Octaword integer)";
6483     case DSC__K_DTYPE_G:
6484       return "G (Double precision G floating, 64 bit)";
6485     case DSC__K_DTYPE_H:
6486       return "H (Quadruple precision floating, 128 bit)";
6487     case DSC__K_DTYPE_GC:
6488       return "GC (Double precision complex, G floating)";
6489     case DSC__K_DTYPE_HC:
6490       return "HC (Quadruple precision complex, H floating)";
6491     case DSC__K_DTYPE_CIT:
6492       return "CIT (COBOL intermediate temporary)";
6493     case DSC__K_DTYPE_BPV:
6494       return "BPV (Bound Procedure Value)";
6495     case DSC__K_DTYPE_BLV:
6496       return "BLV (Bound Label Value)";
6497     case DSC__K_DTYPE_VU:
6498       return "VU (Bit Unaligned)";
6499     case DSC__K_DTYPE_ADT:
6500       return "ADT (Absolute Date-Time)";
6501     case DSC__K_DTYPE_VT:
6502       return "VT (Varying Text)";
6503     case DSC__K_DTYPE_T2:
6504       return "T2 (16-bit char)";
6505     case DSC__K_DTYPE_VT2:
6506       return "VT2 (16-bit varying char)";
6507     default:
6508       return "?? (unknown)";
6509     }
6510 }
6511
6512 static void
6513 evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6514 {
6515   unsigned char bclass = buf[3];
6516   unsigned char dtype = buf[2];
6517   unsigned int len = (unsigned)bfd_getl16 (buf);
6518   unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6519
6520   evax_bfd_print_indent (indent, file);
6521
6522   if (len == 1 && pointer == 0xffffffffUL)
6523     {
6524       /* 64 bits.  */
6525       fprintf (file, _("64 bits *unhandled*\n"));
6526     }
6527   else
6528     {
6529       fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6530                bclass, dtype, len, pointer);
6531       switch (bclass)
6532         {
6533         case DSC__K_CLASS_NCA:
6534           {
6535             const struct vms_dsc_nca *dsc = (const void *)buf;
6536             unsigned int i;
6537             const unsigned char *b;
6538
6539             evax_bfd_print_indent (indent, file);
6540             fprintf (file, _("non-contiguous array of %s\n"),
6541                      evax_bfd_get_dsc_name (dsc->dtype));
6542             evax_bfd_print_indent (indent + 1, file);
6543             fprintf (file,
6544                      _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6545                      dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6546             evax_bfd_print_indent (indent + 1, file);
6547             fprintf (file,
6548                      _("arsize: %u, a0: 0x%08x\n"),
6549                      (unsigned)bfd_getl32 (dsc->arsize),
6550                      (unsigned)bfd_getl32 (dsc->a0));
6551             evax_bfd_print_indent (indent + 1, file);
6552             fprintf (file, _("Strides:\n"));
6553             b = buf + sizeof (*dsc);
6554             for (i = 0; i < dsc->dimct; i++)
6555               {
6556                 evax_bfd_print_indent (indent + 2, file);
6557                 fprintf (file, _("[%u]: %u\n"), i + 1,
6558                          (unsigned)bfd_getl32 (b));
6559                 b += 4;
6560               }
6561             evax_bfd_print_indent (indent + 1, file);
6562             fprintf (file, _("Bounds:\n"));
6563             b = buf + sizeof (*dsc);
6564             for (i = 0; i < dsc->dimct; i++)
6565               {
6566                 evax_bfd_print_indent (indent + 2, file);
6567                 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6568                          (unsigned)bfd_getl32 (b + 0),
6569                          (unsigned)bfd_getl32 (b + 4));
6570                 b += 8;
6571               }
6572           }
6573           break;
6574         case DSC__K_CLASS_UBS:
6575           {
6576             const struct vms_dsc_ubs *ubs = (const void *)buf;
6577
6578             evax_bfd_print_indent (indent, file);
6579             fprintf (file, _("unaligned bit-string of %s\n"),
6580                      evax_bfd_get_dsc_name (ubs->dtype));
6581             evax_bfd_print_indent (indent + 1, file);
6582             fprintf (file,
6583                      _("base: %u, pos: %u\n"),
6584                      (unsigned)bfd_getl32 (ubs->base),
6585                      (unsigned)bfd_getl32 (ubs->pos));
6586           }
6587           break;
6588         default:
6589           fprintf (file, _("*unhandled*\n"));
6590           break;
6591         }
6592     }
6593 }
6594
6595 static unsigned int
6596 evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6597 {
6598   unsigned int vflags = buf[0];
6599   unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6600   unsigned int len = 5;
6601
6602   evax_bfd_print_indent (indent, file);
6603   fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6604   buf += 5;
6605
6606   switch (vflags)
6607     {
6608     case DST__K_VFLAGS_NOVAL:
6609       fprintf (file, _("(no value)\n"));
6610       break;
6611     case DST__K_VFLAGS_NOTACTIVE:
6612       fprintf (file, _("(not active)\n"));
6613       break;
6614     case DST__K_VFLAGS_UNALLOC:
6615       fprintf (file, _("(not allocated)\n"));
6616       break;
6617     case DST__K_VFLAGS_DSC:
6618       fprintf (file, _("(descriptor)\n"));
6619       evax_bfd_print_desc (buf + value, indent + 1, file);
6620       break;
6621     case DST__K_VFLAGS_TVS:
6622       fprintf (file, _("(trailing value)\n"));
6623       break;
6624     case DST__K_VS_FOLLOWS:
6625       fprintf (file, _("(value spec follows)\n"));
6626       break;
6627     case DST__K_VFLAGS_BITOFFS:
6628       fprintf (file, _("(at bit offset %u)\n"), value);
6629       break;
6630     default:
6631       fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6632                (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6633                vflags & DST__K_DISP ? 1 : 0,
6634                vflags & DST__K_INDIR ? 1 : 0);
6635       switch (vflags & DST__K_VALKIND_MASK)
6636         {
6637         case DST__K_VALKIND_LITERAL:
6638           fputs (_("literal"), file);
6639           break;
6640         case DST__K_VALKIND_ADDR:
6641           fputs (_("address"), file);
6642           break;
6643         case DST__K_VALKIND_DESC:
6644           fputs (_("desc"), file);
6645           break;
6646         case DST__K_VALKIND_REG:
6647           fputs (_("reg"), file);
6648           break;
6649         }
6650       fputs (")\n", file);
6651       break;
6652     }
6653   return len;
6654 }
6655
6656 static void
6657 evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6658 {
6659   unsigned char kind = buf[2];
6660   unsigned int len = (unsigned)bfd_getl16 (buf);
6661
6662   evax_bfd_print_indent (indent, file);
6663   fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6664   buf += 3;
6665   switch (kind)
6666     {
6667     case DST__K_TS_ATOM:
6668       fprintf (file, ("atomic, type=0x%02x %s\n"),
6669                buf[0], evax_bfd_get_dsc_name (buf[0]));
6670       break;
6671     case DST__K_TS_IND:
6672       fprintf (file, ("indirect, defined at 0x%08x\n"),
6673                (unsigned)bfd_getl32 (buf));
6674       break;
6675     case DST__K_TS_TPTR:
6676       fprintf (file, ("typed pointer\n"));
6677       evax_bfd_print_typspec (buf, indent + 1, file);
6678       break;
6679     case DST__K_TS_PTR:
6680       fprintf (file, ("pointer\n"));
6681       break;
6682     case DST__K_TS_ARRAY:
6683       {
6684         const unsigned char *vs;
6685         unsigned int vec_len;
6686         unsigned int i;
6687
6688         fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6689         vec_len = (buf[0] + 1 + 7) / 8;
6690         for (i = 0; i < vec_len; i++)
6691           fprintf (file, " %02x", buf[i + 1]);
6692         fputc ('\n', file);
6693         vs = buf + 1 + vec_len;
6694         evax_bfd_print_indent (indent, file);
6695         fprintf (file, ("array descriptor:\n"));
6696         vs += evax_bfd_print_valspec (vs, indent + 1, file);
6697         for (i = 0; i < buf[0] + 1U; i++)
6698           if (buf[1 + i / 8] & (1 << (i % 8)))
6699             {
6700               evax_bfd_print_indent (indent, file);
6701               if (i == 0)
6702                 fprintf (file, ("type spec for element:\n"));
6703               else
6704                 fprintf (file, ("type spec for subscript %u:\n"), i);
6705               evax_bfd_print_typspec (vs, indent + 1, file);
6706               vs += bfd_getl16 (vs);
6707             }
6708       }
6709       break;
6710     default:
6711       fprintf (file, ("*unhandled*\n"));
6712     }
6713 }
6714
6715 static void
6716 evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6717 {
6718   unsigned int off = 0;
6719   unsigned int pc = 0;
6720   unsigned int line = 0;
6721
6722   fprintf (file, _("Debug symbol table:\n"));
6723
6724   while (dst_size > 0)
6725     {
6726       struct vms_dst_header dsth;
6727       unsigned int len;
6728       unsigned int type;
6729       unsigned char *buf;
6730
6731       if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6732         {
6733           fprintf (file, _("cannot read DST header\n"));
6734           return;
6735         }
6736       len = bfd_getl16 (dsth.length);
6737       type = bfd_getl16 (dsth.type);
6738       fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6739                type, len, off);
6740       if (len == 0)
6741         {
6742           fputc ('\n', file);
6743           break;
6744         }
6745       len++;
6746       dst_size -= len;
6747       off += len;
6748       len -= sizeof (dsth);
6749       buf = bfd_malloc (len);
6750       if (bfd_bread (buf, len, abfd) != len)
6751         {
6752           fprintf (file, _("cannot read DST symbol\n"));
6753           return;
6754         }
6755       switch (type)
6756         {
6757         case DSC__K_DTYPE_V:
6758         case DSC__K_DTYPE_BU:
6759         case DSC__K_DTYPE_WU:
6760         case DSC__K_DTYPE_LU:
6761         case DSC__K_DTYPE_QU:
6762         case DSC__K_DTYPE_B:
6763         case DSC__K_DTYPE_W:
6764         case DSC__K_DTYPE_L:
6765         case DSC__K_DTYPE_Q:
6766         case DSC__K_DTYPE_F:
6767         case DSC__K_DTYPE_D:
6768         case DSC__K_DTYPE_FC:
6769         case DSC__K_DTYPE_DC:
6770         case DSC__K_DTYPE_T:
6771         case DSC__K_DTYPE_NU:
6772         case DSC__K_DTYPE_NL:
6773         case DSC__K_DTYPE_NLO:
6774         case DSC__K_DTYPE_NR:
6775         case DSC__K_DTYPE_NRO:
6776         case DSC__K_DTYPE_NZ:
6777         case DSC__K_DTYPE_P:
6778         case DSC__K_DTYPE_ZI:
6779         case DSC__K_DTYPE_ZEM:
6780         case DSC__K_DTYPE_DSC:
6781         case DSC__K_DTYPE_OU:
6782         case DSC__K_DTYPE_O:
6783         case DSC__K_DTYPE_G:
6784         case DSC__K_DTYPE_H:
6785         case DSC__K_DTYPE_GC:
6786         case DSC__K_DTYPE_HC:
6787         case DSC__K_DTYPE_CIT:
6788         case DSC__K_DTYPE_BPV:
6789         case DSC__K_DTYPE_BLV:
6790         case DSC__K_DTYPE_VU:
6791         case DSC__K_DTYPE_ADT:
6792         case DSC__K_DTYPE_VT:
6793         case DSC__K_DTYPE_T2:
6794         case DSC__K_DTYPE_VT2:
6795           fprintf (file, _("standard data: %s\n"),
6796                    evax_bfd_get_dsc_name (type));
6797           evax_bfd_print_valspec (buf, 4, file);
6798           fprintf (file, _("    name: %.*s\n"), buf[5], buf + 6);
6799           break;
6800         case DST__K_MODBEG:
6801           {
6802             struct vms_dst_modbeg *dst = (void *)buf;
6803             const char *name = (const char *)buf + sizeof (*dst);
6804
6805             fprintf (file, _("modbeg\n"));
6806             fprintf (file, _("   flags: %d, language: %u, "
6807                              "major: %u, minor: %u\n"),
6808                      dst->flags,
6809                      (unsigned)bfd_getl32 (dst->language),
6810                      (unsigned)bfd_getl16 (dst->major),
6811                      (unsigned)bfd_getl16 (dst->minor));
6812             fprintf (file, _("   module name: %.*s\n"),
6813                      name[0], name + 1);
6814             name += name[0] + 1;
6815             fprintf (file, _("   compiler   : %.*s\n"),
6816                      name[0], name + 1);
6817           }
6818           break;
6819         case DST__K_MODEND:
6820           fprintf (file, _("modend\n"));
6821           break;
6822         case DST__K_RTNBEG:
6823           {
6824             struct vms_dst_rtnbeg *dst = (void *)buf;
6825             const char *name = (const char *)buf + sizeof (*dst);
6826
6827             fputs (_("rtnbeg\n"), file);
6828             fprintf (file, _("    flags: %u, address: 0x%08x, "
6829                              "pd-address: 0x%08x\n"),
6830                      dst->flags,
6831                      (unsigned)bfd_getl32 (dst->address),
6832                      (unsigned)bfd_getl32 (dst->pd_address));
6833             fprintf (file, _("    routine name: %.*s\n"),
6834                      name[0], name + 1);
6835           }
6836           break;
6837         case DST__K_RTNEND:
6838           {
6839             struct vms_dst_rtnend *dst = (void *)buf;
6840
6841             fprintf (file, _("rtnend: size 0x%08x\n"),
6842                      (unsigned)bfd_getl32 (dst->size));
6843           }
6844           break;
6845         case DST__K_PROLOG:
6846           {
6847             struct vms_dst_prolog *dst = (void *)buf;
6848
6849             fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6850                      (unsigned)bfd_getl32 (dst->bkpt_addr));
6851           }
6852           break;
6853         case DST__K_EPILOG:
6854           {
6855             struct vms_dst_epilog *dst = (void *)buf;
6856
6857             fprintf (file, _("epilog: flags: %u, count: %u\n"),
6858                      dst->flags, (unsigned)bfd_getl32 (dst->count));
6859           }
6860           break;
6861         case DST__K_BLKBEG:
6862           {
6863             struct vms_dst_blkbeg *dst = (void *)buf;
6864             const char *name = (const char *)buf + sizeof (*dst);
6865
6866             fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6867                      (unsigned)bfd_getl32 (dst->address),
6868                      name[0], name + 1);
6869           }
6870           break;
6871         case DST__K_BLKEND:
6872           {
6873             struct vms_dst_blkend *dst = (void *)buf;
6874
6875             fprintf (file, _("blkend: size: 0x%08x\n"),
6876                      (unsigned)bfd_getl32 (dst->size));
6877           }
6878           break;
6879         case DST__K_TYPSPEC:
6880           {
6881             fprintf (file, _("typspec (len: %u)\n"), len);
6882             fprintf (file, _("    name: %.*s\n"), buf[0], buf + 1);
6883             evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
6884           }
6885           break;
6886         case DST__K_SEPTYP:
6887           {
6888             fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
6889             evax_bfd_print_valspec (buf, 4, file);
6890           }
6891           break;
6892         case DST__K_RECBEG:
6893           {
6894             struct vms_dst_recbeg *recbeg = (void *)buf;
6895             const char *name = (const char *)buf + sizeof (*recbeg);
6896
6897             fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
6898             evax_bfd_print_valspec (buf, 4, file);
6899             fprintf (file, ("    len: %u bits\n"),
6900                      (unsigned)bfd_getl32 (name + 1 + name[0]));
6901           }
6902           break;
6903         case DST__K_RECEND:
6904           fprintf (file, _("recend\n"));
6905           break;
6906         case DST__K_ENUMBEG:
6907           fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
6908                    buf[0], buf[1], buf + 2);
6909           break;
6910         case DST__K_ENUMELT:
6911           fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
6912           evax_bfd_print_valspec (buf, 4, file);
6913           break;
6914         case DST__K_ENUMEND:
6915           fprintf (file, _("enumend\n"));
6916           break;
6917         case DST__K_LABEL:
6918           {
6919             struct vms_dst_label *lab = (void *)buf;
6920             fprintf (file, ("label, name: %.*s\n"),
6921                      lab->name[0], lab->name + 1);
6922             fprintf (file, ("    address: 0x%08x\n"),
6923                      (unsigned)bfd_getl32 (lab->value));
6924           }
6925           break;
6926         case DST__K_DIS_RANGE:
6927           {
6928             unsigned int cnt = bfd_getl32 (buf);
6929             unsigned char *rng = buf + 4;
6930             unsigned int i;
6931
6932             fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
6933             for (i = 0; i < cnt; i++, rng += 8)
6934               fprintf (file, _("    address: 0x%08x, size: %u\n"),
6935                        (unsigned)bfd_getl32 (rng),
6936                        (unsigned)bfd_getl32 (rng + 4));
6937
6938           }
6939           break;
6940         case DST__K_LINE_NUM:
6941           {
6942             unsigned char *buf_orig = buf;
6943
6944             fprintf (file, _("line num  (len: %u)\n"), len);
6945
6946             while (len > 0)
6947               {
6948                 signed char cmd;
6949                 unsigned char cmdlen;
6950                 unsigned int val;
6951
6952                 cmd = buf[0];
6953                 cmdlen = 0;
6954
6955                 fputs ("    ", file);
6956
6957                 switch (cmd)
6958                   {
6959                   case DST__K_DELTA_PC_W:
6960                     val = bfd_getl16 (buf + 1);
6961                     fprintf (file, _("delta_pc_w %u\n"), val);
6962                     pc += val;
6963                     line++;
6964                     cmdlen = 3;
6965                     break;
6966                   case DST__K_INCR_LINUM:
6967                     val = buf[1];
6968                     fprintf (file, _("incr_linum(b): +%u\n"), val);
6969                     line += val;
6970                     cmdlen = 2;
6971                     break;
6972                   case DST__K_INCR_LINUM_W:
6973                     val = bfd_getl16 (buf + 1);
6974                     fprintf (file, _("incr_linum_w: +%u\n"), val);
6975                     line += val;
6976                     cmdlen = 3;
6977                     break;
6978                   case DST__K_INCR_LINUM_L:
6979                     val = bfd_getl32 (buf + 1);
6980                     fprintf (file, _("incr_linum_l: +%u\n"), val);
6981                     line += val;
6982                     cmdlen = 5;
6983                     break;
6984                   case DST__K_SET_LINUM:
6985                     line = bfd_getl16 (buf + 1);
6986                     fprintf (file, _("set_line_num(w) %u\n"), line);
6987                     cmdlen = 3;
6988                     break;
6989                   case DST__K_SET_LINUM_B:
6990                     line = buf[1];
6991                     fprintf (file, _("set_line_num_b %u\n"), line);
6992                     cmdlen = 2;
6993                     break;
6994                   case DST__K_SET_LINUM_L:
6995                     line = bfd_getl32 (buf + 1);
6996                     fprintf (file, _("set_line_num_l %u\n"), line);
6997                     cmdlen = 5;
6998                     break;
6999                   case DST__K_SET_ABS_PC:
7000                     pc = bfd_getl32 (buf + 1);
7001                     fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7002                     cmdlen = 5;
7003                     break;
7004                   case DST__K_DELTA_PC_L:
7005                     fprintf (file, _("delta_pc_l: +0x%08x\n"),
7006                              (unsigned)bfd_getl32 (buf + 1));
7007                     cmdlen = 5;
7008                     break;
7009                   case DST__K_TERM:
7010                     fprintf (file, _("term(b): 0x%02x"), buf[1]);
7011                     pc += buf[1];
7012                     fprintf (file, _("        pc: 0x%08x\n"), pc);
7013                     cmdlen = 2;
7014                     break;
7015                   case DST__K_TERM_W:
7016                     val = bfd_getl16 (buf + 1);
7017                     fprintf (file, _("term_w: 0x%04x"), val);
7018                     pc += val;
7019                     fprintf (file, _("    pc: 0x%08x\n"), pc);
7020                     cmdlen = 3;
7021                     break;
7022                   default:
7023                     if (cmd <= 0)
7024                       {
7025                         fprintf (file, _("delta pc +%-4d"), -cmd);
7026                         line++;  /* FIXME: curr increment.  */
7027                         pc += -cmd;
7028                         fprintf (file, _("    pc: 0x%08x line: %5u\n"),
7029                                  pc, line);
7030                         cmdlen = 1;
7031                       }
7032                     else
7033                       fprintf (file, _("    *unhandled* cmd %u\n"), cmd);
7034                     break;
7035                   }
7036                 if (cmdlen == 0)
7037                   break;
7038                 len -= cmdlen;
7039                 buf += cmdlen;
7040               }
7041             buf = buf_orig;
7042           }
7043           break;
7044         case DST__K_SOURCE:
7045           {
7046             unsigned char *buf_orig = buf;
7047
7048             fprintf (file, _("source (len: %u)\n"), len);
7049
7050             while (len > 0)
7051               {
7052                 signed char cmd = buf[0];
7053                 unsigned char cmdlen = 0;
7054
7055                 switch (cmd)
7056                   {
7057                   case DST__K_SRC_DECLFILE:
7058                     {
7059                       struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7060                       const char *name;
7061
7062                       fprintf (file, _("   declfile: len: %u, flags: %u, "
7063                                        "fileid: %u\n"),
7064                                src->length, src->flags,
7065                                (unsigned)bfd_getl16 (src->fileid));
7066                       fprintf (file, _("   rms: cdt: 0x%08x %08x, "
7067                                        "ebk: 0x%08x, ffb: 0x%04x, "
7068                                        "rfo: %u\n"),
7069                                (unsigned)bfd_getl32 (src->rms_cdt + 4),
7070                                (unsigned)bfd_getl32 (src->rms_cdt + 0),
7071                                (unsigned)bfd_getl32 (src->rms_ebk),
7072                                (unsigned)bfd_getl16 (src->rms_ffb),
7073                                src->rms_rfo);
7074                       name = (const char *)buf + 1 + sizeof (*src);
7075                       fprintf (file, _("   filename   : %.*s\n"),
7076                                name[0], name + 1);
7077                       name += name[0] + 1;
7078                       fprintf (file, _("   module name: %.*s\n"),
7079                                name[0], name + 1);
7080                       cmdlen = 2 + src->length;
7081                     }
7082                     break;
7083                   case DST__K_SRC_SETFILE:
7084                     fprintf (file, _("   setfile %u\n"),
7085                              (unsigned)bfd_getl16 (buf + 1));
7086                     cmdlen = 3;
7087                     break;
7088                   case DST__K_SRC_SETREC_W:
7089                     fprintf (file, _("   setrec %u\n"),
7090                              (unsigned)bfd_getl16 (buf + 1));
7091                     cmdlen = 3;
7092                     break;
7093                   case DST__K_SRC_SETREC_L:
7094                     fprintf (file, _("   setrec %u\n"),
7095                              (unsigned)bfd_getl32 (buf + 1));
7096                     cmdlen = 5;
7097                     break;
7098                   case DST__K_SRC_SETLNUM_W:
7099                     fprintf (file, _("   setlnum %u\n"),
7100                              (unsigned)bfd_getl16 (buf + 1));
7101                     cmdlen = 3;
7102                     break;
7103                   case DST__K_SRC_SETLNUM_L:
7104                     fprintf (file, _("   setlnum %u\n"),
7105                              (unsigned)bfd_getl32 (buf + 1));
7106                     cmdlen = 5;
7107                     break;
7108                   case DST__K_SRC_DEFLINES_W:
7109                     fprintf (file, _("   deflines %u\n"),
7110                              (unsigned)bfd_getl16 (buf + 1));
7111                     cmdlen = 3;
7112                     break;
7113                   case DST__K_SRC_DEFLINES_B:
7114                     fprintf (file, _("   deflines %u\n"), buf[1]);
7115                     cmdlen = 2;
7116                     break;
7117                   case DST__K_SRC_FORMFEED:
7118                     fprintf (file, _("   formfeed\n"));
7119                     cmdlen = 1;
7120                     break;
7121                   default:
7122                     fprintf (file, _("   *unhandled* cmd %u\n"), cmd);
7123                     break;
7124                   }
7125                 if (cmdlen == 0)
7126                   break;
7127                 len -= cmdlen;
7128                 buf += cmdlen;
7129               }
7130             buf = buf_orig;
7131           }
7132           break;
7133         default:
7134           fprintf (file, _("*unhandled* dst type %u\n"), type);
7135           break;
7136         }
7137       free (buf);
7138     }
7139 }
7140
7141 static void
7142 evax_bfd_print_image (bfd *abfd, FILE *file)
7143 {
7144   struct vms_eihd eihd;
7145   const char *name;
7146   unsigned int val;
7147   unsigned int eiha_off;
7148   unsigned int eihi_off;
7149   unsigned int eihs_off;
7150   unsigned int eisd_off;
7151   unsigned int eihef_off = 0;
7152   unsigned int eihnp_off = 0;
7153   unsigned int dmt_vbn = 0;
7154   unsigned int dmt_size = 0;
7155   unsigned int dst_vbn = 0;
7156   unsigned int dst_size = 0;
7157   unsigned int gst_vbn = 0;
7158   unsigned int gst_size = 0;
7159   unsigned int eiaf_vbn = 0;
7160   unsigned int eiaf_size = 0;
7161   unsigned int eihvn_off;
7162
7163   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7164       || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7165     {
7166       fprintf (file, _("cannot read EIHD\n"));
7167       return;
7168     }
7169   fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7170            (unsigned)bfd_getl32 (eihd.size),
7171            (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7172   fprintf (file, _(" majorid: %u, minorid: %u\n"),
7173            (unsigned)bfd_getl32 (eihd.majorid),
7174            (unsigned)bfd_getl32 (eihd.minorid));
7175
7176   val = (unsigned)bfd_getl32 (eihd.imgtype);
7177   switch (val)
7178     {
7179     case EIHD__K_EXE:
7180       name = _("executable");
7181       break;
7182     case EIHD__K_LIM:
7183       name = _("linkable image");
7184       break;
7185     default:
7186       name = _("unknown");
7187       break;
7188     }
7189   fprintf (file, _(" image type: %u (%s)"), val, name);
7190
7191   val = (unsigned)bfd_getl32 (eihd.subtype);
7192   switch (val)
7193     {
7194     case EIHD__C_NATIVE:
7195       name = _("native");
7196       break;
7197     case EIHD__C_CLI:
7198       name = _("CLI");
7199       break;
7200     default:
7201       name = _("unknown");
7202       break;
7203     }
7204   fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7205
7206   eisd_off = bfd_getl32 (eihd.isdoff);
7207   eiha_off = bfd_getl32 (eihd.activoff);
7208   eihi_off = bfd_getl32 (eihd.imgidoff);
7209   eihs_off = bfd_getl32 (eihd.symdbgoff);
7210   fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7211                    "imgid: %u, patch: %u\n"),
7212            eisd_off, eiha_off, eihs_off, eihi_off,
7213            (unsigned)bfd_getl32 (eihd.patchoff));
7214   fprintf (file, _(" fixup info rva: "));
7215   bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7216   fprintf (file, _(", symbol vector rva: "));
7217   bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7218   eihvn_off = bfd_getl32 (eihd.version_array_off);
7219   fprintf (file, _("\n"
7220                    " version array off: %u\n"),
7221            eihvn_off);
7222   fprintf (file,
7223            _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7224            (unsigned)bfd_getl32 (eihd.imgiocnt),
7225            (unsigned)bfd_getl32 (eihd.iochancnt),
7226            (unsigned)bfd_getl32 (eihd.privreqs + 4),
7227            (unsigned)bfd_getl32 (eihd.privreqs + 0));
7228   val = (unsigned)bfd_getl32 (eihd.lnkflags);
7229   fprintf (file, _(" linker flags: %08x:"), val);
7230   if (val & EIHD__M_LNKDEBUG)
7231     fprintf (file, " LNKDEBUG");
7232   if (val & EIHD__M_LNKNOTFR)
7233     fprintf (file, " LNKNOTFR");
7234   if (val & EIHD__M_NOP0BUFS)
7235     fprintf (file, " NOP0BUFS");
7236   if (val & EIHD__M_PICIMG)
7237     fprintf (file, " PICIMG");
7238   if (val & EIHD__M_P0IMAGE)
7239     fprintf (file, " P0IMAGE");
7240   if (val & EIHD__M_DBGDMT)
7241     fprintf (file, " DBGDMT");
7242   if (val & EIHD__M_INISHR)
7243     fprintf (file, " INISHR");
7244   if (val & EIHD__M_XLATED)
7245     fprintf (file, " XLATED");
7246   if (val & EIHD__M_BIND_CODE_SEC)
7247     fprintf (file, " BIND_CODE_SEC");
7248   if (val & EIHD__M_BIND_DATA_SEC)
7249     fprintf (file, " BIND_DATA_SEC");
7250   if (val & EIHD__M_MKTHREADS)
7251     fprintf (file, " MKTHREADS");
7252   if (val & EIHD__M_UPCALLS)
7253     fprintf (file, " UPCALLS");
7254   if (val & EIHD__M_OMV_READY)
7255     fprintf (file, " OMV_READY");
7256   if (val & EIHD__M_EXT_BIND_SECT)
7257     fprintf (file, " EXT_BIND_SECT");
7258   fprintf (file, "\n");
7259   fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7260                    "match ctrl: %u, symvect_size: %u\n"),
7261            (unsigned)bfd_getl32 (eihd.ident),
7262            (unsigned)bfd_getl32 (eihd.sysver),
7263            eihd.matchctl,
7264            (unsigned)bfd_getl32 (eihd.symvect_size));
7265   fprintf (file, _(" BPAGE: %u"),
7266            (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7267   if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7268     {
7269       eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7270       eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7271       fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7272                eihef_off, eihnp_off);
7273     }
7274   fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7275
7276   if (eihvn_off != 0)
7277     {
7278       struct vms_eihvn eihvn;
7279       unsigned int mask;
7280       unsigned int j;
7281
7282       fprintf (file, _("system version array information:\n"));
7283       if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7284           || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7285         {
7286           fprintf (file, _("cannot read EIHVN header\n"));
7287           return;
7288         }
7289       mask = bfd_getl32 (eihvn.subsystem_mask);
7290       for (j = 0; j < 32; j++)
7291         if (mask & (1 << j))
7292           {
7293             struct vms_eihvn_subversion ver;
7294             if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7295               {
7296                 fprintf (file, _("cannot read EIHVN version\n"));
7297                 return;
7298               }
7299             fprintf (file, _("   %02u "), j);
7300             switch (j)
7301               {
7302               case EIHVN__BASE_IMAGE_BIT:
7303                 fputs (_("BASE_IMAGE       "), file);
7304                 break;
7305               case EIHVN__MEMORY_MANAGEMENT_BIT:
7306                 fputs (_("MEMORY_MANAGEMENT"), file);
7307                 break;
7308               case EIHVN__IO_BIT:
7309                 fputs (_("IO               "), file);
7310                 break;
7311               case EIHVN__FILES_VOLUMES_BIT:
7312                 fputs (_("FILES_VOLUMES    "), file);
7313                 break;
7314               case EIHVN__PROCESS_SCHED_BIT:
7315                 fputs (_("PROCESS_SCHED    "), file);
7316                 break;
7317               case EIHVN__SYSGEN_BIT:
7318                 fputs (_("SYSGEN           "), file);
7319                 break;
7320               case EIHVN__CLUSTERS_LOCKMGR_BIT:
7321                 fputs (_("CLUSTERS_LOCKMGR "), file);
7322                 break;
7323               case EIHVN__LOGICAL_NAMES_BIT:
7324                 fputs (_("LOGICAL_NAMES    "), file);
7325                 break;
7326               case EIHVN__SECURITY_BIT:
7327                 fputs (_("SECURITY         "), file);
7328                 break;
7329               case EIHVN__IMAGE_ACTIVATOR_BIT:
7330                 fputs (_("IMAGE_ACTIVATOR  "), file);
7331                 break;
7332               case EIHVN__NETWORKS_BIT:
7333                 fputs (_("NETWORKS         "), file);
7334                 break;
7335               case EIHVN__COUNTERS_BIT:
7336                 fputs (_("COUNTERS         "), file);
7337                 break;
7338               case EIHVN__STABLE_BIT:
7339                 fputs (_("STABLE           "), file);
7340                 break;
7341               case EIHVN__MISC_BIT:
7342                 fputs (_("MISC             "), file);
7343                 break;
7344               case EIHVN__CPU_BIT:
7345                 fputs (_("CPU              "), file);
7346                 break;
7347               case EIHVN__VOLATILE_BIT:
7348                 fputs (_("VOLATILE         "), file);
7349                 break;
7350               case EIHVN__SHELL_BIT:
7351                 fputs (_("SHELL            "), file);
7352                 break;
7353               case EIHVN__POSIX_BIT:
7354                 fputs (_("POSIX            "), file);
7355                 break;
7356               case EIHVN__MULTI_PROCESSING_BIT:
7357                 fputs (_("MULTI_PROCESSING "), file);
7358                 break;
7359               case EIHVN__GALAXY_BIT:
7360                 fputs (_("GALAXY           "), file);
7361                 break;
7362               default:
7363                 fputs (_("*unknown*        "), file);
7364                 break;
7365               }
7366             fprintf (file, _(": %u.%u\n"),
7367                      (unsigned)bfd_getl16 (ver.major),
7368                      (unsigned)bfd_getl16 (ver.minor));
7369           }
7370     }
7371
7372   if (eiha_off != 0)
7373     {
7374       struct vms_eiha eiha;
7375
7376       if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7377           || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7378         {
7379           fprintf (file, _("cannot read EIHA\n"));
7380           return;
7381         }
7382       fprintf (file, _("Image activation:  (size=%u)\n"),
7383                (unsigned)bfd_getl32 (eiha.size));
7384       fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7385                (unsigned)bfd_getl32 (eiha.tfradr1_h),
7386                (unsigned)bfd_getl32 (eiha.tfradr1));
7387       fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7388                (unsigned)bfd_getl32 (eiha.tfradr2_h),
7389                (unsigned)bfd_getl32 (eiha.tfradr2));
7390       fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7391                (unsigned)bfd_getl32 (eiha.tfradr3_h),
7392                (unsigned)bfd_getl32 (eiha.tfradr3));
7393       fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7394                (unsigned)bfd_getl32 (eiha.tfradr4_h),
7395                (unsigned)bfd_getl32 (eiha.tfradr4));
7396       fprintf (file, _(" Shared image  : 0x%08x 0x%08x\n"),
7397                (unsigned)bfd_getl32 (eiha.inishr_h),
7398                (unsigned)bfd_getl32 (eiha.inishr));
7399     }
7400   if (eihi_off != 0)
7401     {
7402       struct vms_eihi eihi;
7403
7404       if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7405           || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7406         {
7407           fprintf (file, _("cannot read EIHI\n"));
7408           return;
7409         }
7410       fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7411                (unsigned)bfd_getl32 (eihi.majorid),
7412                (unsigned)bfd_getl32 (eihi.minorid));
7413       fprintf (file, _(" image name       : %.*s\n"),
7414                eihi.imgnam[0], eihi.imgnam + 1);
7415       fprintf (file, _(" link time        : %s\n"),
7416                vms_time_to_str (eihi.linktime));
7417       fprintf (file, _(" image ident      : %.*s\n"),
7418                eihi.imgid[0], eihi.imgid + 1);
7419       fprintf (file, _(" linker ident     : %.*s\n"),
7420                eihi.linkid[0], eihi.linkid + 1);
7421       fprintf (file, _(" image build ident: %.*s\n"),
7422                eihi.imgbid[0], eihi.imgbid + 1);
7423     }
7424   if (eihs_off != 0)
7425     {
7426       struct vms_eihs eihs;
7427
7428       if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7429           || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7430         {
7431           fprintf (file, _("cannot read EIHS\n"));
7432           return;
7433         }
7434       fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7435                (unsigned)bfd_getl32 (eihs.majorid),
7436                (unsigned)bfd_getl32 (eihs.minorid));
7437       dst_vbn = bfd_getl32 (eihs.dstvbn);
7438       dst_size = bfd_getl32 (eihs.dstsize);
7439       fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7440                dst_vbn, dst_size, dst_size);
7441       gst_vbn = bfd_getl32 (eihs.gstvbn);
7442       gst_size = bfd_getl32 (eihs.gstsize);
7443       fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7444                gst_vbn, gst_size);
7445       dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7446       dmt_size = bfd_getl32 (eihs.dmtsize);
7447       fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7448                dmt_vbn, dmt_size);
7449     }
7450   while (eisd_off != 0)
7451     {
7452       struct vms_eisd eisd;
7453       unsigned int len;
7454
7455       while (1)
7456         {
7457           if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7458               || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7459             {
7460               fprintf (file, _("cannot read EISD\n"));
7461               return;
7462             }
7463           len = (unsigned)bfd_getl32 (eisd.eisdsize);
7464           if (len != (unsigned)-1)
7465             break;
7466
7467           /* Next block.  */
7468           eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7469         }
7470       fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7471                        "size: %u, offset: %u)\n"),
7472                (unsigned)bfd_getl32 (eisd.majorid),
7473                (unsigned)bfd_getl32 (eisd.minorid),
7474                len, eisd_off);
7475       if (len == 0)
7476         break;
7477       fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7478                (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7479                (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7480                (unsigned)bfd_getl32 (eisd.secsize));
7481       val = (unsigned)bfd_getl32 (eisd.flags);
7482       fprintf (file, _(" flags: 0x%04x"), val);
7483       if (val & EISD__M_GBL)
7484         fprintf (file, " GBL");
7485       if (val & EISD__M_CRF)
7486         fprintf (file, " CRF");
7487       if (val & EISD__M_DZRO)
7488         fprintf (file, " DZRO");
7489       if (val & EISD__M_WRT)
7490         fprintf (file, " WRT");
7491       if (val & EISD__M_INITALCODE)
7492         fprintf (file, " INITALCODE");
7493       if (val & EISD__M_BASED)
7494         fprintf (file, " BASED");
7495       if (val & EISD__M_FIXUPVEC)
7496         fprintf (file, " FIXUPVEC");
7497       if (val & EISD__M_RESIDENT)
7498         fprintf (file, " RESIDENT");
7499       if (val & EISD__M_VECTOR)
7500         fprintf (file, " VECTOR");
7501       if (val & EISD__M_PROTECT)
7502         fprintf (file, " PROTECT");
7503       if (val & EISD__M_LASTCLU)
7504         fprintf (file, " LASTCLU");
7505       if (val & EISD__M_EXE)
7506         fprintf (file, " EXE");
7507       if (val & EISD__M_NONSHRADR)
7508         fprintf (file, " NONSHRADR");
7509       if (val & EISD__M_QUAD_LENGTH)
7510         fprintf (file, " QUAD_LENGTH");
7511       if (val & EISD__M_ALLOC_64BIT)
7512         fprintf (file, " ALLOC_64BIT");
7513       fprintf (file, "\n");
7514       if (val & EISD__M_FIXUPVEC)
7515         {
7516           eiaf_vbn = bfd_getl32 (eisd.vbn);
7517           eiaf_size = bfd_getl32 (eisd.secsize);
7518         }
7519       fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7520                (unsigned)bfd_getl32 (eisd.vbn),
7521                eisd.pfc, eisd.matchctl, eisd.type);
7522       switch (eisd.type)
7523         {
7524         case EISD__K_NORMAL:
7525           fputs (_("NORMAL"), file);
7526           break;
7527         case EISD__K_SHRFXD:
7528           fputs (_("SHRFXD"), file);
7529           break;
7530         case EISD__K_PRVFXD:
7531           fputs (_("PRVFXD"), file);
7532           break;
7533         case EISD__K_SHRPIC:
7534           fputs (_("SHRPIC"), file);
7535           break;
7536         case EISD__K_PRVPIC:
7537           fputs (_("PRVPIC"), file);
7538           break;
7539         case EISD__K_USRSTACK:
7540           fputs (_("USRSTACK"), file);
7541           break;
7542         default:
7543           fputs (_("*unknown*"), file);
7544           break;
7545         }
7546       fputs (_(")\n"), file);
7547       if (val & EISD__M_GBL)
7548         fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7549                  (unsigned)bfd_getl32 (eisd.ident),
7550                  eisd.gblnam[0], eisd.gblnam + 1);
7551       eisd_off += len;
7552     }
7553
7554   if (dmt_vbn != 0)
7555     {
7556       if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7557         {
7558           fprintf (file, _("cannot read DMT\n"));
7559           return;
7560         }
7561
7562       fprintf (file, _("Debug module table:\n"));
7563
7564       while (dmt_size > 0)
7565         {
7566           struct vms_dmt_header dmth;
7567           unsigned int count;
7568
7569           if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7570             {
7571               fprintf (file, _("cannot read DMT header\n"));
7572               return;
7573             }
7574           count = bfd_getl16 (dmth.psect_count);
7575           fprintf (file,
7576                    _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
7577                    (unsigned)bfd_getl32 (dmth.modbeg),
7578                    (unsigned)bfd_getl32 (dmth.size), count);
7579           dmt_size -= sizeof (dmth);
7580           while (count > 0)
7581             {
7582               struct vms_dmt_psect dmtp;
7583
7584               if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7585                 {
7586                   fprintf (file, _("cannot read DMT psect\n"));
7587                   return;
7588                 }
7589               fprintf (file, _("  psect start: 0x%08x, length: %u\n"),
7590                        (unsigned)bfd_getl32 (dmtp.start),
7591                        (unsigned)bfd_getl32 (dmtp.length));
7592               count--;
7593               dmt_size -= sizeof (dmtp);
7594             }
7595         }
7596     }
7597
7598   if (dst_vbn != 0)
7599     {
7600       if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7601         {
7602           fprintf (file, _("cannot read DST\n"));
7603           return;
7604         }
7605
7606       evax_bfd_print_dst (abfd, dst_size, file);
7607     }
7608   if (gst_vbn != 0)
7609     {
7610       if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7611         {
7612           fprintf (file, _("cannot read GST\n"));
7613           return;
7614         }
7615
7616       fprintf (file, _("Global symbol table:\n"));
7617       evax_bfd_print_eobj (abfd, file);
7618     }
7619   if (eiaf_vbn != 0)
7620     {
7621       unsigned char *buf;
7622       struct vms_eiaf *eiaf;
7623       unsigned int qrelfixoff;
7624       unsigned int lrelfixoff;
7625       unsigned int qdotadroff;
7626       unsigned int ldotadroff;
7627       unsigned int shrimgcnt;
7628       unsigned int shlstoff;
7629       unsigned int codeadroff;
7630       unsigned int lpfixoff;
7631       unsigned int chgprtoff;
7632
7633       buf = bfd_malloc (eiaf_size);
7634
7635       if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7636           || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7637         {
7638           fprintf (file, _("cannot read EIHA\n"));
7639           free (buf);
7640           return;
7641         }
7642       eiaf = (struct vms_eiaf *)buf;
7643       fprintf (file,
7644                _("Image activator fixup: (major: %u, minor: %u)\n"),
7645                (unsigned)bfd_getl32 (eiaf->majorid),
7646                (unsigned)bfd_getl32 (eiaf->minorid));
7647       fprintf (file, _("  iaflink : 0x%08x %08x\n"),
7648                (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7649                (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7650       fprintf (file, _("  fixuplnk: 0x%08x %08x\n"),
7651                (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7652                (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7653       fprintf (file, _("  size : %u\n"),
7654                (unsigned)bfd_getl32 (eiaf->size));
7655       fprintf (file, _("  flags: 0x%08x\n"),
7656                (unsigned)bfd_getl32 (eiaf->flags));
7657       qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7658       lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7659       fprintf (file, _("  qrelfixoff: %5u, lrelfixoff: %5u\n"),
7660                qrelfixoff, lrelfixoff);
7661       qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7662       ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7663       fprintf (file, _("  qdotadroff: %5u, ldotadroff: %5u\n"),
7664                qdotadroff, ldotadroff);
7665       codeadroff = bfd_getl32 (eiaf->codeadroff);
7666       lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7667       fprintf (file, _("  codeadroff: %5u, lpfixoff  : %5u\n"),
7668                codeadroff, lpfixoff);
7669       chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7670       fprintf (file, _("  chgprtoff : %5u\n"), chgprtoff);
7671       shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7672       shlstoff = bfd_getl32 (eiaf->shlstoff);
7673       fprintf (file, _("  shlstoff  : %5u, shrimgcnt : %5u\n"),
7674                shlstoff, shrimgcnt);
7675       fprintf (file, _("  shlextra  : %5u, permctx   : %5u\n"),
7676                (unsigned)bfd_getl32 (eiaf->shlextra),
7677                (unsigned)bfd_getl32 (eiaf->permctx));
7678       fprintf (file, _("  base_va : 0x%08x\n"),
7679                (unsigned)bfd_getl32 (eiaf->base_va));
7680       fprintf (file, _("  lppsbfixoff: %5u\n"),
7681                (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7682
7683       if (shlstoff)
7684         {
7685           struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7686           unsigned int j;
7687
7688           fprintf (file, _(" Shareable images:\n"));
7689           for (j = 0; j < shrimgcnt; j++, shl++)
7690             {
7691               fprintf (file,
7692                        _("  %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7693                        j, shl->size, shl->flags,
7694                        shl->imgnam[0], shl->imgnam + 1);
7695             }
7696         }
7697       if (qrelfixoff != 0)
7698         {
7699           fprintf (file, _(" quad-word relocation fixups:\n"));
7700           evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7701         }
7702       if (lrelfixoff != 0)
7703         {
7704           fprintf (file, _(" long-word relocation fixups:\n"));
7705           evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7706         }
7707       if (qdotadroff != 0)
7708         {
7709           fprintf (file, _(" quad-word .address reference fixups:\n"));
7710           evax_bfd_print_address_fixups (file, buf + qdotadroff);
7711         }
7712       if (ldotadroff != 0)
7713         {
7714           fprintf (file, _(" long-word .address reference fixups:\n"));
7715           evax_bfd_print_address_fixups (file, buf + ldotadroff);
7716         }
7717       if (codeadroff != 0)
7718         {
7719           fprintf (file, _(" Code Address Reference Fixups:\n"));
7720           evax_bfd_print_reference_fixups (file, buf + codeadroff);
7721         }
7722       if (lpfixoff != 0)
7723         {
7724           fprintf (file, _(" Linkage Pairs Reference Fixups:\n"));
7725           evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7726         }
7727       if (chgprtoff)
7728         {
7729           unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7730           struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7731           unsigned int j;
7732
7733           fprintf (file, _(" Change Protection (%u entries):\n"), count);
7734           for (j = 0; j < count; j++, eicp++)
7735             {
7736               unsigned int prot = bfd_getl32 (eicp->newprt);
7737               fprintf (file,
7738                        _("  base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7739                        (unsigned)bfd_getl32 (eicp->baseva + 4),
7740                        (unsigned)bfd_getl32 (eicp->baseva + 0),
7741                        (unsigned)bfd_getl32 (eicp->size),
7742                        (unsigned)bfd_getl32 (eicp->newprt));
7743               switch (prot)
7744                 {
7745                 case PRT__C_NA:
7746                   fprintf (file, "NA");
7747                   break;
7748                 case PRT__C_RESERVED:
7749                   fprintf (file, "RES");
7750                   break;
7751                 case PRT__C_KW:
7752                   fprintf (file, "KW");
7753                   break;
7754                 case PRT__C_KR:
7755                   fprintf (file, "KR");
7756                   break;
7757                 case PRT__C_UW:
7758                   fprintf (file, "UW");
7759                   break;
7760                 case PRT__C_EW:
7761                   fprintf (file, "EW");
7762                   break;
7763                 case PRT__C_ERKW:
7764                   fprintf (file, "ERKW");
7765                   break;
7766                 case PRT__C_ER:
7767                   fprintf (file, "ER");
7768                   break;
7769                 case PRT__C_SW:
7770                   fprintf (file, "SW");
7771                   break;
7772                 case PRT__C_SREW:
7773                   fprintf (file, "SREW");
7774                   break;
7775                 case PRT__C_SRKW:
7776                   fprintf (file, "SRKW");
7777                   break;
7778                 case PRT__C_SR:
7779                   fprintf (file, "SR");
7780                   break;
7781                 case PRT__C_URSW:
7782                   fprintf (file, "URSW");
7783                   break;
7784                 case PRT__C_UREW:
7785                   fprintf (file, "UREW");
7786                   break;
7787                 case PRT__C_URKW:
7788                   fprintf (file, "URKW");
7789                   break;
7790                 case PRT__C_UR:
7791                   fprintf (file, "UR");
7792                   break;
7793                 default:
7794                   fputs ("??", file);
7795                   break;
7796                 }
7797               fputc ('\n', file);
7798             }
7799         }
7800       free (buf);
7801     }
7802 }
7803
7804 static bfd_boolean
7805 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7806 {
7807   FILE *file = (FILE *)ptr;
7808
7809   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7810     evax_bfd_print_image (abfd, file);
7811   else
7812     {
7813       if (bfd_seek (abfd, 0, SEEK_SET))
7814         return FALSE;
7815       evax_bfd_print_eobj (abfd, file);
7816     }
7817   return TRUE;
7818 }
7819 \f
7820 /* Linking.  */
7821
7822 /* Slurp ETIR/EDBG/ETBT VMS object records.  */
7823
7824 static bfd_boolean
7825 alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7826 {
7827   asection *cur_section;
7828   file_ptr cur_offset;
7829   asection *dst_section;
7830   file_ptr dst_offset;
7831
7832   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7833     return FALSE;
7834
7835   cur_section = NULL;
7836   cur_offset = 0;
7837
7838   dst_section = PRIV (dst_section);
7839   dst_offset = 0;
7840   if (info)
7841     {
7842       if (info->strip == strip_all || info->strip == strip_debugger)
7843         {
7844           /* Discard the DST section.  */
7845           dst_offset = 0;
7846           dst_section = NULL;
7847         }
7848       else if (dst_section)
7849         {
7850           dst_offset = dst_section->output_offset;
7851           dst_section = dst_section->output_section;
7852         }
7853     }
7854
7855   while (1)
7856     {
7857       int type;
7858       bfd_boolean res;
7859
7860       type = _bfd_vms_get_object_record (abfd);
7861       if (type < 0)
7862         {
7863           vms_debug2 ((2, "next_record failed\n"));
7864           return FALSE;
7865         }
7866       switch (type)
7867         {
7868         case EOBJ__C_ETIR:
7869           PRIV (image_section) = cur_section;
7870           PRIV (image_offset) = cur_offset;
7871           res = _bfd_vms_slurp_etir (abfd, info);
7872           cur_section = PRIV (image_section);
7873           cur_offset = PRIV (image_offset);
7874           break;
7875         case EOBJ__C_EDBG:
7876         case EOBJ__C_ETBT:
7877           if (dst_section == NULL)
7878             continue;
7879           PRIV (image_section) = dst_section;
7880           PRIV (image_offset) = dst_offset;
7881           res = _bfd_vms_slurp_etir (abfd, info);
7882           dst_offset = PRIV (image_offset);
7883           break;
7884         case EOBJ__C_EEOM:
7885           return TRUE;
7886         default:
7887           continue;
7888         }
7889       if (!res)
7890         {
7891           vms_debug2 ((2, "slurp eobj type %d failed\n", type));
7892           return FALSE;
7893         }
7894     }
7895 }
7896
7897 static int
7898 alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
7899                           struct bfd_link_info *info ATTRIBUTE_UNUSED)
7900 {
7901   return 0;
7902 }
7903
7904 /* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
7905
7906 static void
7907 alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
7908 {
7909   struct alpha_vms_shlib_el *sl;
7910   asection *sect = PRIV2 (src, image_section);
7911   file_ptr offset = PRIV2 (src, image_offset);
7912
7913   sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7914                 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7915   sl->has_fixups = TRUE;
7916   VEC_APPEND_EL (sl->lp, bfd_vma,
7917                  sect->output_section->vma + sect->output_offset + offset);
7918   sect->output_section->flags |= SEC_RELOC;
7919 }
7920
7921 /* Add a code address fixup at address SECT + OFFSET to SHLIB. */
7922
7923 static void
7924 alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
7925 {
7926   struct alpha_vms_shlib_el *sl;
7927   asection *sect = PRIV2 (src, image_section);
7928   file_ptr offset = PRIV2 (src, image_offset);
7929
7930   sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7931                 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7932   sl->has_fixups = TRUE;
7933   VEC_APPEND_EL (sl->ca, bfd_vma,
7934                  sect->output_section->vma + sect->output_offset + offset);
7935   sect->output_section->flags |= SEC_RELOC;
7936 }
7937
7938 /* Add a quad word relocation fixup at address SECT + OFFSET to SHLIB. */
7939
7940 static void
7941 alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
7942                         bfd *shlib, bfd_vma vec)
7943 {
7944   struct alpha_vms_shlib_el *sl;
7945   struct alpha_vms_vma_ref *r;
7946   asection *sect = PRIV2 (src, image_section);
7947   file_ptr offset = PRIV2 (src, image_offset);
7948
7949   sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7950                 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7951   sl->has_fixups = TRUE;
7952   r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
7953   r->vma = sect->output_section->vma + sect->output_offset + offset;
7954   r->ref = vec;
7955   sect->output_section->flags |= SEC_RELOC;
7956 }
7957
7958 static void
7959 alpha_vms_add_fixup_lr (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7960                         unsigned int shr ATTRIBUTE_UNUSED,
7961                         bfd_vma vec ATTRIBUTE_UNUSED)
7962 {
7963   /* Not yet supported.  */
7964   abort ();
7965 }
7966
7967 /* Add relocation.  FIXME: Not yet emitted.  */
7968
7969 static void
7970 alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
7971 {
7972 }
7973
7974 static void
7975 alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
7976 {
7977 }
7978
7979 static struct bfd_hash_entry *
7980 alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
7981                              struct bfd_hash_table *table,
7982                              const char *string)
7983 {
7984   struct alpha_vms_link_hash_entry *ret =
7985     (struct alpha_vms_link_hash_entry *) entry;
7986
7987   /* Allocate the structure if it has not already been allocated by a
7988      subclass.  */
7989   if (ret == NULL)
7990     ret = ((struct alpha_vms_link_hash_entry *)
7991            bfd_hash_allocate (table,
7992                               sizeof (struct alpha_vms_link_hash_entry)));
7993   if (ret == NULL)
7994     return NULL;
7995
7996   /* Call the allocation method of the superclass.  */
7997   ret = ((struct alpha_vms_link_hash_entry *)
7998          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
7999                                  table, string));
8000
8001   ret->sym = NULL;
8002
8003   return (struct bfd_hash_entry *) ret;
8004 }
8005
8006 /* Create an Alpha/VMS link hash table.  */
8007
8008 static struct bfd_link_hash_table *
8009 alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8010 {
8011   struct alpha_vms_link_hash_table *ret;
8012   bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8013
8014   ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8015   if (ret == NULL)
8016     return NULL;
8017   if (!_bfd_link_hash_table_init (&ret->root, abfd,
8018                                   alpha_vms_link_hash_newfunc,
8019                                   sizeof (struct alpha_vms_link_hash_entry)))
8020     {
8021       free (ret);
8022       return NULL;
8023     }
8024
8025   VEC_INIT (ret->shrlibs);
8026   ret->fixup = NULL;
8027
8028   return &ret->root;
8029 }
8030
8031 static bfd_boolean
8032 alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8033 {
8034   unsigned int i;
8035
8036   for (i = 0; i < PRIV (gsd_sym_count); i++)
8037     {
8038       struct vms_symbol_entry *e = PRIV (syms)[i];
8039       struct alpha_vms_link_hash_entry *h;
8040       struct bfd_link_hash_entry *h_root;
8041       asymbol sym;
8042
8043       if (!alpha_vms_convert_symbol (abfd, e, &sym))
8044         return FALSE;
8045
8046       if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8047         {
8048           /* In selective_search mode, only add definition that are
8049              required.  */
8050           h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8051             (info->hash, sym.name, FALSE, FALSE, FALSE);
8052           if (h == NULL || h->root.type != bfd_link_hash_undefined)
8053             continue;
8054         }
8055       else
8056         h = NULL;
8057
8058       h_root = (struct bfd_link_hash_entry *) h;
8059       if (_bfd_generic_link_add_one_symbol
8060           (info, abfd, sym.name, sym.flags, sym.section, sym.value,
8061            NULL, FALSE, FALSE, &h_root) == FALSE)
8062         return FALSE;
8063       h = (struct alpha_vms_link_hash_entry *) h_root;
8064
8065       if ((e->flags & EGSY__V_DEF)
8066           && h->sym == NULL
8067           && abfd->xvec == info->output_bfd->xvec)
8068         h->sym = e;
8069     }
8070
8071   if (abfd->flags & DYNAMIC)
8072     {
8073       struct alpha_vms_shlib_el *shlib;
8074
8075       /* We do not want to include any of the sections in a dynamic
8076          object in the output file.  See comment in elflink.c.  */
8077       bfd_section_list_clear (abfd);
8078
8079       shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8080                           struct alpha_vms_shlib_el);
8081       shlib->abfd = abfd;
8082       VEC_INIT (shlib->ca);
8083       VEC_INIT (shlib->lp);
8084       VEC_INIT (shlib->qr);
8085       PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8086     }
8087
8088   return TRUE;
8089 }
8090
8091 static bfd_boolean
8092 alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8093 {
8094   int pass;
8095   struct bfd_link_hash_entry **pundef;
8096   struct bfd_link_hash_entry **next_pundef;
8097
8098   /* We only accept VMS libraries.  */
8099   if (info->output_bfd->xvec != abfd->xvec)
8100     {
8101       bfd_set_error (bfd_error_wrong_format);
8102       return FALSE;
8103     }
8104
8105   /* The archive_pass field in the archive itself is used to
8106      initialize PASS, since we may search the same archive multiple
8107      times.  */
8108   pass = ++abfd->archive_pass;
8109
8110   /* Look through the list of undefined symbols.  */
8111   for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8112     {
8113       struct bfd_link_hash_entry *h;
8114       symindex symidx;
8115       bfd *element;
8116       bfd *orig_element;
8117
8118       h = *pundef;
8119       next_pundef = &(*pundef)->u.undef.next;
8120
8121       /* When a symbol is defined, it is not necessarily removed from
8122          the list.  */
8123       if (h->type != bfd_link_hash_undefined
8124           && h->type != bfd_link_hash_common)
8125         {
8126           /* Remove this entry from the list, for general cleanliness
8127              and because we are going to look through the list again
8128              if we search any more libraries.  We can't remove the
8129              entry if it is the tail, because that would lose any
8130              entries we add to the list later on.  */
8131           if (*pundef != info->hash->undefs_tail)
8132             {
8133               *pundef = *next_pundef;
8134               next_pundef = pundef;
8135             }
8136           continue;
8137         }
8138
8139       /* Look for this symbol in the archive hash table.  */
8140       symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8141       if (symidx == BFD_NO_MORE_SYMBOLS)
8142         {
8143           /* Nothing in this slot.  */
8144           continue;
8145         }
8146
8147       element = bfd_get_elt_at_index (abfd, symidx);
8148       if (element == NULL)
8149         return FALSE;
8150
8151       if (element->archive_pass == -1 || element->archive_pass == pass)
8152         {
8153           /* Next symbol if this archive is wrong or already handled.  */
8154           continue;
8155         }
8156
8157       if (! bfd_check_format (element, bfd_object))
8158         {
8159           element->archive_pass = -1;
8160           return FALSE;
8161         }
8162
8163       orig_element = element;
8164       if (bfd_is_thin_archive (abfd))
8165         {
8166           element = _bfd_vms_lib_get_imagelib_file (element);
8167           if (element == NULL || !bfd_check_format (element, bfd_object))
8168             {
8169               orig_element->archive_pass = -1;
8170               return FALSE;
8171             }
8172         }
8173
8174       /* Unlike the generic linker, we know that this element provides
8175          a definition for an undefined symbol and we know that we want
8176          to include it.  We don't need to check anything.  */
8177       if (!(*info->callbacks
8178             ->add_archive_element) (info, element, h->root.string, &element))
8179         return FALSE;
8180       if (!alpha_vms_link_add_object_symbols (element, info))
8181         return FALSE;
8182
8183       orig_element->archive_pass = pass;
8184     }
8185
8186   return TRUE;
8187 }
8188
8189 static bfd_boolean
8190 alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8191 {
8192   switch (bfd_get_format (abfd))
8193     {
8194     case bfd_object:
8195       vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8196                    abfd->filename));
8197       return alpha_vms_link_add_object_symbols (abfd, info);
8198       break;
8199     case bfd_archive:
8200       vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8201                    abfd->filename));
8202       return alpha_vms_link_add_archive_symbols (abfd, info);
8203       break;
8204     default:
8205       bfd_set_error (bfd_error_wrong_format);
8206       return FALSE;
8207     }
8208 }
8209
8210 static bfd_boolean
8211 alpha_vms_build_fixups (struct bfd_link_info *info)
8212 {
8213   struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8214   unsigned char *content;
8215   unsigned int i;
8216   unsigned int sz = 0;
8217   unsigned int lp_sz = 0;
8218   unsigned int ca_sz = 0;
8219   unsigned int qr_sz = 0;
8220   unsigned int shrimg_cnt = 0;
8221   unsigned int chgprt_num = 0;
8222   unsigned int chgprt_sz = 0;
8223   struct vms_eiaf *eiaf;
8224   unsigned int off;
8225   asection *sec;
8226
8227   /* Shared libraries.  */
8228   for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8229     {
8230       struct alpha_vms_shlib_el *shlib;
8231
8232       shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8233
8234       if (!shlib->has_fixups)
8235         continue;
8236
8237       shrimg_cnt++;
8238
8239       if (VEC_COUNT (shlib->ca) > 0)
8240         {
8241           /* Header + entries.  */
8242           ca_sz += 8;
8243           ca_sz += VEC_COUNT (shlib->ca) * 4;
8244         }
8245       if (VEC_COUNT (shlib->lp) > 0)
8246         {
8247           /* Header + entries.  */
8248           lp_sz += 8;
8249           lp_sz += VEC_COUNT (shlib->lp) * 4;
8250         }
8251       if (VEC_COUNT (shlib->qr) > 0)
8252         {
8253           /* Header + entries.  */
8254           qr_sz += 8;
8255           qr_sz += VEC_COUNT (shlib->qr) * 8;
8256         }
8257     }
8258   /* Add markers.  */
8259   if (ca_sz > 0)
8260     ca_sz += 8;
8261   if (lp_sz > 0)
8262     lp_sz += 8;
8263   if (qr_sz > 0)
8264     qr_sz += 8;
8265
8266   /* Finish now if there is no content.  */
8267   if (ca_sz + lp_sz + qr_sz == 0)
8268     return TRUE;
8269
8270   /* Add an eicp entry for the fixup itself.  */
8271   chgprt_num = 1;
8272   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8273     {
8274       /* This isect could be made RO or EXE after relocations are applied.  */
8275       if ((sec->flags & SEC_RELOC) != 0
8276           && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8277         chgprt_num++;
8278     }
8279   chgprt_sz = 4 + chgprt_num * sizeof (struct vms_eicp);
8280
8281   /* Allocate section content (round-up size)  */
8282   sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8283     + ca_sz + lp_sz + qr_sz + chgprt_sz;
8284   sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8285   content = bfd_zalloc (info->output_bfd, sz);
8286   if (content == NULL)
8287     return FALSE;
8288
8289   sec = alpha_vms_link_hash (info)->fixup;
8290   sec->contents = content;
8291   sec->size = sz;
8292
8293   eiaf = (struct vms_eiaf *)content;
8294   off = sizeof (struct vms_eiaf);
8295   bfd_putl32 (0, eiaf->majorid);
8296   bfd_putl32 (0, eiaf->minorid);
8297   bfd_putl32 (0, eiaf->iaflink);
8298   bfd_putl32 (0, eiaf->fixuplnk);
8299   bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8300   bfd_putl32 (0, eiaf->flags);
8301   bfd_putl32 (0, eiaf->qrelfixoff);
8302   bfd_putl32 (0, eiaf->lrelfixoff);
8303   bfd_putl32 (0, eiaf->qdotadroff);
8304   bfd_putl32 (0, eiaf->ldotadroff);
8305   bfd_putl32 (0, eiaf->codeadroff);
8306   bfd_putl32 (0, eiaf->lpfixoff);
8307   bfd_putl32 (0, eiaf->chgprtoff);
8308   bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8309   bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8310   bfd_putl32 (0, eiaf->shlextra);
8311   bfd_putl32 (0, eiaf->permctx);
8312   bfd_putl32 (0, eiaf->base_va);
8313   bfd_putl32 (0, eiaf->lppsbfixoff);
8314
8315   if (shrimg_cnt)
8316     {
8317       shrimg_cnt = 0;
8318
8319       /* Write shl.  */
8320       for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8321         {
8322           struct alpha_vms_shlib_el *shlib;
8323           struct vms_shl *shl;
8324
8325           shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8326
8327           if (!shlib->has_fixups)
8328             continue;
8329
8330           /* Renumber shared images.  */
8331           PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8332
8333           shl = (struct vms_shl *)(content + off);
8334           bfd_putl32 (0, shl->baseva);
8335           bfd_putl32 (0, shl->shlptr);
8336           bfd_putl32 (0, shl->ident);
8337           bfd_putl32 (0, shl->permctx);
8338           shl->size = sizeof (struct vms_shl);
8339           bfd_putl16 (0, shl->fill_1);
8340           shl->flags = 0;
8341           bfd_putl32 (0, shl->icb);
8342           shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8343           memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8344                   shl->imgnam[0]);
8345
8346           off += sizeof (struct vms_shl);
8347         }
8348
8349       /* CA fixups.  */
8350       if (ca_sz != 0)
8351         {
8352           bfd_putl32 (off, eiaf->codeadroff);
8353
8354           for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8355             {
8356               struct alpha_vms_shlib_el *shlib;
8357               unsigned int j;
8358
8359               shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8360
8361               if (VEC_COUNT (shlib->ca) == 0)
8362                 continue;
8363
8364               bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8365               bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8366               off += 8;
8367
8368               for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8369                 {
8370                   bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8371                               content + off);
8372                   off += 4;
8373                 }
8374             }
8375
8376           bfd_putl32 (0, content + off);
8377           bfd_putl32 (0, content + off + 4);
8378           off += 8;
8379         }
8380
8381       /* LP fixups.  */
8382       if (lp_sz != 0)
8383         {
8384           bfd_putl32 (off, eiaf->lpfixoff);
8385
8386           for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8387             {
8388               struct alpha_vms_shlib_el *shlib;
8389               unsigned int j;
8390
8391               shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8392
8393               if (VEC_COUNT (shlib->lp) == 0)
8394                 continue;
8395
8396               bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8397               bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8398               off += 8;
8399
8400               for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8401                 {
8402                   bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8403                               content + off);
8404                   off += 4;
8405                 }
8406             }
8407
8408           bfd_putl32 (0, content + off);
8409           bfd_putl32 (0, content + off + 4);
8410           off += 8;
8411         }
8412
8413       /* QR fixups.  */
8414       if (qr_sz != 0)
8415         {
8416           bfd_putl32 (off, eiaf->qdotadroff);
8417
8418           for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8419             {
8420               struct alpha_vms_shlib_el *shlib;
8421               unsigned int j;
8422
8423               shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8424
8425               if (VEC_COUNT (shlib->qr) == 0)
8426                 continue;
8427
8428               bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8429               bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8430               off += 8;
8431
8432               for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8433                 {
8434                   struct alpha_vms_vma_ref *r;
8435                   r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8436                   bfd_putl32 (r->vma - t->base_addr, content + off);
8437                   bfd_putl32 (r->ref, content + off + 4);
8438                   off += 8;
8439                 }
8440             }
8441
8442           bfd_putl32 (0, content + off);
8443           bfd_putl32 (0, content + off + 4);
8444           off += 8;
8445         }
8446     }
8447
8448   /* Write the change protection table.  */
8449   bfd_putl32 (off, eiaf->chgprtoff);
8450   bfd_putl32 (chgprt_num, content + off);
8451   off += 4;
8452
8453   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8454     {
8455       struct vms_eicp *eicp;
8456       unsigned int prot;
8457
8458       if ((sec->flags & SEC_LINKER_CREATED) != 0 &&
8459           strcmp (sec->name, "$FIXUP$") == 0)
8460         prot = PRT__C_UREW;
8461       else if ((sec->flags & SEC_RELOC) != 0
8462                && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8463         prot = PRT__C_UR;
8464       else
8465         continue;
8466
8467       eicp = (struct vms_eicp *)(content + off);
8468       bfd_putl64 (sec->vma - t->base_addr, eicp->baseva);
8469       bfd_putl32 ((sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1),
8470                   eicp->size);
8471       bfd_putl32 (prot, eicp->newprt);
8472       off += sizeof (struct vms_eicp);
8473     }
8474
8475   return TRUE;
8476 }
8477
8478 /* Called by bfd_hash_traverse to fill the symbol table.
8479    Return FALSE in case of failure.  */
8480
8481 static bfd_boolean
8482 alpha_vms_link_output_symbol (struct bfd_hash_entry *bh, void *infov)
8483 {
8484   struct bfd_link_hash_entry *hc = (struct bfd_link_hash_entry *) bh;
8485   struct bfd_link_info *info = (struct bfd_link_info *)infov;
8486   struct alpha_vms_link_hash_entry *h;
8487   struct vms_symbol_entry *sym;
8488
8489   if (hc->type == bfd_link_hash_warning)
8490     {
8491       hc = hc->u.i.link;
8492       if (hc->type == bfd_link_hash_new)
8493         return TRUE;
8494     }
8495   h = (struct alpha_vms_link_hash_entry *) hc;
8496
8497   switch (h->root.type)
8498     {
8499     case bfd_link_hash_undefined:
8500       return TRUE;
8501     case bfd_link_hash_new:
8502     case bfd_link_hash_warning:
8503       abort ();
8504     case bfd_link_hash_undefweak:
8505       return TRUE;
8506     case bfd_link_hash_defined:
8507     case bfd_link_hash_defweak:
8508       {
8509         asection *sec = h->root.u.def.section;
8510
8511         /* FIXME: this is certainly a symbol from a dynamic library.  */
8512         if (bfd_is_abs_section (sec))
8513           return TRUE;
8514
8515         if (sec->owner->flags & DYNAMIC)
8516           return TRUE;
8517       }
8518       break;
8519     case bfd_link_hash_common:
8520       break;
8521     case bfd_link_hash_indirect:
8522       return TRUE;
8523     }
8524
8525   /* Do not write not kept symbols.  */
8526   if (info->strip == strip_some
8527       && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8528                           FALSE, FALSE) != NULL)
8529     return TRUE;
8530
8531   if (h->sym == NULL)
8532     {
8533       /* This symbol doesn't come from a VMS object.  So we suppose it is
8534          a data.  */
8535       int len = strlen (h->root.root.string);
8536
8537       sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8538                                                    sizeof (*sym) + len);
8539       if (sym == NULL)
8540         abort ();
8541       sym->namelen = len;
8542       memcpy (sym->name, h->root.root.string, len);
8543       sym->name[len] = 0;
8544       sym->owner = info->output_bfd;
8545
8546       sym->typ = EGSD__C_SYMG;
8547       sym->data_type = 0;
8548       sym->flags = EGSY__V_DEF | EGSY__V_REL;
8549       sym->symbol_vector = h->root.u.def.value;
8550       sym->section = h->root.u.def.section;
8551       sym->value = h->root.u.def.value;
8552     }
8553   else
8554     sym = h->sym;
8555
8556   if (!add_symbol_entry (info->output_bfd, sym))
8557     return FALSE;
8558
8559   return TRUE;
8560 }
8561
8562 static bfd_boolean
8563 alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8564 {
8565   asection *o;
8566   struct bfd_link_order *p;
8567   bfd *sub;
8568   asection *fixupsec;
8569   bfd_vma base_addr;
8570   bfd_vma last_addr;
8571   asection *dst;
8572   asection *dmt;
8573
8574   if (info->relocatable)
8575     {
8576       /* FIXME: we do not yet support relocatable link.  It is not obvious
8577          how to do it for debug infos.  */
8578       (*info->callbacks->einfo)(_("%P: relocatable link is not supported\n"));
8579       return FALSE;
8580     }
8581
8582   bfd_get_outsymbols (abfd) = NULL;
8583   bfd_get_symcount (abfd) = 0;
8584
8585   /* Mark all sections which will be included in the output file.  */
8586   for (o = abfd->sections; o != NULL; o = o->next)
8587     for (p = o->map_head.link_order; p != NULL; p = p->next)
8588       if (p->type == bfd_indirect_link_order)
8589         p->u.indirect.section->linker_mark = TRUE;
8590
8591 #if 0
8592   /* Handle all the link order information for the sections.  */
8593   for (o = abfd->sections; o != NULL; o = o->next)
8594     {
8595       printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8596               o->name, (unsigned)o->vma, (unsigned)o->flags);
8597
8598       for (p = o->map_head.link_order; p != NULL; p = p->next)
8599         {
8600           printf (" at 0x%08x - 0x%08x: ",
8601                   (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8602           switch (p->type)
8603             {
8604             case bfd_section_reloc_link_order:
8605             case bfd_symbol_reloc_link_order:
8606               printf ("  section/symbol reloc\n");
8607               break;
8608             case bfd_indirect_link_order:
8609               printf ("  section %s of %s\n",
8610                       p->u.indirect.section->name,
8611                       p->u.indirect.section->owner->filename);
8612               break;
8613             case bfd_data_link_order:
8614               printf ("  explicit data\n");
8615               break;
8616             default:
8617               printf ("  *unknown* type %u\n", p->type);
8618               break;
8619             }
8620         }
8621     }
8622 #endif
8623
8624   /* Generate the symbol table.  */
8625   BFD_ASSERT (PRIV (syms) == NULL);
8626   if (info->strip != strip_all)
8627     bfd_hash_traverse (&info->hash->table, alpha_vms_link_output_symbol, info);
8628
8629   /* Find the entry point.  */
8630   if (bfd_get_start_address (abfd) == 0)
8631     {
8632       bfd *startbfd = NULL;
8633
8634       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
8635         {
8636           /* Consider only VMS object files.  */
8637           if (sub->xvec != abfd->xvec)
8638             continue;
8639
8640           if (!PRIV2 (sub, eom_data).eom_has_transfer)
8641             continue;
8642           if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8643             continue;
8644           if (startbfd != NULL
8645               && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8646             {
8647               (*info->callbacks->einfo)
8648                 (_("%P: multiple entry points: in modules %B and %B\n"),
8649                  startbfd, sub);
8650               continue;
8651             }
8652           startbfd = sub;
8653         }
8654
8655       if (startbfd)
8656         {
8657           unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8658           bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8659           asection *sec;
8660
8661           sec = PRIV2 (startbfd, sections)[ps_idx];
8662
8663           bfd_set_start_address
8664             (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8665         }
8666     }
8667
8668   /* Set transfer addresses.  */
8669   {
8670     int i;
8671     struct bfd_link_hash_entry *h;
8672
8673     i = 0;
8674     PRIV (transfer_address[i++]) = 0xffffffff00000340ULL;       /* SYS$IMGACT */
8675     h = bfd_link_hash_lookup (info->hash, "LIB$INITIALIZE", FALSE, FALSE, TRUE);
8676     if (h != NULL && h->type == bfd_link_hash_defined)
8677       PRIV (transfer_address[i++]) =
8678         alpha_vms_get_sym_value (h->u.def.section, h->u.def.value);
8679     PRIV (transfer_address[i++]) = bfd_get_start_address (abfd);
8680     while (i < 4)
8681       PRIV (transfer_address[i++]) = 0;
8682   }
8683
8684   /* Allocate contents.
8685      Also compute the virtual base address.  */
8686   base_addr = (bfd_vma)-1;
8687   last_addr = 0;
8688   for (o = abfd->sections; o != NULL; o = o->next)
8689     {
8690       if (o->flags & SEC_HAS_CONTENTS)
8691         {
8692           o->contents = bfd_alloc (abfd, o->size);
8693           if (o->contents == NULL)
8694             return FALSE;
8695         }
8696       if (o->flags & SEC_LOAD)
8697         {
8698           if (o->vma < base_addr)
8699             base_addr = o->vma;
8700           if (o->vma + o->size > last_addr)
8701             last_addr = o->vma + o->size;
8702         }
8703       /* Clear the RELOC flags.  Currently we don't support incremental
8704          linking.  We use the RELOC flag for computing the eicp entries.  */
8705       o->flags &= ~SEC_RELOC;
8706     }
8707
8708   /* Create the fixup section.  */
8709   fixupsec = bfd_make_section_anyway_with_flags
8710     (info->output_bfd, "$FIXUP$",
8711      SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8712   if (fixupsec == NULL)
8713     return FALSE;
8714   last_addr = (last_addr + 0xffff) & ~0xffff;
8715   fixupsec->vma = last_addr;
8716
8717   alpha_vms_link_hash (info)->fixup = fixupsec;
8718   alpha_vms_link_hash (info)->base_addr = base_addr;
8719
8720   /* Create the DMT section, if necessary.  */
8721   BFD_ASSERT (PRIV (dst_section) == NULL);
8722   dst = bfd_get_section_by_name (abfd, "$DST$");
8723   if (dst != NULL && dst->size == 0)
8724     dst = NULL;
8725   if (dst != NULL)
8726     {
8727       PRIV (dst_section) = dst;
8728       dmt = bfd_make_section_anyway_with_flags
8729         (info->output_bfd, "$DMT$",
8730          SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8731       if (dmt == NULL)
8732         return FALSE;
8733     }
8734   else
8735     dmt = NULL;
8736
8737   /* Read all sections from the inputs.  */
8738   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
8739     {
8740       if (sub->flags & DYNAMIC)
8741         {
8742           alpha_vms_create_eisd_for_shared (abfd, sub);
8743           continue;
8744         }
8745
8746       if (!alpha_vms_read_sections_content (sub, info))
8747         return FALSE;
8748     }
8749
8750   /* Handle all the link order information for the sections.
8751      Note: past this point, it is not possible to create new sections.  */
8752   for (o = abfd->sections; o != NULL; o = o->next)
8753     {
8754       for (p = o->map_head.link_order; p != NULL; p = p->next)
8755         {
8756           switch (p->type)
8757             {
8758             case bfd_section_reloc_link_order:
8759             case bfd_symbol_reloc_link_order:
8760               abort ();
8761               return FALSE;
8762             case bfd_indirect_link_order:
8763               /* Already done.  */
8764               break;
8765             default:
8766               if (! _bfd_default_link_order (abfd, info, o, p))
8767                 return FALSE;
8768               break;
8769             }
8770         }
8771     }
8772
8773   /* Compute fixups.  */
8774   if (!alpha_vms_build_fixups (info))
8775     return FALSE;
8776
8777   /* Compute the DMT.  */
8778   if (dmt != NULL)
8779     {
8780       int pass;
8781       unsigned char *contents = NULL;
8782
8783       /* In pass 1, compute the size.  In pass 2, write the DMT contents.  */
8784       for (pass = 0; pass < 2; pass++)
8785         {
8786           unsigned int off = 0;
8787
8788           /* For each object file (ie for each module).  */
8789           for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
8790             {
8791               asection *sub_dst;
8792               struct vms_dmt_header *dmth = NULL;
8793               unsigned int psect_count;
8794
8795               /* Skip this module if it has no DST.  */
8796               sub_dst = PRIV2 (sub, dst_section);
8797               if (sub_dst == NULL || sub_dst->size == 0)
8798                 continue;
8799
8800               if (pass == 1)
8801                 {
8802                   /* Write the header.  */
8803                   dmth = (struct vms_dmt_header *)(contents + off);
8804                   bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8805                   bfd_putl32 (sub_dst->size, dmth->size);
8806                 }
8807
8808               off += sizeof (struct vms_dmt_header);
8809               psect_count = 0;
8810
8811               /* For each section (ie for each psect).  */
8812               for (o = sub->sections; o != NULL; o = o->next)
8813                 {
8814                   /* Only consider interesting sections.  */
8815                   if (!(o->flags & SEC_ALLOC))
8816                     continue;
8817                   if (o->flags & SEC_LINKER_CREATED)
8818                     continue;
8819
8820                   if (pass == 1)
8821                     {
8822                       /* Write an entry.  */
8823                       struct vms_dmt_psect *dmtp;
8824
8825                       dmtp = (struct vms_dmt_psect *)(contents + off);
8826                       bfd_putl32 (o->output_offset + o->output_section->vma,
8827                                   dmtp->start);
8828                       bfd_putl32 (o->size, dmtp->length);
8829                       psect_count++;
8830                     }
8831                   off += sizeof (struct vms_dmt_psect);
8832                 }
8833               if (pass == 1)
8834                 bfd_putl32 (psect_count, dmth->psect_count);
8835             }
8836
8837           if (pass == 0)
8838             {
8839               contents = bfd_zalloc (info->output_bfd, off);
8840               if (contents == NULL)
8841                 return FALSE;
8842               dmt->contents = contents;
8843               dmt->size = off;
8844             }
8845           else
8846             {
8847               BFD_ASSERT (off == dmt->size);
8848             }
8849         }
8850     }
8851
8852   return TRUE;
8853 }
8854
8855 /* Read the contents of a section.
8856    buf points to a buffer of buf_size bytes to be filled with
8857    section data (starting at offset into section)  */
8858
8859 static bfd_boolean
8860 alpha_vms_get_section_contents (bfd *abfd, asection *section,
8861                                 void *buf, file_ptr offset,
8862                                 bfd_size_type count)
8863 {
8864   asection *sec;
8865
8866   /* Image are easy.  */
8867   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8868     return _bfd_generic_get_section_contents (abfd, section,
8869                                               buf, offset, count);
8870
8871   /* Safety check.  */
8872   if (offset + count < count
8873       || offset + count > section->size)
8874     {
8875       bfd_set_error (bfd_error_invalid_operation);
8876       return FALSE;
8877     }
8878
8879   /* If the section is already in memory, just copy it.  */
8880   if (section->flags & SEC_IN_MEMORY)
8881     {
8882       BFD_ASSERT (section->contents != NULL);
8883       memcpy (buf, section->contents + offset, count);
8884       return TRUE;
8885     }
8886   if (section->size == 0)
8887     return TRUE;
8888
8889   /* Alloc in memory and read ETIRs.  */
8890   for (sec = abfd->sections; sec; sec = sec->next)
8891     {
8892       BFD_ASSERT (sec->contents == NULL);
8893
8894       if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
8895         {
8896           sec->contents = bfd_alloc (abfd, sec->size);
8897           if (sec->contents == NULL)
8898             return FALSE;
8899         }
8900     }
8901   if (!alpha_vms_read_sections_content (abfd, NULL))
8902     return FALSE;
8903   for (sec = abfd->sections; sec; sec = sec->next)
8904     if (sec->contents)
8905       sec->flags |= SEC_IN_MEMORY;
8906   memcpy (buf, section->contents + offset, count);
8907   return TRUE;
8908 }
8909
8910
8911 /* Set the format of a file being written.  */
8912
8913 static bfd_boolean
8914 alpha_vms_mkobject (bfd * abfd)
8915 {
8916   const bfd_arch_info_type *arch;
8917
8918   vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
8919
8920   if (!vms_initialize (abfd))
8921     return FALSE;
8922
8923   PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
8924   if (PRIV (recwr.buf) == NULL)
8925     return FALSE;
8926
8927   arch = bfd_scan_arch ("alpha");
8928
8929   if (arch == 0)
8930     {
8931       bfd_set_error (bfd_error_wrong_format);
8932       return FALSE;
8933     }
8934
8935   abfd->arch_info = arch;
8936   return TRUE;
8937 }
8938
8939
8940 /* 4.1, generic.  */
8941
8942 /* Called when the BFD is being closed to do any necessary cleanup.  */
8943
8944 static bfd_boolean
8945 vms_close_and_cleanup (bfd * abfd)
8946 {
8947   vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
8948
8949   if (abfd == NULL || abfd->tdata.any == NULL)
8950     return TRUE;
8951
8952   if (abfd->format == bfd_archive)
8953     {
8954       bfd_release (abfd, abfd->tdata.any);
8955       abfd->tdata.any = NULL;
8956       return TRUE;
8957     }
8958
8959   if (PRIV (recrd.buf) != NULL)
8960     free (PRIV (recrd.buf));
8961
8962   if (PRIV (sections) != NULL)
8963     free (PRIV (sections));
8964
8965   bfd_release (abfd, abfd->tdata.any);
8966   abfd->tdata.any = NULL;
8967
8968 #ifdef VMS
8969   if (abfd->direction == write_direction)
8970     {
8971       /* Last step on VMS is to convert the file to variable record length
8972          format.  */
8973       if (bfd_cache_close (abfd) != TRUE)
8974         return FALSE;
8975       if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
8976         return FALSE;
8977     }
8978 #endif
8979
8980   return TRUE;
8981 }
8982
8983 /* Called when a new section is created.  */
8984
8985 static bfd_boolean
8986 vms_new_section_hook (bfd * abfd, asection *section)
8987 {
8988   bfd_size_type amt;
8989
8990   vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
8991                abfd, section->index, section->name));
8992
8993   if (! bfd_set_section_alignment (abfd, section, 0))
8994     return FALSE;
8995
8996   vms_debug2 ((7, "%d: %s\n", section->index, section->name));
8997
8998   amt = sizeof (struct vms_section_data_struct);
8999   section->used_by_bfd = bfd_zalloc (abfd, amt);
9000   if (section->used_by_bfd == NULL)
9001     return FALSE;
9002
9003   /* Create the section symbol.  */
9004   return _bfd_generic_new_section_hook (abfd, section);
9005 }
9006
9007 /* Part 4.5, symbols.  */
9008
9009 /* Print symbol to file according to how. how is one of
9010    bfd_print_symbol_name        just print the name
9011    bfd_print_symbol_more        print more (???)
9012    bfd_print_symbol_all print all we know, which is not much right now :-).  */
9013
9014 static void
9015 vms_print_symbol (bfd * abfd,
9016                   void * file,
9017                   asymbol *symbol,
9018                   bfd_print_symbol_type how)
9019 {
9020   vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
9021                abfd, file, symbol, how));
9022
9023   switch (how)
9024     {
9025       case bfd_print_symbol_name:
9026       case bfd_print_symbol_more:
9027         fprintf ((FILE *)file," %s", symbol->name);
9028       break;
9029
9030       case bfd_print_symbol_all:
9031         {
9032           const char *section_name = symbol->section->name;
9033
9034           bfd_print_symbol_vandf (abfd, file, symbol);
9035
9036           fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9037         }
9038       break;
9039     }
9040 }
9041
9042 /* Return information about symbol in ret.
9043
9044    fill type, value and name
9045    type:
9046         A       absolute
9047         B       bss segment symbol
9048         C       common symbol
9049         D       data segment symbol
9050         f       filename
9051         t       a static function symbol
9052         T       text segment symbol
9053         U       undefined
9054         -       debug.  */
9055
9056 static void
9057 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9058                      asymbol *symbol,
9059                      symbol_info *ret)
9060 {
9061   asection *sec;
9062
9063   vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9064
9065   sec = symbol->section;
9066
9067   if (ret == NULL)
9068     return;
9069
9070   if (sec == NULL)
9071     ret->type = 'U';
9072   else if (bfd_is_com_section (sec))
9073     ret->type = 'C';
9074   else if (bfd_is_abs_section (sec))
9075     ret->type = 'A';
9076   else if (bfd_is_und_section (sec))
9077     ret->type = 'U';
9078   else if (bfd_is_ind_section (sec))
9079     ret->type = 'I';
9080   else if ((symbol->flags & BSF_FUNCTION)
9081            || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
9082     ret->type = 'T';
9083   else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9084     ret->type = 'D';
9085   else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9086     ret->type = 'B';
9087   else
9088     ret->type = '?';
9089
9090   if (ret->type != 'U')
9091     ret->value = symbol->value + symbol->section->vma;
9092   else
9093     ret->value = 0;
9094   ret->name = symbol->name;
9095 }
9096
9097 /* Return TRUE if the given symbol sym in the BFD abfd is
9098    a compiler generated local label, else return FALSE.  */
9099
9100 static bfd_boolean
9101 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9102                              const char *name)
9103 {
9104   return name[0] == '$';
9105 }
9106 \f
9107 /* Part 4.7, writing an object file.  */
9108
9109 /* Sets the contents of the section section in BFD abfd to the data starting
9110    in memory at LOCATION. The data is written to the output section starting
9111    at offset offset for count bytes.
9112
9113    Normally TRUE is returned, else FALSE. Possible error returns are:
9114    o bfd_error_no_contents - The output section does not have the
9115         SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9116    o and some more too  */
9117
9118 static bfd_boolean
9119 _bfd_vms_set_section_contents (bfd * abfd,
9120                                asection *section,
9121                                const void * location,
9122                                file_ptr offset,
9123                                bfd_size_type count)
9124 {
9125   if (section->contents == NULL)
9126     {
9127       section->contents = bfd_alloc (abfd, section->size);
9128       if (section->contents == NULL)
9129         return FALSE;
9130
9131       memcpy (section->contents + offset, location, (size_t) count);
9132     }
9133
9134   return TRUE;
9135 }
9136
9137 /* Set the architecture and machine type in BFD abfd to arch and mach.
9138    Find the correct pointer to a structure and insert it into the arch_info
9139    pointer.  */
9140
9141 static bfd_boolean
9142 alpha_vms_set_arch_mach (bfd *abfd,
9143                          enum bfd_architecture arch, unsigned long mach)
9144 {
9145   if (arch != bfd_arch_alpha
9146       && arch != bfd_arch_unknown)
9147     return FALSE;
9148
9149   return bfd_default_set_arch_mach (abfd, arch, mach);
9150 }
9151
9152 /* Set section VMS flags.  Clear NO_FLAGS and set FLAGS.  */
9153
9154 void
9155 bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9156                            asection *sec, flagword no_flags, flagword flags)
9157 {
9158   vms_section_data (sec)->no_flags = no_flags;
9159   vms_section_data (sec)->flags = flags;
9160 }
9161
9162 struct vms_private_data_struct *
9163 bfd_vms_get_data (bfd *abfd)
9164 {
9165   return (struct vms_private_data_struct *)abfd->tdata.any;
9166 }
9167
9168 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9169 #define vms_bfd_link_just_syms            _bfd_generic_link_just_syms
9170 #define vms_bfd_copy_link_hash_symbol_type \
9171   _bfd_generic_copy_link_hash_symbol_type
9172 #define vms_bfd_is_group_section          bfd_generic_is_group_section
9173 #define vms_bfd_discard_group             bfd_generic_discard_group
9174 #define vms_section_already_linked        _bfd_generic_section_already_linked
9175 #define vms_bfd_define_common_symbol      bfd_generic_define_common_symbol
9176 #define vms_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data
9177
9178 #define vms_bfd_copy_private_bfd_data     _bfd_generic_bfd_copy_private_bfd_data
9179 #define vms_bfd_free_cached_info          _bfd_generic_bfd_free_cached_info
9180 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9181 #define vms_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
9182 #define vms_bfd_set_private_flags         _bfd_generic_bfd_set_private_flags
9183 #define vms_bfd_merge_private_bfd_data    _bfd_generic_bfd_merge_private_bfd_data
9184
9185 /* Symbols table.  */
9186 #define alpha_vms_make_empty_symbol        _bfd_generic_make_empty_symbol
9187 #define alpha_vms_bfd_is_target_special_symbol \
9188    ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9189 #define alpha_vms_print_symbol             vms_print_symbol
9190 #define alpha_vms_get_symbol_info          vms_get_symbol_info
9191 #define alpha_vms_read_minisymbols         _bfd_generic_read_minisymbols
9192 #define alpha_vms_minisymbol_to_symbol     _bfd_generic_minisymbol_to_symbol
9193 #define alpha_vms_get_lineno               _bfd_nosymbols_get_lineno
9194 #define alpha_vms_find_inliner_info        _bfd_nosymbols_find_inliner_info
9195 #define alpha_vms_bfd_make_debug_symbol    _bfd_nosymbols_bfd_make_debug_symbol
9196 #define alpha_vms_find_nearest_line        _bfd_vms_find_nearest_line
9197 #define alpha_vms_find_line                _bfd_nosymbols_find_line
9198 #define alpha_vms_bfd_is_local_label_name  vms_bfd_is_local_label_name
9199
9200 /* Generic table.  */
9201 #define alpha_vms_close_and_cleanup        vms_close_and_cleanup
9202 #define alpha_vms_bfd_free_cached_info     vms_bfd_free_cached_info
9203 #define alpha_vms_new_section_hook         vms_new_section_hook
9204 #define alpha_vms_set_section_contents     _bfd_vms_set_section_contents
9205 #define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9206
9207 #define alpha_vms_bfd_get_relocated_section_contents \
9208   bfd_generic_get_relocated_section_contents
9209
9210 #define alpha_vms_bfd_relax_section bfd_generic_relax_section
9211 #define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9212 #define alpha_vms_bfd_lookup_section_flags bfd_generic_lookup_section_flags
9213 #define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9214 #define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9215 #define alpha_vms_bfd_discard_group bfd_generic_discard_group
9216 #define alpha_vms_section_already_linked \
9217   _bfd_generic_section_already_linked
9218
9219 #define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9220 #define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9221 #define alpha_vms_bfd_copy_link_hash_symbol_type \
9222   _bfd_generic_copy_link_hash_symbol_type
9223
9224 #define alpha_vms_bfd_link_split_section  _bfd_generic_link_split_section
9225
9226 #define alpha_vms_get_dynamic_symtab_upper_bound \
9227   _bfd_nodynamic_get_dynamic_symtab_upper_bound
9228 #define alpha_vms_canonicalize_dynamic_symtab \
9229   _bfd_nodynamic_canonicalize_dynamic_symtab
9230 #define alpha_vms_get_dynamic_reloc_upper_bound \
9231   _bfd_nodynamic_get_dynamic_reloc_upper_bound
9232 #define alpha_vms_canonicalize_dynamic_reloc \
9233   _bfd_nodynamic_canonicalize_dynamic_reloc
9234
9235 const bfd_target alpha_vms_vec =
9236 {
9237   "vms-alpha",                  /* Name.  */
9238   bfd_target_evax_flavour,
9239   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */
9240   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */
9241
9242   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9243    | WP_TEXT | D_PAGED),        /* Object flags.  */
9244   (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9245    | SEC_READONLY | SEC_CODE | SEC_DATA
9246    | SEC_HAS_CONTENTS | SEC_IN_MEMORY),         /* Sect flags.  */
9247   0,                            /* symbol_leading_char.  */
9248   ' ',                          /* ar_pad_char.  */
9249   15,                           /* ar_max_namelen.  */
9250   0,                            /* match priority.  */
9251   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9252   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9253   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9254   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9255   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9256   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9257
9258   {_bfd_dummy_target, alpha_vms_object_p,       /* bfd_check_format.  */
9259    _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9260   {bfd_false, alpha_vms_mkobject,               /* bfd_set_format.  */
9261    _bfd_vms_lib_alpha_mkarchive, bfd_false},
9262   {bfd_false, alpha_vms_write_object_contents,  /* bfd_write_contents.  */
9263    _bfd_vms_lib_write_archive_contents, bfd_false},
9264
9265   BFD_JUMP_TABLE_GENERIC (alpha_vms),
9266   BFD_JUMP_TABLE_COPY (vms),
9267   BFD_JUMP_TABLE_CORE (_bfd_nocore),
9268   BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9269   BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9270   BFD_JUMP_TABLE_RELOCS (alpha_vms),
9271   BFD_JUMP_TABLE_WRITE (alpha_vms),
9272   BFD_JUMP_TABLE_LINK (alpha_vms),
9273   BFD_JUMP_TABLE_DYNAMIC (alpha_vms),
9274
9275   NULL,
9276
9277   NULL
9278 };