diff options
Diffstat (limited to 'bfd/vms-misc.c')
| -rw-r--r-- | bfd/vms-misc.c | 670 |
1 files changed, 670 insertions, 0 deletions
diff --git a/bfd/vms-misc.c b/bfd/vms-misc.c new file mode 100644 index 0000000..4581738 --- /dev/null +++ b/bfd/vms-misc.c @@ -0,0 +1,670 @@ +/* vms-misc.c -- BFD back-end for VMS/VAX (openVMS/VAX) and + EVAX (openVMS/Alpha) files. + Copyright (C) 1996-2014 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); +} |