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