Silence gcc printf warnings
[binutils.git] / bfd / vms-misc.c
blob9d0ffdb27361a4fc78d037832908eeaae960737a
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 2007, 2008 Free Software Foundation, Inc.
6 Written by Klaus K"ampf (kkaempf@rmi.de)
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 3 of the License, or
11 (at your option) any later version.
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.
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,
21 MA 02110-1301, USA. */
23 #if __STDC__
24 #include <stdarg.h>
25 #endif
27 #include "sysdep.h"
28 #include "bfd.h"
29 #include "bfdlink.h"
30 #include "libbfd.h"
32 #include "vms.h"
34 #if VMS_DEBUG
35 /* Debug functions. */
37 /* Debug function for all vms extensions
38 evaluates environment variable VMS_DEBUG for a
39 numerical value on the first call
40 all error levels below this value are printed
42 levels:
43 1 toplevel bfd calls (functions from the bfd vector)
44 2 functions called by bfd calls
45 ...
46 9 almost everything
48 level is also indentation level. Indentation is performed
49 if level > 0. */
51 void
52 _bfd_vms_debug (int level, char *format, ...)
54 static int min_level = -1;
55 static FILE *output = NULL;
56 char *eptr;
57 va_list args;
58 int abslvl = (level > 0) ? level : - level;
60 if (min_level == -1)
62 if ((eptr = getenv ("VMS_DEBUG")) != NULL)
64 min_level = atoi (eptr);
65 output = stderr;
67 else
68 min_level = 0;
70 if (output == NULL)
71 return;
72 if (abslvl > min_level)
73 return;
75 while (--level>0)
76 fprintf (output, " ");
77 va_start (args, format);
78 vfprintf (output, format, args);
79 fflush (output);
80 va_end (args);
83 /* A debug function
84 hex dump 'size' bytes starting at 'ptr'. */
86 void
87 _bfd_hexdump (int level,
88 unsigned char *ptr,
89 int size,
90 int offset)
92 unsigned char *lptr = ptr;
93 int count = 0;
94 long start = offset;
96 while (size-- > 0)
98 if ((count%16) == 0)
99 vms_debug (level, "%08lx:", start);
100 vms_debug (-level, " %02x", *ptr++);
101 count++;
102 start++;
103 if (size == 0)
105 while ((count%16) != 0)
107 vms_debug (-level, " ");
108 count++;
111 if ((count%16) == 0)
113 vms_debug (-level, " ");
114 while (lptr < ptr)
116 vms_debug (-level, "%c", (*lptr < 32)?'.':*lptr);
117 lptr++;
119 vms_debug (-level, "\n");
122 if ((count%16) != 0)
123 vms_debug (-level, "\n");
125 #endif
127 /* Hash functions
129 These are needed when reading an object file. */
131 /* Allocate new vms_hash_entry
132 keep the symbol name and a pointer to the bfd symbol in the table. */
134 struct bfd_hash_entry *
135 _bfd_vms_hash_newfunc (struct bfd_hash_entry *entry,
136 struct bfd_hash_table *table,
137 const char *string)
139 vms_symbol_entry *ret;
141 #if VMS_DEBUG
142 vms_debug (5, "_bfd_vms_hash_newfunc (%p, %p, %s)\n", entry, table, string);
143 #endif
145 if (entry == NULL)
147 ret = (vms_symbol_entry *)
148 bfd_hash_allocate (table, sizeof (vms_symbol_entry));
149 if (ret == NULL)
151 bfd_set_error (bfd_error_no_memory);
152 return NULL;
154 entry = (struct bfd_hash_entry *) ret;
157 /* Call the allocation method of the base class. */
158 ret = (vms_symbol_entry *) bfd_hash_newfunc (entry, table, string);
159 #if VMS_DEBUG
160 vms_debug (6, "_bfd_vms_hash_newfunc ret %p\n", ret);
161 #endif
163 ret->symbol = NULL;
165 return (struct bfd_hash_entry *)ret;
168 /* Object file input functions. */
170 /* Return type and length from record header (buf) on Alpha. */
172 void
173 _bfd_vms_get_header_values (bfd * abfd ATTRIBUTE_UNUSED,
174 unsigned char *buf,
175 int *type,
176 int *length)
178 if (type != 0)
179 *type = bfd_getl16 (buf);
180 buf += 2;
181 if (length != 0)
182 *length = bfd_getl16 (buf);
184 #if VMS_DEBUG
185 vms_debug (10, "_bfd_vms_get_header_values type %x, length %x\n", (type?*type:0), (length?*length:0));
186 #endif
189 /* Get next record from object file to vms_buf.
190 Set PRIV(buf_size) and return it
192 This is a little tricky since it should be portable.
194 The openVMS object file has 'variable length' which means that
195 read() returns data in chunks of (hopefully) correct and expected
196 size. The linker (and other tools on vms) depend on that. Unix doesn't
197 know about 'formatted' files, so reading and writing such an object
198 file in a unix environment is not trivial.
200 With the tool 'file' (available on all vms ftp sites), one
201 can view and change the attributes of a file. Changing from
202 'variable length' to 'fixed length, 512 bytes' reveals the
203 record length at the first 2 bytes of every record. The same
204 happens during the transfer of object files from vms to unix,
205 at least with ucx, dec's implementation of tcp/ip.
207 The vms format repeats the length at bytes 2 & 3 of every record.
209 On the first call (file_format == FF_UNKNOWN) we check if
210 the first and the third byte pair (!) of the record match.
211 If they do it's an object file in an unix environment or with
212 wrong attributes (FF_FOREIGN), else we should be in a vms
213 environment where read() returns the record size (FF_NATIVE).
215 Reading is always done in 2 steps.
216 First just the record header is read and the length extracted
217 by get_header_values,
218 then the read buffer is adjusted and the remaining bytes are
219 read in.
221 All file i/o is always done on even file positions. */
224 _bfd_vms_get_record (bfd * abfd)
226 int test_len, test_start, remaining;
227 unsigned char *vms_buf;
229 #if VMS_DEBUG
230 vms_debug (8, "_bfd_vms_get_record\n");
231 #endif
233 /* Minimum is 6 bytes on Alpha
234 (2 bytes length, 2 bytes record id, 2 bytes length repeated)
236 On the VAX there's no length information in the record
237 so start with OBJ_S_C_MAXRECSIZ. */
239 if (PRIV (buf_size) == 0)
241 bfd_size_type amt;
243 if (PRIV (is_vax))
245 amt = OBJ_S_C_MAXRECSIZ;
246 PRIV (file_format) = FF_VAX;
248 else
249 amt = 6;
250 PRIV (vms_buf) = bfd_malloc (amt);
251 PRIV (buf_size) = amt;
254 vms_buf = PRIV (vms_buf);
256 if (vms_buf == 0)
257 return -1;
259 switch (PRIV (file_format))
261 case FF_UNKNOWN:
262 case FF_FOREIGN:
263 test_len = 6; /* Probe 6 bytes. */
264 test_start = 2; /* Where the record starts. */
265 break;
267 case FF_NATIVE:
268 test_len = 4;
269 test_start = 0;
270 break;
272 default:
273 case FF_VAX:
274 test_len = 0;
275 test_start = 0;
276 break;
279 /* Skip odd alignment byte. */
281 if (bfd_tell (abfd) & 1)
283 if (bfd_bread (PRIV (vms_buf), (bfd_size_type) 1, abfd) != 1)
285 bfd_set_error (bfd_error_file_truncated);
286 return 0;
290 /* Read the record header on Alpha. */
291 if ((test_len != 0)
292 && (bfd_bread (PRIV (vms_buf), (bfd_size_type) test_len, abfd)
293 != (bfd_size_type) test_len))
295 bfd_set_error (bfd_error_file_truncated);
296 return 0;
299 /* Check file format on first call. */
300 if (PRIV (file_format) == FF_UNKNOWN)
301 { /* Record length repeats ? */
302 if (vms_buf[0] == vms_buf[4]
303 && vms_buf[1] == vms_buf[5])
305 PRIV (file_format) = FF_FOREIGN; /* Y: foreign environment. */
306 test_start = 2;
308 else
310 PRIV (file_format) = FF_NATIVE; /* N: native environment. */
311 test_start = 0;
315 if (PRIV (is_vax))
317 PRIV (rec_length) = bfd_bread (vms_buf, (bfd_size_type) PRIV (buf_size),
318 abfd);
319 if (PRIV (rec_length) <= 0)
321 bfd_set_error (bfd_error_file_truncated);
322 return 0;
324 PRIV (vms_rec) = vms_buf;
326 else
328 /* Alpha. */
329 /* Extract vms record length. */
331 _bfd_vms_get_header_values (abfd, vms_buf + test_start, NULL,
332 & PRIV (rec_length));
334 if (PRIV (rec_length) <= 0)
336 bfd_set_error (bfd_error_file_truncated);
337 return 0;
340 /* That's what the linker manual says. */
342 if (PRIV (rec_length) > EOBJ_S_C_MAXRECSIZ)
344 bfd_set_error (bfd_error_file_truncated);
345 return 0;
348 /* Adjust the buffer. */
350 if (PRIV (rec_length) > PRIV (buf_size))
352 PRIV (vms_buf) = bfd_realloc_or_free (vms_buf,
353 (bfd_size_type) PRIV (rec_length));
354 vms_buf = PRIV (vms_buf);
355 if (vms_buf == 0)
356 return -1;
357 PRIV (buf_size) = PRIV (rec_length);
360 /* Read the remaining record. */
361 remaining = PRIV (rec_length) - test_len + test_start;
363 #if VMS_DEBUG
364 vms_debug (10, "bfd_bread remaining %d\n", remaining);
365 #endif
366 if (bfd_bread (vms_buf + test_len, (bfd_size_type) remaining, abfd) !=
367 (bfd_size_type) remaining)
369 bfd_set_error (bfd_error_file_truncated);
370 return 0;
372 PRIV (vms_rec) = vms_buf + test_start;
375 #if VMS_DEBUG
376 vms_debug (11, "bfd_bread rec_length %d\n", PRIV (rec_length));
377 #endif
379 return PRIV (rec_length);
382 /* Get next vms record from file
383 update vms_rec and rec_length to new (remaining) values. */
386 _bfd_vms_next_record (bfd * abfd)
388 #if VMS_DEBUG
389 vms_debug (8, "_bfd_vms_next_record (len %d, size %d)\n",
390 PRIV (rec_length), PRIV (rec_size));
391 #endif
393 if (PRIV (rec_length) > 0)
394 PRIV (vms_rec) += PRIV (rec_size);
395 else
397 if (_bfd_vms_get_record (abfd) <= 0)
398 return -1;
401 if (!PRIV (vms_rec) || !PRIV (vms_buf)
402 || PRIV (vms_rec) >= (PRIV (vms_buf) + PRIV (buf_size)))
403 return -1;
405 if (PRIV (is_vax))
407 PRIV (rec_type) = *(PRIV (vms_rec));
408 PRIV (rec_size) = PRIV (rec_length);
410 else
411 _bfd_vms_get_header_values (abfd, PRIV (vms_rec), &PRIV (rec_type),
412 &PRIV (rec_size));
414 PRIV (rec_length) -= PRIV (rec_size);
416 #if VMS_DEBUG
417 vms_debug (8, "_bfd_vms_next_record: rec %p, size %d, length %d, type %d\n",
418 PRIV (vms_rec), PRIV (rec_size), PRIV (rec_length),
419 PRIV (rec_type));
420 #endif
422 return PRIV (rec_type);
425 /* Copy sized string (string with fixed length) to new allocated area
426 size is string length (size of record) */
428 char *
429 _bfd_vms_save_sized_string (unsigned char *str, int size)
431 char *newstr = bfd_malloc ((bfd_size_type) size + 1);
433 if (newstr == NULL)
434 return NULL;
435 strncpy (newstr, (char *) str, (size_t) size);
436 newstr[size] = 0;
438 return newstr;
441 /* Copy counted string (string with length at first byte) to new allocated area
442 ptr points to length byte on entry */
444 char *
445 _bfd_vms_save_counted_string (unsigned char *ptr)
447 int len = *ptr++;
449 return _bfd_vms_save_sized_string (ptr, len);
452 /* Stack routines for vms ETIR commands. */
454 /* Push value and section index. */
456 void
457 _bfd_vms_push (bfd * abfd, uquad val, int psect)
459 static int last_psect;
461 #if VMS_DEBUG
462 vms_debug (4, "<push %016lx (%d) at %d>\n", val, psect, PRIV (stackptr));
463 #endif
465 if (psect >= 0)
466 last_psect = psect;
468 PRIV (stack[PRIV (stackptr)]).value = val;
469 PRIV (stack[PRIV (stackptr)]).psect = last_psect;
470 PRIV (stackptr)++;
471 if (PRIV (stackptr) >= STACKSIZE)
473 bfd_set_error (bfd_error_bad_value);
474 (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
475 exit (1);
479 /* Pop value and section index. */
481 uquad
482 _bfd_vms_pop (bfd * abfd, int *psect)
484 uquad value;
486 if (PRIV (stackptr) == 0)
488 bfd_set_error (bfd_error_bad_value);
489 (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
490 exit (1);
492 PRIV (stackptr)--;
493 value = PRIV (stack[PRIV (stackptr)]).value;
494 if ((psect != NULL) && (PRIV (stack[PRIV (stackptr)]).psect >= 0))
495 *psect = PRIV (stack[PRIV (stackptr)]).psect;
497 #if VMS_DEBUG
498 vms_debug (4, "<pop %016lx(%d)>\n", value, PRIV (stack[PRIV (stackptr)]).psect);
499 #endif
501 return value;
504 /* Object file output functions. */
506 /* GAS tends to write sections in little chunks (bfd_set_section_contents)
507 which we can't use directly. So we save the little chunks in linked
508 lists (one per section) and write them later. */
510 /* Add a new vms_section structure to vms_section_table
511 - forward chaining -. */
513 static vms_section *
514 add_new_contents (bfd * abfd, sec_ptr section)
516 vms_section *sptr, *newptr;
518 sptr = PRIV (vms_section_table)[section->index];
519 if (sptr != NULL)
520 return sptr;
522 newptr = bfd_alloc (abfd, (bfd_size_type) sizeof (vms_section));
523 if (newptr == NULL)
524 return NULL;
525 newptr->contents = bfd_alloc (abfd, section->size);
526 if (newptr->contents == NULL)
527 return NULL;
528 newptr->offset = 0;
529 newptr->size = section->size;
530 newptr->next = 0;
531 PRIV (vms_section_table)[section->index] = newptr;
532 return newptr;
535 /* Save section data & offset to a vms_section structure
536 vms_section_table[] holds the vms_section chain. */
538 bfd_boolean
539 _bfd_save_vms_section (bfd * abfd,
540 sec_ptr section,
541 const void * data,
542 file_ptr offset,
543 bfd_size_type count)
545 vms_section *sptr;
547 if (section->index >= VMS_SECTION_COUNT)
549 bfd_set_error (bfd_error_nonrepresentable_section);
550 return FALSE;
552 if (count == (bfd_size_type)0)
553 return TRUE;
554 sptr = add_new_contents (abfd, section);
555 if (sptr == NULL)
556 return FALSE;
557 memcpy (sptr->contents + offset, data, (size_t) count);
559 return TRUE;
562 /* Get vms_section pointer to saved contents for section # index */
564 vms_section *
565 _bfd_get_vms_section (bfd * abfd, int index)
567 if (index >= VMS_SECTION_COUNT)
569 bfd_set_error (bfd_error_nonrepresentable_section);
570 return NULL;
572 return PRIV (vms_section_table)[index];
575 /* Object output routines. */
577 /* Begin new record or record header
578 write 2 bytes rectype
579 write 2 bytes record length (filled in at flush)
580 write 2 bytes header type (ommitted if rechead == -1). */
582 void
583 _bfd_vms_output_begin (bfd * abfd, int rectype, int rechead)
585 #if VMS_DEBUG
586 vms_debug (6, "_bfd_vms_output_begin (type %d, head %d)\n", rectype,
587 rechead);
588 #endif
590 _bfd_vms_output_short (abfd, (unsigned int) rectype);
592 /* Save current output position to fill in length later. */
594 if (PRIV (push_level) > 0)
595 PRIV (length_pos) = PRIV (output_size);
597 #if VMS_DEBUG
598 vms_debug (6, "_bfd_vms_output_begin: length_pos = %d\n",
599 PRIV (length_pos));
600 #endif
602 /* Placeholder for length. */
603 _bfd_vms_output_short (abfd, 0);
605 if (rechead != -1)
606 _bfd_vms_output_short (abfd, (unsigned int) rechead);
609 /* Set record/subrecord alignment. */
611 void
612 _bfd_vms_output_alignment (bfd * abfd, int alignto)
614 #if VMS_DEBUG
615 vms_debug (6, "_bfd_vms_output_alignment (%d)\n", alignto);
616 #endif
618 PRIV (output_alignment) = alignto;
621 /* Prepare for subrecord fields. */
623 void
624 _bfd_vms_output_push (bfd * abfd)
626 #if VMS_DEBUG
627 vms_debug (6, "vms_output_push (pushed_size = %d)\n", PRIV (output_size));
628 #endif
630 PRIV (push_level)++;
631 PRIV (pushed_size) = PRIV (output_size);
634 /* End of subrecord fields. */
636 void
637 _bfd_vms_output_pop (bfd * abfd)
639 #if VMS_DEBUG
640 vms_debug (6, "vms_output_pop (pushed_size = %d)\n", PRIV (pushed_size));
641 #endif
643 _bfd_vms_output_flush (abfd);
644 PRIV (length_pos) = 2;
646 #if VMS_DEBUG
647 vms_debug (6, "vms_output_pop: length_pos = %d\n", PRIV (length_pos));
648 #endif
650 PRIV (pushed_size) = 0;
651 PRIV (push_level)--;
654 /* Flush unwritten output, ends current record. */
656 void
657 _bfd_vms_output_flush (bfd * abfd)
659 int real_size = PRIV (output_size);
660 int aligncount;
661 int length;
663 #if VMS_DEBUG
664 vms_debug (6, "_bfd_vms_output_flush (real_size = %d, pushed_size %d at lenpos %d)\n",
665 real_size, PRIV (pushed_size), PRIV (length_pos));
666 #endif
668 if (PRIV (push_level) > 0)
669 length = real_size - PRIV (pushed_size);
670 else
671 length = real_size;
673 if (length == 0)
674 return;
675 aligncount = (PRIV (output_alignment)
676 - (length % PRIV (output_alignment))) % PRIV (output_alignment);
678 #if VMS_DEBUG
679 vms_debug (6, "align: adding %d bytes\n", aligncount);
680 #endif
682 while (aligncount-- > 0)
684 PRIV (output_buf)[real_size++] = 0;
685 length++;
688 /* Put length to buffer. */
689 PRIV (output_size) = PRIV (length_pos);
690 _bfd_vms_output_short (abfd, (unsigned int) length);
692 if (PRIV (push_level) == 0)
694 if (0
695 #ifndef VMS
696 /* Write length first, see FF_FOREIGN in the input routines. */
697 || fwrite (PRIV (output_buf) + 2, 2, 1,
698 (FILE *) abfd->iostream) != 1
699 #endif
700 || (real_size != 0
701 && fwrite (PRIV (output_buf), (size_t) real_size, 1,
702 (FILE *) abfd->iostream) != 1))
703 /* FIXME: Return error status. */
704 abort ();
706 PRIV (output_size) = 0;
708 else
710 PRIV (output_size) = real_size;
711 PRIV (pushed_size) = PRIV (output_size);
715 /* End record output. */
717 void
718 _bfd_vms_output_end (bfd * abfd)
720 #if VMS_DEBUG
721 vms_debug (6, "_bfd_vms_output_end\n");
722 #endif
724 _bfd_vms_output_flush (abfd);
727 /* Check remaining buffer size
729 Return what's left. */
732 _bfd_vms_output_check (bfd * abfd, int size)
734 #if VMS_DEBUG
735 vms_debug (6, "_bfd_vms_output_check (%d)\n", size);
736 #endif
738 return (MAX_OUTREC_SIZE - (PRIV (output_size) + size + MIN_OUTREC_LUFT));
741 /* Output byte (8 bit) value. */
743 void
744 _bfd_vms_output_byte (bfd * abfd, unsigned int value)
746 #if VMS_DEBUG
747 vms_debug (6, "_bfd_vms_output_byte (%02x)\n", value);
748 #endif
750 bfd_put_8 (abfd, value & 0xff, PRIV (output_buf) + PRIV (output_size));
751 PRIV (output_size) += 1;
754 /* Output short (16 bit) value. */
756 void
757 _bfd_vms_output_short (bfd * abfd, unsigned int value)
759 #if VMS_DEBUG
760 vms_debug (6, "_bfd_vms_output_short (%04x)\n", value);
761 #endif
763 bfd_put_16 (abfd, (bfd_vma) value & 0xffff,
764 PRIV (output_buf) + PRIV (output_size));
765 PRIV (output_size) += 2;
768 /* Output long (32 bit) value. */
770 void
771 _bfd_vms_output_long (bfd * abfd, unsigned long value)
773 #if VMS_DEBUG
774 vms_debug (6, "_bfd_vms_output_long (%08lx)\n", value);
775 #endif
777 bfd_put_32 (abfd, (bfd_vma) value, PRIV (output_buf) + PRIV (output_size));
778 PRIV (output_size) += 4;
781 /* Output quad (64 bit) value. */
783 void
784 _bfd_vms_output_quad (bfd * abfd, uquad value)
786 #if VMS_DEBUG
787 vms_debug (6, "_bfd_vms_output_quad (%016lx)\n", value);
788 #endif
790 bfd_put_64(abfd, value, PRIV (output_buf) + PRIV (output_size));
791 PRIV (output_size) += 8;
794 /* Output c-string as counted string. */
796 void
797 _bfd_vms_output_counted (bfd * abfd, char *value)
799 int len;
801 #if VMS_DEBUG
802 vms_debug (6, "_bfd_vms_output_counted (%s)\n", value);
803 #endif
805 len = strlen (value);
806 if (len == 0)
808 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
809 return;
811 if (len > 255)
813 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
814 return;
816 _bfd_vms_output_byte (abfd, (unsigned int) len & 0xff);
817 _bfd_vms_output_dump (abfd, (unsigned char *) value, len);
820 /* Output character area. */
822 void
823 _bfd_vms_output_dump (bfd * abfd,
824 unsigned char *data,
825 int length)
827 #if VMS_DEBUG
828 vms_debug (6, "_bfd_vms_output_dump (%d)\n", length);
829 #endif
831 if (length == 0)
832 return;
834 memcpy (PRIV (output_buf) + PRIV (output_size), data, (size_t) length);
835 PRIV (output_size) += length;
838 /* Output count bytes of value. */
840 void
841 _bfd_vms_output_fill (bfd * abfd,
842 int value,
843 int count)
845 #if VMS_DEBUG
846 vms_debug (6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count);
847 #endif
849 if (count == 0)
850 return;
851 memset (PRIV (output_buf) + PRIV (output_size), value, (size_t) count);
852 PRIV (output_size) += count;
855 /* This hash routine borrowed from GNU-EMACS, and strengthened slightly. ERY. */
857 static int
858 hash_string (const char *ptr)
860 const unsigned char *p = (unsigned char *) ptr;
861 const unsigned char *end = p + strlen (ptr);
862 unsigned char c;
863 int hash = 0;
865 while (p != end)
867 c = *p++;
868 hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
870 return hash;
873 /* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
875 char *
876 _bfd_vms_length_hash_symbol (bfd * abfd, const char *in, int maxlen)
878 unsigned long result;
879 int in_len;
880 char *new_name;
881 const char *old_name;
882 int i;
883 static char outbuf[EOBJ_S_C_SYMSIZ+1];
884 char *out = outbuf;
886 #if VMS_DEBUG
887 vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
888 #endif
890 if (maxlen > EOBJ_S_C_SYMSIZ)
891 maxlen = EOBJ_S_C_SYMSIZ;
893 /* Save this for later. */
894 new_name = out;
896 /* We may need to truncate the symbol, save the hash for later. */
897 in_len = strlen (in);
899 result = (in_len > maxlen) ? hash_string (in) : 0;
901 old_name = in;
903 /* Do the length checking. */
904 if (in_len <= maxlen)
905 i = in_len;
906 else
908 if (PRIV (flag_hash_long_names))
909 i = maxlen-9;
910 else
911 i = maxlen;
914 strncpy (out, in, (size_t) i);
915 in += i;
916 out += i;
918 if ((in_len > maxlen)
919 && PRIV (flag_hash_long_names))
920 sprintf (out, "_%08lx", result);
921 else
922 *out = 0;
924 #if VMS_DEBUG
925 vms_debug (4, "--> [%d]\"%s\"\n", strlen (outbuf), outbuf);
926 #endif
928 if (in_len > maxlen
929 && PRIV (flag_hash_long_names)
930 && PRIV (flag_show_after_trunc))
931 printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
933 return outbuf;
936 /* Allocate and initialize a new symbol. */
938 static asymbol *
939 new_symbol (bfd * abfd, char *name)
941 asymbol *symbol;
943 #if VMS_DEBUG
944 _bfd_vms_debug (7, "new_symbol %s\n", name);
945 #endif
947 symbol = bfd_make_empty_symbol (abfd);
948 if (symbol == 0)
949 return symbol;
950 symbol->name = name;
951 symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
953 return symbol;
956 /* Allocate and enter a new private symbol. */
958 vms_symbol_entry *
959 _bfd_vms_enter_symbol (bfd * abfd, char *name)
961 vms_symbol_entry *entry;
963 #if VMS_DEBUG
964 _bfd_vms_debug (6, "_bfd_vms_enter_symbol %s\n", name);
965 #endif
967 entry = (vms_symbol_entry *)
968 bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
969 if (entry == 0)
971 #if VMS_DEBUG
972 _bfd_vms_debug (8, "creating hash entry for %s\n", name);
973 #endif
974 entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
975 name, TRUE, FALSE);
976 if (entry != 0)
978 asymbol *symbol;
979 symbol = new_symbol (abfd, name);
980 if (symbol != 0)
982 entry->symbol = symbol;
983 PRIV (gsd_sym_count)++;
984 abfd->symcount++;
986 else
987 entry = 0;
989 else
990 (*_bfd_error_handler) (_("failed to enter %s"), name);
992 else
994 #if VMS_DEBUG
995 _bfd_vms_debug (8, "found hash entry for %s\n", name);
996 #endif
999 #if VMS_DEBUG
1000 _bfd_vms_debug (7, "-> entry %p, entry->symbol %p\n", entry, entry->symbol);
1001 #endif
1002 return entry;