gnu/dist/gdb6/bfd/vms-misc.c

   1 /* vms-misc.c -- Miscellaneous functions for VAX (openVMS/VAX) and
   2    EVAX (openVMS/Alpha) files.
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5
   6    Written by Klaus K"ampf (kkaempf@rmi.de)
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #if __STDC__
  23 #include <stdarg.h>
  24 #endif
  25
  26 #include "bfd.h"
  27 #include "sysdep.h"
  28 #include "bfdlink.h"
  29 #include "libbfd.h"
  30
  31 #include "vms.h"
  32 \f
  33 #if VMS_DEBUG
  34 /* Debug functions.  */
  35
  36 /* Debug function for all vms extensions
  37    evaluates environment variable VMS_DEBUG for a
  38    numerical value on the first call
  39    all error levels below this value are printed
  40
  41    levels:
  42    1    toplevel bfd calls (functions from the bfd vector)
  43    2    functions called by bfd calls
  44    ...
  45    9    almost everything
  46
  47    level is also indentation level. Indentation is performed
  48    if level > 0.  */
  49
  50 void
  51 _bfd_vms_debug (int level, char *format, ...)
  52 {
  53   static int min_level = -1;
  54   static FILE *output = NULL;
  55   char *eptr;
  56   va_list args;
  57   int abslvl = (level > 0) ? level : - level;
  58
  59   if (min_level == -1)
  60     {
  61       if ((eptr = getenv ("VMS_DEBUG")) != NULL)
  62         {
  63           min_level = atoi (eptr);
  64           output = stderr;
  65         }
  66       else
  67         min_level = 0;
  68     }
  69   if (output == NULL)
  70     return;
  71   if (abslvl > min_level)
  72     return;
  73
  74   while (--level>0)
  75     fprintf (output, " ");
  76   va_start (args, format);
  77   vfprintf (output, format, args);
  78   fflush (output);
  79   va_end (args);
  80 }
  81
  82 /* A debug function
  83    hex dump 'size' bytes starting at 'ptr'.  */
  84
  85 void
  86 _bfd_hexdump (int level,
  87               unsigned char *ptr,
  88               int size,
  89               int offset)
  90 {
  91   unsigned char *lptr = ptr;
  92   int count = 0;
  93   long start = offset;
  94
  95   while (size-- > 0)
  96     {
  97       if ((count%16) == 0)
  98         vms_debug (level, "%08lx:", start);
  99       vms_debug (-level, " %02x", *ptr++);
 100       count++;
 101       start++;
 102       if (size == 0)
 103         {
 104           while ((count%16) != 0)
 105             {
 106               vms_debug (-level, "   ");
 107               count++;
 108             }
 109         }
 110       if ((count%16) == 0)
 111         {
 112           vms_debug (-level, " ");
 113           while (lptr < ptr)
 114             {
 115               vms_debug (-level, "%c", (*lptr < 32)?'.':*lptr);
 116               lptr++;
 117             }
 118           vms_debug (-level, "\n");
 119         }
 120     }
 121   if ((count%16) != 0)
 122     vms_debug (-level, "\n");
 123 }
 124 #endif
 125 \f
 126 /* Hash functions
 127
 128    These are needed when reading an object file.  */
 129
 130 /* Allocate new vms_hash_entry
 131    keep the symbol name and a pointer to the bfd symbol in the table.  */
 132
 133 struct bfd_hash_entry *
 134 _bfd_vms_hash_newfunc (struct bfd_hash_entry *entry,
 135                        struct bfd_hash_table *table,
 136                        const char *string)
 137 {
 138   vms_symbol_entry *ret;
 139
 140 #if VMS_DEBUG
 141   vms_debug (5, "_bfd_vms_hash_newfunc (%p, %p, %s)\n", entry, table, string);
 142 #endif
 143
 144   if (entry == NULL)
 145     {
 146       ret = (vms_symbol_entry *)
 147               bfd_hash_allocate (table, sizeof (vms_symbol_entry));
 148       if (ret ==  NULL)
 149         {
 150           bfd_set_error (bfd_error_no_memory);
 151           return NULL;
 152         }
 153       entry = (struct bfd_hash_entry *) ret;
 154     }
 155
 156   /* Call the allocation method of the base class.  */
 157   ret = (vms_symbol_entry *) bfd_hash_newfunc (entry, table, string);
 158 #if VMS_DEBUG
 159   vms_debug (6, "_bfd_vms_hash_newfunc ret %p\n", ret);
 160 #endif
 161
 162   ret->symbol = NULL;
 163
 164   return (struct bfd_hash_entry *)ret;
 165 }
 166 \f
 167 /* Object file input functions.  */
 168
 169 /* Return type and length from record header (buf) on Alpha.  */
 170
 171 void
 172 _bfd_vms_get_header_values (bfd * abfd ATTRIBUTE_UNUSED,
 173                             unsigned char *buf,
 174                             int *type,
 175                             int *length)
 176 {
 177   if (type != 0)
 178     *type = bfd_getl16 (buf);
 179   buf += 2;
 180   if (length != 0)
 181     *length = bfd_getl16 (buf);
 182
 183 #if VMS_DEBUG
 184   vms_debug (10, "_bfd_vms_get_header_values type %x, length %x\n", (type?*type:0), (length?*length:0));
 185 #endif
 186 }
 187
 188 /* Get next record from object file to vms_buf.
 189    Set PRIV(buf_size) and return it
 190
 191    This is a little tricky since it should be portable.
 192
 193    The openVMS object file has 'variable length' which means that
 194    read() returns data in chunks of (hopefully) correct and expected
 195    size. The linker (and other tools on vms) depend on that. Unix doesn't
 196    know about 'formatted' files, so reading and writing such an object
 197    file in a unix environment is not trivial.
 198
 199    With the tool 'file' (available on all vms ftp sites), one
 200    can view and change the attributes of a file. Changing from
 201    'variable length' to 'fixed length, 512 bytes' reveals the
 202    record length at the first 2 bytes of every record. The same
 203    happens during the transfer of object files from vms to unix,
 204    at least with ucx, dec's implementation of tcp/ip.
 205
 206    The vms format repeats the length at bytes 2 & 3 of every record.
 207
 208    On the first call (file_format == FF_UNKNOWN) we check if
 209    the first and the third byte pair (!) of the record match.
 210    If they do it's an object file in an unix environment or with
 211    wrong attributes (FF_FOREIGN), else we should be in a vms
 212    environment where read() returns the record size (FF_NATIVE).
 213
 214    Reading is always done in 2 steps.
 215    First just the record header is read and the length extracted
 216    by get_header_values,
 217    then the read buffer is adjusted and the remaining bytes are
 218    read in.
 219
 220    All file i/o is always done on even file positions.  */
 221
 222 int
 223 _bfd_vms_get_record (bfd * abfd)
 224 {
 225   int test_len, test_start, remaining;
 226   unsigned char *vms_buf;
 227
 228 #if VMS_DEBUG
 229   vms_debug (8, "_bfd_vms_get_record\n");
 230 #endif
 231
 232   /* Minimum is 6 bytes on Alpha
 233      (2 bytes length, 2 bytes record id, 2 bytes length repeated)
 234
 235      On the VAX there's no length information in the record
 236      so start with OBJ_S_C_MAXRECSIZ.   */
 237
 238   if (PRIV (buf_size) == 0)
 239     {
 240       bfd_size_type amt;
 241
 242       if (PRIV (is_vax))
 243         {
 244           amt = OBJ_S_C_MAXRECSIZ;
 245           PRIV (file_format) = FF_VAX;
 246         }
 247       else
 248         amt = 6;
 249       PRIV (vms_buf) = bfd_malloc (amt);
 250       PRIV (buf_size) = amt;
 251     }
 252
 253   vms_buf = PRIV (vms_buf);
 254
 255   if (vms_buf == 0)
 256     return -1;
 257
 258   switch (PRIV (file_format))
 259     {
 260     case FF_UNKNOWN:
 261     case FF_FOREIGN:
 262       test_len = 6;                     /* Probe 6 bytes.  */
 263       test_start = 2;                   /* Where the record starts.  */
 264       break;
 265
 266     case FF_NATIVE:
 267       test_len = 4;
 268       test_start = 0;
 269       break;
 270
 271     default:
 272     case FF_VAX:
 273       test_len = 0;
 274       test_start = 0;
 275       break;
 276     }
 277
 278   /* Skip odd alignment byte.  */
 279
 280   if (bfd_tell (abfd) & 1)
 281     {
 282       if (bfd_bread (PRIV (vms_buf), (bfd_size_type) 1, abfd) != 1)
 283         {
 284           bfd_set_error (bfd_error_file_truncated);
 285           return 0;
 286         }
 287     }
 288
 289   /* Read the record header on Alpha.  */
 290   if ((test_len != 0)
 291       && (bfd_bread (PRIV (vms_buf), (bfd_size_type) test_len, abfd)
 292           != (bfd_size_type) test_len))
 293     {
 294       bfd_set_error (bfd_error_file_truncated);
 295       return 0;
 296     }
 297
 298   /* Check file format on first call.  */
 299   if (PRIV (file_format) == FF_UNKNOWN)
 300     {                                           /* Record length repeats ?  */
 301       if (vms_buf[0] == vms_buf[4]
 302           && vms_buf[1] == vms_buf[5])
 303         {
 304           PRIV (file_format) = FF_FOREIGN;      /* Y: foreign environment.  */
 305           test_start = 2;
 306         }
 307       else
 308         {
 309           PRIV (file_format) = FF_NATIVE;       /* N: native environment.  */
 310           test_start = 0;
 311         }
 312     }
 313
 314   if (PRIV (is_vax))
 315     {
 316       PRIV (rec_length) = bfd_bread (vms_buf, (bfd_size_type) PRIV (buf_size),
 317                                      abfd);
 318       if (PRIV (rec_length) <= 0)
 319         {
 320           bfd_set_error (bfd_error_file_truncated);
 321           return 0;
 322         }
 323       PRIV (vms_rec) = vms_buf;
 324     }
 325   else
 326     {
 327       /* Alpha.   */
 328       /* Extract vms record length.  */
 329
 330       _bfd_vms_get_header_values (abfd, vms_buf + test_start, NULL,
 331                                   & PRIV (rec_length));
 332
 333       if (PRIV (rec_length) <= 0)
 334         {
 335           bfd_set_error (bfd_error_file_truncated);
 336           return 0;
 337         }
 338
 339       /* That's what the linker manual says.  */
 340
 341       if (PRIV (rec_length) > EOBJ_S_C_MAXRECSIZ)
 342         {
 343           bfd_set_error (bfd_error_file_truncated);
 344           return 0;
 345         }
 346
 347       /* Adjust the buffer.  */
 348
 349       if (PRIV (rec_length) > PRIV (buf_size))
 350         {
 351           PRIV (vms_buf) = bfd_realloc (vms_buf,
 352                                         (bfd_size_type) PRIV (rec_length));
 353           vms_buf = PRIV (vms_buf);
 354           if (vms_buf == 0)
 355             return -1;
 356           PRIV (buf_size) = PRIV (rec_length);
 357         }
 358
 359       /* Read the remaining record.  */
 360       remaining = PRIV (rec_length) - test_len + test_start;
 361
 362 #if VMS_DEBUG
 363       vms_debug (10, "bfd_bread remaining %d\n", remaining);
 364 #endif
 365       if (bfd_bread (vms_buf + test_len, (bfd_size_type) remaining, abfd) !=
 366           (bfd_size_type) remaining)
 367         {
 368           bfd_set_error (bfd_error_file_truncated);
 369           return 0;
 370         }
 371       PRIV (vms_rec) = vms_buf + test_start;
 372     }
 373
 374 #if VMS_DEBUG
 375   vms_debug (11, "bfd_bread rec_length %d\n", PRIV (rec_length));
 376 #endif
 377
 378   return PRIV (rec_length);
 379 }
 380
 381 /* Get next vms record from file
 382    update vms_rec and rec_length to new (remaining) values.  */
 383
 384 int
 385 _bfd_vms_next_record (bfd * abfd)
 386 {
 387 #if VMS_DEBUG
 388   vms_debug (8, "_bfd_vms_next_record (len %d, size %d)\n",
 389               PRIV (rec_length), PRIV (rec_size));
 390 #endif
 391
 392   if (PRIV (rec_length) > 0)
 393     PRIV (vms_rec) += PRIV (rec_size);
 394   else
 395     {
 396       if (_bfd_vms_get_record (abfd) <= 0)
 397         return -1;
 398     }
 399
 400   if (!PRIV (vms_rec) || !PRIV (vms_buf)
 401       || PRIV (vms_rec) >= (PRIV (vms_buf) + PRIV (buf_size)))
 402     return -1;
 403
 404   if (PRIV (is_vax))
 405     {
 406       PRIV (rec_type) = *(PRIV (vms_rec));
 407       PRIV (rec_size) = PRIV (rec_length);
 408     }
 409   else
 410     _bfd_vms_get_header_values (abfd, PRIV (vms_rec), &PRIV (rec_type),
 411                                 &PRIV (rec_size));
 412
 413   PRIV (rec_length) -= PRIV (rec_size);
 414
 415 #if VMS_DEBUG
 416   vms_debug (8, "_bfd_vms_next_record: rec %p, size %d, length %d, type %d\n",
 417               PRIV (vms_rec), PRIV (rec_size), PRIV (rec_length),
 418               PRIV (rec_type));
 419 #endif
 420
 421   return PRIV (rec_type);
 422 }
 423 \f
 424 /* Copy sized string (string with fixed length) to new allocated area
 425    size is string length (size of record)  */
 426
 427 char *
 428 _bfd_vms_save_sized_string (unsigned char *str, int size)
 429 {
 430   char *newstr = bfd_malloc ((bfd_size_type) size + 1);
 431
 432   if (newstr == NULL)
 433     return NULL;
 434   strncpy (newstr, (char *) str, (size_t) size);
 435   newstr[size] = 0;
 436
 437   return newstr;
 438 }
 439
 440 /* Copy counted string (string with length at first byte) to new allocated area
 441    ptr points to length byte on entry  */
 442
 443 char *
 444 _bfd_vms_save_counted_string (unsigned char *ptr)
 445 {
 446   int len = *ptr++;
 447
 448   return _bfd_vms_save_sized_string (ptr, len);
 449 }
 450 \f
 451 /* Stack routines for vms ETIR commands.  */
 452
 453 /* Push value and section index.  */
 454
 455 void
 456 _bfd_vms_push (bfd * abfd, uquad val, int psect)
 457 {
 458   static int last_psect;
 459
 460 #if VMS_DEBUG
 461   vms_debug (4, "<push %016lx (%d) at %d>\n", val, psect, PRIV (stackptr));
 462 #endif
 463
 464   if (psect >= 0)
 465     last_psect = psect;
 466
 467   PRIV (stack[PRIV (stackptr)]).value = val;
 468   PRIV (stack[PRIV (stackptr)]).psect = last_psect;
 469   PRIV (stackptr)++;
 470   if (PRIV (stackptr) >= STACKSIZE)
 471     {
 472       bfd_set_error (bfd_error_bad_value);
 473       (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
 474       exit (1);
 475     }
 476 }
 477
 478 /* Pop value and section index.  */
 479
 480 uquad
 481 _bfd_vms_pop (bfd * abfd, int *psect)
 482 {
 483   uquad value;
 484
 485   if (PRIV (stackptr) == 0)
 486     {
 487       bfd_set_error (bfd_error_bad_value);
 488       (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
 489       exit (1);
 490     }
 491   PRIV (stackptr)--;
 492   value = PRIV (stack[PRIV (stackptr)]).value;
 493   if ((psect != NULL) && (PRIV (stack[PRIV (stackptr)]).psect >= 0))
 494     *psect = PRIV (stack[PRIV (stackptr)]).psect;
 495
 496 #if VMS_DEBUG
 497   vms_debug (4, "<pop %016lx(%d)>\n", value, PRIV (stack[PRIV (stackptr)]).psect);
 498 #endif
 499
 500   return value;
 501 }
 502 \f
 503 /* Object file output functions.  */
 504
 505 /* GAS tends to write sections in little chunks (bfd_set_section_contents)
 506    which we can't use directly. So we save the little chunks in linked
 507    lists (one per section) and write them later.  */
 508
 509 /* Add a new vms_section structure to vms_section_table
 510    - forward chaining -.  */
 511
 512 static vms_section *
 513 add_new_contents (bfd * abfd, sec_ptr section)
 514 {
 515   vms_section *sptr, *newptr;
 516
 517   sptr = PRIV (vms_section_table)[section->index];
 518   if (sptr != NULL)
 519     return sptr;
 520
 521   newptr = bfd_alloc (abfd, (bfd_size_type) sizeof (vms_section));
 522   if (newptr == NULL)
 523     return NULL;
 524   newptr->contents = bfd_alloc (abfd, section->size);
 525   if (newptr->contents == NULL)
 526     return NULL;
 527   newptr->offset = 0;
 528   newptr->size = section->size;
 529   newptr->next = 0;
 530   PRIV (vms_section_table)[section->index] = newptr;
 531   return newptr;
 532 }
 533
 534 /* Save section data & offset to a vms_section structure
 535    vms_section_table[] holds the vms_section chain.  */
 536
 537 bfd_boolean
 538 _bfd_save_vms_section (bfd * abfd,
 539                        sec_ptr section,
 540                        const void * data,
 541                        file_ptr offset,
 542                        bfd_size_type count)
 543 {
 544   vms_section *sptr;
 545
 546   if (section->index >= VMS_SECTION_COUNT)
 547     {
 548       bfd_set_error (bfd_error_nonrepresentable_section);
 549       return FALSE;
 550     }
 551   if (count == (bfd_size_type)0)
 552     return TRUE;
 553   sptr = add_new_contents (abfd, section);
 554   if (sptr == NULL)
 555     return FALSE;
 556   memcpy (sptr->contents + offset, data, (size_t) count);
 557
 558   return TRUE;
 559 }
 560
 561 /* Get vms_section pointer to saved contents for section # index  */
 562
 563 vms_section *
 564 _bfd_get_vms_section (bfd * abfd, int index)
 565 {
 566   if (index >=  VMS_SECTION_COUNT)
 567     {
 568       bfd_set_error (bfd_error_nonrepresentable_section);
 569       return NULL;
 570     }
 571   return PRIV (vms_section_table)[index];
 572 }
 573 \f
 574 /* Object output routines.   */
 575
 576 /* Begin new record or record header
 577    write 2 bytes rectype
 578    write 2 bytes record length (filled in at flush)
 579    write 2 bytes header type (ommitted if rechead == -1).   */
 580
 581 void
 582 _bfd_vms_output_begin (bfd * abfd, int rectype, int rechead)
 583 {
 584 #if VMS_DEBUG
 585   vms_debug (6, "_bfd_vms_output_begin (type %d, head %d)\n", rectype,
 586               rechead);
 587 #endif
 588
 589   _bfd_vms_output_short (abfd, (unsigned int) rectype);
 590
 591   /* Save current output position to fill in length later.   */
 592
 593   if (PRIV (push_level) > 0)
 594     PRIV (length_pos) = PRIV (output_size);
 595
 596 #if VMS_DEBUG
 597   vms_debug (6, "_bfd_vms_output_begin: length_pos = %d\n",
 598               PRIV (length_pos));
 599 #endif
 600
 601   /* Placeholder for length.  */
 602   _bfd_vms_output_short (abfd, 0);
 603
 604   if (rechead != -1)
 605     _bfd_vms_output_short (abfd, (unsigned int) rechead);
 606 }
 607
 608 /* Set record/subrecord alignment.   */
 609
 610 void
 611 _bfd_vms_output_alignment (bfd * abfd, int alignto)
 612 {
 613 #if VMS_DEBUG
 614   vms_debug (6, "_bfd_vms_output_alignment (%d)\n", alignto);
 615 #endif
 616
 617   PRIV (output_alignment) = alignto;
 618 }
 619
 620 /* Prepare for subrecord fields.  */
 621
 622 void
 623 _bfd_vms_output_push (bfd * abfd)
 624 {
 625 #if VMS_DEBUG
 626   vms_debug (6, "vms_output_push (pushed_size = %d)\n", PRIV (output_size));
 627 #endif
 628
 629   PRIV (push_level)++;
 630   PRIV (pushed_size) = PRIV (output_size);
 631 }
 632
 633 /* End of subrecord fields.   */
 634
 635 void
 636 _bfd_vms_output_pop (bfd * abfd)
 637 {
 638 #if VMS_DEBUG
 639   vms_debug (6, "vms_output_pop (pushed_size = %d)\n", PRIV (pushed_size));
 640 #endif
 641
 642   _bfd_vms_output_flush (abfd);
 643   PRIV (length_pos) = 2;
 644
 645 #if VMS_DEBUG
 646   vms_debug (6, "vms_output_pop: length_pos = %d\n", PRIV (length_pos));
 647 #endif
 648
 649   PRIV (pushed_size) = 0;
 650   PRIV (push_level)--;
 651 }
 652
 653 /* Flush unwritten output, ends current record.  */
 654
 655 void
 656 _bfd_vms_output_flush (bfd * abfd)
 657 {
 658   int real_size = PRIV (output_size);
 659   int aligncount;
 660   int length;
 661
 662 #if VMS_DEBUG
 663   vms_debug (6, "_bfd_vms_output_flush (real_size = %d, pushed_size %d at lenpos %d)\n",
 664               real_size, PRIV (pushed_size), PRIV (length_pos));
 665 #endif
 666
 667   if (PRIV (push_level) > 0)
 668     length = real_size - PRIV (pushed_size);
 669   else
 670     length = real_size;
 671
 672   if (length == 0)
 673     return;
 674   aligncount = (PRIV (output_alignment)
 675                 - (length % PRIV (output_alignment))) % PRIV (output_alignment);
 676
 677 #if VMS_DEBUG
 678   vms_debug (6, "align: adding %d bytes\n", aligncount);
 679 #endif
 680
 681   while (aligncount-- > 0)
 682     {
 683       PRIV (output_buf)[real_size++] = 0;
 684       length++;
 685     }
 686
 687   /* Put length to buffer.  */
 688   PRIV (output_size) = PRIV (length_pos);
 689   _bfd_vms_output_short (abfd, (unsigned int) length);
 690
 691   if (PRIV (push_level) == 0)
 692     {
 693 #ifndef VMS
 694         /* Write length first, see FF_FOREIGN in the input routines.  */
 695       fwrite (PRIV (output_buf) + 2, 2, 1, (FILE *) abfd->iostream);
 696 #endif
 697       fwrite (PRIV (output_buf), (size_t) real_size, 1,
 698               (FILE *) abfd->iostream);
 699
 700       PRIV (output_size) = 0;
 701     }
 702   else
 703     {
 704       PRIV (output_size) = real_size;
 705       PRIV (pushed_size) = PRIV (output_size);
 706     }
 707 }
 708
 709 /* End record output.   */
 710
 711 void
 712 _bfd_vms_output_end (bfd * abfd)
 713 {
 714 #if VMS_DEBUG
 715   vms_debug (6, "_bfd_vms_output_end\n");
 716 #endif
 717
 718   _bfd_vms_output_flush (abfd);
 719 }
 720
 721 /* Check remaining buffer size
 722
 723    Return what's left.  */
 724
 725 int
 726 _bfd_vms_output_check (bfd * abfd, int size)
 727 {
 728 #if VMS_DEBUG
 729   vms_debug (6, "_bfd_vms_output_check (%d)\n", size);
 730 #endif
 731
 732   return (MAX_OUTREC_SIZE - (PRIV (output_size) + size + MIN_OUTREC_LUFT));
 733 }
 734
 735 /* Output byte (8 bit) value.  */
 736
 737 void
 738 _bfd_vms_output_byte (bfd * abfd, unsigned int value)
 739 {
 740 #if VMS_DEBUG
 741   vms_debug (6, "_bfd_vms_output_byte (%02x)\n", value);
 742 #endif
 743
 744   bfd_put_8 (abfd, value & 0xff, PRIV (output_buf) + PRIV (output_size));
 745   PRIV (output_size) += 1;
 746 }
 747
 748 /* Output short (16 bit) value.  */
 749
 750 void
 751 _bfd_vms_output_short (bfd * abfd, unsigned int value)
 752 {
 753 #if VMS_DEBUG
 754   vms_debug (6, "_bfd_vms_output_short (%04x)\n", value);
 755 #endif
 756
 757   bfd_put_16 (abfd, (bfd_vma) value & 0xffff,
 758               PRIV (output_buf) + PRIV (output_size));
 759   PRIV (output_size) += 2;
 760 }
 761
 762 /* Output long (32 bit) value.  */
 763
 764 void
 765 _bfd_vms_output_long (bfd * abfd, unsigned long value)
 766 {
 767 #if VMS_DEBUG
 768   vms_debug (6, "_bfd_vms_output_long (%08lx)\n", value);
 769 #endif
 770
 771   bfd_put_32 (abfd, (bfd_vma) value, PRIV (output_buf) + PRIV (output_size));
 772   PRIV (output_size) += 4;
 773 }
 774
 775 /* Output quad (64 bit) value.  */
 776
 777 void
 778 _bfd_vms_output_quad (bfd * abfd, uquad value)
 779 {
 780 #if VMS_DEBUG
 781   vms_debug (6, "_bfd_vms_output_quad (%016lx)\n", value);
 782 #endif
 783
 784   bfd_put_64(abfd, value, PRIV (output_buf) + PRIV (output_size));
 785   PRIV (output_size) += 8;
 786 }
 787
 788 /* Output c-string as counted string.  */
 789
 790 void
 791 _bfd_vms_output_counted (bfd * abfd, char *value)
 792 {
 793   int len;
 794
 795 #if VMS_DEBUG
 796   vms_debug (6, "_bfd_vms_output_counted (%s)\n", value);
 797 #endif
 798
 799   len = strlen (value);
 800   if (len == 0)
 801     {
 802       (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
 803       return;
 804     }
 805   if (len > 255)
 806     {
 807       (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
 808       return;
 809     }
 810   _bfd_vms_output_byte (abfd, (unsigned int) len & 0xff);
 811   _bfd_vms_output_dump (abfd, (unsigned char *) value, len);
 812 }
 813
 814 /* Output character area.  */
 815
 816 void
 817 _bfd_vms_output_dump (bfd * abfd,
 818                       unsigned char *data,
 819                       int length)
 820 {
 821 #if VMS_DEBUG
 822   vms_debug (6, "_bfd_vms_output_dump (%d)\n", length);
 823 #endif
 824
 825   if (length == 0)
 826     return;
 827
 828   memcpy (PRIV (output_buf) + PRIV (output_size), data, (size_t) length);
 829   PRIV (output_size) += length;
 830 }
 831
 832 /* Output count bytes of value.  */
 833
 834 void
 835 _bfd_vms_output_fill (bfd * abfd,
 836                       int value,
 837                       int count)
 838 {
 839 #if VMS_DEBUG
 840   vms_debug (6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count);
 841 #endif
 842
 843   if (count == 0)
 844     return;
 845   memset (PRIV (output_buf) + PRIV (output_size), value, (size_t) count);
 846   PRIV (output_size) += count;
 847 }
 848
 849 /* This hash routine borrowed from GNU-EMACS, and strengthened slightly.  ERY.  */
 850
 851 static int
 852 hash_string (const char *ptr)
 853 {
 854   const unsigned char *p = (unsigned char *) ptr;
 855   const unsigned char *end = p + strlen (ptr);
 856   unsigned char c;
 857   int hash = 0;
 858
 859   while (p != end)
 860     {
 861       c = *p++;
 862       hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
 863     }
 864   return hash;
 865 }
 866
 867 /* Generate a length-hashed VMS symbol name (limited to maxlen chars).  */
 868
 869 char *
 870 _bfd_vms_length_hash_symbol (bfd * abfd, const char *in, int maxlen)
 871 {
 872   long int result;
 873   int in_len;
 874   char *new_name;
 875   const char *old_name;
 876   int i;
 877   static char outbuf[EOBJ_S_C_SYMSIZ+1];
 878   char *out = outbuf;
 879
 880 #if VMS_DEBUG
 881   vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
 882 #endif
 883
 884   if (maxlen > EOBJ_S_C_SYMSIZ)
 885     maxlen = EOBJ_S_C_SYMSIZ;
 886
 887   /* Save this for later.  */
 888   new_name = out;
 889
 890   /* We may need to truncate the symbol, save the hash for later.  */
 891   in_len = strlen (in);
 892
 893   result = (in_len > maxlen) ? hash_string (in) : 0;
 894
 895   old_name = in;
 896
 897   /* Do the length checking.  */
 898   if (in_len <= maxlen)
 899     i = in_len;
 900   else
 901     {
 902       if (PRIV (flag_hash_long_names))
 903         i = maxlen-9;
 904       else
 905         i = maxlen;
 906     }
 907
 908   strncpy (out, in, (size_t) i);
 909   in += i;
 910   out += i;
 911
 912   if ((in_len > maxlen)
 913       && PRIV (flag_hash_long_names))
 914     sprintf (out, "_%08lx", result);
 915   else
 916     *out = 0;
 917
 918 #if VMS_DEBUG
 919   vms_debug (4, "--> [%d]\"%s\"\n", strlen (outbuf), outbuf);
 920 #endif
 921
 922   if (in_len > maxlen
 923         && PRIV (flag_hash_long_names)
 924         && PRIV (flag_show_after_trunc))
 925     printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
 926
 927   return outbuf;
 928 }
 929
 930 /* Allocate and initialize a new symbol.  */
 931
 932 static asymbol *
 933 new_symbol (bfd * abfd, char *name)
 934 {
 935   asymbol *symbol;
 936
 937 #if VMS_DEBUG
 938   _bfd_vms_debug (7,  "new_symbol %s\n", name);
 939 #endif
 940
 941   symbol = bfd_make_empty_symbol (abfd);
 942   if (symbol == 0)
 943     return symbol;
 944   symbol->name = name;
 945   symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
 946
 947   return symbol;
 948 }
 949
 950 /* Allocate and enter a new private symbol.  */
 951
 952 vms_symbol_entry *
 953 _bfd_vms_enter_symbol (bfd * abfd, char *name)
 954 {
 955   vms_symbol_entry *entry;
 956
 957 #if VMS_DEBUG
 958   _bfd_vms_debug (6,  "_bfd_vms_enter_symbol %s\n", name);
 959 #endif
 960
 961   entry = (vms_symbol_entry *)
 962           bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
 963   if (entry == 0)
 964     {
 965 #if VMS_DEBUG
 966       _bfd_vms_debug (8,  "creating hash entry for %s\n", name);
 967 #endif
 968       entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 969                                                     name, TRUE, FALSE);
 970       if (entry != 0)
 971         {
 972           asymbol *symbol;
 973           symbol = new_symbol (abfd, name);
 974           if (symbol != 0)
 975             {
 976               entry->symbol = symbol;
 977               PRIV (gsd_sym_count)++;
 978               abfd->symcount++;
 979             }
 980           else
 981             entry = 0;
 982         }
 983       else
 984         (*_bfd_error_handler) (_("failed to enter %s"), name);
 985     }
 986   else
 987     {
 988 #if VMS_DEBUG
 989       _bfd_vms_debug (8,  "found hash entry for %s\n", name);
 990 #endif
 991     }
 992
 993 #if VMS_DEBUG
 994   _bfd_vms_debug (7, "-> entry %p, entry->symbol %p\n", entry, entry->symbol);
 995 #endif
 996   return entry;
 997 }