/* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.

   Copyright (C) 1996-2023 Free Software Foundation, Inc.

   Initial version written by Klaus Kaempf (kkaempf@rmi.de)

   Major rewrite by Adacore.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/* TODO:

   o  overlayed sections

   o  PIC

   o  Generation of shared image

   o  Relocation optimizations

   o  EISD for the stack

   o  Vectors isect

   o  64 bits sections

   o  Entry point

   o  LIB$INITIALIZE

   o  protected sections (for messages)

   ...

*/

#include "sysdep.h"

#include <limits.h>

#include "bfd.h"

#include "bfdlink.h"

#include "libbfd.h"

#include "bfdver.h"

#include "vms.h"

#include "vms/eihd.h"

#include "vms/eiha.h"

#include "vms/eihi.h"

#include "vms/eihs.h"

#include "vms/eisd.h"

#include "vms/dmt.h"

#include "vms/dst.h"

#include "vms/eihvn.h"

#include "vms/eobjrec.h"

#include "vms/egsd.h"

#include "vms/egps.h"

#include "vms/esgps.h"

#include "vms/eeom.h"

#include "vms/emh.h"

#include "vms/eiaf.h"

#include "vms/shl.h"

#include "vms/eicp.h"

#include "vms/etir.h"

#include "vms/egsy.h"

#include "vms/esdf.h"

#include "vms/esdfm.h"

#include "vms/esdfv.h"

#include "vms/esrf.h"

#include "vms/egst.h"

#include "vms/eidc.h"

#include "vms/dsc.h"

#include "vms/prt.h"

#include "vms/internal.h"

#define MIN(a,b) ((a) < (b) ? (a) : (b))

#ifndef CHAR_BIT

#define CHAR_BIT 8

#endif

/* The r_type field in a reloc is one of the following values.  */

#define ALPHA_R_IGNORE    0

#define ALPHA_R_REFQUAD   1

#define ALPHA_R_BRADDR    2

#define ALPHA_R_HINT    3

#define ALPHA_R_SREL16    4

#define ALPHA_R_SREL32    5

#define ALPHA_R_SREL64    6

#define ALPHA_R_OP_PUSH   7

#define ALPHA_R_OP_STORE  8

#define ALPHA_R_OP_PSUB   9

#define ALPHA_R_OP_PRSHIFT  10

#define ALPHA_R_LINKAGE   11

#define ALPHA_R_REFLONG   12

#define ALPHA_R_CODEADDR  13

#define ALPHA_R_NOP   14

#define ALPHA_R_BSR   15

#define ALPHA_R_LDA   16

#define ALPHA_R_BOH   17

/* These are used with DST_S_C_LINE_NUM.  */

#define DST_S_C_LINE_NUM_HEADER_SIZE 4

/* These are used with DST_S_C_SOURCE */

#define DST_S_B_PCLINE_UNSBYTE   1

#define DST_S_W_PCLINE_UNSWORD   1

#define DST_S_L_PCLINE_UNSLONG   1

#define DST_S_B_MODBEG_NAME 14

#define DST_S_L_RTNBEG_ADDRESS   5

#define DST_S_B_RTNBEG_NAME 13

#define DST_S_L_RTNEND_SIZE  5

/* These are used with DST_S_C_SOURCE.  */

#define DST_S_C_SOURCE_HEADER_SIZE 4

#define DST_S_B_SRC_DF_LENGTH   1

#define DST_S_W_SRC_DF_FILEID   3

#define DST_S_B_SRC_DF_FILENAME  20

#define DST_S_B_SRC_UNSBYTE   1

#define DST_S_W_SRC_UNSWORD   1

#define DST_S_L_SRC_UNSLONG   1

/* Debugger symbol definitions.  */

#define DBG_S_L_DMT_MODBEG   0

#define DBG_S_L_DST_SIZE   4

#define DBG_S_W_DMT_PSECT_COUNT  8

#define DBG_S_C_DMT_HEADER_SIZE 12

#define DBG_S_L_DMT_PSECT_START  0

#define DBG_S_L_DMT_PSECT_LENGTH 4

#define DBG_S_C_DMT_PSECT_SIZE   8

/* VMS module header.  */

struct hdr_struct

{

  char hdr_b_strlvl;

  int hdr_l_arch1;

  int hdr_l_arch2;

  int hdr_l_recsiz;

  char *hdr_t_name;

