OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [vms-hdr.c] - Diff between revs 157 and 225

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
/* vms-hdr.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
/* vms-hdr.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
   EVAX (openVMS/Alpha) files.
   EVAX (openVMS/Alpha) files.
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
   2007 Free Software Foundation, Inc.
   2007, 2008, 2009 Free Software Foundation, Inc.
 
 
   HDR record handling functions
   HDR record handling functions
   EMH record handling functions
   EMH record handling functions
   and
 
   EOM record handling functions
   EOM record handling functions
   EEOM record handling functions
   EEOM record handling functions
 
 
 
   IHD record handling functions
 
   EIHD record handling functions
 
 
 
   ISD record handling functions
 
   EISD record handling functions
 
 
 
   IHS record handling functions
 
   EIHS record handling functions
 
 
 
   DBG record handling functions
 
   EDBG record handling functions
 
 
 
   TBT record handling functions
 
   ETBT record handling functions
 
 
 
   DST/DMT section handling functions
 
 
   Written by Klaus K"ampf (kkaempf@rmi.de)
   Written by Klaus K"ampf (kkaempf@rmi.de)
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
Line 33... Line 50...
#include "safe-ctype.h"
#include "safe-ctype.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
#include "vms.h"
#include "vms.h"
 
 
#ifdef HAVE_ALLOCA_H
static struct module *new_module (bfd *);
#include <alloca.h>
static void parse_module
#endif
  (bfd *, struct module *, unsigned char *, unsigned int);
 
static struct module *build_module_list (bfd *);
 
static bfd_boolean module_find_nearest_line
 
  (bfd *, struct module *, bfd_vma, const char **, const char **,
 
   unsigned int *);
 
static int vms_slurp_debug (bfd *);
 
 
 
#define SET_MODULE_PARSED(m) \
 
  do { if ((m)->name == NULL) (m)->name = ""; } while (0)
 
#define IS_MODULE_PARSED(m) ((m)->name != NULL)
 
 
 
 
/* Read & process emh record
/* Read & process emh record
   return 0 on success, -1 on error.  */
   return 0 on success, -1 on error.  */
 
 
int
int
Line 83... Line 110...
      ptr += *ptr + 1;
      ptr += *ptr + 1;
      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
      break;
      break;
 
 
    case MHD_S_C_LNM:
    case MHD_S_C_LNM:
      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 2));
      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
      break;
      break;
 
 
    case MHD_S_C_SRC:
    case MHD_S_C_SRC:
      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 2));
      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
      break;
      break;
 
 
    case MHD_S_C_TTL:
    case MHD_S_C_TTL:
      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 2));
      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
      break;
      break;
 
 
    case EMH_S_C_MHD + EVAX_OFFSET:
    case EMH_S_C_MHD + EVAX_OFFSET:
      /* Module header.  */
      /* Module header.  */
      PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
      PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
Line 108... Line 135...
      ptr += *ptr + 1;
      ptr += *ptr + 1;
      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
      PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
      break;
      break;
 
 
    case EMH_S_C_LNM + EVAX_OFFSET:
    case EMH_S_C_LNM + EVAX_OFFSET:
      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 6));
      PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
      break;
      break;
 
 
    case EMH_S_C_SRC + EVAX_OFFSET:
    case EMH_S_C_SRC + EVAX_OFFSET:
      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 6));
      PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
      break;
      break;
 
 
    case EMH_S_C_TTL + EVAX_OFFSET:
    case EMH_S_C_TTL + EVAX_OFFSET:
      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_length - 6));
      PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
      break;
      break;
 
 
    case MHD_S_C_CPR:
    case MHD_S_C_CPR:
    case MHD_S_C_MTC:
    case MHD_S_C_MTC:
    case MHD_S_C_GTX:
    case MHD_S_C_GTX:
