bfd/vms-misc.c

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