vms-misc.c revision 1.1
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 65void 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 100void 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 138 139/* Copy sized string (string with fixed size) to new allocated area 140 size is string size (size of record) */ 141 142char * 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 158char * 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. */ 167 168/* Begin new record. 169 Write 2 bytes rectype and 2 bytes record length. */ 170 171void 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 188void 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 208void 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 219static 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 236void 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 262void 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 296int 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 306void 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 317void 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 328void 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 339void 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 350void 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 374void 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 388void 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 404static void 405vms_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 423static int 424vms_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 436int 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 448unsigned char * 449get_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 485char * 486vms_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 546time_t 547vms_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 585void 586vms_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 635time_t 636vms_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 644void 645vms_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 663void 664vms_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} 672