Line 187... Line 214...
{
{
  asymbol *symbol;
  asymbol *symbol;
  unsigned int symnum;
  unsigned int symnum;
  int had_case = 0;
  int had_case = 0;
  int had_file = 0;
  int had_file = 0;
 
  char version [256];
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (2, "vms_write_hdr (%p)\n", abfd);
  vms_debug (2, "vms_write_hdr (%p)\n", abfd);
#endif
#endif
 
 
Line 210... Line 238...
    {
    {
      /* Strip path and suffix information.  */
      /* Strip path and suffix information.  */
      char *fname, *fout, *fptr;
      char *fname, *fout, *fptr;
 
 
      fptr = bfd_get_filename (abfd);
      fptr = bfd_get_filename (abfd);
      fname = alloca (strlen (fptr) + 1);
      fname = strdup (fptr);
      strcpy (fname, fptr);
 
 
      /* Strip VMS path.  */
      fout = strrchr (fname, ']');
      fout = strrchr (fname, ']');
      if (fout == 0)
      if (fout == NULL)
        fout = strchr (fname, ':');
        fout = strchr (fname, ':');
      if (fout != 0)
      if (fout != NULL)
        fout++;
        fout++;
      else
      else
        fout = fname;
        fout = fname;
 
 
 
      /* Strip UNIX path.  */
 
      fptr = strrchr (fout, '/');
 
      if (fptr != NULL)
 
        fout = fptr + 1;
 
 
      /* Strip .obj suffix.  */
      /* Strip .obj suffix.  */
      fptr = strrchr (fname, '.');
      fptr = strrchr (fout, '.');
      if ((fptr != 0)
      if (fptr != 0 && strcasecmp (fptr, ".OBJ") == 0)
          && (strcasecmp (fptr, ".OBJ") == 0))
 
        *fptr = 0;
        *fptr = 0;
 
 
 
      /* Convert to upper case and truncate at 31 characters.
 
         (VMS object file format restricts module name length to 31).  */
      fptr = fout;
      fptr = fout;
      while (*fptr != 0)
      while (*fptr != 0)
        {
        {
          *fptr = TOUPPER (*fptr);
          *fptr = TOUPPER (*fptr);
          fptr++;
          fptr++;
          if ((*fptr == ';')
          if (*fptr == ';' || (fptr - fout) >= 31)
             || ((fptr - fout) > 31))
 
            *fptr = 0;
            *fptr = 0;
        }
        }
      _bfd_vms_output_counted (abfd, fout);
      _bfd_vms_output_counted (abfd, fout);
 
      free (fname);
    }
    }
  else
  else
    _bfd_vms_output_counted (abfd, "NONAME");
    _bfd_vms_output_counted (abfd, "NONAME");
 
 
  _bfd_vms_output_counted (abfd, BFD_VERSION_STRING);
  _bfd_vms_output_counted (abfd, BFD_VERSION_STRING);
  _bfd_vms_output_dump (abfd, get_vms_time_string (), 17);
  _bfd_vms_output_dump (abfd, get_vms_time_string (), EMH_DATE_LENGTH);
  _bfd_vms_output_fill (abfd, 0, 17);
  _bfd_vms_output_fill (abfd, 0, EMH_DATE_LENGTH);
  _bfd_vms_output_flush (abfd);
  _bfd_vms_output_flush (abfd);
 
 
  /* LMN.  */
  /* LMN.  */
  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
  _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("GAS proGIS"));
  snprintf (version, sizeof (version), "GAS BFD v%s", BFD_VERSION_STRING);
 
  _bfd_vms_output_dump (abfd, (unsigned char *)version, strlen (version));
  _bfd_vms_output_flush (abfd);
  _bfd_vms_output_flush (abfd);
 
 
  /* SRC.  */
  /* SRC.  */
  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_SRC);
  _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_SRC);
 
 
Line 318... Line 354...
     || (objtype == OBJ_S_C_EOMW))
     || (objtype == OBJ_S_C_EOMW))
    {
    {
    }
    }
  else
  else
    {
    {
      PRIV (eom_data).eom_l_total_lps = bfd_getl32 (vms_rec + 4);
      PRIV (eom_data).eom_l_total_lps
      PRIV (eom_data).eom_b_comcod = *(vms_rec + 8);
        = bfd_getl32 (vms_rec + EEOM_S_L_TOTAL_LPS);
 
      PRIV (eom_data).eom_w_comcod = bfd_getl16 (vms_rec + EEOM_S_W_COMCOD);
      if (PRIV (eom_data).eom_b_comcod > 1)
      if (PRIV (eom_data).eom_w_comcod > 1)
        {
        {
          (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
          (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
          bfd_set_error (bfd_error_bad_value);
          bfd_set_error (bfd_error_bad_value);
          return -1;
          return -1;
        }
        }
      PRIV (eom_data).eom_has_transfer = FALSE;
      PRIV (eom_data).eom_has_transfer = FALSE;
      if (PRIV (rec_size) > 10)
      if (PRIV (rec_size) > 10)
        {
        {
           PRIV (eom_data).eom_has_transfer = TRUE;
           PRIV (eom_data).eom_has_transfer = TRUE;
           PRIV (eom_data).eom_b_tfrflg = *(vms_rec + 9);
           PRIV (eom_data).eom_b_tfrflg = vms_rec[EEOM_S_B_TFRFLG];
           PRIV (eom_data).eom_l_psindx = bfd_getl32 (vms_rec + 12);
           PRIV (eom_data).eom_l_psindx
           PRIV (eom_data).eom_l_tfradr = bfd_getl32 (vms_rec + 16);
             = bfd_getl32 (vms_rec + EEOM_S_L_PSINDX);
 
           PRIV (eom_data).eom_l_tfradr
 
             = bfd_getl32 (vms_rec + EEOM_S_L_TFRADR);
 
 
           abfd->start_address = PRIV (eom_data).eom_l_tfradr;
           abfd->start_address = PRIV (eom_data).eom_l_tfradr;
        }
        }
    }
    }
  return 0;
  return 0;
Line 376... Line 414...
 
 
  _bfd_vms_output_end (abfd);
  _bfd_vms_output_end (abfd);
  return 0;
  return 0;
}
}
 
 
 No newline at end of file
 No newline at end of file
 