  char *hdr_t_version;

  char *hdr_t_date;

  char *hdr_c_lnm;

  char *hdr_c_src;

  char *hdr_c_ttl;

};

#define EMH_DATE_LENGTH  17

/* VMS End-Of-Module records (EOM/EEOM).  */

struct eom_struct

{

  unsigned int eom_l_total_lps;

  unsigned short eom_w_comcod;

  bool eom_has_transfer;

  unsigned char eom_b_tfrflg;

  unsigned int eom_l_psindx;

  unsigned int eom_l_tfradr;

};

struct vms_symbol_entry

{

  bfd *owner;

  /* Common fields.  */

  unsigned char typ;

  unsigned char data_type;

  unsigned short flags;

  /* Section and offset/value of the symbol.  */

  unsigned int value;

  asection *section;

  /* Section and offset/value for the entry point (only for subprg).  */

  asection *code_section;

  unsigned int code_value;

  /* Symbol vector offset.  */

  unsigned int symbol_vector;

  /* Length of the name.  */

  unsigned char namelen;

  char name[1];

};

/* Stack value for push/pop commands.  */

struct stack_struct

{

  bfd_vma value;

  unsigned int reloc;

};

#define STACKSIZE 128

/* A minimal decoding of DST compilation units.  We only decode

   what's needed to get to the line number information.  */

struct fileinfo

{

  char *name;

  unsigned int srec;

};

struct srecinfo

{

  struct srecinfo *next;

  unsigned int line;

  unsigned int sfile;

  unsigned int srec;

};

struct lineinfo

{

  struct lineinfo *next;

  bfd_vma address;

  unsigned int line;

};

struct funcinfo

{

  struct funcinfo *next;

  char *name;

  bfd_vma low;

  bfd_vma high;

};

struct module

{

  /* Chain the previously read compilation unit.  */

  struct module *next;

  /* The module name.  */

  char *name;

  /* The start offset and size of debug info in the DST section.  */

  unsigned int modbeg;

  unsigned int size;

  /* The lowest and highest addresses contained in this compilation

     unit as specified in the compilation unit header.  */

  bfd_vma low;

  bfd_vma high;

  /* The listing line table.  */

  struct lineinfo *line_table;

  /* The source record table.  */

  struct srecinfo *srec_table;

  /* A list of the functions found in this module.  */

  struct funcinfo *func_table;

  /* Current allocation of file_table.  */

  unsigned int file_table_count;

  /* An array of the files making up this module.  */

  struct fileinfo *file_table;

};

/* BFD private data for alpha-vms.  */

struct vms_private_data_struct

{

  /* If 1, relocs have been read successfully, if 0 they have yet to be

     read, if -1 reading relocs failed.  */

  int reloc_done;

  /* Record input buffer.  */

  struct vms_rec_rd recrd;

  struct vms_rec_wr recwr;

  struct hdr_struct hdr_data;   /* data from HDR/EMH record  */

  struct eom_struct eom_data;   /* data from EOM/EEOM record  */

  /* Transfer addresses (entry points).  */

  bfd_vma transfer_address[4];

  /* Array of GSD sections to get the correspond BFD one.  */

  unsigned int section_max;   /* Size of the sections array.  */

  unsigned int section_count;   /* Number of GSD sections.  */

  asection **sections;

  /* Array of raw symbols.  */

  struct vms_symbol_entry **syms;

  /* Canonicalized symbols.  */

  asymbol **csymbols;

  /* Number of symbols.  */

  unsigned int gsd_sym_count;

  /* Size of the syms array.  */

  unsigned int max_sym_count;

  /* Number of procedure symbols.  */

  unsigned int norm_sym_count;

  /* Stack used to evaluate TIR/ETIR commands.  */

  struct stack_struct *stack;

  int stackptr;

  /* Content reading.  */

  asection *image_section;    /* section for image_ptr  */

  file_ptr image_offset;    /* Offset for image_ptr.  */

  struct module *modules;   /* list of all compilation units */

  /* The DST section.  */

  asection *dst_section;

  unsigned int dst_ptr_offsets_count; /* # of offsets in following array  */

  unsigned int *dst_ptr_offsets;  /* array of saved image_ptr offsets */

  /* Shared library support */

  bfd_vma symvva; /* relative virtual address of symbol vector */

  unsigned int ident;

  unsigned char matchctl;

