Subversion Repositories open8_urisc

/* vms-misc.c -- BFD back-end for VMS/VAX (openVMS/VAX) and

   EVAX (openVMS/Alpha) files.

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

   2007, 2008, 2009, 2010  Free Software Foundation, Inc.

   Miscellaneous functions.

   Written by Klaus K"ampf (kkaempf@rmi.de)

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

#if __STDC__

#include <stdarg.h>

#endif

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "libbfd.h"

#include "safe-ctype.h"

#ifdef VMS

#define __NEW_STARLET

#include <rms.h>

#include <unixlib.h>

#include <gen64def.h>

#include <starlet.h>

#define RME$C_SETRFM 0x00000001

#include <unistd.h>

#endif

#include <time.h>

#include "vms.h"

#include "vms/emh.h"

#if VMS_DEBUG

/* Debug functions.  */

/* Debug function for all vms extensions evaluates environment

   variable VMS_DEBUG for a numerical value on the first call all

   error levels below this value are printed:

   Levels:

   1    toplevel bfd calls (functions from the bfd vector)

   2    functions called by bfd calls

   ...

   9    almost everything

   Level is also indentation level. Indentation is performed

   if level > 0.  */

void

_bfd_vms_debug (int level, char *format, ...)

{

  static int min_level = -1;

  static FILE *output = NULL;

  char *eptr;

  va_list args;

  int abslvl = (level > 0) ? level : - level;

  if (min_level == -1)

    {

      if ((eptr = getenv ("VMS_DEBUG")) != NULL)

        {

          min_level = atoi (eptr);

          output = stderr;

        }

      else

        min_level = 0;

    }

  if (output == NULL)

    return;

  if (abslvl > min_level)

    return;

  while (--level > 0)

    fprintf (output, " ");

  va_start (args, format);

  vfprintf (output, format, args);

  fflush (output);

  va_end (args);

}

/* A debug function

   hex dump 'size' bytes starting at 'ptr'.  */

void

_bfd_hexdump (int level, unsigned char *ptr, int size, int offset)

{

  unsigned char *lptr = ptr;

  int count = 0;

  long start = offset;

  while (size-- > 0)

    {

      if ((count % 16) == 0)

        vms_debug (level, "%08lx:", start);

      vms_debug (-level, " %02x", *ptr++);

      count++;

      start++;

      if (size == 0)

        {

          while ((count % 16) != 0)

            {

              vms_debug (-level, "   ");

              count++;

            }

        }

      if ((count % 16) == 0)

        {

          vms_debug (-level, " ");

          while (lptr < ptr)

            {

              vms_debug (-level, "%c", (*lptr < 32) ? '.' : *lptr);

              lptr++;

            }

          vms_debug (-level, "\n");

        }

    }

  if ((count % 16) != 0)

    vms_debug (-level, "\n");

}

#endif

/* Copy sized string (string with fixed size) to new allocated area

   size is string size (size of record)  */

char *

_bfd_vms_save_sized_string (unsigned char *str, int size)

{

  char *newstr = bfd_malloc ((bfd_size_type) size + 1);

  if (newstr == NULL)

    return NULL;

  memcpy (newstr, (char *) str, (size_t) size);

  newstr[size] = 0;

  return newstr;

}

/* Copy counted string (string with size at first byte) to new allocated area

   ptr points to size byte on entry  */

char *

_bfd_vms_save_counted_string (unsigned char *ptr)

{

  int len = *ptr++;

  return _bfd_vms_save_sized_string (ptr, len);

}

/* Object output routines.   */

/* Begin new record.

   Write 2 bytes rectype and 2 bytes record length.  */

void

_bfd_vms_output_begin (struct vms_rec_wr *recwr, int rectype)

{

  vms_debug2 ((6, "_bfd_vms_output_begin (type %d)\n", rectype));

  /* Record must have been closed.  */

  BFD_ASSERT (recwr->size == 0);

  _bfd_vms_output_short (recwr, (unsigned int) rectype);

  /* Placeholder for length.  */

  _bfd_vms_output_short (recwr, 0);

}

/* Begin new sub-record.

   Write 2 bytes rectype, and 2 bytes record length.  */

void

_bfd_vms_output_begin_subrec (struct vms_rec_wr *recwr, int rectype)

{

  vms_debug2 ((6, "_bfd_vms_output_begin_subrec (type %d)\n", rectype));

  /* Subrecord must have been closed.  */

  BFD_ASSERT (recwr->subrec_offset == 0);

  /* Save start of subrecord offset.  */

  recwr->subrec_offset = recwr->size;

  /* Subrecord type.  */

  _bfd_vms_output_short (recwr, (unsigned int) rectype);

  /* Placeholder for length.  */

  _bfd_vms_output_short (recwr, 0);

}