/* Read & process IHD/EIHD record.
 
   Return 0 on success, -1 on error  */
 
int
 
_bfd_vms_slurp_ihd (bfd *abfd, unsigned int *isd_offset,
 
                    unsigned int *ihs_offset)
 
{
 
  unsigned int imgtype, size;
 
  bfd_vma symvva;
 
 
 
#if VMS_DEBUG
 
  vms_debug (8, "_bfd_vms_slurp_ihd\n");
 
#endif
 
 
 
  size = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
 
  imgtype = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_IMGTYPE);
 
 
 
  if (imgtype == EIHD_S_K_EXE)
 
    abfd->flags |= EXEC_P;
 
 
 
  symvva = bfd_getl64 (PRIV (vms_rec) + EIHD_S_Q_SYMVVA);
 
  if (symvva != 0)
 
    {
 
      PRIV (symvva) = symvva;
 
      abfd->flags |= DYNAMIC;
 
    }
 
 
 
  *isd_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_ISDOFF);
 
  *ihs_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SYMDBGOFF);
 
 
 
#if VMS_DEBUG
 
  vms_debug (4, "EIHD record size %d imgtype %d symvva 0x%llx isd %d ihs %d\n",
 
             size, imgtype, symvva, *isd_offset, *ihs_offset);
 
#endif
 
 
 
  return 0;
 
}
 
 
 
/* Read & process ISD/EISD record
 
   return 0 on success, -1 on error  */
 
 
 
int
 
_bfd_vms_slurp_isd (bfd *abfd, unsigned int offset)
 