  /* Shared library index.  This is used for input bfd while linking.  */

  unsigned int shr_index;

  /* Used to place structures in the file.  */

  file_ptr file_pos;

  /* Simply linked list of eisd.  */

  struct vms_internal_eisd_map *eisd_head;

  struct vms_internal_eisd_map *eisd_tail;

  /* Simply linked list of eisd for shared libraries.  */

  struct vms_internal_eisd_map *gbl_eisd_head;

  struct vms_internal_eisd_map *gbl_eisd_tail;

  /* linkage index counter used by conditional store commands */

  unsigned int vms_linkage_index;

};

#define PRIV2(abfd, name) \

  (((struct vms_private_data_struct *)(abfd)->tdata.any)->name)

#define PRIV(name) PRIV2(abfd,name)

/* Used to keep extra VMS specific information for a given section.

   reloc_size holds the size of the relocation stream, note this

   is very different from the number of relocations as VMS relocations

   are variable length.

   reloc_stream is the actual stream of relocation entries.  */

struct vms_section_data_struct

{

  /* Maximnum number of entries in sec->relocation.  */

  unsigned reloc_max;

  /* Corresponding eisd.  Used only while generating executables.  */

  struct vms_internal_eisd_map *eisd;

  /* PSC flags to be clear.  */

  flagword no_flags;

  /* PSC flags to be set.  */

  flagword flags;

};

#define vms_section_data(sec) \

  ((struct vms_section_data_struct *)sec->used_by_bfd)

/* To be called from the debugger.  */

struct vms_private_data_struct *bfd_vms_get_data (bfd *);

static int vms_get_remaining_object_record (bfd *, unsigned int);

static bool _bfd_vms_slurp_object_records (bfd * abfd);

static bool alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);

static bool alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);

static bool alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,

            bfd_vma);

static bool alpha_vms_add_fixup_lr (struct bfd_link_info *, unsigned int,

            bfd_vma);

static bool alpha_vms_add_lw_reloc (struct bfd_link_info *);

static bool alpha_vms_add_qw_reloc (struct bfd_link_info *);

struct vector_type

{

  unsigned int max_el;

  unsigned int nbr_el;

  void *els;

};

/* Number of elements in VEC.  */

#define VEC_COUNT(VEC) ((VEC).nbr_el)

/* Get the address of the Nth element.  */

#define VEC_EL(VEC, TYPE, N) (((TYPE *)((VEC).els))[N])

#define VEC_INIT(VEC)       \

  do {           \

    (VEC).max_el = 0;       \

    (VEC).nbr_el = 0;       \

    (VEC).els = NULL;       \

  } while (0)

/* Be sure there is room for a new element.  */

static void *vector_grow1 (struct vector_type *vec, size_t elsz);

/* Allocate room for a new element and return its address.  */

#define VEC_APPEND(VEC, TYPE)         \

  ((TYPE *) vector_grow1 (&VEC, sizeof (TYPE)))

struct alpha_vms_vma_ref

{

  bfd_vma vma;  /* Vma in the output.  */

  bfd_vma ref;  /* Reference in the input.  */

};

struct alpha_vms_shlib_el

{

  bfd *abfd;

  bool has_fixups;

  struct vector_type lp;  /* Vector of bfd_vma.  */

  struct vector_type ca;  /* Vector of bfd_vma.  */

  struct vector_type qr;  /* Vector of struct alpha_vms_vma_ref.  */

};

/* Alpha VMS linker hash table.  */

struct alpha_vms_link_hash_table

{

  struct bfd_link_hash_table root;

  /* Vector of shared libraries.  */

  struct vector_type shrlibs;

  /* Fixup section.  */

  asection *fixup;

  /* Base address.  Used by fixups.  */

  bfd_vma base_addr;

};

#define alpha_vms_link_hash(INFO) \

  ((struct alpha_vms_link_hash_table *)(INFO->hash))

/* Alpha VMS linker hash table entry.  */

struct alpha_vms_link_hash_entry

{

  struct bfd_link_hash_entry root;

  /* Pointer to the original vms symbol.  */

  struct vms_symbol_entry *sym;

};

/* Image reading.  */

/* Read & process EIHD record.

   Return TRUE on success, FALSE on error.  */

static bool

_bfd_vms_slurp_eihd (bfd *abfd, unsigned int *eisd_offset,

         unsigned int *eihs_offset)

