bfd/vms-alpha.c

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