{
 
  int section_count = 0;
 
  unsigned char *p;
 
  unsigned int rec_size;
 
 
 
#if VMS_DEBUG
 
  vms_debug (8, "_bfd_vms_slurp_isd\n");
 
#endif
 
 
 
  for (p = PRIV (vms_rec) + offset;
 
       (rec_size = bfd_getl32 (p + EISD_S_L_EISDSIZE)) != 0;
 
       p += rec_size)
 
    {
 
      unsigned long long vaddr = bfd_getl64 (p + EISD_S_Q_VIR_ADDR);
 
      unsigned int size = bfd_getl32 (p + EISD_S_L_SECSIZE);
 
      unsigned int flags = bfd_getl32 (p + EISD_S_L_FLAGS);
 
      unsigned int vbn = bfd_getl32 (p + EISD_S_L_VBN);
 
      char *name = NULL;
 
      asection *section;
 
      flagword bfd_flags;
 
 
 
#if VMS_DEBUG
 
      vms_debug (4, "EISD record at 0x%x size 0x%x addr 0x%x bfd_flags 0x%x block %d\n",
 
                 p - PRIV (vms_rec), size, vaddr, flags, vbn);
 
#endif
 
 
 
      /* 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 (flags & EISD_S_M_EXE)
 
        bfd_flags |= SEC_CODE | SEC_HAS_CONTENTS | SEC_LOAD;
 
 
 
      if (flags & EISD_S_M_NONSHRADR)
 
        bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
 
 
 
      if (!(flags & EISD_S_M_WRT))
 
        bfd_flags |= SEC_READONLY;
 
 
 
      if (flags & EISD_S_M_DZRO)
 
        bfd_flags |= SEC_DATA;
 
 
 
      if (flags & EISD_S_M_FIXUPVEC)
 
        bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
 
 
 
      if (flags & EISD_S_M_CRF)
 
        bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
 
 
 
      if (flags & EISD_S_M_GBL)
 
        {
 
          name = _bfd_vms_save_counted_string (p + EISD_S_T_GBLNAM);
 
          bfd_flags |= SEC_COFF_SHARED_LIBRARY;
 
          bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
 
        }
 
      else
 
        {
 
          name = (char*) bfd_alloc (abfd, 32);
 
          sprintf (name, "$LOCAL_%03d$", section_count++);
 
        }
 
 
 
      section = bfd_make_section (abfd, name);
 
 
 
      if (!section)
 
        return -1;
 
 
 
      section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : (unsigned int)-1;
 
      section->size = size;
 
      section->vma = vaddr;
 
 
 
      if (!bfd_set_section_flags (abfd, section, bfd_flags))
 
        return -1;
 
    }
 
 
 
  return 0;
 
}
 
 
 
/* Read & process IHS/EIHS record
 
   return 0 on success, -1 on error  */
 
int
 
_bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset)
 
{
 
  unsigned char *p = PRIV (vms_rec) + offset;
 
  unsigned int gstvbn = bfd_getl32 (p + EIHS_S_L_GSTVBN);
 
  unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS_S_L_GSTSIZE);
 
  unsigned int dstvbn = bfd_getl32 (p + EIHS_S_L_DSTVBN);
 
  unsigned int dstsize = bfd_getl32 (p + EIHS_S_L_DSTSIZE);
 
  unsigned int dmtvbn = bfd_getl32 (p + EIHS_S_L_DMTVBN);
 
  unsigned int dmtbytes = bfd_getl32 (p + EIHS_S_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 -1;
 
 
 
      section->size = dstsize;
 
      section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
 
 
 
      if (!bfd_set_section_flags (abfd, section, bfd_flags))
 
        return -1;
 
 
 
      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 -1;
 
 
 
      section->size = dmtbytes;
 
      section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
 
 
 
      if (!bfd_set_section_flags (abfd, section, bfd_flags))
 
        return -1;
 
    }
 
 
 
  if (gstvbn)
 
    {
 
      flagword bfd_flags = SEC_HAS_CONTENTS;
 
 
 
      section = bfd_make_section (abfd, "$GST$");
 
      if (!section)
 
        return -1;
 
 
 
      if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
 
        {
 
          bfd_set_error (bfd_error_file_truncated);
 
          return -1;
 
        }
 
 
 
      if (_bfd_vms_slurp_object_records (abfd) != 0)
 
        return -1;
 
 
 
      section->filepos = VMS_BLOCK_SIZE * (gstvbn - 1);
 
      section->size = bfd_tell (abfd) - section->filepos;
 
 
 
      if (!bfd_set_section_flags (abfd, section, bfd_flags))
 
        return -1;
 
 
 
      abfd->flags |= HAS_SYMS;
 
    }
 
 
 
  return 0;
 
}
 
 
 
/* Build a new module for the specified BFD.  */
 
 
 
static struct module *
 
new_module (bfd *abfd)
 
{
 
  struct module *module
 
    = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
 
  module->file_table_count = 16; /* Arbitrary.  */
 
  module->file_table
 
    = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
 
  return module;
 
}
 
 
 
/* Parse debug info for a module and internalize it.  */
 
 
 
static void
 
parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
 
              unsigned int length)
 
{
 
  unsigned char *maxptr = ptr + length, *src_ptr, *pcl_ptr;
 
  unsigned int prev_linum = 0, curr_linenum = 0;
 
  bfd_vma prev_pc = 0, curr_pc = 0;
 
  struct srecinfo *curr_srec, *srec;
 
  struct lineinfo *curr_line, *line;
 
  struct funcinfo *funcinfo;
 
 
 
  /* Initialize tables with zero element.  */
 
  curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
 
  module->srec_table = curr_srec;
 
 
 
  curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
 
  module->line_table = curr_line;
 
 
 
  while (ptr < maxptr)
 
    {
 
      /* The first byte is not counted in the recorded length.  */
 
      int rec_length = bfd_getl16 (ptr) + 1;
 
      int rec_type = bfd_getl16 (ptr + 2);
 
 
 
#if VMS_DEBUG
 
      _bfd_vms_debug (2, "DST record: length %d, type %d\n",
 
                      rec_length, rec_type);
 
#endif
 
 
 
      switch (rec_type)
 
        {
 
        case DST_S_C_MODBEG:
 
          module->name
 
            = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
 
 
 
          curr_pc = 0;
 
          prev_pc = 0;
 
          curr_linenum = 0;
 
          prev_linum = 0;
 
 
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "module: %s\n", module->name);
 
#endif
 
          break;
 
 
 
        case DST_S_C_MODEND:
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "end module\n");
 
#endif
 
          break;
 
 
 
        case DST_S_C_RTNBEG:
 
          funcinfo = (struct funcinfo *)
 
            bfd_zalloc (abfd, sizeof (struct funcinfo));
 
          funcinfo->name
 
            = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
 
          funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
 
          funcinfo->next = module->func_table;
 
          module->func_table = funcinfo;
 
 
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "routine: %s at 0x%x\n",
 
                          funcinfo->name, funcinfo->low);
 
