bfd/vms-alpha.c

   1 /* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
   2    Copyright 1996-2013 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     {
2478       bfd_set_error (bfd_error_file_truncated);
2479       goto error_ret;
2480     }
2481
2482   /* Is it an image?  */
2483   if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
2484       && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
2485     {
2486       unsigned int to_read;
2487       unsigned int read_so_far;
2488       unsigned int remaining;
2489       unsigned int eisd_offset, eihs_offset;
2490
2491       /* Extract the header size.  */
2492       PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
2493
2494       /* The header size is 0 for DSF files.  */
2495       if (PRIV (recrd.rec_size) == 0)
2496         PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
2497
2498       if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
2499         {
2500           buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
2501
2502           if (buf == NULL)
2503             {
2504               PRIV (recrd.buf) = NULL;
2505               bfd_set_error (bfd_error_no_memory);
2506               goto error_ret;
2507             }
2508           PRIV (recrd.buf) = buf;
2509           PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
2510         }
2511
2512       /* Read the remaining record.  */
2513       remaining = PRIV (recrd.rec_size) - test_len;
2514       to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
2515       read_so_far = test_len;
2516
2517       while (remaining > 0)
2518         {
2519           if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
2520             {
2521               bfd_set_error (bfd_error_file_truncated);
2522               goto err_wrong_format;
2523             }
2524
2525           read_so_far += to_read;
2526           remaining -= to_read;
2527
2528           to_read = MIN (VMS_BLOCK_SIZE, remaining);
2529         }
2530
2531       /* Reset the record pointer.  */
2532       PRIV (recrd.rec) = buf;
2533
2534       vms_debug2 ((2, "file type is image\n"));
2535
2536       if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
2537         goto err_wrong_format;
2538
2539       if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
2540         goto err_wrong_format;
2541
2542       /* EIHS is optional.  */
2543       if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
2544         goto err_wrong_format;
2545     }
2546   else
2547     {
2548       int type;
2549
2550       /* Assume it's a module and adjust record pointer if necessary.  */
2551       maybe_adjust_record_pointer_for_object (abfd);
2552
2553       /* But is it really a module?  */
2554       if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
2555           && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
2556         {
2557           if (vms_get_remaining_object_record (abfd, test_len) <= 0)
2558             goto err_wrong_format;
2559
2560           vms_debug2 ((2, "file type is module\n"));
2561
2562           type = bfd_getl16 (PRIV (recrd.rec));
2563           if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
2564             goto err_wrong_format;
2565
2566           if (_bfd_vms_slurp_object_records (abfd) != TRUE)
2567             goto err_wrong_format;
2568         }
2569       else
2570         goto err_wrong_format;
2571     }
2572
2573   /* Set arch_info to alpha.   */
2574
2575   if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
2576     goto err_wrong_format;
2577
2578   return abfd->xvec;
2579
2580  err_wrong_format:
2581   bfd_set_error (bfd_error_wrong_format);
2582
2583  error_ret:
2584   if (PRIV (recrd.buf))
2585     free (PRIV (recrd.buf));
2586   if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
2587     bfd_release (abfd, abfd->tdata.any);
2588   abfd->tdata.any = tdata_save;
2589   return NULL;
2590 }
2591 \f
2592 /* Image write.  */
2593
2594 /* Write an EMH/MHD record.  */
2595
2596 static void
2597 _bfd_vms_write_emh (bfd *abfd)
2598 {
2599   struct vms_rec_wr *recwr = &PRIV (recwr);
2600
2601   _bfd_vms_output_alignment (recwr, 2);
2602
2603   /* EMH.  */
2604   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2605   _bfd_vms_output_short (recwr, EMH__C_MHD);
2606   _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
2607   _bfd_vms_output_long (recwr, 0);
2608   _bfd_vms_output_long (recwr, 0);
2609   _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
2610
2611   /* Create module name from filename.  */
2612   if (bfd_get_filename (abfd) != 0)
2613     {
2614       char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2615       _bfd_vms_output_counted (recwr, module);
2616       free (module);
2617     }
2618   else
2619     _bfd_vms_output_counted (recwr, "NONAME");
2620
2621   _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
2622   _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
2623   _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
2624   _bfd_vms_output_end (abfd, recwr);
2625 }
2626
2627 /* Write an EMH/LMN record.  */
2628
2629 static void
2630 _bfd_vms_write_lmn (bfd *abfd, const char *name)
2631 {
2632   char version [64];
2633   struct vms_rec_wr *recwr = &PRIV (recwr);
2634   unsigned int ver = BFD_VERSION / 10000;
2635
2636   /* LMN.  */
2637   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2638   _bfd_vms_output_short (recwr, EMH__C_LNM);
2639   snprintf (version, sizeof (version), "%s %d.%d.%d", name,
2640             ver / 10000, (ver / 100) % 100, ver % 100);
2641   _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
2642   _bfd_vms_output_end (abfd, recwr);
2643 }
2644
2645
2646 /* Write eom record for bfd abfd.  Return FALSE on error.  */
2647
2648 static bfd_boolean
2649 _bfd_vms_write_eeom (bfd *abfd)
2650 {
2651   struct vms_rec_wr *recwr = &PRIV (recwr);
2652
2653   vms_debug2 ((2, "vms_write_eeom\n"));
2654
2655   _bfd_vms_output_alignment (recwr, 2);
2656
2657   _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
2658   _bfd_vms_output_long (recwr, PRIV (vms_linkage_index + 1) >> 1);
2659   _bfd_vms_output_byte (recwr, 0);      /* Completion code.  */
2660   _bfd_vms_output_byte (recwr, 0);      /* Fill byte.  */
2661
2662   if ((abfd->flags & EXEC_P) == 0
2663       && bfd_get_start_address (abfd) != (bfd_vma)-1)
2664     {
2665       asection *section;
2666
2667       section = bfd_get_section_by_name (abfd, ".link");
2668       if (section == 0)
2669         {
2670           bfd_set_error (bfd_error_nonrepresentable_section);
2671           return FALSE;
2672         }
2673       _bfd_vms_output_short (recwr, 0);
2674       _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
2675       _bfd_vms_output_long (recwr,
2676                              (unsigned long) bfd_get_start_address (abfd));
2677       _bfd_vms_output_long (recwr, 0);
2678     }
2679
2680   _bfd_vms_output_end (abfd, recwr);
2681   return TRUE;
2682 }
2683
2684 static void
2685 vector_grow1 (struct vector_type *vec, size_t elsz)
2686 {
2687   if (vec->nbr_el + 1 < vec->max_el)
2688     return;
2689
2690   if (vec->max_el == 0)
2691     {
2692       vec->max_el = 16;
2693       vec->els = bfd_malloc2 (vec->max_el, elsz);
2694     }
2695   else
2696     {
2697       vec->max_el *= 2;
2698       vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
2699     }
2700 }
2701
2702 /* Bump ABFD file position to next block.  */
2703
2704 static void
2705 alpha_vms_file_position_block (bfd *abfd)
2706 {
2707   /* Next block.  */
2708   PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
2709   PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
2710 }
2711
2712 /* Convert from internal structure SRC to external structure DST.  */
2713
2714 static void
2715 alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
2716                          struct vms_eisd *dst)
2717 {
2718   bfd_putl32 (src->u.eisd.majorid, dst->majorid);
2719   bfd_putl32 (src->u.eisd.minorid, dst->minorid);
2720   bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
2721   if (src->u.eisd.eisdsize <= EISD__K_LENEND)
2722     return;
2723   bfd_putl32 (src->u.eisd.secsize, dst->secsize);
2724   bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
2725   bfd_putl32 (src->u.eisd.flags, dst->flags);
2726   bfd_putl32 (src->u.eisd.vbn, dst->vbn);
2727   dst->pfc = src->u.eisd.pfc;
2728   dst->matchctl = src->u.eisd.matchctl;
2729   dst->type = src->u.eisd.type;
2730   dst->fill_1 = 0;
2731   if (src->u.eisd.flags & EISD__M_GBL)
2732     {
2733       bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
2734       memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
2735               src->u.gbl_eisd.gblnam[0] + 1);
2736     }
2737 }
2738
2739 /* Append EISD to the list of extra eisd for ABFD.  */
2740
2741 static void
2742 alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
2743 {
2744   eisd->next = NULL;
2745   if (PRIV (gbl_eisd_head) == NULL)
2746     PRIV (gbl_eisd_head) = eisd;
2747   else
2748     PRIV (gbl_eisd_tail)->next = eisd;
2749   PRIV (gbl_eisd_tail) = eisd;
2750 }
2751
2752 /* Create an EISD for shared image SHRIMG.
2753    Return FALSE in case of error.  */
2754
2755 static bfd_boolean
2756 alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
2757 {
2758   struct vms_internal_eisd_map *eisd;
2759   int namlen;
2760
2761   namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
2762   if (namlen + 5 > EISD__K_GBLNAMLEN)
2763     {
2764       /* Won't fit.  */
2765       return FALSE;
2766     }
2767
2768   eisd = bfd_alloc (abfd, sizeof (*eisd));
2769   if (eisd == NULL)
2770     return FALSE;
2771
2772   /* Fill the fields.  */
2773   eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
2774   eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
2775   eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
2776   eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE;     /* Must not be 0.  */
2777   eisd->u.gbl_eisd.common.virt_addr = 0;
2778   eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
2779   eisd->u.gbl_eisd.common.vbn = 0;
2780   eisd->u.gbl_eisd.common.pfc = 0;
2781   eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
2782   eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
2783
2784   eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
2785   eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
2786   memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
2787           namlen);
2788   memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
2789
2790   /* Append it to the list.  */
2791   alpha_vms_append_extra_eisd (abfd, eisd);
2792
2793   return TRUE;
2794 }
2795
2796 /* Create an EISD for section SEC.
2797    Return FALSE in case of failure.  */
2798
2799 static bfd_boolean
2800 alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
2801 {
2802   struct vms_internal_eisd_map *eisd;
2803
2804   /* Only for allocating section.  */
2805   if (!(sec->flags & SEC_ALLOC))
2806     return TRUE;
2807
2808   BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
2809   eisd = bfd_alloc (abfd, sizeof (*eisd));
2810   if (eisd == NULL)
2811     return FALSE;
2812   vms_section_data (sec)->eisd = eisd;
2813
2814   /* Fill the fields.  */
2815   eisd->u.eisd.majorid = EISD__K_MAJORID;
2816   eisd->u.eisd.minorid = EISD__K_MINORID;
2817   eisd->u.eisd.eisdsize = EISD__K_LEN;
2818   eisd->u.eisd.secsize =
2819     (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
2820   eisd->u.eisd.virt_addr = sec->vma;
2821   eisd->u.eisd.flags = 0;
2822   eisd->u.eisd.vbn = 0; /* To be later defined.  */
2823   eisd->u.eisd.pfc = 0; /* Default.  */
2824   eisd->u.eisd.matchctl = EISD__K_MATALL;
2825   eisd->u.eisd.type = EISD__K_NORMAL;
2826
2827   if (sec->flags & SEC_CODE)
2828     eisd->u.eisd.flags |= EISD__M_EXE;
2829   if (!(sec->flags & SEC_READONLY))
2830     eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2831
2832   /* If relocations or fixup will be applied, make this isect writeable.  */
2833   if (sec->flags & SEC_RELOC)
2834     eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2835
2836   if (!(sec->flags & SEC_HAS_CONTENTS))
2837     {
2838       eisd->u.eisd.flags |= EISD__M_DZRO;
2839       eisd->u.eisd.flags &= ~EISD__M_CRF;
2840     }
2841   if (sec->flags & SEC_LINKER_CREATED)
2842     {
2843       if (strcmp (sec->name, "$FIXUP$") == 0)
2844         eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
2845     }
2846
2847   /* Append it to the list.  */
2848   eisd->next = NULL;
2849   if (PRIV (eisd_head) == NULL)
2850     PRIV (eisd_head) = eisd;
2851   else
2852     PRIV (eisd_tail)->next = eisd;
2853   PRIV (eisd_tail) = eisd;
2854
2855   return TRUE;
2856 }
2857
2858 /* Layout executable ABFD and write it to the disk.
2859    Return FALSE in case of failure.  */
2860
2861 static bfd_boolean
2862 alpha_vms_write_exec (bfd *abfd)
2863 {
2864   struct vms_eihd eihd;
2865   struct vms_eiha *eiha;
2866   struct vms_eihi *eihi;
2867   struct vms_eihs *eihs = NULL;
2868   asection *sec;
2869   struct vms_internal_eisd_map *first_eisd;
2870   struct vms_internal_eisd_map *eisd;
2871   asection *dst;
2872   asection *dmt;
2873   file_ptr gst_filepos = 0;
2874   unsigned int lnkflags = 0;
2875
2876   /* Build the EIHD.  */
2877   PRIV (file_pos) = EIHD__C_LENGTH;
2878
2879   memset (&eihd, 0, sizeof (eihd));
2880   memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
2881
2882   bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
2883   bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
2884
2885   bfd_putl32 (sizeof (eihd), eihd.size);
2886   bfd_putl32 (0, eihd.isdoff);
2887   bfd_putl32 (0, eihd.activoff);
2888   bfd_putl32 (0, eihd.symdbgoff);
2889   bfd_putl32 (0, eihd.imgidoff);
2890   bfd_putl32 (0, eihd.patchoff);
2891   bfd_putl64 (0, eihd.iafva);
2892   bfd_putl32 (0, eihd.version_array_off);
2893
2894   bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
2895   bfd_putl32 (0, eihd.subtype);
2896
2897   bfd_putl32 (0, eihd.imgiocnt);
2898   bfd_putl32 (-1, eihd.privreqs);
2899   bfd_putl32 (-1, eihd.privreqs + 4);
2900
2901   bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
2902               eihd.hdrblkcnt);
2903   bfd_putl32 (0, eihd.ident);
2904   bfd_putl32 (0, eihd.sysver);
2905
2906   eihd.matchctl = 0;
2907   bfd_putl32 (0, eihd.symvect_size);
2908   bfd_putl32 (16, eihd.virt_mem_block_size);
2909   bfd_putl32 (0, eihd.ext_fixup_off);
2910   bfd_putl32 (0, eihd.noopt_psect_off);
2911   bfd_putl32 (-1, eihd.alias);
2912
2913   /* Alloc EIHA.  */
2914   eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
2915   bfd_putl32 (PRIV (file_pos), eihd.activoff);
2916   PRIV (file_pos) += sizeof (struct vms_eiha);
2917
2918   bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
2919   bfd_putl32 (0, eiha->spare);
2920   bfd_putl64 (PRIV (transfer_address[0]), eiha->tfradr1);
2921   bfd_putl64 (PRIV (transfer_address[1]), eiha->tfradr2);
2922   bfd_putl64 (PRIV (transfer_address[2]), eiha->tfradr3);
2923   bfd_putl64 (PRIV (transfer_address[3]), eiha->tfradr4);
2924   bfd_putl64 (0, eiha->inishr);
2925
2926   /* Alloc EIHI.  */
2927   eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
2928   bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
2929   PRIV (file_pos) += sizeof (struct vms_eihi);
2930
2931   bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
2932   bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
2933   {
2934     char *module;
2935     unsigned int len;
2936
2937     /* Set module name.  */
2938     module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2939     len = strlen (module);
2940     if (len > sizeof (eihi->imgnam) - 1)
2941       len = sizeof (eihi->imgnam) - 1;
2942     eihi->imgnam[0] = len;
2943     memcpy (eihi->imgnam + 1, module, len);
2944     free (module);
2945   }
2946   {
2947     unsigned int lo;
2948     unsigned int hi;
2949
2950     /* Set time.  */
2951     vms_get_time (&hi, &lo);
2952     bfd_putl32 (lo, eihi->linktime + 0);
2953     bfd_putl32 (hi, eihi->linktime + 4);
2954   }
2955   eihi->imgid[0] = 0;
2956   eihi->linkid[0] = 0;
2957   eihi->imgbid[0] = 0;
2958
2959   /* Alloc EIHS.  */
2960   dst = PRIV (dst_section);
2961   dmt = bfd_get_section_by_name (abfd, "$DMT$");
2962   if (dst != NULL && dst->size != 0)
2963     {
2964       eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
2965       bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
2966       PRIV (file_pos) += sizeof (struct vms_eihs);
2967
2968       bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
2969       bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
2970       bfd_putl32 (0, eihs->dstvbn);
2971       bfd_putl32 (0, eihs->dstsize);
2972       bfd_putl32 (0, eihs->gstvbn);
2973       bfd_putl32 (0, eihs->gstsize);
2974       bfd_putl32 (0, eihs->dmtvbn);
2975       bfd_putl32 (0, eihs->dmtsize);
2976     }
2977
2978   /* One EISD per section.  */
2979   for (sec = abfd->sections; sec; sec = sec->next)
2980     {
2981       if (!alpha_vms_create_eisd_for_section (abfd, sec))
2982         return FALSE;
2983     }
2984
2985   /* Merge section EIDS which extra ones.  */
2986   if (PRIV (eisd_tail))
2987     PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
2988   else
2989     PRIV (eisd_head) = PRIV (gbl_eisd_head);
2990   if (PRIV (gbl_eisd_tail))
2991     PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
2992
2993   first_eisd = PRIV (eisd_head);
2994
2995   /* Add end of eisd.  */
2996   if (first_eisd)
2997     {
2998       eisd = bfd_zalloc (abfd, sizeof (*eisd));
2999       if (eisd == NULL)
3000         return FALSE;
3001       eisd->u.eisd.majorid = 0;
3002       eisd->u.eisd.minorid = 0;
3003       eisd->u.eisd.eisdsize = 0;
3004       alpha_vms_append_extra_eisd (abfd, eisd);
3005     }
3006
3007   /* Place EISD in the file.  */
3008   for (eisd = first_eisd; eisd; eisd = eisd->next)
3009     {
3010       file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
3011
3012       /* First block is a little bit special: there is a word at the end.  */
3013       if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
3014         room -= 2;
3015       if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
3016         alpha_vms_file_position_block (abfd);
3017
3018       eisd->file_pos = PRIV (file_pos);
3019       PRIV (file_pos) += eisd->u.eisd.eisdsize;
3020
3021       if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
3022         bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
3023     }
3024
3025   if (first_eisd != NULL)
3026     {
3027       bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
3028       /* Real size of end of eisd marker.  */
3029       PRIV (file_pos) += EISD__K_LENEND;
3030     }
3031
3032   bfd_putl32 (PRIV (file_pos), eihd.size);
3033   bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
3034               eihd.hdrblkcnt);
3035
3036   /* Place sections.  */
3037   for (sec = abfd->sections; sec; sec = sec->next)
3038     {
3039       if (!(sec->flags & SEC_HAS_CONTENTS))
3040         continue;
3041
3042       eisd = vms_section_data (sec)->eisd;
3043
3044       /* Align on a block.  */
3045       alpha_vms_file_position_block (abfd);
3046       sec->filepos = PRIV (file_pos);
3047
3048       if (eisd != NULL)
3049         eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
3050
3051       PRIV (file_pos) += sec->size;
3052     }
3053
3054   /* Update EIHS.  */
3055   if (eihs != NULL && dst != NULL)
3056     {
3057       bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
3058       bfd_putl32 (dst->size, eihs->dstsize);
3059
3060       if (dmt != NULL)
3061         {
3062           lnkflags |= EIHD__M_DBGDMT;
3063           bfd_putl32 ((dmt->filepos / VMS_BLOCK_SIZE) + 1, eihs->dmtvbn);
3064           bfd_putl32 (dmt->size, eihs->dmtsize);
3065         }
3066       if (PRIV (gsd_sym_count) != 0)
3067         {
3068           alpha_vms_file_position_block (abfd);
3069           gst_filepos = PRIV (file_pos);
3070           bfd_putl32 ((gst_filepos / VMS_BLOCK_SIZE) + 1, eihs->gstvbn);
3071           bfd_putl32 ((PRIV (gsd_sym_count) + 4) / 5 + 4, eihs->gstsize);
3072         }
3073     }
3074
3075   /* Write EISD in hdr.  */
3076   for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
3077        eisd = eisd->next)
3078     alpha_vms_swap_eisd_out
3079       (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
3080
3081   /* Write first block.  */
3082   bfd_putl32 (lnkflags, eihd.lnkflags);
3083   if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
3084     return FALSE;
3085
3086   /* Write remaining eisd.  */
3087   if (eisd != NULL)
3088     {
3089       unsigned char blk[VMS_BLOCK_SIZE];
3090       struct vms_internal_eisd_map *next_eisd;
3091
3092       memset (blk, 0xff, sizeof (blk));
3093       while (eisd != NULL)
3094         {
3095           alpha_vms_swap_eisd_out
3096             (eisd,
3097              (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
3098
3099           next_eisd = eisd->next;
3100           if (next_eisd == NULL
3101               || (next_eisd->file_pos / VMS_BLOCK_SIZE
3102                   != eisd->file_pos / VMS_BLOCK_SIZE))
3103             {
3104               if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
3105                 return FALSE;
3106
3107               memset (blk, 0xff, sizeof (blk));
3108             }
3109           eisd = next_eisd;
3110         }
3111     }
3112
3113   /* Write sections.  */
3114   for (sec = abfd->sections; sec; sec = sec->next)
3115     {
3116       unsigned char blk[VMS_BLOCK_SIZE];
3117       bfd_size_type len;
3118
3119       if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
3120         continue;
3121       if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
3122         return FALSE;
3123
3124       /* Pad.  */
3125       len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
3126       if (len != VMS_BLOCK_SIZE)
3127         {
3128           memset (blk, 0, len);
3129           if (bfd_bwrite (blk, len, abfd) != len)
3130             return FALSE;
3131         }
3132     }
3133
3134   /* Write GST.  */
3135   if (gst_filepos != 0)
3136     {
3137       struct vms_rec_wr *recwr = &PRIV (recwr);
3138       unsigned int i;
3139
3140       _bfd_vms_write_emh (abfd);
3141       _bfd_vms_write_lmn (abfd, "GNU LD");
3142
3143       /* PSC for the absolute section.  */
3144       _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3145       _bfd_vms_output_long (recwr, 0);
3146       _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3147       _bfd_vms_output_short (recwr, 0);
3148       _bfd_vms_output_short (recwr, EGPS__V_PIC | EGPS__V_LIB | EGPS__V_RD);
3149       _bfd_vms_output_long (recwr, 0);
3150       _bfd_vms_output_counted (recwr, ".$$ABS$$.");
3151       _bfd_vms_output_end_subrec (recwr);
3152       _bfd_vms_output_end (abfd, recwr);
3153
3154       for (i = 0; i < PRIV (gsd_sym_count); i++)
3155         {
3156           struct vms_symbol_entry *sym = PRIV (syms)[i];
3157           bfd_vma val;
3158           bfd_vma ep;
3159
3160           if ((i % 5) == 0)
3161             {
3162               _bfd_vms_output_alignment (recwr, 8);
3163               _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3164               _bfd_vms_output_long (recwr, 0);
3165             }
3166           _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYMG);
3167           _bfd_vms_output_short (recwr, 0); /* Data type, alignment.  */
3168           _bfd_vms_output_short (recwr, sym->flags);
3169
3170           if (sym->code_section)
3171             ep = alpha_vms_get_sym_value (sym->code_section, sym->code_value);
3172           else
3173             {
3174               BFD_ASSERT (sym->code_value == 0);
3175               ep = 0;
3176             }
3177           val = alpha_vms_get_sym_value (sym->section, sym->value);
3178           _bfd_vms_output_quad
3179             (recwr, sym->typ == EGSD__C_SYMG ? sym->symbol_vector : val);
3180           _bfd_vms_output_quad (recwr, ep);
3181           _bfd_vms_output_quad (recwr, val);
3182           _bfd_vms_output_long (recwr, 0);
3183           _bfd_vms_output_counted (recwr, sym->name);
3184           _bfd_vms_output_end_subrec (recwr);
3185           if ((i % 5) == 4)
3186             _bfd_vms_output_end (abfd, recwr);
3187         }
3188       if ((i % 5) != 0)
3189         _bfd_vms_output_end (abfd, recwr);
3190
3191       if (!_bfd_vms_write_eeom (abfd))
3192         return FALSE;
3193     }
3194   return TRUE;
3195 }
3196 \f
3197 /* Object write.  */
3198
3199 /* Write section and symbol directory of bfd abfd.  Return FALSE on error.  */
3200
3201 static bfd_boolean
3202 _bfd_vms_write_egsd (bfd *abfd)
3203 {
3204   asection *section;
3205   asymbol *symbol;
3206   unsigned int symnum;
3207   const char *sname;
3208   flagword new_flags, old_flags;
3209   int abs_section_index = -1;
3210   unsigned int target_index = 0;
3211   struct vms_rec_wr *recwr = &PRIV (recwr);
3212
3213   vms_debug2 ((2, "vms_write_egsd\n"));
3214
3215   /* Egsd is quadword aligned.  */
3216   _bfd_vms_output_alignment (recwr, 8);
3217
3218   _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3219   _bfd_vms_output_long (recwr, 0);
3220
3221   /* Number sections.  */
3222   for (section = abfd->sections; section != NULL; section = section->next)
3223     {
3224       if (section->flags & SEC_DEBUGGING)
3225         continue;
3226       if (!strcmp (section->name, ".vmsdebug"))
3227         {
3228           section->flags |= SEC_DEBUGGING;
3229           continue;
3230         }
3231       section->target_index = target_index++;
3232     }
3233
3234   for (section = abfd->sections; section != NULL; section = section->next)
3235     {
3236       vms_debug2 ((3, "Section #%d %s, %d bytes\n",
3237                    section->target_index, section->name, (int)section->size));
3238
3239       /* Don't write out the VMS debug info section since it is in the
3240          ETBT and EDBG sections in etir. */
3241       if (section->flags & SEC_DEBUGGING)
3242         continue;
3243
3244       /* 13 bytes egsd, max 31 chars name -> should be 44 bytes.  */
3245       if (_bfd_vms_output_check (recwr, 64) < 0)
3246         {
3247           _bfd_vms_output_end (abfd, recwr);
3248           _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3249           _bfd_vms_output_long (recwr, 0);
3250         }
3251
3252       /* Don't know if this is necessary for the linker but for now it keeps
3253          vms_slurp_gsd happy.  */
3254       sname = section->name;
3255       if (*sname == '.')
3256         {
3257           /* Remove leading dot.  */
3258           sname++;
3259           if ((*sname == 't') && (strcmp (sname, "text") == 0))
3260             sname = EVAX_CODE_NAME;
3261           else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
3262             sname = EVAX_DATA_NAME;
3263           else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
3264             sname = EVAX_BSS_NAME;
3265           else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
3266             sname = EVAX_LINK_NAME;
3267           else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
3268             sname = EVAX_READONLY_NAME;
3269           else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
3270             sname = EVAX_LITERAL_NAME;
3271           else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
3272             sname = EVAX_LITERALS_NAME;
3273           else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
3274             sname = EVAX_COMMON_NAME;
3275           else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
3276             sname = EVAX_LOCAL_NAME;
3277         }
3278
3279       if (bfd_is_com_section (section))
3280         new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
3281                      | EGPS__V_WRT | EGPS__V_NOMOD | EGPS__V_COM);
3282       else
3283         new_flags = vms_esecflag_by_name (evax_section_flags, sname,
3284                                           section->size > 0);
3285
3286       /* Modify them as directed.  */
3287       if (section->flags & SEC_READONLY)
3288         new_flags &= ~EGPS__V_WRT;
3289
3290       new_flags &= ~vms_section_data (section)->no_flags;
3291       new_flags |= vms_section_data (section)->flags;
3292
3293       vms_debug2 ((3, "sec flags %x\n", section->flags));
3294       vms_debug2 ((3, "new_flags %x, _raw_size %lu\n",
3295                    new_flags, (unsigned long)section->size));
3296
3297       _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3298       _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
3299       _bfd_vms_output_short (recwr, new_flags);
3300       _bfd_vms_output_long (recwr, (unsigned long) section->size);
3301       _bfd_vms_output_counted (recwr, sname);
3302       _bfd_vms_output_end_subrec (recwr);
3303
3304       /* If the section is an obsolute one, remind its index as it will be
3305          used later for absolute symbols.  */
3306       if ((new_flags & EGPS__V_REL) == 0 && abs_section_index < 0)
3307         abs_section_index = section->target_index;
3308     }
3309
3310   /* Output symbols.  */
3311   vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
3312
3313   bfd_set_start_address (abfd, (bfd_vma) -1);
3314
3315   for (symnum = 0; symnum < abfd->symcount; symnum++)
3316     {
3317       symbol = abfd->outsymbols[symnum];
3318       old_flags = symbol->flags;
3319
3320       /* Work-around a missing feature:  consider __main as the main entry
3321          point.  */
3322       if (symbol->name[0] == '_' && strcmp (symbol->name, "__main") == 0)
3323         bfd_set_start_address (abfd, (bfd_vma)symbol->value);
3324
3325       /* Only put in the GSD the global and the undefined symbols.  */
3326       if (old_flags & BSF_FILE)
3327         continue;
3328
3329       if ((old_flags & BSF_GLOBAL) == 0 && !bfd_is_und_section (symbol->section))
3330         {
3331           /* If the LIB$INITIIALIZE section is present, add a reference to
3332              LIB$INITIALIZE symbol.  FIXME: this should be done explicitely
3333              in the assembly file.  */
3334           if (!((old_flags & BSF_SECTION_SYM) != 0
3335                 && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
3336             continue;
3337         }
3338
3339       /* 13 bytes egsd, max 64 chars name -> should be 77 bytes.  Add 16 more
3340          bytes for a possible ABS section.  */
3341       if (_bfd_vms_output_check (recwr, 80 + 16) < 0)
3342         {
3343           _bfd_vms_output_end (abfd, recwr);
3344           _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3345           _bfd_vms_output_long (recwr, 0);
3346         }
3347
3348       if ((old_flags & BSF_GLOBAL) != 0
3349           && bfd_is_abs_section (symbol->section)
3350           && abs_section_index <= 0)
3351         {
3352           /* Create an absolute section if none was defined.  It is highly
3353              unlikely that the name $ABS$ clashes with a user defined
3354              non-absolute section name.  */
3355           _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3356           _bfd_vms_output_short (recwr, 4);
3357           _bfd_vms_output_short (recwr, EGPS__V_SHR);
3358           _bfd_vms_output_long (recwr, 0);
3359           _bfd_vms_output_counted (recwr, "$ABS$");
3360           _bfd_vms_output_end_subrec (recwr);
3361
3362           abs_section_index = target_index++;
3363         }
3364
3365       _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
3366
3367       /* Data type, alignment.  */
3368       _bfd_vms_output_short (recwr, 0);
3369
3370       new_flags = 0;
3371
3372       if (old_flags & BSF_WEAK)
3373         new_flags |= EGSY__V_WEAK;
3374       if (bfd_is_com_section (symbol->section))         /* .comm  */
3375         new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
3376
3377       if (old_flags & BSF_FUNCTION)
3378         {
3379           new_flags |= EGSY__V_NORM;
3380           new_flags |= EGSY__V_REL;
3381         }
3382       if (old_flags & BSF_GLOBAL)
3383         {
3384           new_flags |= EGSY__V_DEF;
3385           if (!bfd_is_abs_section (symbol->section))
3386             new_flags |= EGSY__V_REL;
3387         }
3388       _bfd_vms_output_short (recwr, new_flags);
3389
3390       if (old_flags & BSF_GLOBAL)
3391         {
3392           /* Symbol definition.  */
3393           bfd_vma code_address = 0;
3394           unsigned long ca_psindx = 0;
3395           unsigned long psindx;
3396
3397           if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
3398             {
3399               asymbol *sym;
3400
3401               sym =
3402                 ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
3403               code_address = sym->value;
3404               ca_psindx = sym->section->target_index;
3405             }
3406           if (bfd_is_abs_section (symbol->section))
3407             psindx = abs_section_index;
3408           else
3409             psindx = symbol->section->target_index;
3410
3411           _bfd_vms_output_quad (recwr, symbol->value);
3412           _bfd_vms_output_quad (recwr, code_address);
3413           _bfd_vms_output_long (recwr, ca_psindx);
3414           _bfd_vms_output_long (recwr, psindx);
3415         }
3416       _bfd_vms_output_counted (recwr, symbol->name);
3417
3418       _bfd_vms_output_end_subrec (recwr);
3419     }
3420
3421   _bfd_vms_output_alignment (recwr, 8);
3422   _bfd_vms_output_end (abfd, recwr);
3423
3424   return TRUE;
3425 }
3426
3427 /* Write object header for bfd abfd.  Return FALSE on error.  */
3428
3429 static bfd_boolean
3430 _bfd_vms_write_ehdr (bfd *abfd)
3431 {
3432   asymbol *symbol;
3433   unsigned int symnum;
3434   struct vms_rec_wr *recwr = &PRIV (recwr);
3435
3436   vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
3437
3438   _bfd_vms_output_alignment (recwr, 2);
3439
3440   _bfd_vms_write_emh (abfd);
3441   _bfd_vms_write_lmn (abfd, "GNU AS");
3442
3443   /* SRC.  */
3444   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3445   _bfd_vms_output_short (recwr, EMH__C_SRC);
3446
3447   for (symnum = 0; symnum < abfd->symcount; symnum++)
3448     {
3449       symbol = abfd->outsymbols[symnum];
3450
3451       if (symbol->flags & BSF_FILE)
3452         {
3453           _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
3454                                 (int) strlen (symbol->name));
3455           break;
3456         }
3457     }
3458
3459   if (symnum == abfd->symcount)
3460     _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
3461
3462   _bfd_vms_output_end (abfd, recwr);
3463
3464   /* TTL.  */
3465   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3466   _bfd_vms_output_short (recwr, EMH__C_TTL);
3467   _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
3468   _bfd_vms_output_end (abfd, recwr);
3469
3470   /* CPR.  */
3471   _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3472   _bfd_vms_output_short (recwr, EMH__C_CPR);
3473   _bfd_vms_output_dump (recwr,
3474                         (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
3475                          39);
3476   _bfd_vms_output_end (abfd, recwr);
3477
3478   return TRUE;
3479 }
3480
3481 /* Part 4.6, relocations.  */
3482
3483 \f
3484 /* WRITE ETIR SECTION
3485
3486    This is still under construction and therefore not documented.  */
3487
3488 /* Close the etir/etbt record.  */
3489
3490 static void
3491 end_etir_record (bfd * abfd)
3492 {
3493   struct vms_rec_wr *recwr = &PRIV (recwr);
3494
3495   _bfd_vms_output_end (abfd, recwr);
3496 }
3497
3498 static void
3499 start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
3500 {
3501   struct vms_rec_wr *recwr = &PRIV (recwr);
3502
3503   if (section->flags & SEC_DEBUGGING)
3504     {
3505       _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
3506
3507       if (offset == 0)
3508         {
3509           /* Push start offset.  */
3510           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3511           _bfd_vms_output_long (recwr, (unsigned long) 0);
3512           _bfd_vms_output_end_subrec (recwr);
3513
3514           /* Set location.  */
3515           _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
3516           _bfd_vms_output_end_subrec (recwr);
3517         }
3518     }
3519   else
3520     {
3521       _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
3522
3523       if (offset == 0)
3524         {
3525           /* Push start offset.  */
3526           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3527           _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
3528           _bfd_vms_output_quad (recwr, offset);
3529           _bfd_vms_output_end_subrec (recwr);
3530
3531           /* Start = pop ().  */
3532           _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
3533           _bfd_vms_output_end_subrec (recwr);
3534         }
3535     }
3536 }
3537
3538 /* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
3539    address VADDR in section specified by SEC_INDEX and NAME.  */
3540
3541 static void
3542 sto_imm (bfd *abfd, asection *section,
3543          bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
3544 {
3545   bfd_size_type size;
3546   struct vms_rec_wr *recwr = &PRIV (recwr);
3547
3548 #if VMS_DEBUG
3549   _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
3550   _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
3551 #endif
3552
3553   while (ssize > 0)
3554     {
3555       /* Try all the rest.  */
3556       size = ssize;
3557
3558       if (_bfd_vms_output_check (recwr, size) < 0)
3559         {
3560           /* Doesn't fit, split !  */
3561           end_etir_record (abfd);
3562
3563           start_etir_or_etbt_record (abfd, section, vaddr);
3564
3565           size = _bfd_vms_output_check (recwr, 0);      /* get max size */
3566           if (size > ssize)                     /* more than what's left ? */
3567             size = ssize;
3568         }
3569
3570       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
3571       _bfd_vms_output_long (recwr, (unsigned long) (size));
3572       _bfd_vms_output_dump (recwr, cptr, size);
3573       _bfd_vms_output_end_subrec (recwr);
3574
3575 #if VMS_DEBUG
3576       _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
3577       _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
3578 #endif
3579
3580       vaddr += size;
3581       cptr += size;
3582       ssize -= size;
3583     }
3584 }
3585
3586 static void
3587 etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
3588 {
3589   if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
3590     {
3591       /* Not enough room in this record.  Close it and open a new one.  */
3592       end_etir_record (abfd);
3593       start_etir_or_etbt_record (abfd, section, vaddr);
3594     }
3595 }
3596
3597 /* Return whether RELOC must be deferred till the end.  */
3598
3599 static bfd_boolean
3600 defer_reloc_p (arelent *reloc)
3601 {
3602   switch (reloc->howto->type)
3603     {
3604     case ALPHA_R_NOP:
3605     case ALPHA_R_LDA:
3606     case ALPHA_R_BSR:
3607     case ALPHA_R_BOH:
3608       return TRUE;
3609
3610     default:
3611       return FALSE;
3612     }
3613 }
3614
3615 /* Write section contents for bfd abfd.  Return FALSE on error.  */
3616
3617 static bfd_boolean
3618 _bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
3619 {
3620   asection *section;
3621   struct vms_rec_wr *recwr = &PRIV (recwr);
3622
3623   vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
3624
3625   _bfd_vms_output_alignment (recwr, 4);
3626
3627   PRIV (vms_linkage_index) = 0;
3628
3629   for (section = abfd->sections; section; section = section->next)
3630     {
3631       vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
3632                    section->target_index, section->name, (int) (section->size)));
3633
3634       if (!(section->flags & SEC_HAS_CONTENTS)
3635           || bfd_is_com_section (section))
3636         continue;
3637
3638       if (!section->contents)
3639         {
3640           bfd_set_error (bfd_error_no_contents);
3641           return FALSE;
3642         }
3643
3644       start_etir_or_etbt_record (abfd, section, 0);
3645
3646       if (section->flags & SEC_RELOC)
3647         {
3648           bfd_vma curr_addr = 0;
3649           unsigned char *curr_data = section->contents;
3650           bfd_size_type size;
3651           int pass2_needed = 0;
3652           int pass2_in_progress = 0;
3653           unsigned int irel;
3654
3655           if (section->reloc_count == 0)
3656             (*_bfd_error_handler)
3657               (_("SEC_RELOC with no relocs in section %s"), section->name);
3658
3659 #if VMS_DEBUG
3660           else
3661             {
3662               int i = section->reloc_count;
3663               arelent **rptr = section->orelocation;
3664               _bfd_vms_debug (4, "%d relocations:\n", i);
3665               while (i-- > 0)
3666                 {
3667                   _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
3668                                      "addr %08lx, off %08lx, len %d: %s\n",
3669                                   (*(*rptr)->sym_ptr_ptr)->name,
3670                                   (*(*rptr)->sym_ptr_ptr)->section->name,
3671                                   (long) (*(*rptr)->sym_ptr_ptr)->value,
3672                                   (unsigned long)(*rptr)->address,
3673                                   (unsigned long)(*rptr)->addend,
3674                                   bfd_get_reloc_size ((*rptr)->howto),
3675                                   ( *rptr)->howto->name);
3676                   rptr++;
3677                 }
3678             }
3679 #endif
3680
3681         new_pass:
3682           for (irel = 0; irel < section->reloc_count; irel++)
3683             {
3684               struct evax_private_udata_struct *udata;
3685               arelent *rptr = section->orelocation [irel];
3686               bfd_vma addr = rptr->address;
3687               asymbol *sym = *rptr->sym_ptr_ptr;
3688               asection *sec = sym->section;
3689               bfd_boolean defer = defer_reloc_p (rptr);
3690               unsigned int slen;
3691
3692               if (pass2_in_progress)
3693                 {
3694                   /* Non-deferred relocs have already been output.  */
3695                   if (!defer)
3696                     continue;
3697                 }
3698               else
3699                 {
3700                   /* Deferred relocs must be output at the very end.  */
3701                   if (defer)
3702                     {
3703                       pass2_needed = 1;
3704                       continue;
3705                     }
3706
3707                   /* Regular relocs are intertwined with binary data.  */
3708                   if (curr_addr > addr)
3709                     (*_bfd_error_handler) (_("Size error in section %s"),
3710                                            section->name);
3711                   size = addr - curr_addr;
3712                   sto_imm (abfd, section, size, curr_data, curr_addr);
3713                   curr_data += size;
3714                   curr_addr += size;
3715                 }
3716
3717               size = bfd_get_reloc_size (rptr->howto);
3718
3719               switch (rptr->howto->type)
3720                 {
3721                 case ALPHA_R_IGNORE:
3722                   break;
3723
3724                 case ALPHA_R_REFLONG:
3725                   if (bfd_is_und_section (sym->section))
3726                     {
3727                       bfd_vma addend = rptr->addend;
3728                       slen = strlen ((char *) sym->name);
3729                       etir_output_check (abfd, section, curr_addr, slen);
3730                       if (addend)
3731                         {
3732                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3733                           _bfd_vms_output_counted (recwr, sym->name);
3734                           _bfd_vms_output_end_subrec (recwr);
3735                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3736                           _bfd_vms_output_long (recwr, (unsigned long) addend);
3737                           _bfd_vms_output_end_subrec (recwr);
3738                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3739                           _bfd_vms_output_end_subrec (recwr);
3740                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3741                           _bfd_vms_output_end_subrec (recwr);
3742                         }
3743                       else
3744                         {
3745                           _bfd_vms_output_begin_subrec
3746                             (recwr, ETIR__C_STO_GBL_LW);
3747                           _bfd_vms_output_counted (recwr, sym->name);
3748                           _bfd_vms_output_end_subrec (recwr);
3749                         }
3750                     }
3751                   else if (bfd_is_abs_section (sym->section))
3752                     {
3753                       etir_output_check (abfd, section, curr_addr, 16);
3754                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3755                       _bfd_vms_output_long (recwr, (unsigned long) sym->value);
3756                       _bfd_vms_output_end_subrec (recwr);
3757                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3758                       _bfd_vms_output_end_subrec (recwr);
3759                     }
3760                   else
3761                     {
3762                       etir_output_check (abfd, section, curr_addr, 32);
3763                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3764                       _bfd_vms_output_long (recwr,
3765                                             (unsigned long) sec->target_index);
3766                       _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3767                       _bfd_vms_output_end_subrec (recwr);
3768                       /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
3769                          says that we should have a ETIR__C_STO_OFF here.
3770                          But the relocation would not be BFD_RELOC_32 then.
3771                          This case is very likely unreachable.  */
3772                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3773                       _bfd_vms_output_end_subrec (recwr);
3774                     }
3775                   break;
3776
3777                 case ALPHA_R_REFQUAD:
3778                   if (bfd_is_und_section (sym->section))
3779                     {
3780                       bfd_vma addend = rptr->addend;
3781                       slen = strlen ((char *) sym->name);
3782                       etir_output_check (abfd, section, curr_addr, slen);
3783                       if (addend)
3784                         {
3785                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3786                           _bfd_vms_output_counted (recwr, sym->name);
3787                           _bfd_vms_output_end_subrec (recwr);
3788                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3789                           _bfd_vms_output_quad (recwr, addend);
3790                           _bfd_vms_output_end_subrec (recwr);
3791                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3792                           _bfd_vms_output_end_subrec (recwr);
3793                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3794                           _bfd_vms_output_end_subrec (recwr);
3795                         }
3796                       else
3797                         {
3798                           _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
3799                           _bfd_vms_output_counted (recwr, sym->name);
3800                           _bfd_vms_output_end_subrec (recwr);
3801                         }
3802                     }
3803                   else if (bfd_is_abs_section (sym->section))
3804                     {
3805                       etir_output_check (abfd, section, curr_addr, 16);
3806                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3807                       _bfd_vms_output_quad (recwr, sym->value);
3808                       _bfd_vms_output_end_subrec (recwr);
3809                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3810                       _bfd_vms_output_end_subrec (recwr);
3811                     }
3812                   else
3813                     {
3814                       etir_output_check (abfd, section, curr_addr, 32);
3815                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3816                       _bfd_vms_output_long (recwr,
3817                                             (unsigned long) sec->target_index);
3818                       _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3819                       _bfd_vms_output_end_subrec (recwr);
3820                       _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
3821                       _bfd_vms_output_end_subrec (recwr);
3822                     }
3823                   break;
3824
3825                 case ALPHA_R_HINT:
3826                   sto_imm (abfd, section, size, curr_data, curr_addr);
3827                   break;
3828
3829                 case ALPHA_R_LINKAGE:
3830                   etir_output_check (abfd, section, curr_addr, 64);
3831                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
3832                   _bfd_vms_output_long
3833                     (recwr, (unsigned long) rptr->addend);
3834                   if (rptr->addend > PRIV (vms_linkage_index))
3835                     PRIV (vms_linkage_index) = rptr->addend;
3836                   _bfd_vms_output_counted (recwr, sym->name);
3837                   _bfd_vms_output_byte (recwr, 0);
3838                   _bfd_vms_output_end_subrec (recwr);
3839                   break;
3840
3841                 case ALPHA_R_CODEADDR:
3842                   slen = strlen ((char *) sym->name);
3843                   etir_output_check (abfd, section, curr_addr, slen);
3844                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
3845                   _bfd_vms_output_counted (recwr, sym->name);
3846                   _bfd_vms_output_end_subrec (recwr);
3847                   break;
3848
3849                 case ALPHA_R_NOP:
3850                   udata
3851                     = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3852                   etir_output_check (abfd, section, curr_addr,
3853                                      32 + 1 + strlen (udata->origname));
3854                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
3855                   _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3856                   _bfd_vms_output_long
3857                     (recwr, (unsigned long) section->target_index);
3858                   _bfd_vms_output_quad (recwr, rptr->address);
3859                   _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3860                   _bfd_vms_output_long
3861                     (recwr, (unsigned long) section->target_index);
3862                   _bfd_vms_output_quad (recwr, rptr->addend);
3863                   _bfd_vms_output_counted (recwr, udata->origname);
3864                   _bfd_vms_output_end_subrec (recwr);
3865                   break;
3866
3867                 case ALPHA_R_BSR:
3868                   (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3869                   break;
3870
3871                 case ALPHA_R_LDA:
3872                   udata
3873                     = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3874                   etir_output_check (abfd, section, curr_addr,
3875                                      32 + 1 + strlen (udata->origname));
3876                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
3877                   _bfd_vms_output_long
3878                     (recwr, (unsigned long) udata->lkindex + 1);
3879                   _bfd_vms_output_long
3880                     (recwr, (unsigned long) section->target_index);
3881                   _bfd_vms_output_quad (recwr, rptr->address);
3882                   _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
3883                   _bfd_vms_output_long
3884                     (recwr, (unsigned long) udata->bsym->section->target_index);
3885                   _bfd_vms_output_quad (recwr, rptr->addend);
3886                   _bfd_vms_output_counted (recwr, udata->origname);
3887                   _bfd_vms_output_end_subrec (recwr);
3888                   break;
3889
3890                 case ALPHA_R_BOH:
3891                   udata
3892                     = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3893                   etir_output_check (abfd, section, curr_addr,
3894                                        32 + 1 + strlen (udata->origname));
3895                   _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
3896                   _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3897                   _bfd_vms_output_long
3898                     (recwr, (unsigned long) section->target_index);
3899                   _bfd_vms_output_quad (recwr, rptr->address);
3900                   _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
3901                   _bfd_vms_output_long
3902                     (recwr, (unsigned long) section->target_index);
3903                   _bfd_vms_output_quad (recwr, rptr->addend);
3904                   _bfd_vms_output_counted (recwr, udata->origname);
3905                   _bfd_vms_output_end_subrec (recwr);
3906                   break;
3907
3908                 default:
3909                   (*_bfd_error_handler) (_("Unhandled relocation %s"),
3910                                          rptr->howto->name);
3911                   break;
3912                 }
3913
3914               curr_data += size;
3915               curr_addr += size;
3916             } /* End of relocs loop.  */
3917
3918           if (!pass2_in_progress)
3919             {
3920               /* Output rest of section.  */
3921               if (curr_addr > section->size)
3922                 (*_bfd_error_handler) (_("Size error in section %s"),
3923                                        section->name);
3924               size = section->size - curr_addr;
3925               sto_imm (abfd, section, size, curr_data, curr_addr);
3926               curr_data += size;
3927               curr_addr += size;
3928
3929               if (pass2_needed)
3930                 {
3931                   pass2_in_progress = 1;
3932                   goto new_pass;
3933                 }
3934             }
3935         }
3936
3937       else /* (section->flags & SEC_RELOC) */
3938         sto_imm (abfd, section, section->size, section->contents, 0);
3939
3940       end_etir_record (abfd);
3941     }
3942
3943   _bfd_vms_output_alignment (recwr, 2);
3944   return TRUE;
3945 }
3946
3947 /* Write cached information into a file being written, at bfd_close.  */
3948
3949 static bfd_boolean
3950 alpha_vms_write_object_contents (bfd *abfd)
3951 {
3952   vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
3953
3954   if (abfd->flags & (EXEC_P | DYNAMIC))
3955     {
3956       return alpha_vms_write_exec (abfd);
3957     }
3958   else
3959     {
3960       if (abfd->section_count > 0)                      /* we have sections */
3961         {
3962           if (_bfd_vms_write_ehdr (abfd) != TRUE)
3963             return FALSE;
3964           if (_bfd_vms_write_egsd (abfd) != TRUE)
3965             return FALSE;
3966           if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
3967             return FALSE;
3968           if (_bfd_vms_write_eeom (abfd) != TRUE)
3969             return FALSE;
3970         }
3971     }
3972   return TRUE;
3973 }
3974 \f
3975 /* Debug stuff: nearest line.  */
3976
3977 #define SET_MODULE_PARSED(m) \
3978   do { if ((m)->name == NULL) (m)->name = ""; } while (0)
3979 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
3980
3981 /* Build a new module for the specified BFD.  */
3982
3983 static struct module *
3984 new_module (bfd *abfd)
3985 {
3986   struct module *module
3987     = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
3988   module->file_table_count = 16; /* Arbitrary.  */
3989   module->file_table
3990     = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
3991   return module;
3992 }
3993
3994 /* Parse debug info for a module and internalize it.  */
3995
3996 static void
3997 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
3998               int length)
3999 {
4000   unsigned char *maxptr = ptr + length;
4001   unsigned char *src_ptr, *pcl_ptr;
4002   unsigned int prev_linum = 0, curr_linenum = 0;
4003   bfd_vma prev_pc = 0, curr_pc = 0;
4004   struct srecinfo *curr_srec, *srec;
4005   struct lineinfo *curr_line, *line;
4006   struct funcinfo *funcinfo;
4007
4008   /* Initialize tables with zero element.  */
4009   curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4010   module->srec_table = curr_srec;
4011
4012   curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4013   module->line_table = curr_line;
4014
4015   while (length == -1 || ptr < maxptr)
4016     {
4017       /* The first byte is not counted in the recorded length.  */
4018       int rec_length = bfd_getl16 (ptr) + 1;
4019       int rec_type = bfd_getl16 (ptr + 2);
4020
4021       vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4022
4023       if (length == -1 && rec_type == DST__K_MODEND)
4024         break;
4025
4026       switch (rec_type)
4027         {
4028         case DST__K_MODBEG:
4029           module->name
4030             = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4031
4032           curr_pc = 0;
4033           prev_pc = 0;
4034           curr_linenum = 0;
4035           prev_linum = 0;
4036
4037           vms_debug2 ((3, "module: %s\n", module->name));
4038           break;
4039
4040         case DST__K_MODEND:
4041           break;
4042
4043         case DST__K_RTNBEG:
4044           funcinfo = (struct funcinfo *)
4045             bfd_zalloc (abfd, sizeof (struct funcinfo));
4046           funcinfo->name
4047             = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4048           funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4049           funcinfo->next = module->func_table;
4050           module->func_table = funcinfo;
4051
4052           vms_debug2 ((3, "routine: %s at 0x%lx\n",
4053                        funcinfo->name, (unsigned long) funcinfo->low));
4054           break;
4055
4056         case DST__K_RTNEND:
4057           module->func_table->high = module->func_table->low
4058             + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4059
4060           if (module->func_table->high > module->high)
4061             module->high = module->func_table->high;
4062
4063           vms_debug2 ((3, "end routine\n"));
4064           break;
4065
4066         case DST__K_PROLOG:
4067           vms_debug2 ((3, "prologue\n"));
4068           break;
4069
4070         case DST__K_EPILOG:
4071           vms_debug2 ((3, "epilog\n"));
4072           break;
4073
4074         case DST__K_BLKBEG:
4075           vms_debug2 ((3, "block\n"));
4076           break;
4077
4078         case DST__K_BLKEND:
4079           vms_debug2 ((3, "end block\n"));
4080           break;
4081
4082         case DST__K_SOURCE:
4083           src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4084
4085           vms_debug2 ((3, "source info\n"));
4086
4087           while (src_ptr < ptr + rec_length)
4088             {
4089               int cmd = src_ptr[0], cmd_length, data;
4090
4091               switch (cmd)
4092                 {
4093                 case DST__K_SRC_DECLFILE:
4094                   {
4095                     unsigned int fileid
4096                       = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4097                     char *filename
4098                       = _bfd_vms_save_counted_string (src_ptr
4099                           + DST_S_B_SRC_DF_FILENAME);
4100
4101                     while (fileid >= module->file_table_count)
4102                       {
4103                         module->file_table_count *= 2;
4104                         module->file_table
4105                           = bfd_realloc (module->file_table,
4106                                          module->file_table_count
4107                                            * sizeof (struct fileinfo));
4108                       }
4109
4110                     module->file_table [fileid].name = filename;
4111                     module->file_table [fileid].srec = 1;
4112                     cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4113                     vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4114                                  fileid, module->file_table [fileid].name));
4115                   }
4116                   break;
4117
4118                 case DST__K_SRC_DEFLINES_B:
4119                   /* Perform the association and set the next higher index
4120                      to the limit.  */
4121                   data = src_ptr[DST_S_B_SRC_UNSBYTE];
4122                   srec = (struct srecinfo *)
4123                     bfd_zalloc (abfd, sizeof (struct srecinfo));
4124                   srec->line = curr_srec->line + data;
4125                   srec->srec = curr_srec->srec + data;
4126                   srec->sfile = curr_srec->sfile;
4127                   curr_srec->next = srec;
4128                   curr_srec = srec;
4129                   cmd_length = 2;
4130                   vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4131                   break;
4132
4133                 case DST__K_SRC_DEFLINES_W:
4134                   /* Perform the association and set the next higher index
4135                      to the limit.  */
4136                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4137                   srec = (struct srecinfo *)
4138                     bfd_zalloc (abfd, sizeof (struct srecinfo));
4139                   srec->line = curr_srec->line + data;
4140                   srec->srec = curr_srec->srec + data,
4141                   srec->sfile = curr_srec->sfile;
4142                   curr_srec->next = srec;
4143                   curr_srec = srec;
4144                   cmd_length = 3;
4145                   vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4146                   break;
4147
4148                 case DST__K_SRC_INCRLNUM_B:
4149                   data = src_ptr[DST_S_B_SRC_UNSBYTE];
4150                   curr_srec->line += data;
4151                   cmd_length = 2;
4152                   vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4153                   break;
4154
4155                 case DST__K_SRC_SETFILE:
4156                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4157                   curr_srec->sfile = data;
4158                   curr_srec->srec = module->file_table[data].srec;
4159                   cmd_length = 3;
4160                   vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4161                   break;
4162
4163                 case DST__K_SRC_SETLNUM_L:
4164                   data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4165                   curr_srec->line = data;
4166                   cmd_length = 5;
4167                   vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4168                   break;
4169
4170                 case DST__K_SRC_SETLNUM_W:
4171                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4172                   curr_srec->line = data;
4173                   cmd_length = 3;
4174                   vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4175                   break;
4176
4177                 case DST__K_SRC_SETREC_L:
4178                   data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4179                   curr_srec->srec = data;
4180                   module->file_table[curr_srec->sfile].srec = data;
4181                   cmd_length = 5;
4182                   vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4183                   break;
4184
4185                 case DST__K_SRC_SETREC_W:
4186                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4187                   curr_srec->srec = data;
4188                   module->file_table[curr_srec->sfile].srec = data;
4189                   cmd_length = 3;
4190                   vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4191                   break;
4192
4193                 case DST__K_SRC_FORMFEED:
4194                   cmd_length = 1;
4195                   vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4196                   break;
4197
4198                 default:
4199                   (*_bfd_error_handler) (_("unknown source command %d"),
4200                                          cmd);
4201                   cmd_length = 2;
4202                   break;
4203                 }
4204
4205               src_ptr += cmd_length;
4206             }
4207           break;
4208
4209         case DST__K_LINE_NUM:
4210           pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4211
4212           vms_debug2 ((3, "line info\n"));
4213
4214           while (pcl_ptr < ptr + rec_length)
4215             {
4216               /* The command byte is signed so we must sign-extend it.  */
4217               int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4218
4219               switch (cmd)
4220                 {
4221                 case DST__K_DELTA_PC_W:
4222                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4223                   curr_pc += data;
4224                   curr_linenum += 1;
4225                   cmd_length = 3;
4226                   vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4227                   break;
4228
4229                 case DST__K_DELTA_PC_L:
4230                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4231                   curr_pc += data;
4232                   curr_linenum += 1;
4233                   cmd_length = 5;
4234                   vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4235                   break;
4236
4237                 case DST__K_INCR_LINUM:
4238                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4239                   curr_linenum += data;
4240                   cmd_length = 2;
4241                   vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4242                   break;
4243
4244                 case DST__K_INCR_LINUM_W:
4245                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4246                   curr_linenum += data;
4247                   cmd_length = 3;
4248                   vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4249                   break;
4250
4251                 case DST__K_INCR_LINUM_L:
4252                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4253                   curr_linenum += data;
4254                   cmd_length = 5;
4255                   vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4256                   break;
4257
4258                 case DST__K_SET_LINUM_INCR:
4259                   (*_bfd_error_handler)
4260                     (_("DST__K_SET_LINUM_INCR not implemented"));
4261                   cmd_length = 2;
4262                   break;
4263
4264                 case DST__K_SET_LINUM_INCR_W:
4265                   (*_bfd_error_handler)
4266                     (_("DST__K_SET_LINUM_INCR_W not implemented"));
4267                   cmd_length = 3;
4268                   break;
4269
4270                 case DST__K_RESET_LINUM_INCR:
4271                   (*_bfd_error_handler)
4272                     (_("DST__K_RESET_LINUM_INCR not implemented"));
4273                   cmd_length = 1;
4274                   break;
4275
4276                 case DST__K_BEG_STMT_MODE:
4277                   (*_bfd_error_handler)
4278                     (_("DST__K_BEG_STMT_MODE not implemented"));
4279                   cmd_length = 1;
4280                   break;
4281
4282                 case DST__K_END_STMT_MODE:
4283                   (*_bfd_error_handler)
4284                     (_("DST__K_END_STMT_MODE not implemented"));
4285                   cmd_length = 1;
4286                   break;
4287
4288                 case DST__K_SET_LINUM_B:
4289                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4290                   curr_linenum = data;
4291                   cmd_length = 2;
4292                   vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4293                   break;
4294
4295                 case DST__K_SET_LINUM:
4296                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4297                   curr_linenum = data;
4298                   cmd_length = 3;
4299                   vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4300                   break;
4301
4302                 case DST__K_SET_LINUM_L:
4303                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4304                   curr_linenum = data;
4305                   cmd_length = 5;
4306                   vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4307                   break;
4308
4309                 case DST__K_SET_PC:
4310                   (*_bfd_error_handler)
4311                     (_("DST__K_SET_PC not implemented"));
4312                   cmd_length = 2;
4313                   break;
4314
4315                 case DST__K_SET_PC_W:
4316                   (*_bfd_error_handler)
4317                     (_("DST__K_SET_PC_W not implemented"));
4318                   cmd_length = 3;
4319                   break;
4320
4321                 case DST__K_SET_PC_L:
4322                   (*_bfd_error_handler)
4323                     (_("DST__K_SET_PC_L not implemented"));
4324                   cmd_length = 5;
4325                   break;
4326
4327                 case DST__K_SET_STMTNUM:
4328                   (*_bfd_error_handler)
4329                     (_("DST__K_SET_STMTNUM not implemented"));
4330                   cmd_length = 2;
4331                   break;
4332
4333                 case DST__K_TERM:
4334                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4335                   curr_pc += data;
4336                   cmd_length = 2;
4337                   vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4338                   break;
4339
4340                 case DST__K_TERM_W:
4341                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4342                   curr_pc += data;
4343                   cmd_length = 3;
4344                   vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4345                   break;
4346
4347                 case DST__K_TERM_L:
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_TERM_L: %d\n", data));
4352                   break;
4353
4354                 case DST__K_SET_ABS_PC:
4355                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4356                   curr_pc = data;
4357                   cmd_length = 5;
4358                   vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4359                   break;
4360
4361                 default:
4362                   if (cmd <= 0)
4363                     {
4364                       curr_pc -= cmd;
4365                       curr_linenum += 1;
4366                       cmd_length = 1;
4367                       vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4368                                    (unsigned long)curr_pc, curr_linenum));
4369                     }
4370                   else
4371                     {
4372                       (*_bfd_error_handler) (_("unknown line command %d"),
4373                                              cmd);
4374                       cmd_length = 2;
4375                     }
4376                   break;
4377                 }
4378
4379               if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4380                   || cmd <= 0
4381                   || cmd == DST__K_DELTA_PC_L
4382                   || cmd == DST__K_DELTA_PC_W)
4383                 {
4384                   line = (struct lineinfo *)
4385                     bfd_zalloc (abfd, sizeof (struct lineinfo));
4386                   line->address = curr_pc;
4387                   line->line = curr_linenum;
4388
4389                   curr_line->next = line;
4390                   curr_line = line;
4391
4392                   prev_linum = curr_linenum;
4393                   prev_pc = curr_pc;
4394                   vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4395                                (unsigned long)curr_pc, curr_linenum));
4396                 }
4397
4398               pcl_ptr += cmd_length;
4399             }
4400           break;
4401
4402         case 0x17: /* Undocumented type used by DEC C to declare equates.  */
4403           vms_debug2 ((3, "undocumented type 0x17\n"));
4404           break;
4405
4406         default:
4407           vms_debug2 ((3, "ignoring record\n"));
4408           break;
4409
4410         }
4411
4412       ptr += rec_length;
4413     }
4414
4415   /* Finalize tables with EOL marker.  */
4416   srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4417   srec->line = (unsigned int) -1;
4418   srec->srec = (unsigned int) -1;
4419   curr_srec->next = srec;
4420
4421   line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4422   line->line = (unsigned int) -1;
4423   line->address = (bfd_vma) -1;
4424   curr_line->next = line;
4425
4426   /* Advertise that this module has been parsed.  This is needed
4427      because parsing can be either performed at module creation
4428      or deferred until debug info is consumed.  */
4429   SET_MODULE_PARSED (module);
4430 }
4431
4432 /* Build the list of modules for the specified BFD.  */
4433
4434 static struct module *
4435 build_module_list (bfd *abfd)
4436 {
4437   struct module *module, *list = NULL;
4438   asection *dmt;
4439
4440   if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4441     {
4442       /* We have a DMT section so this must be an image.  Parse the
4443          section and build the list of modules.  This is sufficient
4444          since we can compute the start address and the end address
4445          of every module from the section contents.  */
4446       bfd_size_type size = bfd_get_section_size (dmt);
4447       unsigned char *ptr, *end;
4448
4449       ptr = (unsigned char *) bfd_alloc (abfd, size);
4450       if (! ptr)
4451         return NULL;
4452
4453       if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4454         return NULL;
4455
4456       vms_debug2 ((2, "DMT\n"));
4457
4458       end = ptr + size;
4459
4460       while (ptr < end)
4461         {
4462           /* Each header declares a module with its start offset and size
4463              of debug info in the DST section, as well as the count of
4464              program sections (i.e. address spans) it contains.  */
4465           int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4466           int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4467           int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4468           ptr += DBG_S_C_DMT_HEADER_SIZE;
4469
4470           vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4471                        modbeg, msize, count));
4472
4473           /* We create a 'module' structure for each program section since
4474              we only support contiguous addresses in a 'module' structure.
4475              As a consequence, the actual debug info in the DST section is
4476              shared and can be parsed multiple times; that doesn't seem to
4477              cause problems in practice.  */
4478           while (count-- > 0)
4479             {
4480               int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4481               int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4482               module = new_module (abfd);
4483               module->modbeg = modbeg;
4484               module->size = msize;
4485               module->low = start;
4486               module->high = start + length;
4487               module->next = list;
4488               list = module;
4489               ptr += DBG_S_C_DMT_PSECT_SIZE;
4490
4491               vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4492                            start, length));
4493             }
4494         }
4495     }
4496   else
4497     {
4498       /* We don't have a DMT section so this must be an object.  Parse
4499          the module right now in order to compute its start address and
4500          end address.  */
4501       void *dst = PRIV (dst_section)->contents;
4502
4503       if (dst == NULL)
4504         return NULL;
4505
4506       module = new_module (abfd);
4507       parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4508       list = module;
4509     }
4510
4511   return list;
4512 }
4513
4514 /* Calculate and return the name of the source file and the line nearest
4515    to the wanted location in the specified module.  */
4516
4517 static bfd_boolean
4518 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4519                           const char **file, const char **func,
4520                           unsigned int *line)
4521 {
4522   struct funcinfo *funcinfo;
4523   struct lineinfo *lineinfo;
4524   struct srecinfo *srecinfo;
4525   bfd_boolean ret = FALSE;
4526
4527   /* Parse this module if that was not done at module creation.  */
4528   if (! IS_MODULE_PARSED (module))
4529     {
4530       unsigned int size = module->size;
4531       unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4532       unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4533
4534       if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4535           || bfd_bread (buffer, size, abfd) != size)
4536         {
4537           bfd_set_error (bfd_error_no_debug_section);
4538           return FALSE;
4539         }
4540
4541       parse_module (abfd, module, buffer, size);
4542       free (buffer);
4543     }
4544
4545   /* Find out the function (if any) that contains the address.  */
4546   for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4547     if (addr >= funcinfo->low && addr <= funcinfo->high)
4548       {
4549         *func = funcinfo->name;
4550         ret = TRUE;
4551         break;
4552       }
4553
4554   /* Find out the source file and the line nearest to the address.  */
4555   for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4556     if (lineinfo->next && addr < lineinfo->next->address)
4557       {
4558         for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4559           if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4560             {
4561               if (srecinfo->sfile > 0)
4562                 {
4563                   *file = module->file_table[srecinfo->sfile].name;
4564                   *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4565                 }
4566               else
4567                 {
4568                   *file = module->name;
4569                   *line = lineinfo->line;
4570                 }
4571               return TRUE;
4572             }
4573
4574         break;
4575       }
4576
4577   return ret;
4578 }
4579
4580 /* Provided a BFD, a section and an offset into the section, calculate and
4581    return the name of the source file and the line nearest to the wanted
4582    location.  */
4583
4584 static bfd_boolean
4585 _bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
4586                                 asymbol **symbols ATTRIBUTE_UNUSED,
4587                                 bfd_vma offset, const char **file,
4588                                 const char **func, unsigned int *line)
4589 {
4590   struct module *module;
4591
4592   /* What address are we looking for?  */
4593   bfd_vma addr = section->vma + offset;
4594
4595   *file = NULL;
4596   *func = NULL;
4597   *line = 0;
4598
4599   /* We can't do anything if there is no DST (debug symbol table).  */
4600   if (PRIV (dst_section) == NULL)
4601     return FALSE;
4602
4603   /* Create the module list - if not already done.  */
4604   if (PRIV (modules) == NULL)
4605     {
4606       PRIV (modules) = build_module_list (abfd);
4607       if (PRIV (modules) == NULL)
4608         return FALSE;
4609     }
4610
4611   for (module = PRIV (modules); module; module = module->next)
4612     if (addr >= module->low && addr <= module->high)
4613       return module_find_nearest_line (abfd, module, addr, file, func, line);
4614
4615   return FALSE;
4616 }
4617
4618 /* Likewise but with a discriminator.  */
4619
4620 static bfd_boolean
4621 _bfd_vms_find_nearest_line_discriminator (bfd *abfd,
4622                                           asection *section,
4623                                           asymbol **symbols,
4624                                           bfd_vma offset,
4625                                           const char **filename_ptr,
4626                                           const char **functionname_ptr,
4627                                           unsigned int *line_ptr,
4628                                           unsigned int *discriminator)
4629 {
4630   *discriminator = 0;
4631
4632   return _bfd_vms_find_nearest_dst_line (abfd, section, symbols, offset,
4633                                          filename_ptr, functionname_ptr,
4634                                          line_ptr);
4635 }
4636
4637 \f
4638 /* Canonicalizations.  */
4639 /* Set name, value, section and flags of SYM from E.  */
4640
4641 static bfd_boolean
4642 alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4643 {
4644   flagword flags;
4645   symvalue value;
4646   asection *sec;
4647   const char *name;
4648
4649   name = e->name;
4650   value = 0;
4651   flags = BSF_NO_FLAGS;
4652   sec = NULL;
4653
4654   switch (e->typ)
4655     {
4656     case EGSD__C_SYM:
4657       if (e->flags & EGSY__V_WEAK)
4658         flags |= BSF_WEAK;
4659
4660       if (e->flags & EGSY__V_DEF)
4661         {
4662           /* Symbol definition.  */
4663           flags |= BSF_GLOBAL;
4664           if (e->flags & EGSY__V_NORM)
4665             flags |= BSF_FUNCTION;
4666           value = e->value;
4667           sec = e->section;
4668         }
4669       else
4670         {
4671           /* Symbol reference.  */
4672           sec = bfd_und_section_ptr;
4673         }
4674       break;
4675
4676     case EGSD__C_SYMG:
4677       /* A universal symbol is by definition global...  */
4678       flags |= BSF_GLOBAL;
4679
4680       /* ...and dynamic in shared libraries.  */
4681       if (abfd->flags & DYNAMIC)
4682         flags |= BSF_DYNAMIC;
4683
4684       if (e->flags & EGSY__V_WEAK)
4685         flags |= BSF_WEAK;
4686
4687       if (!(e->flags & EGSY__V_DEF))
4688         abort ();
4689
4690       if (e->flags & EGSY__V_NORM)
4691         flags |= BSF_FUNCTION;
4692
4693       value = e->value;
4694       /* sec = e->section; */
4695       sec = bfd_abs_section_ptr;
4696       break;
4697
4698     default:
4699       return FALSE;
4700     }
4701
4702   sym->name = name;
4703   sym->section = sec;
4704   sym->flags = flags;
4705   sym->value = value;
4706   return TRUE;
4707 }
4708
4709
4710 /* Return the number of bytes required to store a vector of pointers
4711    to asymbols for all the symbols in the BFD abfd, including a
4712    terminal NULL pointer. If there are no symbols in the BFD,
4713    then return 0.  If an error occurs, return -1.  */
4714
4715 static long
4716 alpha_vms_get_symtab_upper_bound (bfd *abfd)
4717 {
4718   vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4719                abfd, PRIV (gsd_sym_count)));
4720
4721   return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4722 }
4723
4724 /* Read the symbols from the BFD abfd, and fills in the vector
4725    location with pointers to the symbols and a trailing NULL.
4726
4727    Return number of symbols read.   */
4728
4729 static long
4730 alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4731 {
4732   unsigned int i;
4733
4734   vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4735
4736   if (PRIV (csymbols) == NULL)
4737     {
4738       PRIV (csymbols) = (asymbol **) bfd_alloc
4739         (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4740
4741       /* Traverse table and fill symbols vector.  */
4742       for (i = 0; i < PRIV (gsd_sym_count); i++)
4743         {
4744           struct vms_symbol_entry *e = PRIV (syms)[i];
4745           asymbol *sym;
4746
4747           sym = bfd_make_empty_symbol (abfd);
4748           if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4749             {
4750               bfd_release (abfd, PRIV (csymbols));
4751               PRIV (csymbols) = NULL;
4752               return -1;
4753             }
4754
4755           PRIV (csymbols)[i] = sym;
4756         }
4757     }
4758
4759   if (symbols != NULL)
4760     {
4761       for (i = 0; i < PRIV (gsd_sym_count); i++)
4762         symbols[i] = PRIV (csymbols)[i];
4763       symbols[i] = NULL;
4764     }
4765
4766   return PRIV (gsd_sym_count);
4767 }
4768
4769 /* Read and convert relocations from ETIR.  We do it once for all sections.  */
4770
4771 static bfd_boolean
4772 alpha_vms_slurp_relocs (bfd *abfd)
4773 {
4774   int cur_psect = -1;
4775
4776   vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4777
4778   /* We slurp relocs only once, for all sections.  */
4779   if (PRIV (reloc_done))
4780       return TRUE;
4781   PRIV (reloc_done) = TRUE;
4782
4783   if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4784     return FALSE;
4785
4786   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4787     return FALSE;
4788
4789   while (1)
4790     {
4791       unsigned char *begin;
4792       unsigned char *end;
4793       unsigned char *ptr;
4794       bfd_reloc_code_real_type reloc_code;
4795       int type;
4796       bfd_vma vaddr = 0;
4797
4798       int length;
4799
4800       bfd_vma cur_address;
4801       int cur_psidx = -1;
4802       unsigned char *cur_sym = NULL;
4803       int prev_cmd = -1;
4804       bfd_vma cur_addend = 0;
4805
4806       /* Skip non-ETIR records.  */
4807       type = _bfd_vms_get_object_record (abfd);
4808       if (type == EOBJ__C_EEOM)
4809         break;
4810       if (type != EOBJ__C_ETIR)
4811         continue;
4812
4813       begin = PRIV (recrd.rec) + 4;
4814       end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4815
4816       for (ptr = begin; ptr < end; ptr += length)
4817         {
4818           int cmd;
4819
4820           cmd = bfd_getl16 (ptr);
4821           length = bfd_getl16 (ptr + 2);
4822
4823           cur_address = vaddr;
4824
4825           vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4826                        _bfd_vms_etir_name (cmd)));
4827
4828           switch (cmd)
4829             {
4830             case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4831                                   /* ALPHA_R_REFQUAD und_section, step 1 */
4832               cur_sym = ptr + 4;
4833               prev_cmd = cmd;
4834               continue;
4835
4836             case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4837               cur_psidx = bfd_getl32 (ptr + 4);
4838               cur_addend = bfd_getl64 (ptr + 8);
4839               prev_cmd = cmd;
4840               continue;
4841
4842             case ETIR__C_CTL_SETRB:
4843               if (prev_cmd != ETIR__C_STA_PQ)
4844                 {
4845                   (*_bfd_error_handler)
4846                     (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4847                      _bfd_vms_etir_name (cmd));
4848                   return FALSE;
4849                 }
4850               cur_psect = cur_psidx;
4851               vaddr = cur_addend;
4852               cur_psidx = -1;
4853               cur_addend = 0;
4854               continue;
4855
4856             case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4857                                  /* ALPHA_R_REFLONG und_section, step 2 */
4858               if (prev_cmd != -1)
4859                 {
4860                   if (prev_cmd != ETIR__C_STA_GBL)
4861                     {
4862                       (*_bfd_error_handler)
4863                         (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4864                          _bfd_vms_etir_name (ETIR__C_STA_LW));
4865                       return FALSE;
4866                     }
4867                 }
4868               cur_addend = bfd_getl32 (ptr + 4);
4869               prev_cmd = cmd;
4870               continue;
4871
4872             case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4873                                  /* ALPHA_R_REFQUAD und_section, step 2 */
4874               if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4875                 {
4876                   (*_bfd_error_handler)
4877                     (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4878                      _bfd_vms_etir_name (ETIR__C_STA_QW));
4879                   return FALSE;
4880                 }
4881               cur_addend = bfd_getl64 (ptr + 4);
4882               prev_cmd = cmd;
4883               continue;
4884
4885             case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4886                                  /* ALPHA_R_REFLONG abs_section, step 2 */
4887                                  /* ALPHA_R_REFLONG others, step 2 */
4888               if (prev_cmd != ETIR__C_OPR_ADD
4889                   && prev_cmd != ETIR__C_STA_LW
4890                   && prev_cmd != ETIR__C_STA_PQ)
4891                 {
4892                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4893                                          _bfd_vms_etir_name (prev_cmd),
4894                                          _bfd_vms_etir_name (ETIR__C_STO_LW));
4895                   return FALSE;
4896                 }
4897               reloc_code = BFD_RELOC_32;
4898               break;
4899
4900             case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
4901                                  /* ALPHA_R_REFQUAD abs_section, step 2 */
4902               if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
4903                 {
4904                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4905                                          _bfd_vms_etir_name (prev_cmd),
4906                                          _bfd_vms_etir_name (ETIR__C_STO_QW));
4907                   return FALSE;
4908                 }
4909               reloc_code = BFD_RELOC_64;
4910               break;
4911
4912             case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
4913               if (prev_cmd != ETIR__C_STA_PQ)
4914                 {
4915                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4916                                          _bfd_vms_etir_name (prev_cmd),
4917                                          _bfd_vms_etir_name (ETIR__C_STO_OFF));
4918                   return FALSE;
4919                 }
4920               reloc_code = BFD_RELOC_64;
4921               break;
4922
4923             case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
4924                                   /* ALPHA_R_REFQUAD und_section, step 3 */
4925               if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
4926                 {
4927                   (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4928                                          _bfd_vms_etir_name (prev_cmd),
4929                                          _bfd_vms_etir_name (ETIR__C_OPR_ADD));
4930                   return FALSE;
4931                 }
4932               prev_cmd = ETIR__C_OPR_ADD;
4933               continue;
4934
4935             case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
4936               reloc_code = BFD_RELOC_ALPHA_CODEADDR;
4937               cur_sym = ptr + 4;
4938               break;
4939
4940             case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
4941               reloc_code = BFD_RELOC_64;
4942               cur_sym = ptr + 4;
4943               break;
4944
4945             case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
4946               reloc_code = BFD_RELOC_32;
4947               cur_sym = ptr + 4;
4948               break;
4949
4950             case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
4951               reloc_code = BFD_RELOC_ALPHA_LINKAGE;
4952               cur_sym = ptr + 8;
4953               break;
4954
4955             case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
4956               reloc_code = BFD_RELOC_ALPHA_NOP;
4957               goto call_reloc;
4958
4959             case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
4960               reloc_code = BFD_RELOC_ALPHA_BSR;
4961               goto call_reloc;
4962
4963             case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
4964               reloc_code = BFD_RELOC_ALPHA_LDA;
4965               goto call_reloc;
4966
4967             case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
4968               reloc_code = BFD_RELOC_ALPHA_BOH;
4969               goto call_reloc;
4970
4971             call_reloc:
4972               cur_sym = ptr + 4 + 32;
4973               cur_address = bfd_getl64 (ptr + 4 + 8);
4974               cur_addend = bfd_getl64 (ptr + 4 + 24);
4975               break;
4976
4977             case ETIR__C_STO_IMM:
4978               vaddr += bfd_getl32 (ptr + 4);
4979               continue;
4980
4981             default:
4982               (*_bfd_error_handler) (_("Unknown reloc %s"),
4983                                      _bfd_vms_etir_name (cmd));
4984               return FALSE;
4985             }
4986
4987           {
4988             asection *sec;
4989             struct vms_section_data_struct *vms_sec;
4990             arelent *reloc;
4991
4992             /* Get section to which the relocation applies.  */
4993             if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
4994               {
4995                 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
4996                 return FALSE;
4997               }
4998
4999             sec = PRIV (sections)[cur_psect];
5000             if (sec == bfd_abs_section_ptr)
5001               {
5002                 (*_bfd_error_handler) (_("Relocation for non-REL psect"));
5003                 return FALSE;
5004               }
5005
5006             vms_sec = vms_section_data (sec);
5007
5008             /* Allocate a reloc entry.  */
5009             if (sec->reloc_count >= vms_sec->reloc_max)
5010               {
5011                 if (vms_sec->reloc_max == 0)
5012                   {
5013                     vms_sec->reloc_max = 64;
5014                     sec->relocation = bfd_zmalloc
5015                       (vms_sec->reloc_max * sizeof (arelent));
5016                   }
5017                 else
5018                   {
5019                     vms_sec->reloc_max *= 2;
5020                     sec->relocation = bfd_realloc
5021                       (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5022                   }
5023               }
5024             reloc = &sec->relocation[sec->reloc_count];
5025             sec->reloc_count++;
5026
5027             reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5028
5029             if (cur_sym != NULL)
5030               {
5031                 unsigned int j;
5032                 unsigned int symlen = *cur_sym;
5033                 asymbol **sym;
5034
5035                 /* Linear search.  */
5036                 symlen = *cur_sym;
5037                 cur_sym++;
5038                 sym = NULL;
5039
5040                 for (j = 0; j < PRIV (gsd_sym_count); j++)
5041                   if (PRIV (syms)[j]->namelen == symlen
5042                       && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5043                     {
5044                       sym = &PRIV (csymbols)[j];
5045                       break;
5046                     }
5047                 if (sym == NULL)
5048                   {
5049                     (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5050                                            _bfd_vms_etir_name (cmd));
5051                     reloc->sym_ptr_ptr = NULL;
5052                   }
5053                 else
5054                   reloc->sym_ptr_ptr = sym;
5055               }
5056             else if (cur_psidx >= 0)
5057               reloc->sym_ptr_ptr =
5058                 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5059             else
5060               reloc->sym_ptr_ptr = NULL;
5061
5062             reloc->address = cur_address;
5063             reloc->addend = cur_addend;
5064
5065             vaddr += bfd_get_reloc_size (reloc->howto);
5066           }
5067
5068           cur_addend = 0;
5069           prev_cmd = -1;
5070           cur_sym = NULL;
5071           cur_psidx = -1;
5072         }
5073     }
5074   vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5075
5076   return TRUE;
5077 }
5078
5079 /* Return the number of bytes required to store the relocation
5080    information associated with the given section.  */
5081
5082 static long
5083 alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5084 {
5085   alpha_vms_slurp_relocs (abfd);
5086
5087   return (section->reloc_count + 1) * sizeof (arelent *);
5088 }
5089
5090 /* Convert relocations from VMS (external) form into BFD internal
5091    form.  Return the number of relocations.  */
5092
5093 static long
5094 alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5095                               asymbol **symbols ATTRIBUTE_UNUSED)
5096 {
5097   arelent *tblptr;
5098   int count;
5099
5100   if (!alpha_vms_slurp_relocs (abfd))
5101     return -1;
5102
5103   count = section->reloc_count;
5104   tblptr = section->relocation;
5105
5106   while (count--)
5107     *relptr++ = tblptr++;
5108
5109   *relptr = (arelent *) NULL;
5110   return section->reloc_count;
5111 }
5112 \f
5113 /* This is just copied from ecoff-alpha, needs to be fixed probably.  */
5114
5115 /* How to process the various reloc types.  */
5116
5117 static bfd_reloc_status_type
5118 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5119            arelent *reloc ATTRIBUTE_UNUSED,
5120            asymbol *sym ATTRIBUTE_UNUSED,
5121            void * data ATTRIBUTE_UNUSED,
5122            asection *sec ATTRIBUTE_UNUSED,
5123            bfd *output_bfd ATTRIBUTE_UNUSED,
5124            char **error_message ATTRIBUTE_UNUSED)
5125 {
5126 #if VMS_DEBUG
5127   vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5128   vms_debug (2, "In section %s, symbol %s\n",
5129         sec->name, sym->name);
5130   vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5131                 reloc->sym_ptr_ptr[0]->name,
5132                 (unsigned long)reloc->address,
5133                 (unsigned long)reloc->addend, reloc->howto->name);
5134   vms_debug (2, "data at %p\n", data);
5135   /*  _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5136 #endif
5137
5138   return bfd_reloc_ok;
5139 }
5140
5141 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5142    from smaller values.  Start with zero, widen, *then* decrement.  */
5143 #define MINUS_ONE       (((bfd_vma)0) - 1)
5144
5145 static reloc_howto_type alpha_howto_table[] =
5146 {
5147   HOWTO (ALPHA_R_IGNORE,        /* Type.  */
5148          0,                     /* Rightshift.  */
5149          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5150          8,                     /* Bitsize.  */
5151          TRUE,                  /* PC relative.  */
5152          0,                     /* Bitpos.  */
5153          complain_overflow_dont,/* Complain_on_overflow.  */
5154          reloc_nil,             /* Special_function.  */
5155          "IGNORE",              /* Name.  */
5156          TRUE,                  /* Partial_inplace.  */
5157          0,                     /* Source mask */
5158          0,                     /* Dest mask.  */
5159          TRUE),                 /* PC rel offset.  */
5160
5161   /* A 64 bit reference to a symbol.  */
5162   HOWTO (ALPHA_R_REFQUAD,       /* Type.  */
5163          0,                     /* Rightshift.  */
5164          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5165          64,                    /* Bitsize.  */
5166          FALSE,                 /* PC relative.  */
5167          0,                     /* Bitpos.  */
5168          complain_overflow_bitfield, /* Complain_on_overflow.  */
5169          reloc_nil,             /* Special_function.  */
5170          "REFQUAD",             /* Name.  */
5171          TRUE,                  /* Partial_inplace.  */
5172          MINUS_ONE,             /* Source mask.  */
5173          MINUS_ONE,             /* Dest mask.  */
5174          FALSE),                /* PC rel offset.  */
5175
5176   /* A 21 bit branch.  The native assembler generates these for
5177      branches within the text segment, and also fills in the PC
5178      relative offset in the instruction.  */
5179   HOWTO (ALPHA_R_BRADDR,        /* Type.  */
5180          2,                     /* Rightshift.  */
5181          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5182          21,                    /* Bitsize.  */
5183          TRUE,                  /* PC relative.  */
5184          0,                     /* Bitpos.  */
5185          complain_overflow_signed, /* Complain_on_overflow.  */
5186          reloc_nil,             /* Special_function.  */
5187          "BRADDR",              /* Name.  */
5188          TRUE,                  /* Partial_inplace.  */
5189          0x1fffff,              /* Source mask.  */
5190          0x1fffff,              /* Dest mask.  */
5191          FALSE),                /* PC rel offset.  */
5192
5193   /* A hint for a jump to a register.  */
5194   HOWTO (ALPHA_R_HINT,          /* Type.  */
5195          2,                     /* Rightshift.  */
5196          1,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5197          14,                    /* Bitsize.  */
5198          TRUE,                  /* PC relative.  */
5199          0,                     /* Bitpos.  */
5200          complain_overflow_dont,/* Complain_on_overflow.  */
5201          reloc_nil,             /* Special_function.  */
5202          "HINT",                /* Name.  */
5203          TRUE,                  /* Partial_inplace.  */
5204          0x3fff,                /* Source mask.  */
5205          0x3fff,                /* Dest mask.  */
5206          FALSE),                /* PC rel offset.  */
5207
5208   /* 16 bit PC relative offset.  */
5209   HOWTO (ALPHA_R_SREL16,        /* Type.  */
5210          0,                     /* Rightshift.  */
5211          1,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5212          16,                    /* Bitsize.  */
5213          TRUE,                  /* PC relative.  */
5214          0,                     /* Bitpos.  */
5215          complain_overflow_signed, /* Complain_on_overflow.  */
5216          reloc_nil,             /* Special_function.  */
5217          "SREL16",              /* Name.  */
5218          TRUE,                  /* Partial_inplace.  */
5219          0xffff,                /* Source mask.  */
5220          0xffff,                /* Dest mask.  */
5221          FALSE),                /* PC rel offset.  */
5222
5223   /* 32 bit PC relative offset.  */
5224   HOWTO (ALPHA_R_SREL32,        /* Type.  */
5225          0,                     /* Rightshift.  */
5226          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5227          32,                    /* Bitsize.  */
5228          TRUE,                  /* PC relative.  */
5229          0,                     /* Bitpos.  */
5230          complain_overflow_signed, /* Complain_on_overflow.  */
5231          reloc_nil,             /* Special_function.  */
5232          "SREL32",              /* Name.  */
5233          TRUE,                  /* Partial_inplace.  */
5234          0xffffffff,            /* Source mask.  */
5235          0xffffffff,            /* Dest mask.  */
5236          FALSE),                /* PC rel offset.  */
5237
5238   /* A 64 bit PC relative offset.  */
5239   HOWTO (ALPHA_R_SREL64,        /* Type.  */
5240          0,                     /* Rightshift.  */
5241          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5242          64,                    /* Bitsize.  */
5243          TRUE,                  /* PC relative.  */
5244          0,                     /* Bitpos.  */
5245          complain_overflow_signed, /* Complain_on_overflow.  */
5246          reloc_nil,             /* Special_function.  */
5247          "SREL64",              /* Name.  */
5248          TRUE,                  /* Partial_inplace.  */
5249          MINUS_ONE,             /* Source mask.  */
5250          MINUS_ONE,             /* Dest mask.  */
5251          FALSE),                /* PC rel offset.  */
5252
5253   /* Push a value on the reloc evaluation stack.  */
5254   HOWTO (ALPHA_R_OP_PUSH,       /* Type.  */
5255          0,                     /* Rightshift.  */
5256          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5257          0,                     /* Bitsize.  */
5258          FALSE,                 /* PC relative.  */
5259          0,                     /* Bitpos.  */
5260          complain_overflow_dont,/* Complain_on_overflow.  */
5261          reloc_nil,             /* Special_function.  */
5262          "OP_PUSH",             /* Name.  */
5263          FALSE,                 /* Partial_inplace.  */
5264          0,                     /* Source mask.  */
5265          0,                     /* Dest mask.  */
5266          FALSE),                /* PC rel offset.  */
5267
5268   /* Store the value from the stack at the given address.  Store it in
5269      a bitfield of size r_size starting at bit position r_offset.  */
5270   HOWTO (ALPHA_R_OP_STORE,      /* Type.  */
5271          0,                     /* Rightshift.  */
5272          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5273          64,                    /* Bitsize.  */
5274          FALSE,                 /* PC relative.  */
5275          0,                     /* Bitpos.  */
5276          complain_overflow_dont,/* Complain_on_overflow.  */
5277          reloc_nil,             /* Special_function.  */
5278          "OP_STORE",            /* Name.  */
5279          FALSE,                 /* Partial_inplace.  */
5280          0,                     /* Source mask.  */
5281          MINUS_ONE,             /* Dest mask.  */
5282          FALSE),                /* PC rel offset.  */
5283
5284   /* Subtract the reloc address from the value on the top of the
5285      relocation stack.  */
5286   HOWTO (ALPHA_R_OP_PSUB,       /* Type.  */
5287          0,                     /* Rightshift.  */
5288          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5289          0,                     /* Bitsize.  */
5290          FALSE,                 /* PC relative.  */
5291          0,                     /* Bitpos.  */
5292          complain_overflow_dont,/* Complain_on_overflow.  */
5293          reloc_nil,             /* Special_function.  */
5294          "OP_PSUB",             /* Name.  */
5295          FALSE,                 /* Partial_inplace.  */
5296          0,                     /* Source mask.  */
5297          0,                     /* Dest mask.  */
5298          FALSE),                /* PC rel offset.  */
5299
5300   /* Shift the value on the top of the relocation stack right by the
5301      given value.  */
5302   HOWTO (ALPHA_R_OP_PRSHIFT,    /* Type.  */
5303          0,                     /* Rightshift.  */
5304          0,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5305          0,                     /* Bitsize.  */
5306          FALSE,                 /* PC relative.  */
5307          0,                     /* Bitpos.  */
5308          complain_overflow_dont,/* Complain_on_overflow.  */
5309          reloc_nil,             /* Special_function.  */
5310          "OP_PRSHIFT",          /* Name.  */
5311          FALSE,                 /* Partial_inplace.  */
5312          0,                     /* Source mask.  */
5313          0,                     /* Dest mask.  */
5314          FALSE),                /* PC rel offset.  */
5315
5316   /* Hack. Linkage is done by linker.  */
5317   HOWTO (ALPHA_R_LINKAGE,       /* Type.  */
5318          0,                     /* Rightshift.  */
5319          8,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5320          256,                   /* Bitsize.  */
5321          FALSE,                 /* PC relative.  */
5322          0,                     /* Bitpos.  */
5323          complain_overflow_dont,/* Complain_on_overflow.  */
5324          reloc_nil,             /* Special_function.  */
5325          "LINKAGE",             /* Name.  */
5326          FALSE,                 /* Partial_inplace.  */
5327          0,                     /* Source mask.  */
5328          0,                     /* Dest mask.  */
5329          FALSE),                /* PC rel offset.  */
5330
5331   /* A 32 bit reference to a symbol.  */
5332   HOWTO (ALPHA_R_REFLONG,       /* Type.  */
5333          0,                     /* Rightshift.  */
5334          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5335          32,                    /* Bitsize.  */
5336          FALSE,                 /* PC relative.  */
5337          0,                     /* Bitpos.  */
5338          complain_overflow_bitfield, /* Complain_on_overflow.  */
5339          reloc_nil,             /* Special_function.  */
5340          "REFLONG",             /* Name.  */
5341          TRUE,                  /* Partial_inplace.  */
5342          0xffffffff,            /* Source mask.  */
5343          0xffffffff,            /* Dest mask.  */
5344          FALSE),                /* PC rel offset.  */
5345
5346   /* A 64 bit reference to a procedure, written as 32 bit value.  */
5347   HOWTO (ALPHA_R_CODEADDR,      /* Type.  */
5348          0,                     /* Rightshift.  */
5349          4,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5350          64,                    /* Bitsize.  */
5351          FALSE,                 /* PC relative.  */
5352          0,                     /* Bitpos.  */
5353          complain_overflow_signed,/* Complain_on_overflow.  */
5354          reloc_nil,             /* Special_function.  */
5355          "CODEADDR",            /* Name.  */
5356          FALSE,                 /* Partial_inplace.  */
5357          0xffffffff,            /* Source mask.  */
5358          0xffffffff,            /* Dest mask.  */
5359          FALSE),                /* PC rel offset.  */
5360
5361   HOWTO (ALPHA_R_NOP,           /* Type.  */
5362          0,                     /* Rightshift.  */
5363          3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5364          0,                     /* Bitsize.  */
5365          /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5366             because the calculations for the 3 relocations are the same.
5367             See B.4.5.2 of the OpenVMS Linker Utility Manual.  */
5368          TRUE,                  /* PC relative.  */
5369          0,                     /* Bitpos.   */
5370          complain_overflow_dont,/* Complain_on_overflow.  */
5371          reloc_nil,             /* Special_function.  */
5372          "NOP",                 /* Name.  */
5373          FALSE,                 /* Partial_inplace.  */
5374          0xffffffff,            /* Source mask.  */
5375          0xffffffff,            /* Dest mask.  */
5376          FALSE),                /* PC rel offset.  */
5377
5378   HOWTO (ALPHA_R_BSR,           /* Type.  */
5379          0,                     /* Rightshift.  */
5380          3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5381          0,                     /* Bitsize.  */
5382          TRUE,                  /* PC relative.  */
5383          0,                     /* Bitpos.  */
5384          complain_overflow_dont,/* Complain_on_overflow.  */
5385          reloc_nil,             /* Special_function.  */
5386          "BSR",                 /* Name.  */
5387          FALSE,                 /* Partial_inplace.  */
5388          0xffffffff,            /* Source mask.  */
5389          0xffffffff,            /* Dest mask.  */
5390          FALSE),                /* PC rel offset.  */
5391
5392   HOWTO (ALPHA_R_LDA,           /* Type.  */
5393          0,                     /* Rightshift.  */
5394          3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
5395          0,                     /* Bitsize.  */
5396          FALSE,                 /* PC relative.  */
5397          0,                     /* Bitpos.  */
5398          complain_overflow_dont,/* Complain_on_overflow.  */
5399          reloc_nil,             /* Special_function.  */
5400          "LDA",                 /* Name.  */
5401          FALSE,                 /* Partial_inplace.  */
5402          0xffffffff,            /* Source mask.  */
5403          0xffffffff,            /* Dest mask.  */
5404          FALSE),                /* PC rel offset.  */
5405
5406   HOWTO (ALPHA_R_BOH,           /* Type.  */
5407          0,                     /* Rightshift.  */
5408          3,                     /* Size (0 = byte, 1 = short, 2 = long, 3 = nil).  */
5409          0,                     /* Bitsize.  */
5410          TRUE,                  /* PC relative.  */
5411          0,                     /* Bitpos.  */
5412          complain_overflow_dont,/* Complain_on_overflow.  */
5413          reloc_nil,             /* Special_function.  */
5414          "BOH",                 /* Name.  */
5415          FALSE,                 /* Partial_inplace.  */
5416          0xffffffff,            /* Source mask.  */
5417          0xffffffff,            /* Dest mask.  */
5418          FALSE),                /* PC rel offset.  */
5419 };
5420
5421 /* Return a pointer to a howto structure which, when invoked, will perform
5422    the relocation code on data from the architecture noted.  */
5423
5424 static const struct reloc_howto_struct *
5425 alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5426                                  bfd_reloc_code_real_type code)
5427 {
5428   int alpha_type;
5429
5430   vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5431
5432   switch (code)
5433     {
5434       case BFD_RELOC_16:                alpha_type = ALPHA_R_SREL16;    break;
5435       case BFD_RELOC_32:                alpha_type = ALPHA_R_REFLONG;   break;
5436       case BFD_RELOC_64:                alpha_type = ALPHA_R_REFQUAD;   break;
5437       case BFD_RELOC_CTOR:              alpha_type = ALPHA_R_REFQUAD;   break;
5438       case BFD_RELOC_23_PCREL_S2:       alpha_type = ALPHA_R_BRADDR;    break;
5439       case BFD_RELOC_ALPHA_HINT:        alpha_type = ALPHA_R_HINT;      break;
5440       case BFD_RELOC_16_PCREL:          alpha_type = ALPHA_R_SREL16;    break;
5441       case BFD_RELOC_32_PCREL:          alpha_type = ALPHA_R_SREL32;    break;
5442       case BFD_RELOC_64_PCREL:          alpha_type = ALPHA_R_SREL64;    break;
5443       case BFD_RELOC_ALPHA_LINKAGE:     alpha_type = ALPHA_R_LINKAGE;   break;
5444       case BFD_RELOC_ALPHA_CODEADDR:    alpha_type = ALPHA_R_CODEADDR;  break;
5445       case BFD_RELOC_ALPHA_NOP:         alpha_type = ALPHA_R_NOP;       break;
5446       case BFD_RELOC_ALPHA_BSR:         alpha_type = ALPHA_R_BSR;       break;
5447       case BFD_RELOC_ALPHA_LDA:         alpha_type = ALPHA_R_LDA;       break;
5448       case BFD_RELOC_ALPHA_BOH:         alpha_type = ALPHA_R_BOH;       break;
5449       default:
5450         (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5451         return NULL;
5452     }
5453   vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5454   return & alpha_howto_table[alpha_type];
5455 }
5456
5457 static reloc_howto_type *
5458 alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5459                                  const char *r_name)
5460 {
5461   unsigned int i;
5462
5463   for (i = 0;
5464        i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5465        i++)
5466     if (alpha_howto_table[i].name != NULL
5467         && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5468       return &alpha_howto_table[i];
5469
5470   return NULL;
5471 }
5472 \f
5473 static long
5474 alpha_vms_get_synthetic_symtab (bfd *abfd,
5475                                 long symcount ATTRIBUTE_UNUSED,
5476                                 asymbol **usyms ATTRIBUTE_UNUSED,
5477                                 long dynsymcount ATTRIBUTE_UNUSED,
5478                                 asymbol **dynsyms ATTRIBUTE_UNUSED,
5479                                 asymbol **ret)
5480 {
5481   asymbol *syms;
5482   unsigned int i;
5483   unsigned int n = 0;
5484
5485   syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5486   *ret = syms;
5487   if (syms == NULL)
5488     return -1;
5489
5490   for (i = 0; i < PRIV (gsd_sym_count); i++)
5491     {
5492       struct vms_symbol_entry *e = PRIV (syms)[i];
5493       asymbol *sym;
5494       flagword flags;
5495       symvalue value;
5496       asection *sec;
5497       const char *name;
5498       char *sname;
5499       int l;
5500
5501       name = e->name;
5502       value = 0;
5503       flags = BSF_LOCAL | BSF_SYNTHETIC;
5504       sec = NULL;
5505
5506       switch (e->typ)
5507         {
5508         case EGSD__C_SYM:
5509         case EGSD__C_SYMG:
5510           if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5511             {
5512               value = e->code_value;
5513               sec = e->code_section;
5514             }
5515           else
5516             continue;
5517           break;
5518
5519         default:
5520           continue;
5521         }
5522
5523       l = strlen (name);
5524       sname = bfd_alloc (abfd, l + 5);
5525       if (sname == NULL)
5526         return FALSE;
5527       memcpy (sname, name, l);
5528       memcpy (sname + l, "..en", 5);
5529
5530       sym = &syms[n++];
5531       sym->name = sname;
5532       sym->section = sec;
5533       sym->flags = flags;
5534       sym->value = value;
5535       sym->udata.p = NULL;
5536     }
5537
5538   return n;
5539 }
5540 \f
5541 /* Private dump.  */
5542
5543 static const char *
5544 vms_time_to_str (unsigned char *buf)
5545 {
5546   time_t t = vms_rawtime_to_time_t (buf);
5547   char *res = ctime (&t);
5548
5549   if (!res)
5550     res = "*invalid time*";
5551   else
5552     res[24] = 0;
5553   return res;
5554 }
5555
5556 static void
5557 evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5558 {
5559   struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5560   unsigned int subtype;
5561
5562   subtype = (unsigned)bfd_getl16 (emh->subtyp);
5563
5564   fprintf (file, _("  EMH %u (len=%u): "), subtype, rec_len);
5565
5566   switch (subtype)
5567     {
5568     case EMH__C_MHD:
5569       {
5570         struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5571         const char *name;
5572
5573         fprintf (file, _("Module header\n"));
5574         fprintf (file, _("   structure level: %u\n"), mhd->strlvl);
5575         fprintf (file, _("   max record size: %u\n"),
5576                  (unsigned)bfd_getl32 (mhd->recsiz));
5577         name = (char *)(mhd + 1);
5578         fprintf (file, _("   module name    : %.*s\n"), name[0], name + 1);
5579         name += name[0] + 1;
5580         fprintf (file, _("   module version : %.*s\n"), name[0], name + 1);
5581         name += name[0] + 1;
5582         fprintf (file, _("   compile date   : %.17s\n"), name);
5583       }
5584       break;
5585     case EMH__C_LNM:
5586       {
5587         fprintf (file, _("Language Processor Name\n"));
5588         fprintf (file, _("   language name: %.*s\n"),
5589                  (int)(rec_len - sizeof (struct vms_emh_common)),
5590                  (char *)rec + sizeof (struct vms_emh_common));
5591       }
5592       break;
5593     case EMH__C_SRC:
5594       {
5595         fprintf (file, _("Source Files Header\n"));
5596         fprintf (file, _("   file: %.*s\n"),
5597                  (int)(rec_len - sizeof (struct vms_emh_common)),
5598                  (char *)rec + sizeof (struct vms_emh_common));
5599       }
5600       break;
5601     case EMH__C_TTL:
5602       {
5603         fprintf (file, _("Title Text Header\n"));
5604         fprintf (file, _("   title: %.*s\n"),
5605                  (int)(rec_len - sizeof (struct vms_emh_common)),
5606                  (char *)rec + sizeof (struct vms_emh_common));
5607       }
5608       break;
5609     case EMH__C_CPR:
5610       {
5611         fprintf (file, _("Copyright Header\n"));
5612         fprintf (file, _("   copyright: %.*s\n"),
5613                  (int)(rec_len - sizeof (struct vms_emh_common)),
5614                  (char *)rec + sizeof (struct vms_emh_common));
5615       }
5616       break;
5617     default:
5618       fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5619       break;
5620     }
5621 }
5622
5623 static void
5624 evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5625 {
5626   struct vms_eeom *eeom = (struct vms_eeom *)rec;
5627
5628   fprintf (file, _("  EEOM (len=%u):\n"), rec_len);
5629   fprintf (file, _("   number of cond linkage pairs: %u\n"),
5630            (unsigned)bfd_getl32 (eeom->total_lps));
5631   fprintf (file, _("   completion code: %u\n"),
5632            (unsigned)bfd_getl16 (eeom->comcod));
5633   if (rec_len > 10)
5634     {
5635       fprintf (file, _("   transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5636       fprintf (file, _("   transfer addr psect: %u\n"),
5637                (unsigned)bfd_getl32 (eeom->psindx));
5638       fprintf (file, _("   transfer address   : 0x%08x\n"),
5639                (unsigned)bfd_getl32 (eeom->tfradr));
5640     }
5641 }
5642
5643 static void
5644 exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5645 {
5646   if (flags & EGSY__V_WEAK)
5647     fputs (_(" WEAK"), file);
5648   if (flags & EGSY__V_DEF)
5649     fputs (_(" DEF"), file);
5650   if (flags & EGSY__V_UNI)
5651     fputs (_(" UNI"), file);
5652   if (flags & EGSY__V_REL)
5653     fputs (_(" REL"), file);
5654   if (flags & EGSY__V_COMM)
5655     fputs (_(" COMM"), file);
5656   if (flags & EGSY__V_VECEP)
5657     fputs (_(" VECEP"), file);
5658   if (flags & EGSY__V_NORM)
5659     fputs (_(" NORM"), file);
5660   if (flags & EGSY__V_QUAD_VAL)
5661     fputs (_(" QVAL"), file);
5662 }
5663
5664 static void
5665 evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5666 {
5667   if (flags & EGPS__V_PIC)
5668     fputs (_(" PIC"), file);
5669   if (flags & EGPS__V_LIB)
5670     fputs (_(" LIB"), file);
5671   if (flags & EGPS__V_OVR)
5672     fputs (_(" OVR"), file);
5673   if (flags & EGPS__V_REL)
5674     fputs (_(" REL"), file);
5675   if (flags & EGPS__V_GBL)
5676     fputs (_(" GBL"), file);
5677   if (flags & EGPS__V_SHR)
5678     fputs (_(" SHR"), file);
5679   if (flags & EGPS__V_EXE)
5680     fputs (_(" EXE"), file);
5681   if (flags & EGPS__V_RD)
5682     fputs (_(" RD"), file);
5683   if (flags & EGPS__V_WRT)
5684     fputs (_(" WRT"), file);
5685   if (flags & EGPS__V_VEC)
5686     fputs (_(" VEC"), file);
5687   if (flags & EGPS__V_NOMOD)
5688     fputs (_(" NOMOD"), file);
5689   if (flags & EGPS__V_COM)
5690     fputs (_(" COM"), file);
5691   if (flags & EGPS__V_ALLOC_64BIT)
5692     fputs (_(" 64B"), file);
5693 }
5694
5695 static void
5696 evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5697 {
5698   unsigned int off = sizeof (struct vms_egsd);
5699   unsigned int n;
5700
5701   fprintf (file, _("  EGSD (len=%u):\n"), rec_len);
5702
5703   n = 0;
5704   for (off = sizeof (struct vms_egsd); off < rec_len; )
5705     {
5706       struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5707       unsigned int type;
5708       unsigned int len;
5709
5710       type = (unsigned)bfd_getl16 (e->gsdtyp);
5711       len = (unsigned)bfd_getl16 (e->gsdsiz);
5712
5713       fprintf (file, _("  EGSD entry %2u (type: %u, len: %u): "),
5714                n, type, len);
5715       n++;
5716
5717       switch (type)
5718         {
5719         case EGSD__C_PSC:
5720           {
5721             struct vms_egps *egps = (struct vms_egps *)e;
5722             unsigned int flags = bfd_getl16 (egps->flags);
5723             unsigned int l;
5724
5725             fprintf (file, _("PSC - Program section definition\n"));
5726             fprintf (file, _("   alignment  : 2**%u\n"), egps->align);
5727             fprintf (file, _("   flags      : 0x%04x"), flags);
5728             evax_bfd_print_egsd_flags (file, flags);
5729             fputc ('\n', file);
5730             l = bfd_getl32 (egps->alloc);
5731             fprintf (file, _("   alloc (len): %u (0x%08x)\n"), l, l);
5732             fprintf (file, _("   name       : %.*s\n"),
5733                      egps->namlng, egps->name);
5734           }
5735           break;
5736         case EGSD__C_SPSC:
5737           {
5738             struct vms_esgps *esgps = (struct vms_esgps *)e;
5739             unsigned int flags = bfd_getl16 (esgps->flags);
5740             unsigned int l;
5741
5742             fprintf (file, _("SPSC - Shared Image Program section def\n"));
5743             fprintf (file, _("   alignment  : 2**%u\n"), esgps->align);
5744             fprintf (file, _("   flags      : 0x%04x"), flags);
5745             evax_bfd_print_egsd_flags (file, flags);
5746             fputc ('\n', file);
5747             l = bfd_getl32 (esgps->alloc);
5748             fprintf (file, _("   alloc (len)   : %u (0x%08x)\n"), l, l);
5749             fprintf (file, _("   image offset  : 0x%08x\n"),
5750                      (unsigned int)bfd_getl32 (esgps->base));
5751             fprintf (file, _("   symvec offset : 0x%08x\n"),
5752                      (unsigned int)bfd_getl32 (esgps->value));
5753             fprintf (file, _("   name          : %.*s\n"),
5754                      esgps->namlng, esgps->name);
5755           }
5756           break;
5757         case EGSD__C_SYM:
5758           {
5759             struct vms_egsy *egsy = (struct vms_egsy *)e;
5760             unsigned int flags = bfd_getl16 (egsy->flags);
5761
5762             if (flags & EGSY__V_DEF)
5763               {
5764                 struct vms_esdf *esdf = (struct vms_esdf *)e;
5765
5766                 fprintf (file, _("SYM - Global symbol definition\n"));
5767                 fprintf (file, _("   flags: 0x%04x"), flags);
5768                 exav_bfd_print_egsy_flags (flags, file);
5769                 fputc ('\n', file);
5770                 fprintf (file, _("   psect offset: 0x%08x\n"),
5771                          (unsigned)bfd_getl32 (esdf->value));
5772                 if (flags & EGSY__V_NORM)
5773                   {
5774                     fprintf (file, _("   code address: 0x%08x\n"),
5775                              (unsigned)bfd_getl32 (esdf->code_address));
5776                     fprintf (file, _("   psect index for entry point : %u\n"),
5777                              (unsigned)bfd_getl32 (esdf->ca_psindx));
5778                   }
5779                 fprintf (file, _("   psect index : %u\n"),
5780                          (unsigned)bfd_getl32 (esdf->psindx));
5781                 fprintf (file, _("   name        : %.*s\n"),
5782                          esdf->namlng, esdf->name);
5783               }
5784             else
5785               {
5786                 struct vms_esrf *esrf = (struct vms_esrf *)e;
5787
5788                 fprintf (file, _("SYM - Global symbol reference\n"));
5789                 fprintf (file, _("   name       : %.*s\n"),
5790                          esrf->namlng, esrf->name);
5791               }
5792           }
5793           break;
5794         case EGSD__C_IDC:
5795           {
5796             struct vms_eidc *eidc = (struct vms_eidc *)e;
5797             unsigned int flags = bfd_getl32 (eidc->flags);
5798             unsigned char *p;
5799
5800             fprintf (file, _("IDC - Ident Consistency check\n"));
5801             fprintf (file, _("   flags         : 0x%08x"), flags);
5802             if (flags & EIDC__V_BINIDENT)
5803               fputs (" BINDENT", file);
5804             fputc ('\n', file);
5805             fprintf (file, _("   id match      : %x\n"),
5806                      (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5807             fprintf (file, _("   error severity: %x\n"),
5808                      (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5809             p = eidc->name;
5810             fprintf (file, _("   entity name   : %.*s\n"), p[0], p + 1);
5811             p += 1 + p[0];
5812             fprintf (file, _("   object name   : %.*s\n"), p[0], p + 1);
5813             p += 1 + p[0];
5814             if (flags & EIDC__V_BINIDENT)
5815               fprintf (file, _("   binary ident  : 0x%08x\n"),
5816                        (unsigned)bfd_getl32 (p + 1));
5817             else
5818               fprintf (file, _("   ascii ident   : %.*s\n"), p[0], p + 1);
5819           }
5820           break;
5821         case EGSD__C_SYMG:
5822           {
5823             struct vms_egst *egst = (struct vms_egst *)e;
5824             unsigned int flags = bfd_getl16 (egst->header.flags);
5825
5826             fprintf (file, _("SYMG - Universal 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, _("   symbol vector offset: 0x%08x\n"),
5831                      (unsigned)bfd_getl32 (egst->value));
5832             fprintf (file, _("   entry point: 0x%08x\n"),
5833                      (unsigned)bfd_getl32 (egst->lp_1));
5834             fprintf (file, _("   proc descr : 0x%08x\n"),
5835                      (unsigned)bfd_getl32 (egst->lp_2));
5836             fprintf (file, _("   psect index: %u\n"),
5837                      (unsigned)bfd_getl32 (egst->psindx));
5838             fprintf (file, _("   name       : %.*s\n"),
5839                      egst->namlng, egst->name);
5840           }
5841           break;
5842         case EGSD__C_SYMV:
5843           {
5844             struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5845             unsigned int flags = bfd_getl16 (esdfv->flags);
5846
5847             fprintf (file, _("SYMV - Vectored symbol definition\n"));
5848             fprintf (file, _("   flags: 0x%04x"), flags);
5849             exav_bfd_print_egsy_flags (flags, file);
5850             fputc ('\n', file);
5851             fprintf (file, _("   vector      : 0x%08x\n"),
5852                      (unsigned)bfd_getl32 (esdfv->vector));
5853             fprintf (file, _("   psect offset: %u\n"),
5854                      (unsigned)bfd_getl32 (esdfv->value));
5855             fprintf (file, _("   psect index : %u\n"),
5856                      (unsigned)bfd_getl32 (esdfv->psindx));
5857             fprintf (file, _("   name        : %.*s\n"),
5858                      esdfv->namlng, esdfv->name);
5859           }
5860           break;
5861         case EGSD__C_SYMM:
5862           {
5863             struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5864             unsigned int flags = bfd_getl16 (esdfm->flags);
5865
5866             fprintf (file, _("SYMM - Global symbol definition with version\n"));
5867             fprintf (file, _("   flags: 0x%04x"), flags);
5868             exav_bfd_print_egsy_flags (flags, file);
5869             fputc ('\n', file);
5870             fprintf (file, _("   version mask: 0x%08x\n"),
5871                      (unsigned)bfd_getl32 (esdfm->version_mask));
5872             fprintf (file, _("   psect offset: %u\n"),
5873                      (unsigned)bfd_getl32 (esdfm->value));
5874             fprintf (file, _("   psect index : %u\n"),
5875                      (unsigned)bfd_getl32 (esdfm->psindx));
5876             fprintf (file, _("   name        : %.*s\n"),
5877                      esdfm->namlng, esdfm->name);
5878           }
5879           break;
5880         default:
5881           fprintf (file, _("unhandled egsd entry type %u\n"), type);
5882           break;
5883         }
5884       off += len;
5885     }
5886 }
5887
5888 static void
5889 evax_bfd_print_hex (FILE *file, const char *pfx,
5890                     const unsigned char *buf, unsigned int len)
5891 {
5892   unsigned int i;
5893   unsigned int n;
5894
5895   n = 0;
5896   for (i = 0; i < len; i++)
5897     {
5898       if (n == 0)
5899         fputs (pfx, file);
5900       fprintf (file, " %02x", buf[i]);
5901       n++;
5902       if (n == 16)
5903         {
5904           n = 0;
5905           fputc ('\n', file);
5906         }
5907     }
5908   if (n != 0)
5909     fputc ('\n', file);
5910 }
5911
5912 static void
5913 evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
5914 {
5915   fprintf (file, _("    linkage index: %u, replacement insn: 0x%08x\n"),
5916            (unsigned)bfd_getl32 (buf),
5917            (unsigned)bfd_getl32 (buf + 16));
5918   fprintf (file, _("    psect idx 1: %u, offset 1: 0x%08x %08x\n"),
5919            (unsigned)bfd_getl32 (buf + 4),
5920            (unsigned)bfd_getl32 (buf + 12),
5921            (unsigned)bfd_getl32 (buf + 8));
5922   fprintf (file, _("    psect idx 2: %u, offset 2: 0x%08x %08x\n"),
5923            (unsigned)bfd_getl32 (buf + 20),
5924            (unsigned)bfd_getl32 (buf + 28),
5925            (unsigned)bfd_getl32 (buf + 24));
5926   if (is_ps)
5927     fprintf (file, _("    psect idx 3: %u, offset 3: 0x%08x %08x\n"),
5928              (unsigned)bfd_getl32 (buf + 32),
5929              (unsigned)bfd_getl32 (buf + 40),
5930              (unsigned)bfd_getl32 (buf + 36));
5931   else
5932     fprintf (file, _("    global name: %.*s\n"), buf[32], buf + 33);
5933 }
5934
5935 static void
5936 evax_bfd_print_etir (FILE *file, const char *name,
5937                      unsigned char *rec, unsigned int rec_len)
5938 {
5939   unsigned int off = sizeof (struct vms_egsd);
5940   unsigned int sec_len = 0;
5941
5942   fprintf (file, _("  %s (len=%u+%u):\n"), name,
5943            (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
5944            (unsigned)sizeof (struct vms_eobjrec));
5945
5946   for (off = sizeof (struct vms_eobjrec); off < rec_len; )
5947     {
5948       struct vms_etir *etir = (struct vms_etir *)(rec + off);
5949       unsigned char *buf;
5950       unsigned int type;
5951       unsigned int size;
5952
5953       type = bfd_getl16 (etir->rectyp);
5954       size = bfd_getl16 (etir->size);
5955       buf = rec + off + sizeof (struct vms_etir);
5956
5957       fprintf (file, _("   (type: %3u, size: 4+%3u): "), type, size - 4);
5958       switch (type)
5959         {
5960         case ETIR__C_STA_GBL:
5961           fprintf (file, _("STA_GBL (stack global) %.*s\n"),
5962                    buf[0], buf + 1);
5963           break;
5964         case ETIR__C_STA_LW:
5965           fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
5966                    (unsigned)bfd_getl32 (buf));
5967           break;
5968         case ETIR__C_STA_QW:
5969           fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
5970                    (unsigned)bfd_getl32 (buf + 4),
5971                    (unsigned)bfd_getl32 (buf + 0));
5972           break;
5973         case ETIR__C_STA_PQ:
5974           fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
5975           fprintf (file, _("    psect: %u, offset: 0x%08x %08x\n"),
5976                    (unsigned)bfd_getl32 (buf + 0),
5977                    (unsigned)bfd_getl32 (buf + 8),
5978                    (unsigned)bfd_getl32 (buf + 4));
5979           break;
5980         case ETIR__C_STA_LI:
5981           fprintf (file, _("STA_LI (stack literal)\n"));
5982           break;
5983         case ETIR__C_STA_MOD:
5984           fprintf (file, _("STA_MOD (stack module)\n"));
5985           break;
5986         case ETIR__C_STA_CKARG:
5987           fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
5988           break;
5989
5990         case ETIR__C_STO_B:
5991           fprintf (file, _("STO_B (store byte)\n"));
5992           break;
5993         case ETIR__C_STO_W:
5994           fprintf (file, _("STO_W (store word)\n"));
5995           break;
5996         case ETIR__C_STO_LW:
5997           fprintf (file, _("STO_LW (store longword)\n"));
5998           break;
5999         case ETIR__C_STO_QW:
6000           fprintf (file, _("STO_QW (store quadword)\n"));
6001           break;
6002         case ETIR__C_STO_IMMR:
6003           {
6004             unsigned int len = bfd_getl32 (buf);
6005             fprintf (file,
6006                      _("STO_IMMR (store immediate repeat) %u bytes\n"),
6007                      len);
6008             evax_bfd_print_hex (file, "   ", buf + 4, len);
6009             sec_len += len;
6010           }
6011           break;
6012         case ETIR__C_STO_GBL:
6013           fprintf (file, _("STO_GBL (store global) %.*s\n"),
6014                    buf[0], buf + 1);
6015           break;
6016         case ETIR__C_STO_CA:
6017           fprintf (file, _("STO_CA (store code address) %.*s\n"),
6018                    buf[0], buf + 1);
6019           break;
6020         case ETIR__C_STO_RB:
6021           fprintf (file, _("STO_RB (store relative branch)\n"));
6022           break;
6023         case ETIR__C_STO_AB:
6024           fprintf (file, _("STO_AB (store absolute branch)\n"));
6025           break;
6026         case ETIR__C_STO_OFF:
6027           fprintf (file, _("STO_OFF (store offset to psect)\n"));
6028           break;
6029         case ETIR__C_STO_IMM:
6030           {
6031             unsigned int len = bfd_getl32 (buf);
6032             fprintf (file,
6033                      _("STO_IMM (store immediate) %u bytes\n"),
6034                      len);
6035             evax_bfd_print_hex (file, "   ", buf + 4, len);
6036             sec_len += len;
6037           }
6038           break;
6039         case ETIR__C_STO_GBL_LW:
6040           fprintf (file, _("STO_GBL_LW (store global longword) %.*s\n"),
6041                    buf[0], buf + 1);
6042           break;
6043         case ETIR__C_STO_LP_PSB:
6044           fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6045           break;
6046         case ETIR__C_STO_HINT_GBL:
6047           fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6048           break;
6049         case ETIR__C_STO_HINT_PS:
6050           fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6051           break;
6052
6053         case ETIR__C_OPR_NOP:
6054           fprintf (file, _("OPR_NOP (no-operation)\n"));
6055           break;
6056         case ETIR__C_OPR_ADD:
6057           fprintf (file, _("OPR_ADD (add)\n"));
6058           break;
6059         case ETIR__C_OPR_SUB:
6060           fprintf (file, _("OPR_SUB (substract)\n"));
6061           break;
6062         case ETIR__C_OPR_MUL:
6063           fprintf (file, _("OPR_MUL (multiply)\n"));
6064           break;
6065         case ETIR__C_OPR_DIV:
6066           fprintf (file, _("OPR_DIV (divide)\n"));
6067           break;
6068         case ETIR__C_OPR_AND:
6069           fprintf (file, _("OPR_AND (logical and)\n"));
6070           break;
6071         case ETIR__C_OPR_IOR:
6072           fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6073           break;
6074         case ETIR__C_OPR_EOR:
6075           fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6076           break;
6077         case ETIR__C_OPR_NEG:
6078           fprintf (file, _("OPR_NEG (negate)\n"));
6079           break;
6080         case ETIR__C_OPR_COM:
6081           fprintf (file, _("OPR_COM (complement)\n"));
6082           break;
6083         case ETIR__C_OPR_INSV:
6084           fprintf (file, _("OPR_INSV (insert field)\n"));
6085           break;
6086         case ETIR__C_OPR_ASH:
6087           fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6088           break;
6089         case ETIR__C_OPR_USH:
6090           fprintf (file, _("OPR_USH (unsigned shift)\n"));
6091           break;
6092         case ETIR__C_OPR_ROT:
6093           fprintf (file, _("OPR_ROT (rotate)\n"));
6094           break;
6095         case ETIR__C_OPR_SEL:
6096           fprintf (file, _("OPR_SEL (select)\n"));
6097           break;
6098         case ETIR__C_OPR_REDEF:
6099           fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6100           break;
6101         case ETIR__C_OPR_DFLIT:
6102           fprintf (file, _("OPR_REDEF (define a literal)\n"));
6103           break;
6104
6105         case ETIR__C_STC_LP:
6106           fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6107           break;
6108         case ETIR__C_STC_LP_PSB:
6109           fprintf (file,
6110                    _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6111           fprintf (file, _("   linkage index: %u, procedure: %.*s\n"),
6112                    (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6113           buf += 4 + 1 + buf[4];
6114           fprintf (file, _("   signature: %.*s\n"), buf[0], buf + 1);
6115           break;
6116         case ETIR__C_STC_GBL:
6117           fprintf (file, _("STC_GBL (store cond global)\n"));
6118           fprintf (file, _("   linkage index: %u, global: %.*s\n"),
6119                    (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6120           break;
6121         case ETIR__C_STC_GCA:
6122           fprintf (file, _("STC_GCA (store cond code address)\n"));
6123           fprintf (file, _("   linkage index: %u, procedure name: %.*s\n"),
6124                    (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6125           break;
6126         case ETIR__C_STC_PS:
6127           fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6128           fprintf (file,
6129                    _("   linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6130                    (unsigned)bfd_getl32 (buf),
6131                    (unsigned)bfd_getl32 (buf + 4),
6132                    (unsigned)bfd_getl32 (buf + 12),
6133                    (unsigned)bfd_getl32 (buf + 8));
6134           break;
6135         case ETIR__C_STC_NOP_GBL:
6136           fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6137           evax_bfd_print_etir_stc_ir (file, buf, 0);
6138           break;
6139         case ETIR__C_STC_NOP_PS:
6140           fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6141           evax_bfd_print_etir_stc_ir (file, buf, 1);
6142           break;
6143         case ETIR__C_STC_BSR_GBL:
6144           fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6145           evax_bfd_print_etir_stc_ir (file, buf, 0);
6146           break;
6147         case ETIR__C_STC_BSR_PS:
6148           fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6149           evax_bfd_print_etir_stc_ir (file, buf, 1);
6150           break;
6151         case ETIR__C_STC_LDA_GBL:
6152           fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6153           evax_bfd_print_etir_stc_ir (file, buf, 0);
6154           break;
6155         case ETIR__C_STC_LDA_PS:
6156           fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6157           evax_bfd_print_etir_stc_ir (file, buf, 1);
6158           break;
6159         case ETIR__C_STC_BOH_GBL:
6160           fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6161           evax_bfd_print_etir_stc_ir (file, buf, 0);
6162           break;
6163         case ETIR__C_STC_BOH_PS:
6164           fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6165           evax_bfd_print_etir_stc_ir (file, buf, 1);
6166           break;
6167         case ETIR__C_STC_NBH_GBL:
6168           fprintf (file,
6169                    _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6170           break;
6171         case ETIR__C_STC_NBH_PS:
6172           fprintf (file,
6173                    _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6174           break;
6175
6176         case ETIR__C_CTL_SETRB:
6177           fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6178           sec_len += 4;
6179           break;
6180         case ETIR__C_CTL_AUGRB:
6181           {
6182             unsigned int val = bfd_getl32 (buf);
6183             fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6184           }
6185           break;
6186         case ETIR__C_CTL_DFLOC:
6187           fprintf (file, _("CTL_DFLOC (define location)\n"));
6188           break;
6189         case ETIR__C_CTL_STLOC:
6190           fprintf (file, _("CTL_STLOC (set location)\n"));
6191           break;
6192         case ETIR__C_CTL_STKDL:
6193           fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6194           break;
6195         default:
6196           fprintf (file, _("*unhandled*\n"));
6197           break;
6198         }
6199       off += size;
6200     }
6201 }
6202
6203 static void
6204 evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6205 {
6206   bfd_boolean is_first = TRUE;
6207   bfd_boolean has_records = FALSE;
6208
6209   while (1)
6210     {
6211       unsigned int rec_len;
6212       unsigned int pad_len;
6213       unsigned char *rec;
6214       unsigned int hdr_size;
6215       unsigned int type;
6216
6217       if (is_first)
6218         {
6219           unsigned char buf[6];
6220
6221           is_first = FALSE;
6222
6223           /* Read 6 bytes.  */
6224           if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6225             {
6226               fprintf (file, _("cannot read GST record length\n"));
6227               return;
6228             }
6229           rec_len = bfd_getl16 (buf + 0);
6230           if (rec_len == bfd_getl16 (buf + 4)
6231               && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6232             {
6233               /* The format is raw: record-size, type, record-size.  */
6234               has_records = TRUE;
6235               pad_len = (rec_len + 1) & ~1U;
6236               hdr_size = 4;
6237             }
6238           else if (rec_len == EOBJ__C_EMH)
6239             {
6240               has_records = FALSE;
6241               pad_len = bfd_getl16 (buf + 2);
6242               hdr_size = 6;
6243             }
6244           else
6245             {
6246               /* Ill-formed.  */
6247               fprintf (file, _("cannot find EMH in first GST record\n"));
6248               return;
6249             }
6250           rec = bfd_malloc (pad_len);
6251           memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6252         }
6253       else
6254         {
6255           unsigned int rec_len2 = 0;
6256           unsigned char hdr[4];
6257
6258           if (has_records)
6259             {
6260               unsigned char buf_len[2];
6261
6262               if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6263                   != sizeof (buf_len))
6264                 {
6265                   fprintf (file, _("cannot read GST record length\n"));
6266                   return;
6267                 }
6268               rec_len2 = (unsigned)bfd_getl16 (buf_len);
6269             }
6270
6271           if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6272             {
6273               fprintf (file, _("cannot read GST record header\n"));
6274               return;
6275             }
6276           rec_len = (unsigned)bfd_getl16 (hdr + 2);
6277           if (has_records)
6278             pad_len = (rec_len + 1) & ~1U;
6279           else
6280             pad_len = rec_len;
6281           rec = bfd_malloc (pad_len);
6282           memcpy (rec, hdr, sizeof (hdr));
6283           hdr_size = sizeof (hdr);
6284           if (has_records && rec_len2 != rec_len)
6285             {
6286               fprintf (file, _(" corrupted GST\n"));
6287               break;
6288             }
6289         }
6290
6291       if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6292           != pad_len - hdr_size)
6293         {
6294           fprintf (file, _("cannot read GST record\n"));
6295           return;
6296         }
6297
6298       type = (unsigned)bfd_getl16 (rec);
6299
6300       switch (type)
6301         {
6302         case EOBJ__C_EMH:
6303           evax_bfd_print_emh (file, rec, rec_len);
6304           break;
6305         case EOBJ__C_EGSD:
6306           evax_bfd_print_egsd (file, rec, rec_len);
6307           break;
6308         case EOBJ__C_EEOM:
6309           evax_bfd_print_eeom (file, rec, rec_len);
6310           free (rec);
6311           return;
6312           break;
6313         case EOBJ__C_ETIR:
6314           evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6315           break;
6316         case EOBJ__C_EDBG:
6317           evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6318           break;
6319         case EOBJ__C_ETBT:
6320           evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6321           break;
6322         default:
6323           fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6324           break;
6325         }
6326       free (rec);
6327     }
6328 }
6329
6330 static void
6331 evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6332                                    unsigned int stride)
6333 {
6334   while (1)
6335     {
6336       unsigned int base;
6337       unsigned int count;
6338       unsigned int j;
6339
6340       count = bfd_getl32 (rel + 0);
6341
6342       if (count == 0)
6343         break;
6344       base = bfd_getl32 (rel + 4);
6345
6346       fprintf (file, _("  bitcount: %u, base addr: 0x%08x\n"),
6347                count, base);
6348
6349       rel += 8;
6350       for (j = 0; count > 0; j += 4, count -= 32)
6351         {
6352           unsigned int k;
6353           unsigned int n = 0;
6354           unsigned int val;
6355
6356           val = bfd_getl32 (rel);
6357           rel += 4;
6358
6359           fprintf (file, _("   bitmap: 0x%08x (count: %u):\n"), val, count);
6360
6361           for (k = 0; k < 32; k++)
6362             if (val & (1 << k))
6363               {
6364                 if (n == 0)
6365                   fputs ("   ", file);
6366                 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6367                 n++;
6368                 if (n == 8)
6369                   {
6370                     fputs ("\n", file);
6371                     n = 0;
6372                   }
6373               }
6374           if (n)
6375             fputs ("\n", file);
6376         }
6377     }
6378 }
6379
6380 static void
6381 evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6382 {
6383   while (1)
6384     {
6385       unsigned int j;
6386       unsigned int count;
6387
6388       count = bfd_getl32 (rel + 0);
6389       if (count == 0)
6390         return;
6391       fprintf (file, _("  image %u (%u entries)\n"),
6392                (unsigned)bfd_getl32 (rel + 4), count);
6393       rel += 8;
6394       for (j = 0; j < count; j++)
6395         {
6396           fprintf (file, _("   offset: 0x%08x, val: 0x%08x\n"),
6397                    (unsigned)bfd_getl32 (rel + 0),
6398                    (unsigned)bfd_getl32 (rel + 4));
6399           rel += 8;
6400         }
6401     }
6402 }
6403
6404 static void
6405 evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6406 {
6407   unsigned int count;
6408
6409   while (1)
6410     {
6411       unsigned int j;
6412       unsigned int n = 0;
6413
6414       count = bfd_getl32 (rel + 0);
6415       if (count == 0)
6416         break;
6417       fprintf (file, _("  image %u (%u entries), offsets:\n"),
6418                (unsigned)bfd_getl32 (rel + 4), count);
6419       rel += 8;
6420       for (j = 0; j < count; j++)
6421         {
6422           if (n == 0)
6423             fputs ("   ", file);
6424           fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6425           n++;
6426           if (n == 7)
6427             {
6428               fputs ("\n", file);
6429               n = 0;
6430             }
6431           rel += 4;
6432         }
6433       if (n)
6434         fputs ("\n", file);
6435     }
6436 }
6437
6438 static void
6439 evax_bfd_print_indent (int indent, FILE *file)
6440 {
6441   for (; indent; indent--)
6442     fputc (' ', file);
6443 }
6444
6445 static const char *
6446 evax_bfd_get_dsc_name (unsigned int v)
6447 {
6448   switch (v)
6449     {
6450     case DSC__K_DTYPE_Z:
6451       return "Z (Unspecified)";
6452     case DSC__K_DTYPE_V:
6453       return "V (Bit)";
6454     case DSC__K_DTYPE_BU:
6455       return "BU (Byte logical)";
6456     case DSC__K_DTYPE_WU:
6457       return "WU (Word logical)";
6458     case DSC__K_DTYPE_LU:
6459       return "LU (Longword logical)";
6460     case DSC__K_DTYPE_QU:
6461       return "QU (Quadword logical)";
6462     case DSC__K_DTYPE_B:
6463       return "B (Byte integer)";
6464     case DSC__K_DTYPE_W:
6465       return "W (Word integer)";
6466     case DSC__K_DTYPE_L:
6467       return "L (Longword integer)";
6468     case DSC__K_DTYPE_Q:
6469       return "Q (Quadword integer)";
6470     case DSC__K_DTYPE_F:
6471       return "F (Single-precision floating)";
6472     case DSC__K_DTYPE_D:
6473       return "D (Double-precision floating)";
6474     case DSC__K_DTYPE_FC:
6475       return "FC (Complex)";
6476     case DSC__K_DTYPE_DC:
6477       return "DC (Double-precision Complex)";
6478     case DSC__K_DTYPE_T:
6479       return "T (ASCII text string)";
6480     case DSC__K_DTYPE_NU:
6481       return "NU (Numeric string, unsigned)";
6482     case DSC__K_DTYPE_NL:
6483       return "NL (Numeric string, left separate sign)";
6484     case DSC__K_DTYPE_NLO:
6485       return "NLO (Numeric string, left overpunched sign)";
6486     case DSC__K_DTYPE_NR:
6487       return "NR (Numeric string, right separate sign)";
6488     case DSC__K_DTYPE_NRO:
6489       return "NRO (Numeric string, right overpunched sig)";
6490     case DSC__K_DTYPE_NZ:
6491       return "NZ (Numeric string, zoned sign)";
6492     case DSC__K_DTYPE_P:
6493       return "P (Packed decimal string)";
6494     case DSC__K_DTYPE_ZI:
6495       return "ZI (Sequence of instructions)";
6496     case DSC__K_DTYPE_ZEM:
6497       return "ZEM (Procedure entry mask)";
6498     case DSC__K_DTYPE_DSC:
6499       return "DSC (Descriptor, used for arrays of dyn strings)";
6500     case DSC__K_DTYPE_OU:
6501       return "OU (Octaword logical)";
6502     case DSC__K_DTYPE_O:
6503       return "O (Octaword integer)";
6504     case DSC__K_DTYPE_G:
6505       return "G (Double precision G floating, 64 bit)";
6506     case DSC__K_DTYPE_H:
6507       return "H (Quadruple precision floating, 128 bit)";
6508     case DSC__K_DTYPE_GC:
6509       return "GC (Double precision complex, G floating)";
6510     case DSC__K_DTYPE_HC:
6511       return "HC (Quadruple precision complex, H floating)";
6512     case DSC__K_DTYPE_CIT:
6513       return "CIT (COBOL intermediate temporary)";
6514     case DSC__K_DTYPE_BPV:
6515       return "BPV (Bound Procedure Value)";
6516     case DSC__K_DTYPE_BLV:
6517       return "BLV (Bound Label Value)";
6518     case DSC__K_DTYPE_VU:
6519       return "VU (Bit Unaligned)";
6520     case DSC__K_DTYPE_ADT:
6521       return "ADT (Absolute Date-Time)";
6522     case DSC__K_DTYPE_VT:
6523       return "VT (Varying Text)";
6524     case DSC__K_DTYPE_T2:
6525       return "T2 (16-bit char)";
6526     case DSC__K_DTYPE_VT2:
6527       return "VT2 (16-bit varying char)";
6528     default:
6529       return "?? (unknown)";
6530     }
6531 }
6532
6533 static void
6534 evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6535 {
6536   unsigned char bclass = buf[3];
6537   unsigned char dtype = buf[2];
6538   unsigned int len = (unsigned)bfd_getl16 (buf);
6539   unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6540
6541   evax_bfd_print_indent (indent, file);
6542
6543   if (len == 1 && pointer == 0xffffffffUL)
6544     {
6545       /* 64 bits.  */
6546       fprintf (file, _("64 bits *unhandled*\n"));
6547     }
6548   else
6549     {
6550       fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6551                bclass, dtype, len, pointer);
6552       switch (bclass)
6553         {
6554         case DSC__K_CLASS_NCA:
6555           {
6556             const struct vms_dsc_nca *dsc = (const void *)buf;
6557             unsigned int i;
6558             const unsigned char *b;
6559
6560             evax_bfd_print_indent (indent, file);
6561             fprintf (file, _("non-contiguous array of %s\n"),
6562                      evax_bfd_get_dsc_name (dsc->dtype));
6563             evax_bfd_print_indent (indent + 1, file);
6564             fprintf (file,
6565                      _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6566                      dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6567             evax_bfd_print_indent (indent + 1, file);
6568             fprintf (file,
6569                      _("arsize: %u, a0: 0x%08x\n"),
6570                      (unsigned)bfd_getl32 (dsc->arsize),
6571                      (unsigned)bfd_getl32 (dsc->a0));
6572             evax_bfd_print_indent (indent + 1, file);
6573             fprintf (file, _("Strides:\n"));
6574             b = buf + sizeof (*dsc);
6575             for (i = 0; i < dsc->dimct; i++)
6576               {
6577                 evax_bfd_print_indent (indent + 2, file);
6578                 fprintf (file, _("[%u]: %u\n"), i + 1,
6579                          (unsigned)bfd_getl32 (b));
6580                 b += 4;
6581               }
6582             evax_bfd_print_indent (indent + 1, file);
6583             fprintf (file, _("Bounds:\n"));
6584             b = buf + sizeof (*dsc);
6585             for (i = 0; i < dsc->dimct; i++)
6586               {
6587                 evax_bfd_print_indent (indent + 2, file);
6588                 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6589                          (unsigned)bfd_getl32 (b + 0),
6590                          (unsigned)bfd_getl32 (b + 4));
6591                 b += 8;
6592               }
6593           }
6594           break;
6595         case DSC__K_CLASS_UBS:
6596           {
6597             const struct vms_dsc_ubs *ubs = (const void *)buf;
6598
6599             evax_bfd_print_indent (indent, file);
6600             fprintf (file, _("unaligned bit-string of %s\n"),
6601                      evax_bfd_get_dsc_name (ubs->dtype));
6602             evax_bfd_print_indent (indent + 1, file);
6603             fprintf (file,
6604                      _("base: %u, pos: %u\n"),
6605                      (unsigned)bfd_getl32 (ubs->base),
6606                      (unsigned)bfd_getl32 (ubs->pos));
6607           }
6608           break;
6609         default:
6610           fprintf (file, _("*unhandled*\n"));
6611           break;
6612         }
6613     }
6614 }
6615
6616 static unsigned int
6617 evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6618 {
6619   unsigned int vflags = buf[0];
6620   unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6621   unsigned int len = 5;
6622
6623   evax_bfd_print_indent (indent, file);
6624   fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6625   buf += 5;
6626
6627   switch (vflags)
6628     {
6629     case DST__K_VFLAGS_NOVAL:
6630       fprintf (file, _("(no value)\n"));
6631       break;
6632     case DST__K_VFLAGS_NOTACTIVE:
6633       fprintf (file, _("(not active)\n"));
6634       break;
6635     case DST__K_VFLAGS_UNALLOC:
6636       fprintf (file, _("(not allocated)\n"));
6637       break;
6638     case DST__K_VFLAGS_DSC:
6639       fprintf (file, _("(descriptor)\n"));
6640       evax_bfd_print_desc (buf + value, indent + 1, file);
6641       break;
6642     case DST__K_VFLAGS_TVS:
6643       fprintf (file, _("(trailing value)\n"));
6644       break;
6645     case DST__K_VS_FOLLOWS:
6646       fprintf (file, _("(value spec follows)\n"));
6647       break;
6648     case DST__K_VFLAGS_BITOFFS:
6649       fprintf (file, _("(at bit offset %u)\n"), value);
6650       break;
6651     default:
6652       fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6653                (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6654                vflags & DST__K_DISP ? 1 : 0,
6655                vflags & DST__K_INDIR ? 1 : 0);
6656       switch (vflags & DST__K_VALKIND_MASK)
6657         {
6658         case DST__K_VALKIND_LITERAL:
6659           fputs (_("literal"), file);
6660           break;
6661         case DST__K_VALKIND_ADDR:
6662           fputs (_("address"), file);
6663           break;
6664         case DST__K_VALKIND_DESC:
6665           fputs (_("desc"), file);
6666           break;
6667         case DST__K_VALKIND_REG:
6668           fputs (_("reg"), file);
6669           break;
6670         }
6671       fputs (")\n", file);
6672       break;
6673     }
6674   return len;
6675 }
6676
6677 static void
6678 evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6679 {
6680   unsigned char kind = buf[2];
6681   unsigned int len = (unsigned)bfd_getl16 (buf);
6682
6683   evax_bfd_print_indent (indent, file);
6684   fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6685   buf += 3;
6686   switch (kind)
6687     {
6688     case DST__K_TS_ATOM:
6689       fprintf (file, ("atomic, type=0x%02x %s\n"),
6690                buf[0], evax_bfd_get_dsc_name (buf[0]));
6691       break;
6692     case DST__K_TS_IND:
6693       fprintf (file, ("indirect, defined at 0x%08x\n"),
6694                (unsigned)bfd_getl32 (buf));
6695       break;
6696     case DST__K_TS_TPTR:
6697       fprintf (file, ("typed pointer\n"));
6698       evax_bfd_print_typspec (buf, indent + 1, file);
6699       break;
6700     case DST__K_TS_PTR:
6701       fprintf (file, ("pointer\n"));
6702       break;
6703     case DST__K_TS_ARRAY:
6704       {
6705         const unsigned char *vs;
6706         unsigned int vec_len;
6707         unsigned int i;
6708
6709         fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6710         vec_len = (buf[0] + 1 + 7) / 8;
6711         for (i = 0; i < vec_len; i++)
6712           fprintf (file, " %02x", buf[i + 1]);
6713         fputc ('\n', file);
6714         vs = buf + 1 + vec_len;
6715         evax_bfd_print_indent (indent, file);
6716         fprintf (file, ("array descriptor:\n"));
6717         vs += evax_bfd_print_valspec (vs, indent + 1, file);
6718         for (i = 0; i < buf[0] + 1U; i++)
6719           if (buf[1 + i / 8] & (1 << (i % 8)))
6720             {
6721               evax_bfd_print_indent (indent, file);
6722               if (i == 0)
6723                 fprintf (file, ("type spec for element:\n"));
6724               else
6725                 fprintf (file, ("type spec for subscript %u:\n"), i);
6726               evax_bfd_print_typspec (vs, indent + 1, file);
6727               vs += bfd_getl16 (vs);
6728             }
6729       }
6730       break;
6731     default:
6732       fprintf (file, ("*unhandled*\n"));
6733     }
6734 }
6735
6736 static void
6737 evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6738 {
6739   unsigned int off = 0;
6740   unsigned int pc = 0;
6741   unsigned int line = 0;
6742
6743   fprintf (file, _("Debug symbol table:\n"));
6744
6745   while (dst_size > 0)
6746     {
6747       struct vms_dst_header dsth;
6748       unsigned int len;
6749       unsigned int type;
6750       unsigned char *buf;
6751
6752       if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6753         {
6754           fprintf (file, _("cannot read DST header\n"));
6755           return;
6756         }
6757       len = bfd_getl16 (dsth.length);
6758       type = bfd_getl16 (dsth.type);
6759       fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6760                type, len, off);
6761       if (len == 0)
6762         {
6763           fputc ('\n', file);
6764           break;
6765         }
6766       len++;
6767       dst_size -= len;
6768       off += len;
6769       len -= sizeof (dsth);
6770       buf = bfd_malloc (len);
6771       if (bfd_bread (buf, len, abfd) != len)
6772         {
6773           fprintf (file, _("cannot read DST symbol\n"));
6774           return;
6775         }
6776       switch (type)
6777         {
6778         case DSC__K_DTYPE_V:
6779         case DSC__K_DTYPE_BU:
6780         case DSC__K_DTYPE_WU:
6781         case DSC__K_DTYPE_LU:
6782         case DSC__K_DTYPE_QU:
6783         case DSC__K_DTYPE_B:
6784         case DSC__K_DTYPE_W:
6785         case DSC__K_DTYPE_L:
6786         case DSC__K_DTYPE_Q:
6787         case DSC__K_DTYPE_F:
6788         case DSC__K_DTYPE_D:
6789         case DSC__K_DTYPE_FC:
6790         case DSC__K_DTYPE_DC:
6791         case DSC__K_DTYPE_T:
6792         case DSC__K_DTYPE_NU:
6793         case DSC__K_DTYPE_NL:
6794         case DSC__K_DTYPE_NLO:
6795         case DSC__K_DTYPE_NR:
6796         case DSC__K_DTYPE_NRO:
6797         case DSC__K_DTYPE_NZ:
6798         case DSC__K_DTYPE_P:
6799         case DSC__K_DTYPE_ZI:
6800         case DSC__K_DTYPE_ZEM:
6801         case DSC__K_DTYPE_DSC:
6802         case DSC__K_DTYPE_OU:
6803         case DSC__K_DTYPE_O:
6804         case DSC__K_DTYPE_G:
6805         case DSC__K_DTYPE_H:
6806         case DSC__K_DTYPE_GC:
6807         case DSC__K_DTYPE_HC:
6808         case DSC__K_DTYPE_CIT:
6809         case DSC__K_DTYPE_BPV:
6810         case DSC__K_DTYPE_BLV:
6811         case DSC__K_DTYPE_VU:
6812         case DSC__K_DTYPE_ADT:
6813         case DSC__K_DTYPE_VT:
6814         case DSC__K_DTYPE_T2:
6815         case DSC__K_DTYPE_VT2:
6816           fprintf (file, _("standard data: %s\n"),
6817                    evax_bfd_get_dsc_name (type));
6818           evax_bfd_print_valspec (buf, 4, file);
6819           fprintf (file, _("    name: %.*s\n"), buf[5], buf + 6);
6820           break;
6821         case DST__K_MODBEG:
6822           {
6823             struct vms_dst_modbeg *dst = (void *)buf;
6824             const char *name = (const char *)buf + sizeof (*dst);
6825
6826             fprintf (file, _("modbeg\n"));
6827             fprintf (file, _("   flags: %d, language: %u, "
6828                              "major: %u, minor: %u\n"),
6829                      dst->flags,
6830                      (unsigned)bfd_getl32 (dst->language),
6831                      (unsigned)bfd_getl16 (dst->major),
6832                      (unsigned)bfd_getl16 (dst->minor));
6833             fprintf (file, _("   module name: %.*s\n"),
6834                      name[0], name + 1);
6835             name += name[0] + 1;
6836             fprintf (file, _("   compiler   : %.*s\n"),
6837                      name[0], name + 1);
6838           }
6839           break;
6840         case DST__K_MODEND:
6841           fprintf (file, _("modend\n"));
6842           break;
6843         case DST__K_RTNBEG:
6844           {
6845             struct vms_dst_rtnbeg *dst = (void *)buf;
6846             const char *name = (const char *)buf + sizeof (*dst);
6847
6848             fputs (_("rtnbeg\n"), file);
6849             fprintf (file, _("    flags: %u, address: 0x%08x, "
6850                              "pd-address: 0x%08x\n"),
6851                      dst->flags,
6852                      (unsigned)bfd_getl32 (dst->address),
6853                      (unsigned)bfd_getl32 (dst->pd_address));
6854             fprintf (file, _("    routine name: %.*s\n"),
6855                      name[0], name + 1);
6856           }
6857           break;
6858         case DST__K_RTNEND:
6859           {
6860             struct vms_dst_rtnend *dst = (void *)buf;
6861
6862             fprintf (file, _("rtnend: size 0x%08x\n"),
6863                      (unsigned)bfd_getl32 (dst->size));
6864           }
6865           break;
6866         case DST__K_PROLOG:
6867           {
6868             struct vms_dst_prolog *dst = (void *)buf;
6869
6870             fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6871                      (unsigned)bfd_getl32 (dst->bkpt_addr));
6872           }
6873           break;
6874         case DST__K_EPILOG:
6875           {
6876             struct vms_dst_epilog *dst = (void *)buf;
6877
6878             fprintf (file, _("epilog: flags: %u, count: %u\n"),
6879                      dst->flags, (unsigned)bfd_getl32 (dst->count));
6880           }
6881           break;
6882         case DST__K_BLKBEG:
6883           {
6884             struct vms_dst_blkbeg *dst = (void *)buf;
6885             const char *name = (const char *)buf + sizeof (*dst);
6886
6887             fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6888                      (unsigned)bfd_getl32 (dst->address),
6889                      name[0], name + 1);
6890           }
6891           break;
6892         case DST__K_BLKEND:
6893           {
6894             struct vms_dst_blkend *dst = (void *)buf;
6895
6896             fprintf (file, _("blkend: size: 0x%08x\n"),
6897                      (unsigned)bfd_getl32 (dst->size));
6898           }
6899           break;
6900         case DST__K_TYPSPEC:
6901           {
6902             fprintf (file, _("typspec (len: %u)\n"), len);
6903             fprintf (file, _("    name: %.*s\n"), buf[0], buf + 1);
6904             evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
6905           }
6906           break;
6907         case DST__K_SEPTYP:
6908           {
6909             fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
6910             evax_bfd_print_valspec (buf, 4, file);
6911           }
6912           break;
6913         case DST__K_RECBEG:
6914           {
6915             struct vms_dst_recbeg *recbeg = (void *)buf;
6916             const char *name = (const char *)buf + sizeof (*recbeg);
6917
6918             fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
6919             evax_bfd_print_valspec (buf, 4, file);
6920             fprintf (file, ("    len: %u bits\n"),
6921                      (unsigned)bfd_getl32 (name + 1 + name[0]));
6922           }
6923           break;
6924         case DST__K_RECEND:
6925           fprintf (file, _("recend\n"));
6926           break;
6927         case DST__K_ENUMBEG:
6928           fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
6929                    buf[0], buf[1], buf + 2);
6930           break;
6931         case DST__K_ENUMELT:
6932           fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
6933           evax_bfd_print_valspec (buf, 4, file);
6934           break;
6935         case DST__K_ENUMEND:
6936           fprintf (file, _("enumend\n"));
6937           break;
6938         case DST__K_LABEL:
6939           {
6940             struct vms_dst_label *lab = (void *)buf;
6941             fprintf (file, ("label, name: %.*s\n"),
6942                      lab->name[0], lab->name + 1);
6943             fprintf (file, ("    address: 0x%08x\n"),
6944                      (unsigned)bfd_getl32 (lab->value));
6945           }
6946           break;
6947         case DST__K_DIS_RANGE:
6948           {
6949             unsigned int cnt = bfd_getl32 (buf);
6950             unsigned char *rng = buf + 4;
6951             unsigned int i;
6952
6953             fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
6954             for (i = 0; i < cnt; i++, rng += 8)
6955               fprintf (file, _("    address: 0x%08x, size: %u\n"),
6956                        (unsigned)bfd_getl32 (rng),
6957                        (unsigned)bfd_getl32 (rng + 4));
6958
6959           }
6960           break;
6961         case DST__K_LINE_NUM:
6962           {
6963             unsigned char *buf_orig = buf;
6964
6965             fprintf (file, _("line num  (len: %u)\n"), len);
6966
6967             while (len > 0)
6968               {
6969                 signed char cmd;
6970                 unsigned char cmdlen;
6971                 unsigned int val;
6972
6973                 cmd = buf[0];
6974                 cmdlen = 0;
6975
6976                 fputs ("    ", file);
6977
6978                 switch (cmd)
6979                   {
6980                   case DST__K_DELTA_PC_W:
6981                     val = bfd_getl16 (buf + 1);
6982                     fprintf (file, _("delta_pc_w %u\n"), val);
6983                     pc += val;
6984                     line++;
6985                     cmdlen = 3;
6986                     break;
6987                   case DST__K_INCR_LINUM:
6988                     val = buf[1];
6989                     fprintf (file, _("incr_linum(b): +%u\n"), val);
6990                     line += val;
6991                     cmdlen = 2;
6992                     break;
6993                   case DST__K_INCR_LINUM_W:
6994                     val = bfd_getl16 (buf + 1);
6995                     fprintf (file, _("incr_linum_w: +%u\n"), val);
6996                     line += val;
6997                     cmdlen = 3;
6998                     break;
6999                   case DST__K_INCR_LINUM_L:
7000                     val = bfd_getl32 (buf + 1);
7001                     fprintf (file, _("incr_linum_l: +%u\n"), val);
7002                     line += val;
7003                     cmdlen = 5;
7004                     break;
7005                   case DST__K_SET_LINUM:
7006                     line = bfd_getl16 (buf + 1);
7007                     fprintf (file, _("set_line_num(w) %u\n"), line);
7008                     cmdlen = 3;
7009                     break;
7010                   case DST__K_SET_LINUM_B:
7011                     line = buf[1];
7012                     fprintf (file, _("set_line_num_b %u\n"), line);
7013                     cmdlen = 2;
7014                     break;
7015                   case DST__K_SET_LINUM_L:
7016                     line = bfd_getl32 (buf + 1);
7017                     fprintf (file, _("set_line_num_l %u\n"), line);
7018                     cmdlen = 5;
7019                     break;
7020                   case DST__K_SET_ABS_PC:
7021                     pc = bfd_getl32 (buf + 1);
7022                     fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7023                     cmdlen = 5;
7024                     break;
7025                   case DST__K_DELTA_PC_L:
7026                     fprintf (file, _("delta_pc_l: +0x%08x\n"),
7027                              (unsigned)bfd_getl32 (buf + 1));
7028                     cmdlen = 5;
7029                     break;
7030                   case DST__K_TERM:
7031                     fprintf (file, _("term(b): 0x%02x"), buf[1]);
7032                     pc += buf[1];
7033                     fprintf (file, _("        pc: 0x%08x\n"), pc);
7034                     cmdlen = 2;
7035                     break;
7036                   case DST__K_TERM_W:
7037                     val = bfd_getl16 (buf + 1);
7038                     fprintf (file, _("term_w: 0x%04x"), val);
7039                     pc += val;
7040                     fprintf (file, _("    pc: 0x%08x\n"), pc);
7041                     cmdlen = 3;
7042                     break;
7043                   default:
7044                     if (cmd <= 0)
7045                       {
7046                         fprintf (file, _("delta pc +%-4d"), -cmd);
7047                         line++;  /* FIXME: curr increment.  */
7048                         pc += -cmd;
7049                         fprintf (file, _("    pc: 0x%08x line: %5u\n"),
7050                                  pc, line);
7051                         cmdlen = 1;
7052                       }
7053                     else
7054                       fprintf (file, _("    *unhandled* cmd %u\n"), cmd);
7055                     break;
7056                   }
7057                 if (cmdlen == 0)
7058                   break;
7059                 len -= cmdlen;
7060                 buf += cmdlen;
7061               }
7062             buf = buf_orig;
7063           }
7064           break;
7065         case DST__K_SOURCE:
7066           {
7067             unsigned char *buf_orig = buf;
7068
7069             fprintf (file, _("source (len: %u)\n"), len);
7070
7071             while (len > 0)
7072               {
7073                 signed char cmd = buf[0];
7074                 unsigned char cmdlen = 0;
7075
7076                 switch (cmd)
7077                   {
7078                   case DST__K_SRC_DECLFILE:
7079                     {
7080                       struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7081                       const char *name;
7082
7083                       fprintf (file, _("   declfile: len: %u, flags: %u, "
7084                                        "fileid: %u\n"),
7085                                src->length, src->flags,
7086                                (unsigned)bfd_getl16 (src->fileid));
7087                       fprintf (file, _("   rms: cdt: 0x%08x %08x, "
7088                                        "ebk: 0x%08x, ffb: 0x%04x, "
7089                                        "rfo: %u\n"),
7090                                (unsigned)bfd_getl32 (src->rms_cdt + 4),
7091                                (unsigned)bfd_getl32 (src->rms_cdt + 0),
7092                                (unsigned)bfd_getl32 (src->rms_ebk),
7093                                (unsigned)bfd_getl16 (src->rms_ffb),
7094                                src->rms_rfo);
7095                       name = (const char *)buf + 1 + sizeof (*src);
7096                       fprintf (file, _("   filename   : %.*s\n"),
7097                                name[0], name + 1);
7098                       name += name[0] + 1;
7099                       fprintf (file, _("   module name: %.*s\n"),
7100                                name[0], name + 1);
7101                       cmdlen = 2 + src->length;
7102                     }
7103                     break;
7104                   case DST__K_SRC_SETFILE:
7105                     fprintf (file, _("   setfile %u\n"),
7106                              (unsigned)bfd_getl16 (buf + 1));
7107                     cmdlen = 3;
7108                     break;
7109                   case DST__K_SRC_SETREC_W:
7110                     fprintf (file, _("   setrec %u\n"),
7111                              (unsigned)bfd_getl16 (buf + 1));
7112                     cmdlen = 3;
7113                     break;
7114                   case DST__K_SRC_SETREC_L:
7115                     fprintf (file, _("   setrec %u\n"),
7116                              (unsigned)bfd_getl32 (buf + 1));
7117                     cmdlen = 5;
7118                     break;
7119                   case DST__K_SRC_SETLNUM_W:
7120                     fprintf (file, _("   setlnum %u\n"),
7121                              (unsigned)bfd_getl16 (buf + 1));
7122                     cmdlen = 3;
7123                     break;
7124                   case DST__K_SRC_SETLNUM_L:
7125                     fprintf (file, _("   setlnum %u\n"),
7126                              (unsigned)bfd_getl32 (buf + 1));
7127                     cmdlen = 5;
7128                     break;
7129                   case DST__K_SRC_DEFLINES_W:
7130                     fprintf (file, _("   deflines %u\n"),
7131                              (unsigned)bfd_getl16 (buf + 1));
7132                     cmdlen = 3;
7133                     break;
7134                   case DST__K_SRC_DEFLINES_B:
7135                     fprintf (file, _("   deflines %u\n"), buf[1]);
7136                     cmdlen = 2;
7137                     break;
7138                   case DST__K_SRC_FORMFEED:
7139                     fprintf (file, _("   formfeed\n"));
7140                     cmdlen = 1;
7141                     break;
7142                   default:
7143                     fprintf (file, _("   *unhandled* cmd %u\n"), cmd);
7144                     break;
7145                   }
7146                 if (cmdlen == 0)
7147                   break;
7148                 len -= cmdlen;
7149                 buf += cmdlen;
7150               }
7151             buf = buf_orig;
7152           }
7153           break;
7154         default:
7155           fprintf (file, _("*unhandled* dst type %u\n"), type);
7156           break;
7157         }
7158       free (buf);
7159     }
7160 }
7161
7162 static void
7163 evax_bfd_print_image (bfd *abfd, FILE *file)
7164 {
7165   struct vms_eihd eihd;
7166   const char *name;
7167   unsigned int val;
7168   unsigned int eiha_off;
7169   unsigned int eihi_off;
7170   unsigned int eihs_off;
7171   unsigned int eisd_off;
7172   unsigned int eihef_off = 0;
7173   unsigned int eihnp_off = 0;
7174   unsigned int dmt_vbn = 0;
7175   unsigned int dmt_size = 0;
7176   unsigned int dst_vbn = 0;
7177   unsigned int dst_size = 0;
7178   unsigned int gst_vbn = 0;
7179   unsigned int gst_size = 0;
7180   unsigned int eiaf_vbn = 0;
7181   unsigned int eiaf_size = 0;
7182   unsigned int eihvn_off;
7183
7184   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7185       || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7186     {
7187       fprintf (file, _("cannot read EIHD\n"));
7188       return;
7189     }
7190   fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7191            (unsigned)bfd_getl32 (eihd.size),
7192            (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7193   fprintf (file, _(" majorid: %u, minorid: %u\n"),
7194            (unsigned)bfd_getl32 (eihd.majorid),
7195            (unsigned)bfd_getl32 (eihd.minorid));
7196
7197   val = (unsigned)bfd_getl32 (eihd.imgtype);
7198   switch (val)
7199     {
7200     case EIHD__K_EXE:
7201       name = _("executable");
7202       break;
7203     case EIHD__K_LIM:
7204       name = _("linkable image");
7205       break;
7206     default:
7207       name = _("unknown");
7208       break;
7209     }
7210   fprintf (file, _(" image type: %u (%s)"), val, name);
7211
7212   val = (unsigned)bfd_getl32 (eihd.subtype);
7213   switch (val)
7214     {
7215     case EIHD__C_NATIVE:
7216       name = _("native");
7217       break;
7218     case EIHD__C_CLI:
7219       name = _("CLI");
7220       break;
7221     default:
7222       name = _("unknown");
7223       break;
7224     }
7225   fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7226
7227   eisd_off = bfd_getl32 (eihd.isdoff);
7228   eiha_off = bfd_getl32 (eihd.activoff);
7229   eihi_off = bfd_getl32 (eihd.imgidoff);
7230   eihs_off = bfd_getl32 (eihd.symdbgoff);
7231   fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7232                    "imgid: %u, patch: %u\n"),
7233            eisd_off, eiha_off, eihs_off, eihi_off,
7234            (unsigned)bfd_getl32 (eihd.patchoff));
7235   fprintf (file, _(" fixup info rva: "));
7236   bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7237   fprintf (file, _(", symbol vector rva: "));
7238   bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7239   eihvn_off = bfd_getl32 (eihd.version_array_off);
7240   fprintf (file, _("\n"
7241                    " version array off: %u\n"),
7242            eihvn_off);
7243   fprintf (file,
7244            _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7245            (unsigned)bfd_getl32 (eihd.imgiocnt),
7246            (unsigned)bfd_getl32 (eihd.iochancnt),
7247            (unsigned)bfd_getl32 (eihd.privreqs + 4),
7248            (unsigned)bfd_getl32 (eihd.privreqs + 0));
7249   val = (unsigned)bfd_getl32 (eihd.lnkflags);
7250   fprintf (file, _(" linker flags: %08x:"), val);
7251   if (val & EIHD__M_LNKDEBUG)
7252     fprintf (file, " LNKDEBUG");
7253   if (val & EIHD__M_LNKNOTFR)
7254     fprintf (file, " LNKNOTFR");
7255   if (val & EIHD__M_NOP0BUFS)
7256     fprintf (file, " NOP0BUFS");
7257   if (val & EIHD__M_PICIMG)
7258     fprintf (file, " PICIMG");
7259   if (val & EIHD__M_P0IMAGE)
7260     fprintf (file, " P0IMAGE");
7261   if (val & EIHD__M_DBGDMT)
7262     fprintf (file, " DBGDMT");
7263   if (val & EIHD__M_INISHR)
7264     fprintf (file, " INISHR");
7265   if (val & EIHD__M_XLATED)
7266     fprintf (file, " XLATED");
7267   if (val & EIHD__M_BIND_CODE_SEC)
7268     fprintf (file, " BIND_CODE_SEC");
7269   if (val & EIHD__M_BIND_DATA_SEC)
7270     fprintf (file, " BIND_DATA_SEC");
7271   if (val & EIHD__M_MKTHREADS)
7272     fprintf (file, " MKTHREADS");
7273   if (val & EIHD__M_UPCALLS)
7274     fprintf (file, " UPCALLS");
7275   if (val & EIHD__M_OMV_READY)
7276     fprintf (file, " OMV_READY");
7277   if (val & EIHD__M_EXT_BIND_SECT)
7278     fprintf (file, " EXT_BIND_SECT");
7279   fprintf (file, "\n");
7280   fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7281                    "match ctrl: %u, symvect_size: %u\n"),
7282            (unsigned)bfd_getl32 (eihd.ident),
7283            (unsigned)bfd_getl32 (eihd.sysver),
7284            eihd.matchctl,
7285            (unsigned)bfd_getl32 (eihd.symvect_size));
7286   fprintf (file, _(" BPAGE: %u"),
7287            (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7288   if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7289     {
7290       eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7291       eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7292       fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7293                eihef_off, eihnp_off);
7294     }
7295   fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7296
7297   if (eihvn_off != 0)
7298     {
7299       struct vms_eihvn eihvn;
7300       unsigned int mask;
7301       unsigned int j;
7302
7303       fprintf (file, _("system version array information:\n"));
7304       if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7305           || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7306         {
7307           fprintf (file, _("cannot read EIHVN header\n"));
7308           return;
7309         }
7310       mask = bfd_getl32 (eihvn.subsystem_mask);
7311       for (j = 0; j < 32; j++)
7312         if (mask & (1 << j))
7313           {
7314             struct vms_eihvn_subversion ver;
7315             if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7316               {
7317                 fprintf (file, _("cannot read EIHVN version\n"));
7318                 return;
7319               }
7320             fprintf (file, _("   %02u "), j);
7321             switch (j)
7322               {
7323               case EIHVN__BASE_IMAGE_BIT:
7324                 fputs (_("BASE_IMAGE       "), file);
7325                 break;
7326               case EIHVN__MEMORY_MANAGEMENT_BIT:
7327                 fputs (_("MEMORY_MANAGEMENT"), file);
7328                 break;
7329               case EIHVN__IO_BIT:
7330                 fputs (_("IO               "), file);
7331                 break;
7332               case EIHVN__FILES_VOLUMES_BIT:
7333                 fputs (_("FILES_VOLUMES    "), file);
7334                 break;
7335               case EIHVN__PROCESS_SCHED_BIT:
7336                 fputs (_("PROCESS_SCHED    "), file);
7337                 break;
7338               case EIHVN__SYSGEN_BIT:
7339                 fputs (_("SYSGEN           "), file);
7340                 break;
7341               case EIHVN__CLUSTERS_LOCKMGR_BIT:
7342                 fputs (_("CLUSTERS_LOCKMGR "), file);
7343                 break;
7344               case EIHVN__LOGICAL_NAMES_BIT:
7345                 fputs (_("LOGICAL_NAMES    "), file);
7346                 break;
7347               case EIHVN__SECURITY_BIT:
7348                 fputs (_("SECURITY         "), file);
7349                 break;
7350               case EIHVN__IMAGE_ACTIVATOR_BIT:
7351                 fputs (_("IMAGE_ACTIVATOR  "), file);
7352                 break;
7353               case EIHVN__NETWORKS_BIT:
7354                 fputs (_("NETWORKS         "), file);
7355                 break;
7356               case EIHVN__COUNTERS_BIT:
7357                 fputs (_("COUNTERS         "), file);
7358                 break;
7359               case EIHVN__STABLE_BIT:
7360                 fputs (_("STABLE           "), file);
7361                 break;
7362               case EIHVN__MISC_BIT:
7363                 fputs (_("MISC             "), file);
7364                 break;
7365               case EIHVN__CPU_BIT:
7366                 fputs (_("CPU              "), file);
7367                 break;
7368               case EIHVN__VOLATILE_BIT:
7369                 fputs (_("VOLATILE         "), file);
7370                 break;
7371               case EIHVN__SHELL_BIT:
7372                 fputs (_("SHELL            "), file);
7373                 break;
7374               case EIHVN__POSIX_BIT:
7375                 fputs (_("POSIX            "), file);
7376                 break;
7377               case EIHVN__MULTI_PROCESSING_BIT:
7378                 fputs (_("MULTI_PROCESSING "), file);
7379                 break;
7380               case EIHVN__GALAXY_BIT:
7381                 fputs (_("GALAXY           "), file);
7382                 break;
7383               default:
7384                 fputs (_("*unknown*        "), file);
7385                 break;
7386               }
7387             fprintf (file, _(": %u.%u\n"),
7388                      (unsigned)bfd_getl16 (ver.major),
7389                      (unsigned)bfd_getl16 (ver.minor));
7390           }
7391     }
7392
7393   if (eiha_off != 0)
7394     {
7395       struct vms_eiha eiha;
7396
7397       if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7398           || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7399         {
7400           fprintf (file, _("cannot read EIHA\n"));
7401           return;
7402         }
7403       fprintf (file, _("Image activation:  (size=%u)\n"),
7404                (unsigned)bfd_getl32 (eiha.size));
7405       fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7406                (unsigned)bfd_getl32 (eiha.tfradr1_h),
7407                (unsigned)bfd_getl32 (eiha.tfradr1));
7408       fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7409                (unsigned)bfd_getl32 (eiha.tfradr2_h),
7410                (unsigned)bfd_getl32 (eiha.tfradr2));
7411       fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7412                (unsigned)bfd_getl32 (eiha.tfradr3_h),
7413                (unsigned)bfd_getl32 (eiha.tfradr3));
7414       fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7415                (unsigned)bfd_getl32 (eiha.tfradr4_h),
7416                (unsigned)bfd_getl32 (eiha.tfradr4));
7417       fprintf (file, _(" Shared image  : 0x%08x 0x%08x\n"),
7418                (unsigned)bfd_getl32 (eiha.inishr_h),
7419                (unsigned)bfd_getl32 (eiha.inishr));
7420     }
7421   if (eihi_off != 0)
7422     {
7423       struct vms_eihi eihi;
7424
7425       if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7426           || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7427         {
7428           fprintf (file, _("cannot read EIHI\n"));
7429           return;
7430         }
7431       fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7432                (unsigned)bfd_getl32 (eihi.majorid),
7433                (unsigned)bfd_getl32 (eihi.minorid));
7434       fprintf (file, _(" image name       : %.*s\n"),
7435                eihi.imgnam[0], eihi.imgnam + 1);
7436       fprintf (file, _(" link time        : %s\n"),
7437                vms_time_to_str (eihi.linktime));
7438       fprintf (file, _(" image ident      : %.*s\n"),
7439                eihi.imgid[0], eihi.imgid + 1);
7440       fprintf (file, _(" linker ident     : %.*s\n"),
7441                eihi.linkid[0], eihi.linkid + 1);
7442       fprintf (file, _(" image build ident: %.*s\n"),
7443                eihi.imgbid[0], eihi.imgbid + 1);
7444     }
7445   if (eihs_off != 0)
7446     {
7447       struct vms_eihs eihs;
7448
7449       if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7450           || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7451         {
7452           fprintf (file, _("cannot read EIHS\n"));
7453           return;
7454         }
7455       fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7456                (unsigned)bfd_getl32 (eihs.majorid),
7457                (unsigned)bfd_getl32 (eihs.minorid));
7458       dst_vbn = bfd_getl32 (eihs.dstvbn);
7459       dst_size = bfd_getl32 (eihs.dstsize);
7460       fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7461                dst_vbn, dst_size, dst_size);
7462       gst_vbn = bfd_getl32 (eihs.gstvbn);
7463       gst_size = bfd_getl32 (eihs.gstsize);
7464       fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7465                gst_vbn, gst_size);
7466       dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7467       dmt_size = bfd_getl32 (eihs.dmtsize);
7468       fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7469                dmt_vbn, dmt_size);
7470     }
7471   while (eisd_off != 0)
7472     {
7473       struct vms_eisd eisd;
7474       unsigned int len;
7475
7476       while (1)
7477         {
7478           if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7479               || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7480             {
7481               fprintf (file, _("cannot read EISD\n"));
7482               return;
7483             }
7484           len = (unsigned)bfd_getl32 (eisd.eisdsize);
7485           if (len != (unsigned)-1)
7486             break;
7487
7488           /* Next block.  */
7489           eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7490         }
7491       fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7492                        "size: %u, offset: %u)\n"),
7493                (unsigned)bfd_getl32 (eisd.majorid),
7494                (unsigned)bfd_getl32 (eisd.minorid),
7495                len, eisd_off);
7496       if (len == 0)
7497         break;
7498       fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7499                (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7500                (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7501                (unsigned)bfd_getl32 (eisd.secsize));
7502       val = (unsigned)bfd_getl32 (eisd.flags);
7503       fprintf (file, _(" flags: 0x%04x"), val);
7504       if (val & EISD__M_GBL)
7505         fprintf (file, " GBL");
7506       if (val & EISD__M_CRF)
7507         fprintf (file, " CRF");
7508       if (val & EISD__M_DZRO)
7509         fprintf (file, " DZRO");
7510       if (val & EISD__M_WRT)
7511         fprintf (file, " WRT");
7512       if (val & EISD__M_INITALCODE)
7513         fprintf (file, " INITALCODE");
7514       if (val & EISD__M_BASED)
7515         fprintf (file, " BASED");
7516       if (val & EISD__M_FIXUPVEC)
7517         fprintf (file, " FIXUPVEC");
7518       if (val & EISD__M_RESIDENT)
7519         fprintf (file, " RESIDENT");
7520       if (val & EISD__M_VECTOR)
7521         fprintf (file, " VECTOR");
7522       if (val & EISD__M_PROTECT)
7523         fprintf (file, " PROTECT");
7524       if (val & EISD__M_LASTCLU)
7525         fprintf (file, " LASTCLU");
7526       if (val & EISD__M_EXE)
7527         fprintf (file, " EXE");
7528       if (val & EISD__M_NONSHRADR)
7529         fprintf (file, " NONSHRADR");
7530       if (val & EISD__M_QUAD_LENGTH)
7531         fprintf (file, " QUAD_LENGTH");
7532       if (val & EISD__M_ALLOC_64BIT)
7533         fprintf (file, " ALLOC_64BIT");
7534       fprintf (file, "\n");
7535       if (val & EISD__M_FIXUPVEC)
7536         {
7537           eiaf_vbn = bfd_getl32 (eisd.vbn);
7538           eiaf_size = bfd_getl32 (eisd.secsize);
7539         }
7540       fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7541                (unsigned)bfd_getl32 (eisd.vbn),
7542                eisd.pfc, eisd.matchctl, eisd.type);
7543       switch (eisd.type)
7544         {
7545         case EISD__K_NORMAL:
7546           fputs (_("NORMAL"), file);
7547           break;
7548         case EISD__K_SHRFXD:
7549           fputs (_("SHRFXD"), file);
7550           break;
7551         case EISD__K_PRVFXD:
7552           fputs (_("PRVFXD"), file);
7553           break;
7554         case EISD__K_SHRPIC:
7555           fputs (_("SHRPIC"), file);
7556           break;
7557         case EISD__K_PRVPIC:
7558           fputs (_("PRVPIC"), file);
7559           break;
7560         case EISD__K_USRSTACK:
7561           fputs (_("USRSTACK"), file);
7562           break;
7563         default:
7564           fputs (_("*unknown*"), file);
7565           break;
7566         }
7567       fputs (_(")\n"), file);
7568       if (val & EISD__M_GBL)
7569         fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7570                  (unsigned)bfd_getl32 (eisd.ident),
7571                  eisd.gblnam[0], eisd.gblnam + 1);
7572       eisd_off += len;
7573     }
7574
7575   if (dmt_vbn != 0)
7576     {
7577       if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7578         {
7579           fprintf (file, _("cannot read DMT\n"));
7580           return;
7581         }
7582
7583       fprintf (file, _("Debug module table:\n"));
7584
7585       while (dmt_size > 0)
7586         {
7587           struct vms_dmt_header dmth;
7588           unsigned int count;
7589
7590           if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7591             {
7592               fprintf (file, _("cannot read DMT header\n"));
7593               return;
7594             }
7595           count = bfd_getl16 (dmth.psect_count);
7596           fprintf (file,
7597                    _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
7598                    (unsigned)bfd_getl32 (dmth.modbeg),
7599                    (unsigned)bfd_getl32 (dmth.size), count);
7600           dmt_size -= sizeof (dmth);
7601           while (count > 0)
7602             {
7603               struct vms_dmt_psect dmtp;
7604
7605               if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7606                 {
7607                   fprintf (file, _("cannot read DMT psect\n"));
7608                   return;
7609                 }
7610               fprintf (file, _("  psect start: 0x%08x, length: %u\n"),
7611                        (unsigned)bfd_getl32 (dmtp.start),
7612                        (unsigned)bfd_getl32 (dmtp.length));
7613               count--;
7614               dmt_size -= sizeof (dmtp);
7615             }
7616         }
7617     }
7618
7619   if (dst_vbn != 0)
7620     {
7621       if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7622         {
7623           fprintf (file, _("cannot read DST\n"));
7624           return;
7625         }
7626
7627       evax_bfd_print_dst (abfd, dst_size, file);
7628     }
7629   if (gst_vbn != 0)
7630     {
7631       if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7632         {
7633           fprintf (file, _("cannot read GST\n"));
7634           return;
7635         }
7636
7637       fprintf (file, _("Global symbol table:\n"));
7638       evax_bfd_print_eobj (abfd, file);
7639     }
7640   if (eiaf_vbn != 0)
7641     {
7642       unsigned char *buf;
7643       struct vms_eiaf *eiaf;
7644       unsigned int qrelfixoff;
7645       unsigned int lrelfixoff;
7646       unsigned int qdotadroff;
7647       unsigned int ldotadroff;
7648       unsigned int shrimgcnt;
7649       unsigned int shlstoff;
7650       unsigned int codeadroff;
7651       unsigned int lpfixoff;
7652       unsigned int chgprtoff;
7653
7654       buf = bfd_malloc (eiaf_size);
7655
7656       if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7657           || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7658         {
7659           fprintf (file, _("cannot read EIHA\n"));
7660           free (buf);
7661           return;
7662         }
7663       eiaf = (struct vms_eiaf *)buf;
7664       fprintf (file,
7665                _("Image activator fixup: (major: %u, minor: %u)\n"),
7666                (unsigned)bfd_getl32 (eiaf->majorid),
7667                (unsigned)bfd_getl32 (eiaf->minorid));
7668       fprintf (file, _("  iaflink : 0x%08x %08x\n"),
7669                (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7670                (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7671       fprintf (file, _("  fixuplnk: 0x%08x %08x\n"),
7672                (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7673                (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7674       fprintf (file, _("  size : %u\n"),
7675                (unsigned)bfd_getl32 (eiaf->size));
7676       fprintf (file, _("  flags: 0x%08x\n"),
7677                (unsigned)bfd_getl32 (eiaf->flags));
7678       qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7679       lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7680       fprintf (file, _("  qrelfixoff: %5u, lrelfixoff: %5u\n"),
7681                qrelfixoff, lrelfixoff);
7682       qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7683       ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7684       fprintf (file, _("  qdotadroff: %5u, ldotadroff: %5u\n"),
7685                qdotadroff, ldotadroff);
7686       codeadroff = bfd_getl32 (eiaf->codeadroff);
7687       lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7688       fprintf (file, _("  codeadroff: %5u, lpfixoff  : %5u\n"),
7689                codeadroff, lpfixoff);
7690       chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7691       fprintf (file, _("  chgprtoff : %5u\n"), chgprtoff);
7692       shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7693       shlstoff = bfd_getl32 (eiaf->shlstoff);
7694       fprintf (file, _("  shlstoff  : %5u, shrimgcnt : %5u\n"),
7695                shlstoff, shrimgcnt);
7696       fprintf (file, _("  shlextra  : %5u, permctx   : %5u\n"),
7697                (unsigned)bfd_getl32 (eiaf->shlextra),
7698                (unsigned)bfd_getl32 (eiaf->permctx));
7699       fprintf (file, _("  base_va : 0x%08x\n"),
7700                (unsigned)bfd_getl32 (eiaf->base_va));
7701       fprintf (file, _("  lppsbfixoff: %5u\n"),
7702                (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7703
7704       if (shlstoff)
7705         {
7706           struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7707           unsigned int j;
7708
7709           fprintf (file, _(" Shareable images:\n"));
7710           for (j = 0; j < shrimgcnt; j++, shl++)
7711             {
7712               fprintf (file,
7713                        _("  %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7714                        j, shl->size, shl->flags,
7715                        shl->imgnam[0], shl->imgnam + 1);
7716             }
7717         }
7718       if (qrelfixoff != 0)
7719         {
7720           fprintf (file, _(" quad-word relocation fixups:\n"));
7721           evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7722         }
7723       if (lrelfixoff != 0)
7724         {
7725           fprintf (file, _(" long-word relocation fixups:\n"));
7726           evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7727         }
7728       if (qdotadroff != 0)
7729         {
7730           fprintf (file, _(" quad-word .address reference fixups:\n"));
7731           evax_bfd_print_address_fixups (file, buf + qdotadroff);
7732         }
7733       if (ldotadroff != 0)
7734         {
7735           fprintf (file, _(" long-word .address reference fixups:\n"));
7736           evax_bfd_print_address_fixups (file, buf + ldotadroff);
7737         }
7738       if (codeadroff != 0)
7739         {
7740           fprintf (file, _(" Code Address Reference Fixups:\n"));
7741           evax_bfd_print_reference_fixups (file, buf + codeadroff);
7742         }
7743       if (lpfixoff != 0)
7744         {
7745           fprintf (file, _(" Linkage Pairs Reference Fixups:\n"));
7746           evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7747         }
7748       if (chgprtoff)
7749         {
7750           unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7751           struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7752           unsigned int j;
7753
7754           fprintf (file, _(" Change Protection (%u entries):\n"), count);
7755           for (j = 0; j < count; j++, eicp++)
7756             {
7757               unsigned int prot = bfd_getl32 (eicp->newprt);
7758               fprintf (file,
7759                        _("  base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7760                        (unsigned)bfd_getl32 (eicp->baseva + 4),
7761                        (unsigned)bfd_getl32 (eicp->baseva + 0),
7762                        (unsigned)bfd_getl32 (eicp->size),
7763                        (unsigned)bfd_getl32 (eicp->newprt));
7764               switch (prot)
7765                 {
7766                 case PRT__C_NA:
7767                   fprintf (file, "NA");
7768                   break;
7769                 case PRT__C_RESERVED:
7770                   fprintf (file, "RES");
7771                   break;
7772                 case PRT__C_KW:
7773                   fprintf (file, "KW");
7774                   break;
7775                 case PRT__C_KR:
7776                   fprintf (file, "KR");
7777                   break;
7778                 case PRT__C_UW:
7779                   fprintf (file, "UW");
7780                   break;
7781                 case PRT__C_EW:
7782                   fprintf (file, "EW");
7783                   break;
7784                 case PRT__C_ERKW:
7785                   fprintf (file, "ERKW");
7786                   break;
7787                 case PRT__C_ER:
7788                   fprintf (file, "ER");
7789                   break;
7790                 case PRT__C_SW:
7791                   fprintf (file, "SW");
7792                   break;
7793                 case PRT__C_SREW:
7794                   fprintf (file, "SREW");
7795                   break;
7796                 case PRT__C_SRKW:
7797                   fprintf (file, "SRKW");
7798                   break;
7799                 case PRT__C_SR:
7800                   fprintf (file, "SR");
7801                   break;
7802                 case PRT__C_URSW:
7803                   fprintf (file, "URSW");
7804                   break;
7805                 case PRT__C_UREW:
7806                   fprintf (file, "UREW");
7807                   break;
7808                 case PRT__C_URKW:
7809                   fprintf (file, "URKW");
7810                   break;
7811                 case PRT__C_UR:
7812                   fprintf (file, "UR");
7813                   break;
7814                 default:
7815                   fputs ("??", file);
7816                   break;
7817                 }
7818               fputc ('\n', file);
7819             }
7820         }
7821       free (buf);
7822     }
7823 }
7824
7825 static bfd_boolean
7826 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7827 {
7828   FILE *file = (FILE *)ptr;
7829
7830   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7831     evax_bfd_print_image (abfd, file);
7832   else
7833     {
7834       if (bfd_seek (abfd, 0, SEEK_SET))
7835         return FALSE;
7836       evax_bfd_print_eobj (abfd, file);
7837     }
7838   return TRUE;
7839 }
7840 \f
7841 /* Linking.  */
7842
7843 /* Slurp ETIR/EDBG/ETBT VMS object records.  */
7844
7845 static bfd_boolean
7846 alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7847 {
7848   asection *cur_section;
7849   file_ptr cur_offset;
7850   asection *dst_section;
7851   file_ptr dst_offset;
7852
7853   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7854     return FALSE;
7855
7856   cur_section = NULL;
7857   cur_offset = 0;
7858
7859   dst_section = PRIV (dst_section);
7860   dst_offset = 0;
7861   if (info)
7862     {
7863       if (info->strip == strip_all || info->strip == strip_debugger)
7864         {
7865           /* Discard the DST section.  */
7866           dst_offset = 0;
7867           dst_section = NULL;
7868         }
7869       else if (dst_section)
7870         {
7871           dst_offset = dst_section->output_offset;
7872           dst_section = dst_section->output_section;
7873         }
7874     }
7875
7876   while (1)
7877     {
7878       int type;
7879       bfd_boolean res;
7880
7881       type = _bfd_vms_get_object_record (abfd);
7882       if (type < 0)
7883         {
7884           vms_debug2 ((2, "next_record failed\n"));
7885           return FALSE;
7886         }
7887       switch (type)
7888         {
7889         case EOBJ__C_ETIR:
7890           PRIV (image_section) = cur_section;
7891           PRIV (image_offset) = cur_offset;
7892           res = _bfd_vms_slurp_etir (abfd, info);
7893           cur_section = PRIV (image_section);
7894           cur_offset = PRIV (image_offset);
7895           break;
7896         case EOBJ__C_EDBG:
7897         case EOBJ__C_ETBT:
7898           if (dst_section == NULL)
7899             continue;
7900           PRIV (image_section) = dst_section;
7901           PRIV (image_offset) = dst_offset;
7902           res = _bfd_vms_slurp_etir (abfd, info);
7903           dst_offset = PRIV (image_offset);
7904           break;
7905         case EOBJ__C_EEOM:
7906           return TRUE;
7907         default:
7908           continue;
7909         }
7910       if (!res)
7911         {
7912           vms_debug2 ((2, "slurp eobj type %d failed\n", type));
7913           return FALSE;
7914         }
7915     }
7916 }
7917
7918 static int
7919 alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
7920                           struct bfd_link_info *info ATTRIBUTE_UNUSED)
7921 {
7922   return 0;
7923 }
7924
7925 /* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
7926
7927 static void
7928 alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
7929 {
7930   struct alpha_vms_shlib_el *sl;
7931   asection *sect = PRIV2 (src, image_section);
7932   file_ptr offset = PRIV2 (src, image_offset);
7933
7934   sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7935                 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7936   sl->has_fixups = TRUE;
7937   VEC_APPEND_EL (sl->lp, bfd_vma,
7938                  sect->output_section->vma + sect->output_offset + offset);
7939   sect->output_section->flags |= SEC_RELOC;
7940 }
7941
7942 /* Add a code address fixup at address SECT + OFFSET to SHLIB. */
7943
7944 static void
7945 alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
7946 {
7947   struct alpha_vms_shlib_el *sl;
7948   asection *sect = PRIV2 (src, image_section);
7949   file_ptr offset = PRIV2 (src, image_offset);
7950
7951   sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7952                 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7953   sl->has_fixups = TRUE;
7954   VEC_APPEND_EL (sl->ca, bfd_vma,
7955                  sect->output_section->vma + sect->output_offset + offset);
7956   sect->output_section->flags |= SEC_RELOC;
7957 }
7958
7959 /* Add a quad word relocation fixup at address SECT + OFFSET to SHLIB. */
7960
7961 static void
7962 alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
7963                         bfd *shlib, bfd_vma vec)
7964 {
7965   struct alpha_vms_shlib_el *sl;
7966   struct alpha_vms_vma_ref *r;
7967   asection *sect = PRIV2 (src, image_section);
7968   file_ptr offset = PRIV2 (src, image_offset);
7969
7970   sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7971                 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7972   sl->has_fixups = TRUE;
7973   r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
7974   r->vma = sect->output_section->vma + sect->output_offset + offset;
7975   r->ref = vec;
7976   sect->output_section->flags |= SEC_RELOC;
7977 }
7978
7979 static void
7980 alpha_vms_add_fixup_lr (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7981                         unsigned int shr ATTRIBUTE_UNUSED,
7982                         bfd_vma vec ATTRIBUTE_UNUSED)
7983 {
7984   /* Not yet supported.  */
7985   abort ();
7986 }
7987
7988 /* Add relocation.  FIXME: Not yet emitted.  */
7989
7990 static void
7991 alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
7992 {
7993 }
7994
7995 static void
7996 alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
7997 {
7998 }
7999
8000 static struct bfd_hash_entry *
8001 alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
8002                              struct bfd_hash_table *table,
8003                              const char *string)
8004 {
8005   struct alpha_vms_link_hash_entry *ret =
8006     (struct alpha_vms_link_hash_entry *) entry;
8007
8008   /* Allocate the structure if it has not already been allocated by a
8009      subclass.  */
8010   if (ret == NULL)
8011     ret = ((struct alpha_vms_link_hash_entry *)
8012            bfd_hash_allocate (table,
8013                               sizeof (struct alpha_vms_link_hash_entry)));
8014   if (ret == NULL)
8015     return NULL;
8016
8017   /* Call the allocation method of the superclass.  */
8018   ret = ((struct alpha_vms_link_hash_entry *)
8019          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
8020                                  table, string));
8021
8022   ret->sym = NULL;
8023
8024   return (struct bfd_hash_entry *) ret;
8025 }
8026
8027 /* Create an Alpha/VMS link hash table.  */
8028
8029 static struct bfd_link_hash_table *
8030 alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8031 {
8032   struct alpha_vms_link_hash_table *ret;
8033   bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8034
8035   ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8036   if (ret == NULL)
8037     return NULL;
8038   if (!_bfd_link_hash_table_init (&ret->root, abfd,
8039                                   alpha_vms_link_hash_newfunc,
8040                                   sizeof (struct alpha_vms_link_hash_entry)))
8041     {
8042       free (ret);
8043       return NULL;
8044     }
8045
8046   VEC_INIT (ret->shrlibs);
8047   ret->fixup = NULL;
8048
8049   return &ret->root;
8050 }
8051
8052 static bfd_boolean
8053 alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8054 {
8055   unsigned int i;
8056
8057   for (i = 0; i < PRIV (gsd_sym_count); i++)
8058     {
8059       struct vms_symbol_entry *e = PRIV (syms)[i];
8060       struct alpha_vms_link_hash_entry *h;
8061       struct bfd_link_hash_entry *h_root;
8062       asymbol sym;
8063
8064       if (!alpha_vms_convert_symbol (abfd, e, &sym))
8065         return FALSE;
8066
8067       if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8068         {
8069           /* In selective_search mode, only add definition that are
8070              required.  */
8071           h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8072             (info->hash, sym.name, FALSE, FALSE, FALSE);
8073           if (h == NULL || h->root.type != bfd_link_hash_undefined)
8074             continue;
8075         }
8076       else
8077         h = NULL;
8078
8079       h_root = (struct bfd_link_hash_entry *) h;
8080       if (_bfd_generic_link_add_one_symbol
8081           (info, abfd, sym.name, sym.flags, sym.section, sym.value,
8082            NULL, FALSE, FALSE, &h_root) == FALSE)
8083         return FALSE;
8084       h = (struct alpha_vms_link_hash_entry *) h_root;
8085
8086       if ((e->flags & EGSY__V_DEF)
8087           && h->sym == NULL
8088           && abfd->xvec == info->output_bfd->xvec)
8089         h->sym = e;
8090     }
8091
8092   if (abfd->flags & DYNAMIC)
8093     {
8094       struct alpha_vms_shlib_el *shlib;
8095
8096       /* We do not want to include any of the sections in a dynamic
8097          object in the output file.  See comment in elflink.c.  */
8098       bfd_section_list_clear (abfd);
8099
8100       shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8101                           struct alpha_vms_shlib_el);
8102       shlib->abfd = abfd;
8103       VEC_INIT (shlib->ca);
8104       VEC_INIT (shlib->lp);
8105       VEC_INIT (shlib->qr);
8106       PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8107     }
8108
8109   return TRUE;
8110 }
8111
8112 static bfd_boolean
8113 alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8114 {
8115   int pass;
8116   struct bfd_link_hash_entry **pundef;
8117   struct bfd_link_hash_entry **next_pundef;
8118
8119   /* We only accept VMS libraries.  */
8120   if (info->output_bfd->xvec != abfd->xvec)
8121     {
8122       bfd_set_error (bfd_error_wrong_format);
8123       return FALSE;
8124     }
8125
8126   /* The archive_pass field in the archive itself is used to
8127      initialize PASS, since we may search the same archive multiple
8128      times.  */
8129   pass = ++abfd->archive_pass;
8130
8131   /* Look through the list of undefined symbols.  */
8132   for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8133     {
8134       struct bfd_link_hash_entry *h;
8135       symindex symidx;
8136       bfd *element;
8137       bfd *orig_element;
8138
8139       h = *pundef;
8140       next_pundef = &(*pundef)->u.undef.next;
8141
8142       /* When a symbol is defined, it is not necessarily removed from
8143          the list.  */
8144       if (h->type != bfd_link_hash_undefined
8145           && h->type != bfd_link_hash_common)
8146         {
8147           /* Remove this entry from the list, for general cleanliness
8148              and because we are going to look through the list again
8149              if we search any more libraries.  We can't remove the
8150              entry if it is the tail, because that would lose any
8151              entries we add to the list later on.  */
8152           if (*pundef != info->hash->undefs_tail)
8153             {
8154               *pundef = *next_pundef;
8155               next_pundef = pundef;
8156             }
8157           continue;
8158         }
8159
8160       /* Look for this symbol in the archive hash table.  */
8161       symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8162       if (symidx == BFD_NO_MORE_SYMBOLS)
8163         {
8164           /* Nothing in this slot.  */
8165           continue;
8166         }
8167
8168       element = bfd_get_elt_at_index (abfd, symidx);
8169       if (element == NULL)
8170         return FALSE;
8171
8172       if (element->archive_pass == -1 || element->archive_pass == pass)
8173         {
8174           /* Next symbol if this archive is wrong or already handled.  */
8175           continue;
8176         }
8177
8178       if (! bfd_check_format (element, bfd_object))
8179         {
8180           element->archive_pass = -1;
8181           return FALSE;
8182         }
8183
8184       orig_element = element;
8185       if (bfd_is_thin_archive (abfd))
8186         {
8187           element = _bfd_vms_lib_get_imagelib_file (element);
8188           if (element == NULL || !bfd_check_format (element, bfd_object))
8189             {
8190               orig_element->archive_pass = -1;
8191               return FALSE;
8192             }
8193         }
8194
8195       /* Unlike the generic linker, we know that this element provides
8196          a definition for an undefined symbol and we know that we want
8197          to include it.  We don't need to check anything.  */
8198       if (!(*info->callbacks
8199             ->add_archive_element) (info, element, h->root.string, &element))
8200         return FALSE;
8201       if (!alpha_vms_link_add_object_symbols (element, info))
8202         return FALSE;
8203
8204       orig_element->archive_pass = pass;
8205     }
8206
8207   return TRUE;
8208 }
8209
8210 static bfd_boolean
8211 alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8212 {
8213   switch (bfd_get_format (abfd))
8214     {
8215     case bfd_object:
8216       vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8217                    abfd->filename));
8218       return alpha_vms_link_add_object_symbols (abfd, info);
8219       break;
8220     case bfd_archive:
8221       vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8222                    abfd->filename));
8223       return alpha_vms_link_add_archive_symbols (abfd, info);
8224       break;
8225     default:
8226       bfd_set_error (bfd_error_wrong_format);
8227       return FALSE;
8228     }
8229 }
8230
8231 static bfd_boolean
8232 alpha_vms_build_fixups (struct bfd_link_info *info)
8233 {
8234   struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8235   unsigned char *content;
8236   unsigned int i;
8237   unsigned int sz = 0;
8238   unsigned int lp_sz = 0;
8239   unsigned int ca_sz = 0;
8240   unsigned int qr_sz = 0;
8241   unsigned int shrimg_cnt = 0;
8242   unsigned int chgprt_num = 0;
8243   unsigned int chgprt_sz = 0;
8244   struct vms_eiaf *eiaf;
8245   unsigned int off;
8246   asection *sec;
8247
8248   /* Shared libraries.  */
8249   for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8250     {
8251       struct alpha_vms_shlib_el *shlib;
8252
8253       shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8254
8255       if (!shlib->has_fixups)
8256         continue;
8257
8258       shrimg_cnt++;
8259
8260       if (VEC_COUNT (shlib->ca) > 0)
8261         {
8262           /* Header + entries.  */
8263           ca_sz += 8;
8264           ca_sz += VEC_COUNT (shlib->ca) * 4;
8265         }
8266       if (VEC_COUNT (shlib->lp) > 0)
8267         {
8268           /* Header + entries.  */
8269           lp_sz += 8;
8270           lp_sz += VEC_COUNT (shlib->lp) * 4;
8271         }
8272       if (VEC_COUNT (shlib->qr) > 0)
8273         {
8274           /* Header + entries.  */
8275           qr_sz += 8;
8276           qr_sz += VEC_COUNT (shlib->qr) * 8;
8277         }
8278     }
8279   /* Add markers.  */
8280   if (ca_sz > 0)
8281     ca_sz += 8;
8282   if (lp_sz > 0)
8283     lp_sz += 8;
8284   if (qr_sz > 0)
8285     qr_sz += 8;
8286
8287   /* Finish now if there is no content.  */
8288   if (ca_sz + lp_sz + qr_sz == 0)
8289     return TRUE;
8290
8291   /* Add an eicp entry for the fixup itself.  */
8292   chgprt_num = 1;
8293   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8294     {
8295       /* This isect could be made RO or EXE after relocations are applied.  */
8296       if ((sec->flags & SEC_RELOC) != 0
8297           && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8298         chgprt_num++;
8299     }
8300   chgprt_sz = 4 + chgprt_num * sizeof (struct vms_eicp);
8301
8302   /* Allocate section content (round-up size)  */
8303   sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8304     + ca_sz + lp_sz + qr_sz + chgprt_sz;
8305   sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8306   content = bfd_zalloc (info->output_bfd, sz);
8307   if (content == NULL)
8308     return FALSE;
8309
8310   sec = alpha_vms_link_hash (info)->fixup;
8311   sec->contents = content;
8312   sec->size = sz;
8313
8314   eiaf = (struct vms_eiaf *)content;
8315   off = sizeof (struct vms_eiaf);
8316   bfd_putl32 (0, eiaf->majorid);
8317   bfd_putl32 (0, eiaf->minorid);
8318   bfd_putl32 (0, eiaf->iaflink);
8319   bfd_putl32 (0, eiaf->fixuplnk);
8320   bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8321   bfd_putl32 (0, eiaf->flags);
8322   bfd_putl32 (0, eiaf->qrelfixoff);
8323   bfd_putl32 (0, eiaf->lrelfixoff);
8324   bfd_putl32 (0, eiaf->qdotadroff);
8325   bfd_putl32 (0, eiaf->ldotadroff);
8326   bfd_putl32 (0, eiaf->codeadroff);
8327   bfd_putl32 (0, eiaf->lpfixoff);
8328   bfd_putl32 (0, eiaf->chgprtoff);
8329   bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8330   bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8331   bfd_putl32 (0, eiaf->shlextra);
8332   bfd_putl32 (0, eiaf->permctx);
8333   bfd_putl32 (0, eiaf->base_va);
8334   bfd_putl32 (0, eiaf->lppsbfixoff);
8335
8336   if (shrimg_cnt)
8337     {
8338       shrimg_cnt = 0;
8339
8340       /* Write shl.  */
8341       for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8342         {
8343           struct alpha_vms_shlib_el *shlib;
8344           struct vms_shl *shl;
8345
8346           shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8347
8348           if (!shlib->has_fixups)
8349             continue;
8350
8351           /* Renumber shared images.  */
8352           PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8353
8354           shl = (struct vms_shl *)(content + off);
8355           bfd_putl32 (0, shl->baseva);
8356           bfd_putl32 (0, shl->shlptr);
8357           bfd_putl32 (0, shl->ident);
8358           bfd_putl32 (0, shl->permctx);
8359           shl->size = sizeof (struct vms_shl);
8360           bfd_putl16 (0, shl->fill_1);
8361           shl->flags = 0;
8362           bfd_putl32 (0, shl->icb);
8363           shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8364           memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8365                   shl->imgnam[0]);
8366
8367           off += sizeof (struct vms_shl);
8368         }
8369
8370       /* CA fixups.  */
8371       if (ca_sz != 0)
8372         {
8373           bfd_putl32 (off, eiaf->codeadroff);
8374
8375           for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8376             {
8377               struct alpha_vms_shlib_el *shlib;
8378               unsigned int j;
8379
8380               shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8381
8382               if (VEC_COUNT (shlib->ca) == 0)
8383                 continue;
8384
8385               bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8386               bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8387               off += 8;
8388
8389               for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8390                 {
8391                   bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8392                               content + off);
8393                   off += 4;
8394                 }
8395             }
8396
8397           bfd_putl32 (0, content + off);
8398           bfd_putl32 (0, content + off + 4);
8399           off += 8;
8400         }
8401
8402       /* LP fixups.  */
8403       if (lp_sz != 0)
8404         {
8405           bfd_putl32 (off, eiaf->lpfixoff);
8406
8407           for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8408             {
8409               struct alpha_vms_shlib_el *shlib;
8410               unsigned int j;
8411
8412               shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8413
8414               if (VEC_COUNT (shlib->lp) == 0)
8415                 continue;
8416
8417               bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8418               bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8419               off += 8;
8420
8421               for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8422                 {
8423                   bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8424                               content + off);
8425                   off += 4;
8426                 }
8427             }
8428
8429           bfd_putl32 (0, content + off);
8430           bfd_putl32 (0, content + off + 4);
8431           off += 8;
8432         }
8433
8434       /* QR fixups.  */
8435       if (qr_sz != 0)
8436         {
8437           bfd_putl32 (off, eiaf->qdotadroff);
8438
8439           for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8440             {
8441               struct alpha_vms_shlib_el *shlib;
8442               unsigned int j;
8443
8444               shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8445
8446               if (VEC_COUNT (shlib->qr) == 0)
8447                 continue;
8448
8449               bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8450               bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8451               off += 8;
8452
8453               for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8454                 {
8455                   struct alpha_vms_vma_ref *r;
8456                   r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8457                   bfd_putl32 (r->vma - t->base_addr, content + off);
8458                   bfd_putl32 (r->ref, content + off + 4);
8459                   off += 8;
8460                 }
8461             }
8462
8463           bfd_putl32 (0, content + off);
8464           bfd_putl32 (0, content + off + 4);
8465           off += 8;
8466         }
8467     }
8468
8469   /* Write the change protection table.  */
8470   bfd_putl32 (off, eiaf->chgprtoff);
8471   bfd_putl32 (chgprt_num, content + off);
8472   off += 4;
8473
8474   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8475     {
8476       struct vms_eicp *eicp;
8477       unsigned int prot;
8478
8479       if ((sec->flags & SEC_LINKER_CREATED) != 0 &&
8480           strcmp (sec->name, "$FIXUP$") == 0)
8481         prot = PRT__C_UREW;
8482       else if ((sec->flags & SEC_RELOC) != 0
8483                && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8484         prot = PRT__C_UR;
8485       else
8486         continue;
8487
8488       eicp = (struct vms_eicp *)(content + off);
8489       bfd_putl64 (sec->vma - t->base_addr, eicp->baseva);
8490       bfd_putl32 ((sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1),
8491                   eicp->size);
8492       bfd_putl32 (prot, eicp->newprt);
8493       off += sizeof (struct vms_eicp);
8494     }
8495
8496   return TRUE;
8497 }
8498
8499 /* Called by bfd_hash_traverse to fill the symbol table.
8500    Return FALSE in case of failure.  */
8501
8502 static bfd_boolean
8503 alpha_vms_link_output_symbol (struct bfd_hash_entry *bh, void *infov)
8504 {
8505   struct bfd_link_hash_entry *hc = (struct bfd_link_hash_entry *) bh;
8506   struct bfd_link_info *info = (struct bfd_link_info *)infov;
8507   struct alpha_vms_link_hash_entry *h;
8508   struct vms_symbol_entry *sym;
8509
8510   if (hc->type == bfd_link_hash_warning)
8511     {
8512       hc = hc->u.i.link;
8513       if (hc->type == bfd_link_hash_new)
8514         return TRUE;
8515     }
8516   h = (struct alpha_vms_link_hash_entry *) hc;
8517
8518   switch (h->root.type)
8519     {
8520     case bfd_link_hash_undefined:
8521       return TRUE;
8522     case bfd_link_hash_new:
8523     case bfd_link_hash_warning:
8524       abort ();
8525     case bfd_link_hash_undefweak:
8526       return TRUE;
8527     case bfd_link_hash_defined:
8528     case bfd_link_hash_defweak:
8529       {
8530         asection *sec = h->root.u.def.section;
8531
8532         /* FIXME: this is certainly a symbol from a dynamic library.  */
8533         if (bfd_is_abs_section (sec))
8534           return TRUE;
8535
8536         if (sec->owner->flags & DYNAMIC)
8537           return TRUE;
8538       }
8539       break;
8540     case bfd_link_hash_common:
8541       break;
8542     case bfd_link_hash_indirect:
8543       return TRUE;
8544     }
8545
8546   /* Do not write not kept symbols.  */
8547   if (info->strip == strip_some
8548       && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8549                           FALSE, FALSE) != NULL)
8550     return TRUE;
8551
8552   if (h->sym == NULL)
8553     {
8554       /* This symbol doesn't come from a VMS object.  So we suppose it is
8555          a data.  */
8556       int len = strlen (h->root.root.string);
8557
8558       sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8559                                                    sizeof (*sym) + len);
8560       if (sym == NULL)
8561         abort ();
8562       sym->namelen = len;
8563       memcpy (sym->name, h->root.root.string, len);
8564       sym->name[len] = 0;
8565       sym->owner = info->output_bfd;
8566
8567       sym->typ = EGSD__C_SYMG;
8568       sym->data_type = 0;
8569       sym->flags = EGSY__V_DEF | EGSY__V_REL;
8570       sym->symbol_vector = h->root.u.def.value;
8571       sym->section = h->root.u.def.section;
8572       sym->value = h->root.u.def.value;
8573     }
8574   else
8575     sym = h->sym;
8576
8577   if (!add_symbol_entry (info->output_bfd, sym))
8578     return FALSE;
8579
8580   return TRUE;
8581 }
8582
8583 static bfd_boolean
8584 alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8585 {
8586   asection *o;
8587   struct bfd_link_order *p;
8588   bfd *sub;
8589   asection *fixupsec;
8590   bfd_vma base_addr;
8591   bfd_vma last_addr;
8592   asection *dst;
8593   asection *dmt;
8594
8595   if (info->relocatable)
8596     {
8597       /* FIXME: we do not yet support relocatable link.  It is not obvious
8598          how to do it for debug infos.  */
8599       (*info->callbacks->einfo)(_("%P: relocatable link is not supported\n"));
8600       return FALSE;
8601     }
8602
8603   bfd_get_outsymbols (abfd) = NULL;
8604   bfd_get_symcount (abfd) = 0;
8605
8606   /* Mark all sections which will be included in the output file.  */
8607   for (o = abfd->sections; o != NULL; o = o->next)
8608     for (p = o->map_head.link_order; p != NULL; p = p->next)
8609       if (p->type == bfd_indirect_link_order)
8610         p->u.indirect.section->linker_mark = TRUE;
8611
8612 #if 0
8613   /* Handle all the link order information for the sections.  */
8614   for (o = abfd->sections; o != NULL; o = o->next)
8615     {
8616       printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8617               o->name, (unsigned)o->vma, (unsigned)o->flags);
8618
8619       for (p = o->map_head.link_order; p != NULL; p = p->next)
8620         {
8621           printf (" at 0x%08x - 0x%08x: ",
8622                   (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8623           switch (p->type)
8624             {
8625             case bfd_section_reloc_link_order:
8626             case bfd_symbol_reloc_link_order:
8627               printf ("  section/symbol reloc\n");
8628               break;
8629             case bfd_indirect_link_order:
8630               printf ("  section %s of %s\n",
8631                       p->u.indirect.section->name,
8632                       p->u.indirect.section->owner->filename);
8633               break;
8634             case bfd_data_link_order:
8635               printf ("  explicit data\n");
8636               break;
8637             default:
8638               printf ("  *unknown* type %u\n", p->type);
8639               break;
8640             }
8641         }
8642     }
8643 #endif
8644
8645   /* Generate the symbol table.  */
8646   BFD_ASSERT (PRIV (syms) == NULL);
8647   if (info->strip != strip_all)
8648     bfd_hash_traverse (&info->hash->table, alpha_vms_link_output_symbol, info);
8649
8650   /* Find the entry point.  */
8651   if (bfd_get_start_address (abfd) == 0)
8652     {
8653       bfd *startbfd = NULL;
8654
8655       for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8656         {
8657           /* Consider only VMS object files.  */
8658           if (sub->xvec != abfd->xvec)
8659             continue;
8660
8661           if (!PRIV2 (sub, eom_data).eom_has_transfer)
8662             continue;
8663           if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8664             continue;
8665           if (startbfd != NULL
8666               && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8667             {
8668               (*info->callbacks->einfo)
8669                 (_("%P: multiple entry points: in modules %B and %B\n"),
8670                  startbfd, sub);
8671               continue;
8672             }
8673           startbfd = sub;
8674         }
8675
8676       if (startbfd)
8677         {
8678           unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8679           bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8680           asection *sec;
8681
8682           sec = PRIV2 (startbfd, sections)[ps_idx];
8683
8684           bfd_set_start_address
8685             (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8686         }
8687     }
8688
8689   /* Set transfer addresses.  */
8690   {
8691     int i;
8692     struct bfd_link_hash_entry *h;
8693
8694     i = 0;
8695     PRIV (transfer_address[i++]) = 0xffffffff00000340ULL;       /* SYS$IMGACT */
8696     h = bfd_link_hash_lookup (info->hash, "LIB$INITIALIZE", FALSE, FALSE, TRUE);
8697     if (h != NULL && h->type == bfd_link_hash_defined)
8698       PRIV (transfer_address[i++]) =
8699         alpha_vms_get_sym_value (h->u.def.section, h->u.def.value);
8700     PRIV (transfer_address[i++]) = bfd_get_start_address (abfd);
8701     while (i < 4)
8702       PRIV (transfer_address[i++]) = 0;
8703   }
8704
8705   /* Allocate contents.
8706      Also compute the virtual base address.  */
8707   base_addr = (bfd_vma)-1;
8708   last_addr = 0;
8709   for (o = abfd->sections; o != NULL; o = o->next)
8710     {
8711       if (o->flags & SEC_HAS_CONTENTS)
8712         {
8713           o->contents = bfd_alloc (abfd, o->size);
8714           if (o->contents == NULL)
8715             return FALSE;
8716         }
8717       if (o->flags & SEC_LOAD)
8718         {
8719           if (o->vma < base_addr)
8720             base_addr = o->vma;
8721           if (o->vma + o->size > last_addr)
8722             last_addr = o->vma + o->size;
8723         }
8724       /* Clear the RELOC flags.  Currently we don't support incremental
8725          linking.  We use the RELOC flag for computing the eicp entries.  */
8726       o->flags &= ~SEC_RELOC;
8727     }
8728
8729   /* Create the fixup section.  */
8730   fixupsec = bfd_make_section_anyway_with_flags
8731     (info->output_bfd, "$FIXUP$",
8732      SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8733   if (fixupsec == NULL)
8734     return FALSE;
8735   last_addr = (last_addr + 0xffff) & ~0xffff;
8736   fixupsec->vma = last_addr;
8737
8738   alpha_vms_link_hash (info)->fixup = fixupsec;
8739   alpha_vms_link_hash (info)->base_addr = base_addr;
8740
8741   /* Create the DMT section, if necessary.  */
8742   BFD_ASSERT (PRIV (dst_section) == NULL);
8743   dst = bfd_get_section_by_name (abfd, "$DST$");
8744   if (dst != NULL && dst->size == 0)
8745     dst = NULL;
8746   if (dst != NULL)
8747     {
8748       PRIV (dst_section) = dst;
8749       dmt = bfd_make_section_anyway_with_flags
8750         (info->output_bfd, "$DMT$",
8751          SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8752       if (dmt == NULL)
8753         return FALSE;
8754     }
8755   else
8756     dmt = NULL;
8757
8758   /* Read all sections from the inputs.  */
8759   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8760     {
8761       if (sub->flags & DYNAMIC)
8762         {
8763           alpha_vms_create_eisd_for_shared (abfd, sub);
8764           continue;
8765         }
8766
8767       if (!alpha_vms_read_sections_content (sub, info))
8768         return FALSE;
8769     }
8770
8771   /* Handle all the link order information for the sections.
8772      Note: past this point, it is not possible to create new sections.  */
8773   for (o = abfd->sections; o != NULL; o = o->next)
8774     {
8775       for (p = o->map_head.link_order; p != NULL; p = p->next)
8776         {
8777           switch (p->type)
8778             {
8779             case bfd_section_reloc_link_order:
8780             case bfd_symbol_reloc_link_order:
8781               abort ();
8782               return FALSE;
8783             case bfd_indirect_link_order:
8784               /* Already done.  */
8785               break;
8786             default:
8787               if (! _bfd_default_link_order (abfd, info, o, p))
8788                 return FALSE;
8789               break;
8790             }
8791         }
8792     }
8793
8794   /* Compute fixups.  */
8795   if (!alpha_vms_build_fixups (info))
8796     return FALSE;
8797
8798   /* Compute the DMT.  */
8799   if (dmt != NULL)
8800     {
8801       int pass;
8802       unsigned char *contents = NULL;
8803
8804       /* In pass 1, compute the size.  In pass 2, write the DMT contents.  */
8805       for (pass = 0; pass < 2; pass++)
8806         {
8807           unsigned int off = 0;
8808
8809           /* For each object file (ie for each module).  */
8810           for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8811             {
8812               asection *sub_dst;
8813               struct vms_dmt_header *dmth = NULL;
8814               unsigned int psect_count;
8815
8816               /* Skip this module if it has no DST.  */
8817               sub_dst = PRIV2 (sub, dst_section);
8818               if (sub_dst == NULL || sub_dst->size == 0)
8819                 continue;
8820
8821               if (pass == 1)
8822                 {
8823                   /* Write the header.  */
8824                   dmth = (struct vms_dmt_header *)(contents + off);
8825                   bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8826                   bfd_putl32 (sub_dst->size, dmth->size);
8827                 }
8828
8829               off += sizeof (struct vms_dmt_header);
8830               psect_count = 0;
8831
8832               /* For each section (ie for each psect).  */
8833               for (o = sub->sections; o != NULL; o = o->next)
8834                 {
8835                   /* Only consider interesting sections.  */
8836                   if (!(o->flags & SEC_ALLOC))
8837                     continue;
8838                   if (o->flags & SEC_LINKER_CREATED)
8839                     continue;
8840
8841                   if (pass == 1)
8842                     {
8843                       /* Write an entry.  */
8844                       struct vms_dmt_psect *dmtp;
8845
8846                       dmtp = (struct vms_dmt_psect *)(contents + off);
8847                       bfd_putl32 (o->output_offset + o->output_section->vma,
8848                                   dmtp->start);
8849                       bfd_putl32 (o->size, dmtp->length);
8850                       psect_count++;
8851                     }
8852                   off += sizeof (struct vms_dmt_psect);
8853                 }
8854               if (pass == 1)
8855                 bfd_putl32 (psect_count, dmth->psect_count);
8856             }
8857
8858           if (pass == 0)
8859             {
8860               contents = bfd_zalloc (info->output_bfd, off);
8861               if (contents == NULL)
8862                 return FALSE;
8863               dmt->contents = contents;
8864               dmt->size = off;
8865             }
8866           else
8867             {
8868               BFD_ASSERT (off == dmt->size);
8869             }
8870         }
8871     }
8872
8873   return TRUE;
8874 }
8875
8876 /* Read the contents of a section.
8877    buf points to a buffer of buf_size bytes to be filled with
8878    section data (starting at offset into section)  */
8879
8880 static bfd_boolean
8881 alpha_vms_get_section_contents (bfd *abfd, asection *section,
8882                                 void *buf, file_ptr offset,
8883                                 bfd_size_type count)
8884 {
8885   asection *sec;
8886
8887   /* Image are easy.  */
8888   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8889     return _bfd_generic_get_section_contents (abfd, section,
8890                                               buf, offset, count);
8891
8892   /* Safety check.  */
8893   if (offset + count < count
8894       || offset + count > section->size)
8895     {
8896       bfd_set_error (bfd_error_invalid_operation);
8897       return FALSE;
8898     }
8899
8900   /* If the section is already in memory, just copy it.  */
8901   if (section->flags & SEC_IN_MEMORY)
8902     {
8903       BFD_ASSERT (section->contents != NULL);
8904       memcpy (buf, section->contents + offset, count);
8905       return TRUE;
8906     }
8907   if (section->size == 0)
8908     return TRUE;
8909
8910   /* Alloc in memory and read ETIRs.  */
8911   for (sec = abfd->sections; sec; sec = sec->next)
8912     {
8913       BFD_ASSERT (sec->contents == NULL);
8914
8915       if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
8916         {
8917           sec->contents = bfd_alloc (abfd, sec->size);
8918           if (sec->contents == NULL)
8919             return FALSE;
8920         }
8921     }
8922   if (!alpha_vms_read_sections_content (abfd, NULL))
8923     return FALSE;
8924   for (sec = abfd->sections; sec; sec = sec->next)
8925     if (sec->contents)
8926       sec->flags |= SEC_IN_MEMORY;
8927   memcpy (buf, section->contents + offset, count);
8928   return TRUE;
8929 }
8930
8931
8932 /* Set the format of a file being written.  */
8933
8934 static bfd_boolean
8935 alpha_vms_mkobject (bfd * abfd)
8936 {
8937   const bfd_arch_info_type *arch;
8938
8939   vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
8940
8941   if (!vms_initialize (abfd))
8942     return FALSE;
8943
8944   PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
8945   if (PRIV (recwr.buf) == NULL)
8946     return FALSE;
8947
8948   arch = bfd_scan_arch ("alpha");
8949
8950   if (arch == 0)
8951     {
8952       bfd_set_error (bfd_error_wrong_format);
8953       return FALSE;
8954     }
8955
8956   abfd->arch_info = arch;
8957   return TRUE;
8958 }
8959
8960
8961 /* 4.1, generic.  */
8962
8963 /* Called when the BFD is being closed to do any necessary cleanup.  */
8964
8965 static bfd_boolean
8966 vms_close_and_cleanup (bfd * abfd)
8967 {
8968   vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
8969
8970   if (abfd == NULL || abfd->tdata.any == NULL)
8971     return TRUE;
8972
8973   if (abfd->format == bfd_archive)
8974     {
8975       bfd_release (abfd, abfd->tdata.any);
8976       abfd->tdata.any = NULL;
8977       return TRUE;
8978     }
8979
8980   if (PRIV (recrd.buf) != NULL)
8981     free (PRIV (recrd.buf));
8982
8983   if (PRIV (sections) != NULL)
8984     free (PRIV (sections));
8985
8986   bfd_release (abfd, abfd->tdata.any);
8987   abfd->tdata.any = NULL;
8988
8989 #ifdef VMS
8990   if (abfd->direction == write_direction)
8991     {
8992       /* Last step on VMS is to convert the file to variable record length
8993          format.  */
8994       if (bfd_cache_close (abfd) != TRUE)
8995         return FALSE;
8996       if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
8997         return FALSE;
8998     }
8999 #endif
9000
9001   return TRUE;
9002 }
9003
9004 /* Called when a new section is created.  */
9005
9006 static bfd_boolean
9007 vms_new_section_hook (bfd * abfd, asection *section)
9008 {
9009   bfd_size_type amt;
9010
9011   vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
9012                abfd, section->index, section->name));
9013
9014   if (! bfd_set_section_alignment (abfd, section, 0))
9015     return FALSE;
9016
9017   vms_debug2 ((7, "%d: %s\n", section->index, section->name));
9018
9019   amt = sizeof (struct vms_section_data_struct);
9020   section->used_by_bfd = bfd_zalloc (abfd, amt);
9021   if (section->used_by_bfd == NULL)
9022     return FALSE;
9023
9024   /* Create the section symbol.  */
9025   return _bfd_generic_new_section_hook (abfd, section);
9026 }
9027
9028 /* Part 4.5, symbols.  */
9029
9030 /* Print symbol to file according to how. how is one of
9031    bfd_print_symbol_name        just print the name
9032    bfd_print_symbol_more        print more (???)
9033    bfd_print_symbol_all print all we know, which is not much right now :-).  */
9034
9035 static void
9036 vms_print_symbol (bfd * abfd,
9037                   void * file,
9038                   asymbol *symbol,
9039                   bfd_print_symbol_type how)
9040 {
9041   vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
9042                abfd, file, symbol, how));
9043
9044   switch (how)
9045     {
9046       case bfd_print_symbol_name:
9047       case bfd_print_symbol_more:
9048         fprintf ((FILE *)file," %s", symbol->name);
9049       break;
9050
9051       case bfd_print_symbol_all:
9052         {
9053           const char *section_name = symbol->section->name;
9054
9055           bfd_print_symbol_vandf (abfd, file, symbol);
9056
9057           fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9058         }
9059       break;
9060     }
9061 }
9062
9063 /* Return information about symbol in ret.
9064
9065    fill type, value and name
9066    type:
9067         A       absolute
9068         B       bss segment symbol
9069         C       common symbol
9070         D       data segment symbol
9071         f       filename
9072         t       a static function symbol
9073         T       text segment symbol
9074         U       undefined
9075         -       debug.  */
9076
9077 static void
9078 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9079                      asymbol *symbol,
9080                      symbol_info *ret)
9081 {
9082   asection *sec;
9083
9084   vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9085
9086   sec = symbol->section;
9087
9088   if (ret == NULL)
9089     return;
9090
9091   if (sec == NULL)
9092     ret->type = 'U';
9093   else if (bfd_is_com_section (sec))
9094     ret->type = 'C';
9095   else if (bfd_is_abs_section (sec))
9096     ret->type = 'A';
9097   else if (bfd_is_und_section (sec))
9098     ret->type = 'U';
9099   else if (bfd_is_ind_section (sec))
9100     ret->type = 'I';
9101   else if ((symbol->flags & BSF_FUNCTION)
9102            || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
9103     ret->type = 'T';
9104   else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9105     ret->type = 'D';
9106   else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9107     ret->type = 'B';
9108   else
9109     ret->type = '?';
9110
9111   if (ret->type != 'U')
9112     ret->value = symbol->value + symbol->section->vma;
9113   else
9114     ret->value = 0;
9115   ret->name = symbol->name;
9116 }
9117
9118 /* Return TRUE if the given symbol sym in the BFD abfd is
9119    a compiler generated local label, else return FALSE.  */
9120
9121 static bfd_boolean
9122 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9123                              const char *name)
9124 {
9125   return name[0] == '$';
9126 }
9127 \f
9128 /* Part 4.7, writing an object file.  */
9129
9130 /* Sets the contents of the section section in BFD abfd to the data starting
9131    in memory at LOCATION. The data is written to the output section starting
9132    at offset offset for count bytes.
9133
9134    Normally TRUE is returned, else FALSE. Possible error returns are:
9135    o bfd_error_no_contents - The output section does not have the
9136         SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9137    o and some more too  */
9138
9139 static bfd_boolean
9140 _bfd_vms_set_section_contents (bfd * abfd,
9141                                asection *section,
9142                                const void * location,
9143                                file_ptr offset,
9144                                bfd_size_type count)
9145 {
9146   if (section->contents == NULL)
9147     {
9148       section->contents = bfd_alloc (abfd, section->size);
9149       if (section->contents == NULL)
9150         return FALSE;
9151
9152       memcpy (section->contents + offset, location, (size_t) count);
9153     }
9154
9155   return TRUE;
9156 }
9157
9158 /* Set the architecture and machine type in BFD abfd to arch and mach.
9159    Find the correct pointer to a structure and insert it into the arch_info
9160    pointer.  */
9161
9162 static bfd_boolean
9163 alpha_vms_set_arch_mach (bfd *abfd,
9164                          enum bfd_architecture arch, unsigned long mach)
9165 {
9166   if (arch != bfd_arch_alpha
9167       && arch != bfd_arch_unknown)
9168     return FALSE;
9169
9170   return bfd_default_set_arch_mach (abfd, arch, mach);
9171 }
9172
9173 /* Set section VMS flags.  Clear NO_FLAGS and set FLAGS.  */
9174
9175 void
9176 bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9177                            asection *sec, flagword no_flags, flagword flags)
9178 {
9179   vms_section_data (sec)->no_flags = no_flags;
9180   vms_section_data (sec)->flags = flags;
9181 }
9182
9183 struct vms_private_data_struct *
9184 bfd_vms_get_data (bfd *abfd)
9185 {
9186   return (struct vms_private_data_struct *)abfd->tdata.any;
9187 }
9188
9189 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9190 #define vms_bfd_link_just_syms            _bfd_generic_link_just_syms
9191 #define vms_bfd_copy_link_hash_symbol_type \
9192   _bfd_generic_copy_link_hash_symbol_type
9193 #define vms_bfd_is_group_section          bfd_generic_is_group_section
9194 #define vms_bfd_discard_group             bfd_generic_discard_group
9195 #define vms_section_already_linked        _bfd_generic_section_already_linked
9196 #define vms_bfd_define_common_symbol      bfd_generic_define_common_symbol
9197 #define vms_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data
9198
9199 #define vms_bfd_copy_private_bfd_data     _bfd_generic_bfd_copy_private_bfd_data
9200 #define vms_bfd_free_cached_info          _bfd_generic_bfd_free_cached_info
9201 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9202 #define vms_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data
9203 #define vms_bfd_set_private_flags         _bfd_generic_bfd_set_private_flags
9204 #define vms_bfd_merge_private_bfd_data    _bfd_generic_bfd_merge_private_bfd_data
9205
9206 /* Symbols table.  */
9207 #define alpha_vms_make_empty_symbol        _bfd_generic_make_empty_symbol
9208 #define alpha_vms_bfd_is_target_special_symbol \
9209    ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9210 #define alpha_vms_print_symbol             vms_print_symbol
9211 #define alpha_vms_get_symbol_info          vms_get_symbol_info
9212 #define alpha_vms_read_minisymbols         _bfd_generic_read_minisymbols
9213 #define alpha_vms_minisymbol_to_symbol     _bfd_generic_minisymbol_to_symbol
9214 #define alpha_vms_get_lineno               _bfd_nosymbols_get_lineno
9215 #define alpha_vms_find_inliner_info        _bfd_nosymbols_find_inliner_info
9216 #define alpha_vms_bfd_make_debug_symbol    _bfd_nosymbols_bfd_make_debug_symbol
9217 #define alpha_vms_find_nearest_line        _bfd_vms_find_nearest_dst_line
9218 #define _bfd_generic_find_nearest_line_discriminator \
9219   _bfd_vms_find_nearest_line_discriminator
9220 #define alpha_vms_bfd_is_local_label_name  vms_bfd_is_local_label_name
9221
9222 /* Generic table.  */
9223 #define alpha_vms_close_and_cleanup        vms_close_and_cleanup
9224 #define alpha_vms_bfd_free_cached_info     vms_bfd_free_cached_info
9225 #define alpha_vms_new_section_hook         vms_new_section_hook
9226 #define alpha_vms_set_section_contents     _bfd_vms_set_section_contents
9227 #define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9228
9229 #define alpha_vms_bfd_get_relocated_section_contents \
9230   bfd_generic_get_relocated_section_contents
9231
9232 #define alpha_vms_bfd_relax_section bfd_generic_relax_section
9233 #define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9234 #define alpha_vms_bfd_lookup_section_flags bfd_generic_lookup_section_flags
9235 #define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9236 #define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9237 #define alpha_vms_bfd_discard_group bfd_generic_discard_group
9238 #define alpha_vms_section_already_linked \
9239   _bfd_generic_section_already_linked
9240
9241 #define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9242 #define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
9243 #define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9244 #define alpha_vms_bfd_copy_link_hash_symbol_type \
9245   _bfd_generic_copy_link_hash_symbol_type
9246
9247 #define alpha_vms_bfd_link_split_section  _bfd_generic_link_split_section
9248
9249 #define alpha_vms_get_dynamic_symtab_upper_bound \
9250   _bfd_nodynamic_get_dynamic_symtab_upper_bound
9251 #define alpha_vms_canonicalize_dynamic_symtab \
9252   _bfd_nodynamic_canonicalize_dynamic_symtab
9253 #define alpha_vms_get_dynamic_reloc_upper_bound \
9254   _bfd_nodynamic_get_dynamic_reloc_upper_bound
9255 #define alpha_vms_canonicalize_dynamic_reloc \
9256   _bfd_nodynamic_canonicalize_dynamic_reloc
9257
9258 const bfd_target vms_alpha_vec =
9259 {
9260   "vms-alpha",                  /* Name.  */
9261   bfd_target_evax_flavour,
9262   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */
9263   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */
9264
9265   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9266    | WP_TEXT | D_PAGED),        /* Object flags.  */
9267   (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9268    | SEC_READONLY | SEC_CODE | SEC_DATA
9269    | SEC_HAS_CONTENTS | SEC_IN_MEMORY),         /* Sect flags.  */
9270   0,                            /* symbol_leading_char.  */
9271   ' ',                          /* ar_pad_char.  */
9272   15,                           /* ar_max_namelen.  */
9273   0,                            /* match priority.  */
9274   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9275   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9276   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9277   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9278   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9279   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9280
9281   {_bfd_dummy_target, alpha_vms_object_p,       /* bfd_check_format.  */
9282    _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9283   {bfd_false, alpha_vms_mkobject,               /* bfd_set_format.  */
9284    _bfd_vms_lib_alpha_mkarchive, bfd_false},
9285   {bfd_false, alpha_vms_write_object_contents,  /* bfd_write_contents.  */
9286    _bfd_vms_lib_write_archive_contents, bfd_false},
9287
9288   BFD_JUMP_TABLE_GENERIC (alpha_vms),
9289   BFD_JUMP_TABLE_COPY (vms),
9290   BFD_JUMP_TABLE_CORE (_bfd_nocore),
9291   BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9292   BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9293   BFD_JUMP_TABLE_RELOCS (alpha_vms),
9294   BFD_JUMP_TABLE_WRITE (alpha_vms),
9295   BFD_JUMP_TABLE_LINK (alpha_vms),
9296   BFD_JUMP_TABLE_DYNAMIC (alpha_vms),
9297
9298   NULL,
9299
9300   NULL
9301 };