Home | History | Annotate | Download | only in bfd
      1 /* vms-misc.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
      2    EVAX (openVMS/Alpha) files.
      3    Copyright (C) 1996-2014 Free Software Foundation, Inc.
      4 
      5    Miscellaneous functions.
      6 
      7    Written by Klaus K"ampf (kkaempf (at) rmi.de)
      8 
      9    This program is free software; you can redistribute it and/or modify
     10    it under the terms of the GNU General Public License as published by
     11    the Free Software Foundation; either version 3 of the License, or
     12    (at your option) any later version.
     13 
     14    This program is distributed in the hope that it will be useful,
     15    but WITHOUT ANY WARRANTY; without even the implied warranty of
     16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     17    GNU General Public License for more details.
     18 
     19    You should have received a copy of the GNU General Public License
     20    along with this program; if not, write to the Free Software
     21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     22    MA 02110-1301, USA.  */
     23 
     24 #if __STDC__
     25 #include <stdarg.h>
     26 #endif
     27 
     28 #include "sysdep.h"
     29 #include "bfd.h"
     30 #include "bfdlink.h"
     31 #include "libbfd.h"
     32 #include "safe-ctype.h"
     33 
     34 #ifdef VMS
     35 #define __NEW_STARLET
     36 #include <rms.h>
     37 #include <unixlib.h>
     38 #include <gen64def.h>
     39 #include <starlet.h>
     40 #define RME$C_SETRFM 0x00000001
     41 #include <unistd.h>
     42 #endif
     43 #include <time.h>
     44 
     45 #include "vms.h"
     46 #include "vms/emh.h"
     47 
     48 #if VMS_DEBUG
     49 /* Debug functions.  */
     50 
     51 /* Debug function for all vms extensions evaluates environment
     52    variable VMS_DEBUG for a numerical value on the first call all
     53    error levels below this value are printed:
     54 
     55    Levels:
     56    1	toplevel bfd calls (functions from the bfd vector)
     57    2	functions called by bfd calls
     58    ...
     59    9	almost everything
     60 
     61    Level is also indentation level. Indentation is performed
     62    if level > 0.  */
     63 
     64 void
     65 _bfd_vms_debug (int level, char *format, ...)
     66 {
     67   static int min_level = -1;
     68   static FILE *output = NULL;
     69   char *eptr;
     70   va_list args;
     71   int abslvl = (level > 0) ? level : - level;
     72 
     73   if (min_level == -1)
     74     {
     75       if ((eptr = getenv ("VMS_DEBUG")) != NULL)
     76 	{
     77 	  min_level = atoi (eptr);
     78 	  output = stderr;
     79 	}
     80       else
     81 	min_level = 0;
     82     }
     83   if (output == NULL)
     84     return;
     85   if (abslvl > min_level)
     86     return;
     87 
     88   while (--level > 0)
     89     fprintf (output, " ");
     90   va_start (args, format);
     91   vfprintf (output, format, args);
     92   fflush (output);
     93   va_end (args);
     94 }
     95 
     96 /* A debug function
     97    hex dump 'size' bytes starting at 'ptr'.  */
     98 
     99 void
    100 _bfd_hexdump (int level, unsigned char *ptr, int size, int offset)
    101 {
    102   unsigned char *lptr = ptr;
    103   int count = 0;
    104   long start = offset;
    105 
    106   while (size-- > 0)
    107     {
    108       if ((count % 16) == 0)
    109 	vms_debug (level, "%08lx:", start);
    110       vms_debug (-level, " %02x", *ptr++);
    111       count++;
    112       start++;
    113       if (size == 0)
    114 	{
    115 	  while ((count % 16) != 0)
    116 	    {
    117 	      vms_debug (-level, "   ");
    118 	      count++;
    119 	    }
    120 	}
    121       if ((count % 16) == 0)
    122 	{
    123 	  vms_debug (-level, " ");
    124 	  while (lptr < ptr)
    125 	    {
    126 	      vms_debug (-level, "%c", (*lptr < 32) ? '.' : *lptr);
    127 	      lptr++;
    128 	    }
    129 	  vms_debug (-level, "\n");
    130 	}
    131     }
    132   if ((count % 16) != 0)
    133     vms_debug (-level, "\n");
    134 }
    135 #endif
    136 
    137 
    139 /* Copy sized string (string with fixed size) to new allocated area
    140    size is string size (size of record)  */
    141 
    142 char *
    143 _bfd_vms_save_sized_string (unsigned char *str, int size)
    144 {
    145   char *newstr = bfd_malloc ((bfd_size_type) size + 1);
    146 
    147   if (newstr == NULL)
    148     return NULL;
    149   memcpy (newstr, (char *) str, (size_t) size);
    150   newstr[size] = 0;
    151 
    152   return newstr;
    153 }
    154 
    155 /* Copy counted string (string with size at first byte) to new allocated area
    156    ptr points to size byte on entry  */
    157 
    158 char *
    159 _bfd_vms_save_counted_string (unsigned char *ptr)
    160 {
    161   int len = *ptr++;
    162 
    163   return _bfd_vms_save_sized_string (ptr, len);
    164 }
    165 
    166 /* Object output routines.   */
    168 
    169 /* Begin new record.
    170    Write 2 bytes rectype and 2 bytes record length.  */
    171 
    172 void
    173 _bfd_vms_output_begin (struct vms_rec_wr *recwr, int rectype)
    174 {
    175   vms_debug2 ((6, "_bfd_vms_output_begin (type %d)\n", rectype));
    176 
    177   /* Record must have been closed.  */
    178   BFD_ASSERT (recwr->size == 0);
    179 
    180   _bfd_vms_output_short (recwr, (unsigned int) rectype);
    181 
    182   /* Placeholder for length.  */
    183   _bfd_vms_output_short (recwr, 0);
    184 }
    185 
    186 /* Begin new sub-record.
    187    Write 2 bytes rectype, and 2 bytes record length.  */
    188 
    189 void
    190 _bfd_vms_output_begin_subrec (struct vms_rec_wr *recwr, int rectype)
    191 {
    192   vms_debug2 ((6, "_bfd_vms_output_begin_subrec (type %d)\n", rectype));
    193 
    194   /* Subrecord must have been closed.  */
    195   BFD_ASSERT (recwr->subrec_offset == 0);
    196 
    197   /* Save start of subrecord offset.  */
    198   recwr->subrec_offset = recwr->size;
    199 
    200   /* Subrecord type.  */
    201   _bfd_vms_output_short (recwr, (unsigned int) rectype);
    202 
    203   /* Placeholder for length.  */
    204   _bfd_vms_output_short (recwr, 0);
    205 }
    206 
    207 /* Set record/subrecord alignment.   */
    208 
    209 void
    210 _bfd_vms_output_alignment (struct vms_rec_wr *recwr, int alignto)
    211 {
    212   vms_debug2 ((6, "_bfd_vms_output_alignment (%d)\n", alignto));
    213   recwr->align = alignto;
    214 }
    215 
    216 /* Align the size of the current record (whose length is LENGTH).
    217    Warning: this obviously changes the record (and the possible subrecord)
    218    length.  */
    219 
    220 static void
    221 _bfd_vms_output_align (struct vms_rec_wr *recwr, unsigned int length)
    222 {
    223   unsigned int real_size = recwr->size;
    224   unsigned int aligncount;
    225 
    226   /* Pad with 0 if alignment is required.  */
    227   aligncount = (recwr->align - (length % recwr->align)) % recwr->align;
    228   vms_debug2 ((6, "align: adding %d bytes\n", aligncount));
    229   while (aligncount-- > 0)
    230     recwr->buf[real_size++] = 0;
    231 
    232   recwr->size = real_size;
    233 }
    234 
    235 /* Ends current sub-record.  Set length field.  */
    236 
    237 void
    238 _bfd_vms_output_end_subrec (struct vms_rec_wr *recwr)
    239 {
    240   int real_size = recwr->size;
    241   int length;
    242 
    243   /* Subrecord must be open.  */
    244   BFD_ASSERT (recwr->subrec_offset != 0);
    245 
    246   length = real_size - recwr->subrec_offset;
    247 
    248   if (length == 0)
    249     return;
    250 
    251   _bfd_vms_output_align (recwr, length);
    252 
    253   /* Put length to buffer.  */
    254   bfd_putl16 ((bfd_vma) (recwr->size - recwr->subrec_offset),
    255               recwr->buf + recwr->subrec_offset + 2);
    256 
    257   /* Close the subrecord.  */
    258   recwr->subrec_offset = 0;
    259 }
    260 
    261 /* Ends current record (and write it).  */
    262 
    263 void
    264 _bfd_vms_output_end (bfd *abfd, struct vms_rec_wr *recwr)
    265 {
    266   vms_debug2 ((6, "_bfd_vms_output_end (size %u)\n", recwr->size));
    267 
    268   /* Subrecord must have been closed.  */
    269   BFD_ASSERT (recwr->subrec_offset == 0);
    270 
    271   if (recwr->size == 0)
    272     return;
    273 
    274   _bfd_vms_output_align (recwr, recwr->size);
    275 
    276   /* Write the length word.  */
    277   bfd_putl16 ((bfd_vma) recwr->size, recwr->buf + 2);
    278 
    279   /* File is open in undefined (UDF) format on VMS, but ultimately will be
    280      converted to variable length (VAR) format.  VAR format has a length
    281      word first which must be explicitly output in UDF format.  */
    282   /* So, first the length word.  */
    283   bfd_bwrite (recwr->buf + 2, 2, abfd);
    284 
    285   /* Align.  */
    286   if (recwr->size & 1)
    287     recwr->buf[recwr->size++] = 0;
    288 
    289   /* Then the record.  */
    290   bfd_bwrite (recwr->buf, (size_t) recwr->size, abfd);
    291 
    292   recwr->size = 0;
    293 }
    294 
    295 /* Check remaining buffer size.  Return what's left.  */
    296 
    297 int
    298 _bfd_vms_output_check (struct vms_rec_wr *recwr, int size)
    299 {
    300   vms_debug2 ((6, "_bfd_vms_output_check (%d)\n", size));
    301 
    302   return (MAX_OUTREC_SIZE - (recwr->size + size + MIN_OUTREC_LUFT));
    303 }
    304 
    305 /* Output byte (8 bit) value.  */
    306 
    307 void
    308 _bfd_vms_output_byte (struct vms_rec_wr *recwr, unsigned int value)
    309 {
    310   vms_debug2 ((6, "_bfd_vms_output_byte (%02x)\n", value));
    311 
    312   *(recwr->buf + recwr->size) = value;
    313   recwr->size += 1;
    314 }
    315 
    316 /* Output short (16 bit) value.  */
    317 
    318 void
    319 _bfd_vms_output_short (struct vms_rec_wr *recwr, unsigned int value)
    320 {
    321   vms_debug2 ((6, "_bfd_vms_output_short (%04x)\n", value));
    322 
    323   bfd_putl16 ((bfd_vma) value & 0xffff, recwr->buf + recwr->size);
    324   recwr->size += 2;
    325 }
    326 
    327 /* Output long (32 bit) value.  */
    328 
    329 void
    330 _bfd_vms_output_long (struct vms_rec_wr *recwr, unsigned long value)
    331 {
    332   vms_debug2 ((6, "_bfd_vms_output_long (%08lx)\n", value));
    333 
    334   bfd_putl32 ((bfd_vma) value, recwr->buf + recwr->size);
    335   recwr->size += 4;
    336 }
    337 
    338 /* Output quad (64 bit) value.  */
    339 
    340 void
    341 _bfd_vms_output_quad (struct vms_rec_wr *recwr, bfd_vma value)
    342 {
    343   vms_debug2 ((6, "_bfd_vms_output_quad (%08lx)\n", (unsigned long)value));
    344 
    345   bfd_putl64 (value, recwr->buf + recwr->size);
    346   recwr->size += 8;
    347 }
    348 
    349 /* Output c-string as counted string.  */
    350 
    351 void
    352 _bfd_vms_output_counted (struct vms_rec_wr *recwr, const char *value)
    353 {
    354   int len;
    355 
    356   vms_debug2 ((6, "_bfd_vms_output_counted (%s)\n", value));
    357 
    358   len = strlen (value);
    359   if (len == 0)
    360     {
    361       (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
    362       return;
    363     }
    364   if (len > 255)
    365     {
    366       (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
    367       return;
    368     }
    369   _bfd_vms_output_byte (recwr, (unsigned int) len & 0xff);
    370   _bfd_vms_output_dump (recwr, (const unsigned char *)value, len);
    371 }
    372 
    373 /* Output character area.  */
    374 
    375 void
    376 _bfd_vms_output_dump (struct vms_rec_wr *recwr, const unsigned char *data, int len)
    377 {
    378   vms_debug2 ((6, "_bfd_vms_output_dump (%d)\n", len));
    379 
    380   if (len == 0)
    381     return;
    382 
    383   memcpy (recwr->buf + recwr->size, data, (size_t) len);
    384   recwr->size += len;
    385 }
    386 
    387 /* Output count bytes of value.  */
    388 
    389 void
    390 _bfd_vms_output_fill (struct vms_rec_wr *recwr, int value, int count)
    391 {
    392   vms_debug2 ((6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count));
    393 
    394   if (count == 0)
    395     return;
    396   memset (recwr->buf + recwr->size, value, (size_t) count);
    397   recwr->size += count;
    398 }
    399 
    400 #ifdef VMS
    401 /* Convert the file to variable record length format. This is done
    402    using undocumented system call sys$modify().
    403    Pure VMS version.  */
    404 
    405 static void
    406 vms_convert_to_var (char * vms_filename)
    407 {
    408   struct FAB fab = cc$rms_fab;
    409 
    410   fab.fab$l_fna = vms_filename;
    411   fab.fab$b_fns = strlen (vms_filename);
    412   fab.fab$b_fac = FAB$M_PUT;
    413   fab.fab$l_fop = FAB$M_ESC;
    414   fab.fab$l_ctx = RME$C_SETRFM;
    415 
    416   sys$open (&fab);
    417 
    418   fab.fab$b_rfm = FAB$C_VAR;
    419 
    420   sys$modify (&fab);
    421   sys$close (&fab);
    422 }
    423 
    424 static int
    425 vms_convert_to_var_1 (char *filename, int type)
    426 {
    427   if (type != DECC$K_FILE)
    428     return FALSE;
    429   vms_convert_to_var (filename);
    430   return TRUE;
    431 }
    432 
    433 /* Convert the file to variable record length format. This is done
    434    using undocumented system call sys$modify().
    435    Unix filename version.  */
    436 
    437 int
    438 _bfd_vms_convert_to_var_unix_filename (const char *unix_filename)
    439 {
    440   if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
    441     return FALSE;
    442   return TRUE;
    443 }
    444 #endif /* VMS */
    445 
    446 /* Manufacture a VMS like time on a unix based system.
    447    stolen from obj-vms.c.  */
    448 
    449 unsigned char *
    450 get_vms_time_string (void)
    451 {
    452   static unsigned char tbuf[18];
    453 #ifndef VMS
    454   char *pnt;
    455   time_t timeb;
    456 
    457   time (& timeb);
    458   pnt = ctime (&timeb);
    459   pnt[3] = 0;
    460   pnt[7] = 0;
    461   pnt[10] = 0;
    462   pnt[16] = 0;
    463   pnt[24] = 0;
    464   sprintf ((char *) tbuf, "%2s-%3s-%s %s",
    465 	   pnt + 8, pnt + 4, pnt + 20, pnt + 11);
    466 #else
    467   struct
    468   {
    469     int Size;
    470     unsigned char *Ptr;
    471   } Descriptor;
    472   Descriptor.Size = 17;
    473   Descriptor.Ptr = tbuf;
    474   SYS$ASCTIM (0, &Descriptor, 0, 0);
    475 #endif /* not VMS */
    476 
    477   vms_debug2 ((6, "vmstimestring:'%s'\n", tbuf));
    478 
    479   return tbuf;
    480 }
    481 
    482 /* Create module name from filename (ie, extract the basename and convert it
    483    in upper cases).  Works on both VMS and UNIX pathes.
    484    The result has to be free().  */
    485 
    486 char *
    487 vms_get_module_name (const char *filename, bfd_boolean upcase)
    488 {
    489   char *fname, *fptr;
    490   const char *fout;
    491 
    492   /* Strip VMS path.  */
    493   fout = strrchr (filename, ']');
    494   if (fout == NULL)
    495     fout = strchr (filename, ':');
    496   if (fout != NULL)
    497     fout++;
    498   else
    499     fout = filename;
    500 
    501   /* Strip UNIX path.  */
    502   fptr = strrchr (fout, '/');
    503   if (fptr != NULL)
    504     fout = fptr + 1;
    505 
    506   fname = strdup (fout);
    507 
    508   /* Strip suffix.  */
    509   fptr = strrchr (fname, '.');
    510   if (fptr != 0)
    511     *fptr = 0;
    512 
    513   /* Convert to upper case and truncate at 31 characters.
    514      (VMS object file format restricts module name length to 31).  */
    515   fptr = fname;
    516   for (fptr = fname; *fptr != 0; fptr++)
    517     {
    518       if (*fptr == ';' || (fptr - fname) >= 31)
    519         {
    520           *fptr = 0;
    521           break;
    522         }
    523       if (upcase)
    524         *fptr = TOUPPER (*fptr);
    525     }
    526   return fname;
    527 }
    528 
    529 /* Compared to usual UNIX time_t, VMS time has less limits:
    530    -  64 bit (63 bits in fact as the MSB must be 0)
    531    -  100ns granularity
    532    -  epoch is Nov 17, 1858.
    533    Here has the constants and the routines used to convert VMS from/to UNIX time.
    534    The conversion routines don't assume 64 bits arithmetic.
    535 
    536    Here we assume that the definition of time_t is the UNIX one, ie integer
    537    type, expressing seconds since the epoch.  */
    538 
    539 /* UNIX time granularity for VMS, ie 1s / 100ns.  */
    540 #define VMS_TIME_FACTOR 10000000
    541 
    542 /* Number of seconds since VMS epoch of the UNIX epoch.  */
    543 #define VMS_TIME_OFFSET 3506716800U
    544 
    545 /* Convert a VMS time to a unix time.  */
    546 
    547 time_t
    548 vms_time_to_time_t (unsigned int hi, unsigned int lo)
    549 {
    550   unsigned int tmp;
    551   unsigned int rlo;
    552   int i;
    553   time_t res;
    554 
    555   /* First convert to seconds.  */
    556   tmp = hi % VMS_TIME_FACTOR;
    557   hi = hi / VMS_TIME_FACTOR;
    558   rlo = 0;
    559   for (i = 0; i < 4; i++)
    560     {
    561       tmp = (tmp << 8) | (lo >> 24);
    562       lo <<= 8;
    563 
    564       rlo = (rlo << 8) | (tmp / VMS_TIME_FACTOR);
    565       tmp %= VMS_TIME_FACTOR;
    566     }
    567   lo = rlo;
    568 
    569   /* Return 0 in case of overflow.  */
    570   if (hi > 1
    571       || (hi == 1 && lo >= VMS_TIME_OFFSET))
    572     return 0;
    573 
    574   /* Return 0 in case of underflow.  */
    575   if (hi == 0 && lo < VMS_TIME_OFFSET)
    576     return 0;
    577 
    578   res = lo - VMS_TIME_OFFSET;
    579   if (res <= 0)
    580     return 0;
    581   return res;
    582 }
    583 
    584 /* Convert a time_t to a VMS time.  */
    585 
    586 void
    587 vms_time_t_to_vms_time (time_t ut, unsigned int *hi, unsigned int *lo)
    588 {
    589   unsigned short val[4];
    590   unsigned short tmp[4];
    591   unsigned int carry;
    592   int i;
    593 
    594   /* Put into val.  */
    595   val[0] = ut & 0xffff;
    596   val[1] = (ut >> 16) & 0xffff;
    597   val[2] = sizeof (ut) > 4 ? (ut >> 32) & 0xffff : 0;
    598   val[3] = sizeof (ut) > 4 ? (ut >> 48) & 0xffff : 0;
    599 
    600   /* Add offset.  */
    601   tmp[0] = VMS_TIME_OFFSET & 0xffff;
    602   tmp[1] = VMS_TIME_OFFSET >> 16;
    603   tmp[2] = 0;
    604   tmp[3] = 0;
    605   carry = 0;
    606   for (i = 0; i < 4; i++)
    607     {
    608       carry += tmp[i] + val[i];
    609       val[i] = carry & 0xffff;
    610       carry = carry >> 16;
    611     }
    612 
    613   /* Multiply by factor, well first by 10000 and then by 1000.  */
    614   carry = 0;
    615   for (i = 0; i < 4; i++)
    616     {
    617       carry += val[i] * 10000;
    618       val[i] = carry & 0xffff;
    619       carry = carry >> 16;
    620     }
    621   carry = 0;
    622   for (i = 0; i < 4; i++)
    623     {
    624       carry += val[i] * 1000;
    625       val[i] = carry & 0xffff;
    626       carry = carry >> 16;
    627     }
    628 
    629   /* Write the result.  */
    630   *lo = val[0] | (val[1] << 16);
    631   *hi = val[2] | (val[3] << 16);
    632 }
    633 
    634 /* Convert a raw (stored in a buffer) VMS time to a unix time.  */
    635 
    636 time_t
    637 vms_rawtime_to_time_t (unsigned char *buf)
    638 {
    639   unsigned int hi = bfd_getl32 (buf + 4);
    640   unsigned int lo = bfd_getl32 (buf + 0);
    641 
    642   return vms_time_to_time_t (hi, lo);
    643 }
    644 
    645 void
    646 vms_get_time (unsigned int *hi, unsigned int *lo)
    647 {
    648 #ifdef VMS
    649   struct _generic_64 t;
    650 
    651   sys$gettim (&t);
    652   *lo = t.gen64$q_quadword;
    653   *hi = t.gen64$q_quadword >> 32;
    654 #else
    655   time_t t;
    656 
    657   time (&t);
    658   vms_time_t_to_vms_time (t, hi, lo);
    659 #endif
    660 }
    661 
    662 /* Get the current time into a raw buffer BUF.  */
    663 
    664 void
    665 vms_raw_get_time (unsigned char *buf)
    666 {
    667   unsigned int hi, lo;
    668 
    669   vms_get_time (&hi, &lo);
    670   bfd_putl32 (lo, buf + 0);
    671   bfd_putl32 (hi, buf + 4);
    672 }
    673