#endif
 
          break;
 
 
 
        case DST_S_C_RTNEND:
 
          module->func_table->high = module->func_table->low
 
            + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
 
 
 
          if (module->func_table->high > module->high)
 
            module->high = module->func_table->high;
 
 
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "end routine\n");
 
#endif
 
          break;
 
 
 
        case DST_S_C_PROLOG:
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "prologue\n");
 
#endif
 
          break;
 
 
 
        case DST_S_C_EPILOG:
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "epilog\n");
 
#endif
 
          break;
 
 
 
        case DST_S_C_BLKBEG:
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "block\n");
 
#endif
 
          break;
 
 
 
        case DST_S_C_BLKEND:
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "end block\n");
 
#endif
 
          break;
 
 
 
        case DST_S_C_SOURCE:
 
          src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
 
 
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "source info\n");
 
#endif
 
 
 
          while (src_ptr < ptr + rec_length)
 
            {
 
              int cmd = src_ptr[0], cmd_length, data;
 
 
 
              switch (cmd)
 
                {
 
                case DST_S_C_SRC_DECLFILE:
 
                  {
 
                    unsigned int fileid
 
                      = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
 
                    char *filename
 
                      = _bfd_vms_save_counted_string (src_ptr
 
                          + DST_S_B_SRC_DF_FILENAME);
 
 
 
                    while (fileid >= module->file_table_count)
 
                      {
 
                        module->file_table_count *= 2;
 
                        module->file_table
 
                          = bfd_realloc (module->file_table,
 
                                         module->file_table_count
 
                                           * sizeof (struct fileinfo));
 
                      }
 
 
 
                    module->file_table [fileid].name = filename;
 
                    module->file_table [fileid].srec = 1;
 
                    cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
 
#if VMS_DEBUG
 
                    _bfd_vms_debug (4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
 
                                    fileid,
 
                                    module->file_table [fileid].name);
 
#endif
 
                  }
 
                  break;
 
 
 
                case DST_S_C_SRC_DEFLINES_B:
 
                  /* Perform the association and set the next higher index
 
                     to the limit.  */
 
                  data = src_ptr[DST_S_B_SRC_UNSBYTE];
 
                  srec = (struct srecinfo *)
 
                    bfd_zalloc (abfd, sizeof (struct srecinfo));
 
                  srec->line = curr_srec->line + data;
 
                  srec->srec = curr_srec->srec + data;
 
                  srec->sfile = curr_srec->sfile;
 
                  curr_srec->next = srec;
 
                  curr_srec = srec;
 
                  cmd_length = 2;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_B: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_DEFLINES_W:
 
                  /* Perform the association and set the next higher index
 
                     to the limit.  */
 
                  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 
                  srec = (struct srecinfo *)
 
                    bfd_zalloc (abfd, sizeof (struct srecinfo));
 
                  srec->line = curr_srec->line + data;
 
                  srec->srec = curr_srec->srec + data,
 
                  srec->sfile = curr_srec->sfile;
 
                  curr_srec->next = srec;
 
                  curr_srec = srec;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_W: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_INCRLNUM_B:
 
                  data = src_ptr[DST_S_B_SRC_UNSBYTE];
 
                  curr_srec->line += data;
 
                  cmd_length = 2;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_SETFILE:
 
                  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 
                  curr_srec->sfile = data;
 
                  curr_srec->srec = module->file_table[data].srec;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_SETFILE: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_SETLNUM_L:
 
                  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
 
                  curr_srec->line = data;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_L: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_SETLNUM_W:
 
                  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 
                  curr_srec->line = data;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_W: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_SETREC_L:
 
                  data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
 
                  curr_srec->srec = data;
 
                  module->file_table[curr_srec->sfile].srec = data;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_L: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_SETREC_W:
 
                  data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 
                  curr_srec->srec = data;
 
                  module->file_table[curr_srec->sfile].srec = data;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_W: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SRC_FORMFEED:
 
                  cmd_length = 1;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SRC_FORMFEED\n");
 
#endif
 
                  break;
 
 
 
                default:
 
                  (*_bfd_error_handler) (_("unknown source command %d"),
 
                                         cmd);
 
                  cmd_length = 2;
 
                  break;
 
                }
 
 
 
              src_ptr += cmd_length;
 
            }
 
          break;
 
 
 
        case DST_S_C_LINE_NUM:
 
          pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
 
 
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "line info\n");
 
