bfd/vms-alpha.c

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