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