#endif
 
 
 
          while (pcl_ptr < ptr + rec_length)
 
            {
 
              /* The command byte is signed so we must sign-extend it.  */
 
              int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
 
 
 
              switch (cmd)
 
                {
 
                case DST_S_C_DELTA_PC_W:
 
                  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 
                  curr_pc += data;
 
                  curr_linenum += 1;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_DELTA_PC_W: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_DELTA_PC_L:
 
                  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 
                  curr_pc += data;
 
                  curr_linenum += 1;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_DELTA_PC_L: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_INCR_LINUM:
 
                  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
 
                  curr_linenum += data;
 
                  cmd_length = 2;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_INCR_LINUM_W:
 
                  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 
                  curr_linenum += data;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_W: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_INCR_LINUM_L:
 
                  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 
                  curr_linenum += data;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_L: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SET_LINUM_INCR:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_SET_LINUM_INCR not implemented"));
 
                  cmd_length = 2;
 
                  break;
 
 
 
                case DST_S_C_SET_LINUM_INCR_W:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_SET_LINUM_INCR_W not implemented"));
 
                  cmd_length = 3;
 
                  break;
 
 
 
                case DST_S_C_RESET_LINUM_INCR:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_RESET_LINUM_INCR not implemented"));
 
                  cmd_length = 1;
 
                  break;
 
 
 
                case DST_S_C_BEG_STMT_MODE:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_BEG_STMT_MODE not implemented"));
 
                  cmd_length = 1;
 
                  break;
 
 
 
                case DST_S_C_END_STMT_MODE:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_END_STMT_MODE not implemented"));
 
                  cmd_length = 1;
 
                  break;
 
 
 
                case DST_S_C_SET_LINUM_B:
 
                  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
 
                  curr_linenum = data;
 
                  cmd_length = 2;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SET_LINUM_B: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SET_LINE_NUM:
 
                  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 
                  curr_linenum = data;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SET_LINE_NUM: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SET_LINUM_L:
 
                  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 
                  curr_linenum = data;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SET_LINUM_L: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SET_PC:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_SET_PC not implemented"));
 
                  cmd_length = 2;
 
                  break;
 
 
 
                case DST_S_C_SET_PC_W:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_SET_PC_W not implemented"));
 
                  cmd_length = 3;
 
                  break;
 
 
 
                case DST_S_C_SET_PC_L:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_SET_PC_L not implemented"));
 
                  cmd_length = 5;
 
                  break;
 
 
 
                case DST_S_C_SET_STMTNUM:
 
                  (*_bfd_error_handler)
 
                    (_("DST_S_C_SET_STMTNUM not implemented"));
 
                  cmd_length = 2;
 
                  break;
 
 
 
                case DST_S_C_TERM:
 
                  data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
 
                  curr_pc += data;
 
                  cmd_length = 2;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_TERM: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_TERM_W:
 
                  data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 
                  curr_pc += data;
 
                  cmd_length = 3;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_TERM_W: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_TERM_L:
 
                  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 
                  curr_pc += data;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_TERM_L: %d\n", data);
 
#endif
 
                  break;
 
 
 
                case DST_S_C_SET_ABS_PC:
 
                  data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 
                  curr_pc = data;
 
                  cmd_length = 5;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "DST_S_C_SET_ABS_PC: 0x%x\n", data);
 
#endif
 
                  break;
 
 
 
                default:
 
                  if (cmd <= 0)
 
                    {
 
                      curr_pc -= cmd;
 
                      curr_linenum += 1;
 
                      cmd_length = 1;
 
#if VMS_DEBUG
 
                      _bfd_vms_debug (4, "bump pc to 0x%llx and line to %d\n",
 
                                      curr_pc, curr_linenum);
 
#endif
 
                    }
 
                  else
 
                    {
 
                      (*_bfd_error_handler) (_("unknown line command %d"),
 
                                             cmd);
 
                      cmd_length = 2;
 
                    }
 
                  break;
 
                }
 
 
 
              if ((curr_linenum != prev_linum && curr_pc != prev_pc)
 
                  || cmd <= 0
 
                  || cmd == DST_S_C_DELTA_PC_L
 
                  || cmd == DST_S_C_DELTA_PC_W)
 
                {
 
                  line = (struct lineinfo *)
 
                    bfd_zalloc (abfd, sizeof (struct lineinfo));
 
                  line->address = curr_pc;
 
                  line->line = curr_linenum;
 
 
 
                  curr_line->next = line;
 
                  curr_line = line;
 
 
 
                  prev_linum = curr_linenum;
 
                  prev_pc = curr_pc;
 
#if VMS_DEBUG
 
                  _bfd_vms_debug (4, "-> correlate pc 0x%llx with line %d\n",
 
                                  curr_pc, curr_linenum);
 
#endif
 
                }
 
 
 
              pcl_ptr += cmd_length;
 
            }
 
          break;
 
 
 
        case 0x17: /* Undocumented type used by DEC C to declare equates.  */
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "undocumented type 0x17\n");
 
