bfd/vms-alpha.c

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