/* Set record/subrecord alignment.   */

void

_bfd_vms_output_alignment (struct vms_rec_wr *recwr, int alignto)

{

  vms_debug2 ((6, "_bfd_vms_output_alignment (%d)\n", alignto));

  recwr->align = alignto;

}

/* Align the size of the current record (whose length is LENGTH).

   Warning: this obviously changes the record (and the possible subrecord)

   length.  */

static void

_bfd_vms_output_align (struct vms_rec_wr *recwr, unsigned int length)

{

  unsigned int real_size = recwr->size;

  unsigned int aligncount;

  /* Pad with 0 if alignment is required.  */

  aligncount = (recwr->align - (length % recwr->align)) % recwr->align;

  vms_debug2 ((6, "align: adding %d bytes\n", aligncount));

  while (aligncount-- > 0)

    recwr->buf[real_size++] = 0;

  recwr->size = real_size;

}

/* Ends current sub-record.  Set length field.  */

void

_bfd_vms_output_end_subrec (struct vms_rec_wr *recwr)

{

  int real_size = recwr->size;

  int length;

  /* Subrecord must be open.  */

  BFD_ASSERT (recwr->subrec_offset != 0);

  length = real_size - recwr->subrec_offset;

  if (length == 0)

    return;

  _bfd_vms_output_align (recwr, length);

  /* Put length to buffer.  */

  bfd_putl16 ((bfd_vma) (recwr->size - recwr->subrec_offset),

              recwr->buf + recwr->subrec_offset + 2);

  /* Close the subrecord.  */

  recwr->subrec_offset = 0;

}

/* Ends current record (and write it).  */

void

_bfd_vms_output_end (bfd *abfd, struct vms_rec_wr *recwr)

{

  vms_debug2 ((6, "_bfd_vms_output_end (size %u)\n", recwr->size));

  /* Subrecord must have been closed.  */

  BFD_ASSERT (recwr->subrec_offset == 0);

  if (recwr->size == 0)

    return;

  _bfd_vms_output_align (recwr, recwr->size);

  /* Write the length word.  */

  bfd_putl16 ((bfd_vma) recwr->size, recwr->buf + 2);

  /* File is open in undefined (UDF) format on VMS, but ultimately will be

     converted to variable length (VAR) format.  VAR format has a length

     word first which must be explicitly output in UDF format.  */

  /* So, first the length word.  */

  bfd_bwrite (recwr->buf + 2, 2, abfd);

  /* Align.  */

  if (recwr->size & 1)

    recwr->buf[recwr->size++] = 0;

  /* Then the record.  */

  bfd_bwrite (recwr->buf, (size_t) recwr->size, abfd);

  recwr->size = 0;

}

/* Check remaining buffer size.  Return what's left.  */

int

_bfd_vms_output_check (struct vms_rec_wr *recwr, int size)

{

  vms_debug2 ((6, "_bfd_vms_output_check (%d)\n", size));

  return (MAX_OUTREC_SIZE - (recwr->size + size + MIN_OUTREC_LUFT));

}

/* Output byte (8 bit) value.  */

void

_bfd_vms_output_byte (struct vms_rec_wr *recwr, unsigned int value)

{

  vms_debug2 ((6, "_bfd_vms_output_byte (%02x)\n", value));

  *(recwr->buf + recwr->size) = value;

  recwr->size += 1;

}

/* Output short (16 bit) value.  */

void

_bfd_vms_output_short (struct vms_rec_wr *recwr, unsigned int value)

{

  vms_debug2 ((6, "_bfd_vms_output_short (%04x)\n", value));

  bfd_putl16 ((bfd_vma) value & 0xffff, recwr->buf + recwr->size);

  recwr->size += 2;

}

/* Output long (32 bit) value.  */

void

_bfd_vms_output_long (struct vms_rec_wr *recwr, unsigned long value)

{

  vms_debug2 ((6, "_bfd_vms_output_long (%08lx)\n", value));

  bfd_putl32 ((bfd_vma) value, recwr->buf + recwr->size);

  recwr->size += 4;

}

/* Output quad (64 bit) value.  */

void

_bfd_vms_output_quad (struct vms_rec_wr *recwr, bfd_vma value)

