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