{

  unsigned int imgtype, size;

  bfd_vma symvva;

  struct vms_eihd *eihd = (struct vms_eihd *)PRIV (recrd.rec);

  vms_debug2 ((8, "_bfd_vms_slurp_eihd\n"));

  /* PR 21813: Check for an undersized record.  */

  if (PRIV (recrd.buf_size) < sizeof (* eihd))

    {

      _bfd_error_handler (_("corrupt EIHD record - size is too small"));

      bfd_set_error (bfd_error_bad_value);

      return false;

    }

  size = bfd_getl32 (eihd->size);

  imgtype = bfd_getl32 (eihd->imgtype);

  if (imgtype == EIHD__K_EXE || imgtype == EIHD__K_LIM)

    abfd->flags |= EXEC_P;

  symvva = bfd_getl64 (eihd->symvva);

  if (symvva != 0)

    {

      PRIV (symvva) = symvva;

      abfd->flags |= DYNAMIC;

    }

  PRIV (ident) = bfd_getl32 (eihd->ident);

  PRIV (matchctl) = eihd->matchctl;

  *eisd_offset = bfd_getl32 (eihd->isdoff);

  *eihs_offset = bfd_getl32 (eihd->symdbgoff);

  vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",

         size, imgtype, (unsigned long)symvva,

         *eisd_offset, *eihs_offset));

  (void) size;

  return true;

}

/* Read & process EISD record.

   Return TRUE on success, FALSE on error.  */

static bool

_bfd_vms_slurp_eisd (bfd *abfd, unsigned int offset)

{

  int section_count = 0;

  vms_debug2 ((8, "_bfd_vms_slurp_eisd\n"));

  while (1)

    {

      struct vms_eisd *eisd;

      unsigned int rec_size;

      unsigned int size;

      uint64_t vaddr;

      unsigned int flags;

      unsigned int vbn;

      char *name = NULL;

      asection *section;

      flagword bfd_flags;

      /* PR 17512: file: 3d9e9fe9.  */

      if (offset > PRIV (recrd.rec_size)

    || (PRIV (recrd.rec_size) - offset

        < offsetof (struct vms_eisd, eisdsize) + 4))

  return false;

      eisd = (struct vms_eisd *) (PRIV (recrd.rec) + offset);

      rec_size = bfd_getl32 (eisd->eisdsize);

      if (rec_size == 0)

  break;

      /* Skip to next block if pad.  */

      if (rec_size == 0xffffffff)

  {

    offset = (offset + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);

    continue;

  }

      /* Make sure that there is enough data present in the record.  */

      if (rec_size < offsetof (struct vms_eisd, type) + 1)

  return false;

      /* Make sure that the record is not too big either.  */

      if (rec_size > PRIV (recrd.rec_size) - offset)

  return false;

      offset += rec_size;

      size = bfd_getl32 (eisd->secsize);

      vaddr = bfd_getl64 (eisd->virt_addr);

      flags = bfd_getl32 (eisd->flags);

      vbn = bfd_getl32 (eisd->vbn);

      vms_debug2 ((4, "EISD at 0x%x size 0x%x addr 0x%lx flags 0x%x blk %d\n",

       offset, size, (unsigned long)vaddr, flags, vbn));

      /* VMS combines psects from .obj files into isects in the .exe.  This

   process doesn't preserve enough information to reliably determine

   what's in each section without examining the data.  This is

   especially true of DWARF debug sections.  */

      bfd_flags = SEC_ALLOC;

      if (vbn != 0)

  bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;

      if (flags & EISD__M_EXE)

  bfd_flags |= SEC_CODE;

      if (flags & EISD__M_NONSHRADR)

  bfd_flags |= SEC_DATA;

      if (!(flags & EISD__M_WRT))

  bfd_flags |= SEC_READONLY;

      if (flags & EISD__M_DZRO)

  bfd_flags |= SEC_DATA;

      if (flags & EISD__M_FIXUPVEC)

  bfd_flags |= SEC_DATA;

      if (flags & EISD__M_CRF)

  bfd_flags |= SEC_DATA;

      if (flags & EISD__M_GBL)

  {

    if (rec_size <= offsetof (struct vms_eisd, gblnam))

      return false;

    else if (rec_size < sizeof (struct vms_eisd))

      name = _bfd_vms_save_counted_string (abfd, eisd->gblnam,

             rec_size - offsetof (struct vms_eisd, gblnam));

    else

      name = _bfd_vms_save_counted_string (abfd, eisd->gblnam,

             EISD__K_GBLNAMLEN);

    if (name == NULL || name[0] == 0)

      return false;

    bfd_flags |= SEC_COFF_SHARED_LIBRARY;

    bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);

  }

      else if (flags & EISD__M_FIXUPVEC)

  name = "$FIXUPVEC$";

      else if (eisd->type == EISD__K_USRSTACK)

  name = "$STACK$";

      else

  {

    const char *pfx;

    name = (char *) bfd_alloc (abfd, 32);

    if (name == NULL)

      return false;

    if (flags & EISD__M_DZRO)

      pfx = "BSS";

    else if (flags & EISD__M_EXE)

      pfx = "CODE";

    else if (!(flags & EISD__M_WRT))

      pfx = "RO";

    else

      pfx = "LOCAL";

    BFD_ASSERT (section_count < 999);

    sprintf (name, "$%s_%03d$", pfx, section_count++);

  }

      section = bfd_make_section (abfd, name);

      if (!section)

  return false;

      section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : 0;

      section->size = size;

      section->vma = vaddr;

      if (!bfd_set_section_flags (section, bfd_flags))

  return false;

    }

  return true;

}

