Subversion Repositories openrisc_2011-10-31

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

   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,

   2006, 2007, 2008, 2009, 2010 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 "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))

/* 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;

  bfd_boolean 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 true, relocs have been read.  */

  bfd_boolean 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 */

  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 */

  int vms_linkage_index;

  /* see tc-alpha.c of gas for a description.  */

  int flag_hash_long_names;     /* -+, hash instead of truncate */

  int flag_show_after_trunc;    /* -H, show hashing/truncation */

};

#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 *abfd);

static int vms_get_remaining_object_record (bfd *abfd, int read_so_far);

static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);

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

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

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

                                    bfd_vma);

static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);

static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);

static void alpha_vms_add_lw_fixup (struct bfd_link_info *, unsigned int,

                                    bfd_vma);

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)                                   \

  (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))

/* Append an element.  */

#define VEC_APPEND_EL(VEC, TYPE, EL)            \

  (*(VEC_APPEND (VEC, TYPE)) = EL)

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;

  bfd_boolean 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 libaries.  */

  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 bfd_boolean

_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"));

  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));

  return TRUE;

}

/* Read & process EISD record.

   Return TRUE on success, FALSE on error.  */

static bfd_boolean

_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;

      unsigned long long vaddr;

      unsigned int flags;

      unsigned int vbn;

      char *name = NULL;

      asection *section;

      flagword bfd_flags;

      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;

        }

      else

        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)

        {

          name = _bfd_vms_save_counted_string (eisd->gblnam);

          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 (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 (abfd, section, bfd_flags))

        return FALSE;

    }

  return TRUE;

}

/* Read & process EIHS record.

   Return TRUE on success, FALSE on error.  */

static bfd_boolean

_bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)

{

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

  unsigned int gstvbn = bfd_getl32 (p + EIHS__L_GSTVBN);

  unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS__L_GSTSIZE);

  unsigned int dstvbn = bfd_getl32 (p + EIHS__L_DSTVBN);

  unsigned int dstsize = bfd_getl32 (p + EIHS__L_DSTSIZE);

  unsigned int dmtvbn = bfd_getl32 (p + EIHS__L_DMTVBN);

  unsigned int dmtbytes = bfd_getl32 (p + EIHS__L_DMTBYTES);

  asection *section;

#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 (abfd, 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 (abfd, 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) != TRUE)

        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