bfd/vms-alpha.c

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