{

  vms_debug2 ((6, "_bfd_vms_output_quad (%08lx)\n", (unsigned long)value));

  bfd_putl64 (value, recwr->buf + recwr->size);

  recwr->size += 8;

}

/* Output c-string as counted string.  */

void

_bfd_vms_output_counted (struct vms_rec_wr *recwr, const char *value)

{

  int len;

  vms_debug2 ((6, "_bfd_vms_output_counted (%s)\n", value));

  len = strlen (value);

  if (len == 0)

    {

      (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));

      return;

    }

  if (len > 255)

    {

      (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));

      return;

    }

  _bfd_vms_output_byte (recwr, (unsigned int) len & 0xff);

  _bfd_vms_output_dump (recwr, (const unsigned char *)value, len);

}

/* Output character area.  */

void

_bfd_vms_output_dump (struct vms_rec_wr *recwr, const unsigned char *data, int len)

{

  vms_debug2 ((6, "_bfd_vms_output_dump (%d)\n", len));

  if (len == 0)

    return;

  memcpy (recwr->buf + recwr->size, data, (size_t) len);

  recwr->size += len;

}

/* Output count bytes of value.  */

void

_bfd_vms_output_fill (struct vms_rec_wr *recwr, int value, int count)

{

  vms_debug2 ((6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count));

  if (count == 0)

    return;

  memset (recwr->buf + recwr->size, value, (size_t) count);

  recwr->size += count;

}

#ifdef VMS

/* Convert the file to variable record length format. This is done

   using undocumented system call sys$modify().

   Pure VMS version.  */

static void

vms_convert_to_var (char * vms_filename)

{

  struct FAB fab = cc$rms_fab;

  fab.fab$l_fna = vms_filename;

  fab.fab$b_fns = strlen (vms_filename);

  fab.fab$b_fac = FAB$M_PUT;

  fab.fab$l_fop = FAB$M_ESC;

  fab.fab$l_ctx = RME$C_SETRFM;

  sys$open (&fab);

  fab.fab$b_rfm = FAB$C_VAR;

  sys$modify (&fab);

  sys$close (&fab);

}

static int

vms_convert_to_var_1 (char *filename, int type)

{

  if (type != DECC$K_FILE)

    return FALSE;

  vms_convert_to_var (filename);

  return TRUE;

}

/* Convert the file to variable record length format. This is done

   using undocumented system call sys$modify().

   Unix filename version.  */

int

_bfd_vms_convert_to_var_unix_filename (const char *unix_filename)

{

  if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)

    return FALSE;

  return TRUE;

}

#endif /* VMS */

/* Manufacture a VMS like time on a unix based system.

   stolen from obj-vms.c.  */

unsigned char *

get_vms_time_string (void)

{

  static unsigned char tbuf[18];

#ifndef VMS

  char *pnt;

  time_t timeb;

  time (& timeb);

  pnt = ctime (&timeb);

  pnt[3] = 0;

  pnt[7] = 0;

  pnt[10] = 0;

  pnt[16] = 0;

  pnt[24] = 0;

  sprintf ((char *) tbuf, "%2s-%3s-%s %s",

           pnt + 8, pnt + 4, pnt + 20, pnt + 11);

#else

  struct

  {

    int Size;

    unsigned char *Ptr;

  } Descriptor;

  Descriptor.Size = 17;

  Descriptor.Ptr = tbuf;

  SYS$ASCTIM (0, &Descriptor, 0, 0);

#endif /* not VMS */

  vms_debug2 ((6, "vmstimestring:'%s'\n", tbuf));

  return tbuf;

}

/* Create module name from filename (ie, extract the basename and convert it

   in upper cases).  Works on both VMS and UNIX pathes.

   The result has to be free().  */

char *

vms_get_module_name (const char *filename, bfd_boolean upcase)

{

  char *fname, *fptr;

  const char *fout;

  /* Strip VMS path.  */

  fout = strrchr (filename, ']');

  if (fout == NULL)

    fout = strchr (filename, ':');

  if (fout != NULL)

    fout++;

  else

    fout = filename;

  /* Strip UNIX path.  */

  fptr = strrchr (fout, '/');

  if (fptr != NULL)

    fout = fptr + 1;

  fname = strdup (fout);

  /* Strip suffix.  */

  fptr = strrchr (fname, '.');

  if (fptr != 0)

    *fptr = 0;

  /* Convert to upper case and truncate at 31 characters.

     (VMS object file format restricts module name length to 31).  */

  fptr = fname;

  for (fptr = fname; *fptr != 0; fptr++)

    {

      if (*fptr == ';' || (fptr - fname) >= 31)

        {

          *fptr = 0;

          break;

        }

      if (upcase)

        *fptr = TOUPPER (*fptr);

    }

  return fname;

}