/* Read & process EIHS record.

   Return TRUE on success, FALSE on error.  */

static bool

_bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)

{

  unsigned char *p = PRIV (recrd.rec) + offset;

  unsigned int gstvbn;

  unsigned int gstsize ATTRIBUTE_UNUSED;

  unsigned int dstvbn;

  unsigned int dstsize;

  unsigned int dmtvbn;

  unsigned int dmtbytes;

  asection *section;

  /* PR 21611: Check that offset is valid.  */

  if (offset > PRIV (recrd.rec_size) - (EIHS__L_DMTBYTES + 4))

    {

      _bfd_error_handler (_("unable to read EIHS record at offset %#x"),

        offset);

      bfd_set_error (bfd_error_file_truncated);

      return false;

    }

  gstvbn   = bfd_getl32 (p + EIHS__L_GSTVBN);

  gstsize  = bfd_getl32 (p + EIHS__L_GSTSIZE);

  dstvbn   = bfd_getl32 (p + EIHS__L_DSTVBN);

  dstsize  = bfd_getl32 (p + EIHS__L_DSTSIZE);

  dmtvbn   = bfd_getl32 (p + EIHS__L_DMTVBN);

  dmtbytes = bfd_getl32 (p + EIHS__L_DMTBYTES);

#if VMS_DEBUG

  vms_debug (8, "_bfd_vms_slurp_ihs\n");

  vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",

       gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);

#endif

  if (dstvbn)

    {

      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;

      section = bfd_make_section (abfd, "$DST$");

      if (!section)

  return false;

      section->size = dstsize;

      section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);

      if (!bfd_set_section_flags (section, bfd_flags))

  return false;

      PRIV (dst_section) = section;

      abfd->flags |= (HAS_DEBUG | HAS_LINENO);

    }

  if (dmtvbn)

    {

      flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;

      section = bfd_make_section (abfd, "$DMT$");

      if (!section)

  return false;

      section->size = dmtbytes;

      section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);

      if (!bfd_set_section_flags (section, bfd_flags))

  return false;

    }

  if (gstvbn)

    {

      if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))

  {

    bfd_set_error (bfd_error_file_truncated);

    return false;

  }

      if (!_bfd_vms_slurp_object_records (abfd))

  return false;

      abfd->flags |= HAS_SYMS;

    }

  return true;

}

/* Object file reading.  */

/* Object file input functions.  */

/* Get next record from object file to vms_buf.

   Set PRIV(buf_size) and return it

   This is a little tricky since it should be portable.

   The openVMS object file has 'variable length' which means that

   read() returns data in chunks of (hopefully) correct and expected

   size.  The linker (and other tools on VMS) depend on that. Unix

   doesn't know about 'formatted' files, so reading and writing such

   an object file in a Unix environment is not trivial.

   With the tool 'file' (available on all VMS FTP sites), one

   can view and change the attributes of a file.  Changing from

   'variable length' to 'fixed length, 512 bytes' reveals the

   record size at the first 2 bytes of every record.  The same

   may happen during the transfer of object files from VMS to Unix,

   at least with UCX, the DEC implementation of TCP/IP.

   The VMS format repeats the size at bytes 2 & 3 of every record.

   On the first call (file_format == FF_UNKNOWN) we check if

   the first and the third byte pair (!) of the record match.

   If they do it's an object file in an Unix environment or with

   wrong attributes (FF_FOREIGN), else we should be in a VMS

   environment where read() returns the record size (FF_NATIVE).

   Reading is always done in 2 steps:

    1. first just the record header is read and the size extracted,

    2. then the read buffer is adjusted and the remaining bytes are

       read in.

   All file I/O is done on even file positions.  */

