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