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