#define VMS_OBJECT_ADJUSTMENT  2

static void

maybe_adjust_record_pointer_for_object (bfd *abfd)

{

  /* Set the file format once for all on the first invocation.  */

  if (PRIV (recrd.file_format) == FF_UNKNOWN)

    {

      if (PRIV (recrd.rec)[0] == PRIV (recrd.rec)[4]

    && PRIV (recrd.rec)[1] == PRIV (recrd.rec)[5])

  PRIV (recrd.file_format) = FF_FOREIGN;

      else

  PRIV (recrd.file_format) = FF_NATIVE;

    }

  /* The adjustment is needed only in an Unix environment.  */

  if (PRIV (recrd.file_format) == FF_FOREIGN)

    PRIV (recrd.rec) += VMS_OBJECT_ADJUSTMENT;

}

/* Implement step #1 of the object record reading procedure.

   Return the record type or -1 on failure.  */

static int

_bfd_vms_get_object_record (bfd *abfd)

{

  unsigned int test_len = 6;

  int type;

  vms_debug2 ((8, "_bfd_vms_get_obj_record\n"));

  /* Skip alignment byte if the current position is odd.  */

  if (PRIV (recrd.file_format) == FF_FOREIGN && (bfd_tell (abfd) & 1))

    {

      if (bfd_read (PRIV (recrd.buf), 1, abfd) != 1)

  {

    bfd_set_error (bfd_error_file_truncated);

    return -1;

  }

    }

  /* Read the record header  */

  if (bfd_read (PRIV (recrd.buf), test_len, abfd) != test_len)

    {

      bfd_set_error (bfd_error_file_truncated);

      return -1;

    }

  /* Reset the record pointer.  */

  PRIV (recrd.rec) = PRIV (recrd.buf);

  maybe_adjust_record_pointer_for_object (abfd);

  if (vms_get_remaining_object_record (abfd, test_len) <= 0)

    return -1;

  type = bfd_getl16 (PRIV (recrd.rec));

  vms_debug2 ((8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",

         PRIV (recrd.rec), PRIV (recrd.rec_size), type));

  return type;

}

/* Implement step #2 of the object record reading procedure.

   Return the size of the record or 0 on failure.  */

static int

vms_get_remaining_object_record (bfd *abfd, unsigned int read_so_far)

{

  unsigned int to_read;

  vms_debug2 ((8, "vms_get_remaining_obj_record\n"));

  /* Extract record size.  */

  PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);

  if (PRIV (recrd.rec_size) == 0)

    {

      bfd_set_error (bfd_error_file_truncated);

      return 0;

    }

  /* That's what the linker manual says.  */

  if (PRIV (recrd.rec_size) > EOBJ__C_MAXRECSIZ)

    {

      bfd_set_error (bfd_error_file_truncated);

      return 0;

    }

  /* Take into account object adjustment.  */

  to_read = PRIV (recrd.rec_size);

  if (PRIV (recrd.file_format) == FF_FOREIGN)

    to_read += VMS_OBJECT_ADJUSTMENT;

  /* Adjust the buffer.  */

  if (to_read > PRIV (recrd.buf_size))

    {

      PRIV (recrd.buf)

  = (unsigned char *) bfd_realloc_or_free (PRIV (recrd.buf), to_read);

      if (PRIV (recrd.buf) == NULL)

  return 0;

      PRIV (recrd.buf_size) = to_read;

    }

  /* PR 17512: file: 025-1974-0.004.  */

  else if (to_read <= read_so_far)

    return 0;

  /* Read the remaining record.  */

  to_read -= read_so_far;

  vms_debug2 ((8, "vms_get_remaining_obj_record: to_read %d\n", to_read));

  if (bfd_read (PRIV (recrd.buf) + read_so_far, to_read, abfd) != to_read)

    {

      bfd_set_error (bfd_error_file_truncated);

      return 0;

    }

  /* Reset the record pointer.  */

  PRIV (recrd.rec) = PRIV (recrd.buf);

  maybe_adjust_record_pointer_for_object (abfd);

  vms_debug2 ((8, "vms_get_remaining_obj_record: size %d\n",

         PRIV (recrd.rec_size)));

  return PRIV (recrd.rec_size);

}

