bfd/vms-alpha.c

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