#endif
 
          break;
 
 
 
        default:
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "ignoring record\n");
 
#endif
 
          break;
 
 
 
        }
 
 
 
      ptr += rec_length;
 
    }
 
 
 
  /* Finalize tables with EOL marker.  */
 
  srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
 
  srec->line = (unsigned int) -1;
 
  srec->srec = (unsigned int) -1;
 
  curr_srec->next = srec;
 
 
 
  line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
 
  line->line = (unsigned int) -1;
 
  line->address = (bfd_vma) -1;
 
  curr_line->next = line;
 
 
 
  /* Advertise that this module has been parsed.  This is needed
 
     because parsing can be either performed at module creation
 
     or deferred until debug info is consumed.  */
 
  SET_MODULE_PARSED (module);
 
}
 
 
 
/* Build the list of modules for the specified BFD.  */
 
 
 
static struct module *
 
build_module_list (bfd *abfd)
 
{
 
  struct module *module, *list = NULL;
 
  asection *dmt;
 
 
 
  if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
 
    {
 
      /* We have a DMT section so this must be an image.  Parse the
 
         section and build the list of modules.  This is sufficient
 
         since we can compute the start address and the end address
 
         of every module from the section contents.  */
 
      bfd_size_type size = bfd_get_section_size (dmt);
 
      unsigned char *ptr, *end;
 
 
 
      ptr = (unsigned char *) bfd_alloc (abfd, size);
 
      if (! ptr)
 
        return NULL;
 
 
 
      if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
 
        return NULL;
 
 
 
#if VMS_DEBUG
 
      _bfd_vms_debug (2, "DMT\n");
 
#endif
 
 
 
      end = ptr + size;
 
 
 
      while (ptr < end)
 
        {
 
          /* Each header declares a module with its start offset and size
 
             of debug info in the DST section, as well as the count of
 
             program sections (i.e. address spans) it contains.  */
 
          int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
 
          int size = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
 
          int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
 
          ptr += DBG_S_C_DMT_HEADER_SIZE;
 
 
 
#if VMS_DEBUG
 
          _bfd_vms_debug (3, "module: modbeg = %d, size = %d, count = %d\n",
 
                          modbeg, size, count);
 
#endif
 
 
 
          /* We create a 'module' structure for each program section since
 
             we only support contiguous addresses in a 'module' structure.
 
             As a consequence, the actual debug info in the DST section is
 
             shared and can be parsed multiple times; that doesn't seem to
 
             cause problems in practice.  */
 
          while (count-- > 0)
 
            {
 
              int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
 
              int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
 
              module = new_module (abfd);
 
              module->modbeg = modbeg;
 
              module->size = size;
 
              module->low = start;
 
              module->high = start + length;
 
              module->next = list;
 
              list = module;
 
              ptr += DBG_S_C_DMT_PSECT_SIZE;
 
 
 
#if VMS_DEBUG
 
              _bfd_vms_debug (4, "section: start = 0x%x, length = %d\n",
 
                              start, length);
 
#endif
 
            }
 
        }
 
    }
 
  else
 
    {
 
      /* We don't have a DMT section so this must be an object.  Parse
 
         the module right now in order to compute its start address and
 
         end address.  */
 
      module = new_module (abfd);
 
      parse_module (abfd, module, PRIV (dst_section)->contents,
 
                    PRIV (dst_ptr_end) - PRIV (dst_section)->contents);
 
      list = module;
 
    }
 
 
 
  return list;
 
}
 
 
 
/* Calculate and return the name of the source file and the line nearest
 
   to the wanted location in the specified module.  */
 
 
 
static bfd_boolean
 
module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
 
                          const char **file, const char **func,
 
                          unsigned int *line)
 