/* Read and process emh record.

   Return TRUE on success, FALSE on error.  */

static bool

_bfd_vms_slurp_ehdr (bfd *abfd)

{

  unsigned char *ptr;

  unsigned char *vms_rec;

  unsigned char *end;

  int subtype;

  vms_rec = PRIV (recrd.rec);

  /* PR 17512: file: 62736583.  */

  end = PRIV (recrd.buf) + PRIV (recrd.buf_size);

  vms_debug2 ((2, "HDR/EMH\n"));

  subtype = bfd_getl16 (vms_rec + 4);

  vms_debug2 ((3, "subtype %d\n", subtype));

  switch (subtype)

    {

    case EMH__C_MHD:

      /* Module header.  */

      if (vms_rec + 21 >= end)

  goto fail;

      PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];

      PRIV (hdr_data).hdr_l_arch1  = bfd_getl32 (vms_rec + 8);

      PRIV (hdr_data).hdr_l_arch2  = bfd_getl32 (vms_rec + 12);

      PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);

      if ((vms_rec + 20 + vms_rec[20] + 1) >= end)

  goto fail;

      PRIV (hdr_data).hdr_t_name

  = _bfd_vms_save_counted_string (abfd, vms_rec + 20, vms_rec[20]);

      ptr = vms_rec + 20 + vms_rec[20] + 1;

      if ((ptr + *ptr + 1) >= end)

  goto fail;

      PRIV (hdr_data).hdr_t_version

  = _bfd_vms_save_counted_string (abfd, ptr, *ptr);

      ptr += *ptr + 1;

      if (ptr + 17 >= end)

  goto fail;

      PRIV (hdr_data).hdr_t_date

  = _bfd_vms_save_sized_string (abfd, ptr, 17);

      break;

    case EMH__C_LNM:

      if (vms_rec + PRIV (recrd.rec_size - 6) > end)

  goto fail;

      PRIV (hdr_data).hdr_c_lnm

  = _bfd_vms_save_sized_string (abfd, vms_rec, PRIV (recrd.rec_size - 6));

      break;

    case EMH__C_SRC:

      if (vms_rec + PRIV (recrd.rec_size - 6) > end)

  goto fail;

      PRIV (hdr_data).hdr_c_src

  = _bfd_vms_save_sized_string (abfd, vms_rec, PRIV (recrd.rec_size - 6));

      break;

    case EMH__C_TTL:

      if (vms_rec + PRIV (recrd.rec_size - 6) > end)

  goto fail;

      PRIV (hdr_data).hdr_c_ttl

  = _bfd_vms_save_sized_string (abfd, vms_rec, PRIV (recrd.rec_size - 6));

      break;

    case EMH__C_CPR:

    case EMH__C_MTC:

    case EMH__C_GTX:

      break;

    default:

    fail:

      bfd_set_error (bfd_error_wrong_format);

      return false;

    }

  return true;

}

/* Typical sections for evax object files.  */

#define EVAX_ABS_NAME   "$ABS$"

#define EVAX_CODE_NAME    "$CODE$"

#define EVAX_LINK_NAME    "$LINK$"

#define EVAX_DATA_NAME    "$DATA$"

#define EVAX_BSS_NAME   "$BSS$"

#define EVAX_READONLYADDR_NAME  "$READONLY_ADDR$"

#define EVAX_READONLY_NAME  "$READONLY$"

#define EVAX_LITERAL_NAME "$LITERAL$"

#define EVAX_LITERALS_NAME  "$LITERALS"

#define EVAX_COMMON_NAME  "$COMMON$"

#define EVAX_LOCAL_NAME   "$LOCAL$"

struct sec_flags_struct

{

  const char *name;   /* Name of section.  */

  int vflags_always;

  flagword flags_always;  /* Flags we set always.  */

  int vflags_hassize;

  flagword flags_hassize; /* Flags we set if the section has a size > 0.  */

};