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