{
 
  struct funcinfo *funcinfo;
 
  struct lineinfo *lineinfo;
 
  struct srecinfo *srecinfo;
 
  bfd_boolean ret = FALSE;
 
 
 
  /* Parse this module if that was not done at module creation.  */
 
  if (! IS_MODULE_PARSED (module))
 
    {
 
      unsigned int size = module->size;
 
      unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
 
      unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
 
 
 
      if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
 
          || bfd_bread (buffer, size, abfd) != size)
 
        {
 
          bfd_set_error (bfd_error_no_debug_section);
 
          return FALSE;
 
        }
 
 
 
      parse_module (abfd, module, buffer, size);
 
      free (buffer);
 
    }
 
 
 
  /* Find out the function (if any) that contains the address.  */
 
  for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
 
    if (addr >= funcinfo->low && addr <= funcinfo->high)
 
      {
 
        *func = funcinfo->name;
 
        ret = TRUE;
 
        break;
 
      }
 
 
 
  /* Find out the source file and the line nearest to the address.  */
 
  for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
 
    if (lineinfo->next && addr < lineinfo->next->address)
 
      {
 
        for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
 
          if (srecinfo->next && lineinfo->line < srecinfo->next->line)
 
            {
 
              if (srecinfo->sfile > 0)
 
                {
 
                  *file = module->file_table[srecinfo->sfile].name;
 
                  *line = srecinfo->srec + lineinfo->line - srecinfo->line;
 
                }
 
              else
 
                {
 
                  *file = module->name;
 
                  *line = lineinfo->line;
 
                }
 
              return TRUE;
 
            }
 
 
 
        break;
 
      }
 
 
 
  return ret;
 
}
 
 
 
/* Provided a BFD, a section and an offset into the section, calculate and
 
   return the name of the source file and the line nearest to the wanted
 
   location.  */
 
 
 
bfd_boolean
 
_bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
 
                                asymbol **symbols ATTRIBUTE_UNUSED,
 
                                bfd_vma offset, const char **file,
 
                                const char **func, unsigned int *line)
 
{
 
  struct module *module;
 
 
 
  /* What address are we looking for?  */
 
  bfd_vma addr = section->vma + offset;
 
 
 
  *file = NULL;
 
  *func = NULL;
 
  *line = 0;
 
 
 
  if (PRIV (dst_section) == NULL)
 
    return FALSE;
 
 
 
  if (PRIV (modules) == NULL)
 
    {
 
      PRIV (modules) = build_module_list (abfd);
 
      if (PRIV (modules) == NULL)
 
        return FALSE;
 
    }
 
 
 
  for (module = PRIV (modules); module; module = module->next)
 
    if (addr >= module->low && addr <= module->high)
 
      return module_find_nearest_line (abfd, module, addr, file, func, line);
 
 
 
  return FALSE;
 
}
 
 
 
/* Process EDBG/ETBT record.
 
   Return 0 on success, -1 on error  */
 
 
 
static int
 
vms_slurp_debug (bfd *abfd)
 
{
 
  if (PRIV (dst_section) == NULL)
 
    {
 
      /* We have no way to find out beforehand how much debug info there
 
         is in an object file, so pick an initial amount and grow it as
 
         needed later.  */
 
      flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC;
 
      asection *section = bfd_make_section (abfd, "$DST$");
 
      if (!section)
 
        return -1;
 
      section->size = 1024;
 
      if (!bfd_set_section_flags (abfd, section, flags))
 
        return -1;
 
      section->contents = ((unsigned char *)
 
                           bfd_zmalloc (section->size));
 
      if (section->contents == NULL)
 
        return -1;
 
      section->filepos = (unsigned int)-1;
 
      PRIV (dst_section) = section;
 
    }
 
 
 
  PRIV (image_section) = PRIV (dst_section);
 
  PRIV (image_ptr) = PRIV (dst_section)->contents;
 
 
 
  return _bfd_vms_slurp_tir (abfd, EOBJ_S_C_ETIR);
 
}
 
 
 
/* Process DBG/EDBG record.
 
   Return 0 on success, -1 on error.  */
 
 
 
int
 
_bfd_vms_slurp_dbg (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 
{
 
#if VMS_DEBUG
 
  _bfd_vms_debug (2, "DBG/EDBG\n");
 
#endif
 
 
 
  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
 
 
 
  return vms_slurp_debug (abfd);
 
}
 
 
 
/* Process TBT/ETBT record.
 
   Return 0 on success, -1 on error.  */
 
 
 
int
 
_bfd_vms_slurp_tbt (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
 
{
 
#if VMS_DEBUG
 
  _bfd_vms_debug (2, "TBT/ETBT\n");
 
#endif
 
 
 
  abfd->flags |= HAS_LINENO;
 
 
 
  return vms_slurp_debug (abfd);
 
}
 
 
 
/* Write DBG/EDBG record.  */
 
 
 
int
 
_bfd_vms_write_dbg (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
 
{
 
#if VMS_DEBUG
 
  _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
 
#endif
 
 
 
  return 0;
 
}
 
 
 
/* Write TBT/ETBT record.  */
 
 
 
int
 
_bfd_vms_write_tbt (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
 
{
 
#if VMS_DEBUG
 
  _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
 
#endif
 
 
 
  return 0;
 
}
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.