/* Compared to usual UNIX time_t, VMS time has less limits:

   -  64 bit (63 bits in fact as the MSB must be 0)

   -  100ns granularity

   -  epoch is Nov 17, 1858.

   Here has the constants and the routines used to convert VMS from/to UNIX time.

   The conversion routines don't assume 64 bits arithmetic.

   Here we assume that the definition of time_t is the UNIX one, ie integer

   type, expressing seconds since the epoch.  */

/* UNIX time granularity for VMS, ie 1s / 100ns.  */

#define VMS_TIME_FACTOR 10000000

/* Number of seconds since VMS epoch of the UNIX epoch.  */

#define VMS_TIME_OFFSET 3506716800U

/* Convert a VMS time to a unix time.  */

time_t

vms_time_to_time_t (unsigned int hi, unsigned int lo)

{

  unsigned int tmp;

  unsigned int rlo;

  int i;

  time_t res;

  /* First convert to seconds.  */

  tmp = hi % VMS_TIME_FACTOR;

  hi = hi / VMS_TIME_FACTOR;

  rlo = 0;

  for (i = 0; i < 4; i++)

    {

      tmp = (tmp << 8) | (lo >> 24);

      lo <<= 8;

      rlo = (rlo << 8) | (tmp / VMS_TIME_FACTOR);

      tmp %= VMS_TIME_FACTOR;

    }

  lo = rlo;

  /* Return 0 in case of overflow.  */

  if (hi > 1

      || (hi == 1 && lo >= VMS_TIME_OFFSET))

    return 0;

  /* Return 0 in case of underflow.  */

  if (hi == 0 && lo < VMS_TIME_OFFSET)

    return 0;

  res = lo - VMS_TIME_OFFSET;

  if (res <= 0)

    return 0;

  return res;

}

/* Convert a time_t to a VMS time.  */

void

vms_time_t_to_vms_time (time_t ut, unsigned int *hi, unsigned int *lo)

{

  unsigned short val[4];

  unsigned short tmp[4];

  unsigned int carry;

  int i;

  /* Put into val.  */

  val[0] = ut & 0xffff;

  val[1] = (ut >> 16) & 0xffff;

  val[2] = sizeof (ut) > 4 ? (ut >> 32) & 0xffff : 0;

  val[3] = sizeof (ut) > 4 ? (ut >> 48) & 0xffff : 0;

  /* Add offset.  */

  tmp[0] = VMS_TIME_OFFSET & 0xffff;

  tmp[1] = VMS_TIME_OFFSET >> 16;

  tmp[2] = 0;

  tmp[3] = 0;

  carry = 0;

  for (i = 0; i < 4; i++)

    {

      carry += tmp[i] + val[i];

      val[i] = carry & 0xffff;

      carry = carry >> 16;

    }

  /* Multiply by factor, well first by 10000 and then by 1000.  */

  carry = 0;

  for (i = 0; i < 4; i++)

    {

      carry += val[i] * 10000;

      val[i] = carry & 0xffff;

      carry = carry >> 16;

    }

  carry = 0;

  for (i = 0; i < 4; i++)

    {

      carry += val[i] * 1000;

      val[i] = carry & 0xffff;

      carry = carry >> 16;

    }

  /* Write the result.  */

  *lo = val[0] | (val[1] << 16);

  *hi = val[2] | (val[3] << 16);

}

/* Convert a raw (stored in a buffer) VMS time to a unix time.  */

time_t

vms_rawtime_to_time_t (unsigned char *buf)

{

  unsigned int hi = bfd_getl32 (buf + 4);

  unsigned int lo = bfd_getl32 (buf + 0);

  return vms_time_to_time_t (hi, lo);

}

void

vms_get_time (unsigned int *hi, unsigned int *lo)

{

#ifdef VMS

  struct _generic_64 t;

  sys$gettim (&t);

  *lo = t.gen64$q_quadword;

  *hi = t.gen64$q_quadword >> 32;

#else

  time_t t;

  time (&t);

  vms_time_t_to_vms_time (t, hi, lo);

#endif

}

/* Get the current time into a raw buffer BUF.  */

void

vms_raw_get_time (unsigned char *buf)

{

  unsigned int hi, lo;

  vms_get_time (&hi, &lo);

  bfd_putl32 (lo, buf + 0);

  bfd_putl32 (hi, buf + 4);

}