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