bfd/vms-alpha.c

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