daily update
[binutils.git] / bfd / vms-misc.c
blob86b84d74104f6873b8aef918f9fee1eda9674403
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
4 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #if __STDC__
23 #include <stdarg.h>
24 #endif
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "bfdlink.h"
29 #include "libbfd.h"
31 #include "vms.h"
33 static vms_section *add_new_contents PARAMS ((bfd *, sec_ptr));
34 static int hash_string PARAMS ((const char *));
35 static asymbol *new_symbol PARAMS ((bfd *, char *));
37 /*-----------------------------------------------------------------------------*/
38 #if VMS_DEBUG
39 /* debug functions */
41 /* debug function for all vms extensions
42 evaluates environment variable VMS_DEBUG for a
43 numerical value on the first call
44 all error levels below this value are printed
46 levels:
47 1 toplevel bfd calls (functions from the bfd vector)
48 2 functions called by bfd calls
49 ...
50 9 almost everything
52 level is also identation level. Indentation is performed
53 if level > 0
56 #if __STDC__
57 void
58 _bfd_vms_debug (int level, char *format, ...)
60 static int min_level = -1;
61 static FILE *output = NULL;
62 char *eptr;
63 va_list args;
64 int abslvl = (level > 0)?level:-level;
66 if (min_level == -1)
68 if ((eptr = getenv("VMS_DEBUG")) != NULL)
70 min_level = atoi(eptr);
71 output = stderr;
73 else
74 min_level = 0;
76 if (output == NULL)
77 return;
78 if (abslvl > min_level)
79 return;
81 while (--level>0)
82 fprintf (output, " ");
83 va_start(args, format);
84 vfprintf (output, format, args);
85 fflush(output);
86 va_end(args);
88 return;
91 #else /* not __STDC__ */
93 void
94 _bfd_vms_debug (level, format, a1, a2, a3, a4, a5, a6)
95 int level;
96 char *format;
97 long a1; long a2; long a3;
98 long a4; long a5; long a6;
100 static int min_level = -1;
101 static FILE *output = NULL;
102 char *eptr;
104 if (min_level == -1)
106 if ((eptr = getenv("VMS_DEBUG")) != NULL)
108 min_level = atoi(eptr);
109 output = stderr;
111 else
112 min_level = 0;
114 if (output == NULL)
115 return;
116 if (level > min_level)
117 return;
119 while (--level>0)
120 fprintf (output, " ");
121 fprintf (output, format, a1, a2, a3, a4, a5, a6);
122 fflush(output);
124 return;
126 #endif /* __STDC__ */
128 /* a debug function
129 hex dump 'size' bytes starting at 'ptr' */
131 void
132 _bfd_hexdump (level, ptr, size, offset)
133 int level;
134 unsigned char *ptr;
135 int size;
136 int offset;
138 unsigned char *lptr = ptr;
139 int count = 0;
140 long start = offset;
142 while (size-- > 0)
144 if ((count%16) == 0)
145 vms_debug (level, "%08lx:", start);
146 vms_debug (-level, " %02x", *ptr++);
147 count++;
148 start++;
149 if (size == 0)
151 while ((count%16) != 0)
153 vms_debug (-level, " ");
154 count++;
157 if ((count%16) == 0)
159 vms_debug (-level, " ");
160 while (lptr < ptr)
162 vms_debug (-level, "%c", (*lptr < 32)?'.':*lptr);
163 lptr++;
165 vms_debug (-level, "\n");
168 if ((count%16) != 0)
169 vms_debug (-level, "\n");
171 return;
173 #endif
175 /* hash functions
177 These are needed when reading an object file. */
179 /* allocate new vms_hash_entry
180 keep the symbol name and a pointer to the bfd symbol in the table */
182 struct bfd_hash_entry *
183 _bfd_vms_hash_newfunc (entry, table, string)
184 struct bfd_hash_entry *entry;
185 struct bfd_hash_table *table;
186 const char *string;
188 vms_symbol_entry *ret;
190 #if VMS_DEBUG
191 vms_debug (5, "_bfd_vms_hash_newfunc(%p, %p, %s)\n", entry, table, string);
192 #endif
194 if (entry == (struct bfd_hash_entry *)NULL)
196 ret = (vms_symbol_entry *)
197 bfd_hash_allocate (table, sizeof (vms_symbol_entry));
198 if (ret == (vms_symbol_entry *) NULL)
200 bfd_set_error (bfd_error_no_memory);
201 return (struct bfd_hash_entry *)NULL;
203 entry = (struct bfd_hash_entry *) ret;
206 /* Call the allocation method of the base class. */
208 ret = (vms_symbol_entry *) bfd_hash_newfunc (entry, table, string);
209 #if VMS_DEBUG
210 vms_debug (6, "_bfd_vms_hash_newfunc ret %p\n", ret);
211 #endif
213 ret->symbol = (asymbol *)NULL;
215 return (struct bfd_hash_entry *)ret;
218 /* object file input functions */
220 /* Return type and length from record header (buf) on Alpha. */
222 void
223 _bfd_vms_get_header_values (abfd, buf, type, length)
224 bfd *abfd ATTRIBUTE_UNUSED;
225 unsigned char *buf;
226 int *type;
227 int *length;
229 if (type != 0)
230 *type = bfd_getl16 (buf);
231 buf += 2;
232 if (length != 0)
233 *length = bfd_getl16 (buf);
235 #if VMS_DEBUG
236 vms_debug (10, "_bfd_vms_get_header_values type %x, length %x\n", (type?*type:0), (length?*length:0));
237 #endif
239 return;
242 /* Get next record from object file to vms_buf
243 set PRIV(buf_size) and return it
245 this is a little tricky since it should be portable.
247 the openVMS object file has 'variable length' which means that
248 read() returns data in chunks of (hopefully) correct and expected
249 size. The linker (and other tools on vms) depend on that. Unix doesn't
250 know about 'formatted' files, so reading and writing such an object
251 file in a unix environment is not trivial.
253 With the tool 'file' (available on all vms ftp sites), one
254 can view and change the attributes of a file. Changing from
255 'variable length' to 'fixed length, 512 bytes' reveals the
256 record length at the first 2 bytes of every record. The same
257 happens during the transfer of object files from vms to unix,
258 at least with ucx, dec's implementation of tcp/ip.
260 The vms format repeats the length at bytes 2 & 3 of every record.
262 On the first call (file_format == FF_UNKNOWN) we check if
263 the first and the third byte pair (!) of the record match.
264 If they do it's an object file in an unix environment or with
265 wrong attributes (FF_FOREIGN), else we should be in a vms
266 environment where read() returns the record size (FF_NATIVE).
268 reading is always done in 2 steps.
269 first just the record header is read and the length extracted
270 by get_header_values
271 then the read buffer is adjusted and the remaining bytes are
272 read in.
274 all file i/o is always done on even file positions */
277 _bfd_vms_get_record (abfd)
278 bfd *abfd;
280 int test_len, test_start, remaining;
281 unsigned char *vms_buf;
283 #if VMS_DEBUG
284 vms_debug (8, "_bfd_vms_get_record\n");
285 #endif
287 /* minimum is 6 bytes on Alpha
288 (2 bytes length, 2 bytes record id, 2 bytes length repeated)
290 on VAX there's no length information in the record
291 so start with OBJ_S_C_MAXRECSIZ */
293 if (PRIV (buf_size) == 0)
295 bfd_size_type amt;
297 if (PRIV (is_vax))
299 amt = OBJ_S_C_MAXRECSIZ;
300 PRIV (file_format) = FF_VAX;
302 else
303 amt = 6;
304 PRIV (vms_buf) = (unsigned char *) bfd_malloc (amt);
305 PRIV (buf_size) = amt;
308 vms_buf = PRIV (vms_buf);
310 if (vms_buf == 0)
311 return -1;
313 switch (PRIV (file_format))
315 case FF_UNKNOWN:
316 case FF_FOREIGN:
317 test_len = 6; /* probe 6 bytes */
318 test_start = 2; /* where the record starts */
319 break;
321 case FF_NATIVE:
322 test_len = 4;
323 test_start = 0;
324 break;
326 default:
327 case FF_VAX:
328 test_len = 0;
329 test_start = 0;
330 break;
333 /* skip odd alignment byte */
335 if (bfd_tell (abfd) & 1)
337 if (bfd_bread (PRIV (vms_buf), (bfd_size_type) 1, abfd) != 1)
339 bfd_set_error (bfd_error_file_truncated);
340 return 0;
344 /* read the record header on Alpha. */
346 if ((test_len != 0)
347 && (bfd_bread (PRIV (vms_buf), (bfd_size_type) test_len, abfd)
348 != (bfd_size_type) test_len))
350 bfd_set_error (bfd_error_file_truncated);
351 return 0;
354 /* check file format on first call */
356 if (PRIV (file_format) == FF_UNKNOWN)
357 { /* record length repeats ? */
358 if (vms_buf[0] == vms_buf[4]
359 && vms_buf[1] == vms_buf[5])
361 PRIV (file_format) = FF_FOREIGN; /* Y: foreign environment */
362 test_start = 2;
364 else
366 PRIV (file_format) = FF_NATIVE; /* N: native environment */
367 test_start = 0;
371 if (PRIV (is_vax))
373 PRIV (rec_length) = bfd_bread (vms_buf, (bfd_size_type) PRIV (buf_size),
374 abfd);
375 if (PRIV (rec_length) <= 0)
377 bfd_set_error (bfd_error_file_truncated);
378 return 0;
380 PRIV (vms_rec) = vms_buf;
382 else /* Alpha */
384 /* extract vms record length */
386 _bfd_vms_get_header_values (abfd, vms_buf + test_start, NULL,
387 &PRIV (rec_length));
389 if (PRIV (rec_length) <= 0)
391 bfd_set_error (bfd_error_file_truncated);
392 return 0;
395 /* that's what the linker manual says */
397 if (PRIV (rec_length) > EOBJ_S_C_MAXRECSIZ)
399 bfd_set_error (bfd_error_file_truncated);
400 return 0;
403 /* adjust the buffer */
405 if (PRIV (rec_length) > PRIV (buf_size))
407 PRIV (vms_buf) = ((unsigned char *)
408 bfd_realloc (vms_buf,
409 (bfd_size_type) PRIV (rec_length)));
410 vms_buf = PRIV (vms_buf);
411 if (vms_buf == 0)
412 return -1;
413 PRIV (buf_size) = PRIV (rec_length);
416 /* read the remaining record */
418 remaining = PRIV (rec_length) - test_len + test_start;
420 #if VMS_DEBUG
421 vms_debug (10, "bfd_bread remaining %d\n", remaining);
422 #endif
423 if (bfd_bread (vms_buf + test_len, (bfd_size_type) remaining, abfd) !=
424 (bfd_size_type) remaining)
426 bfd_set_error (bfd_error_file_truncated);
427 return 0;
429 PRIV (vms_rec) = vms_buf + test_start;
432 #if VMS_DEBUG
433 vms_debug (11, "bfd_bread rec_length %d\n", PRIV (rec_length));
434 #endif
436 return PRIV (rec_length);
439 /* get next vms record from file
440 update vms_rec and rec_length to new (remaining) values */
443 _bfd_vms_next_record (abfd)
444 bfd *abfd;
446 #if VMS_DEBUG
447 vms_debug (8, "_bfd_vms_next_record (len %d, size %d)\n",
448 PRIV (rec_length), PRIV (rec_size));
449 #endif
451 if (PRIV (rec_length) > 0)
453 PRIV (vms_rec) += PRIV (rec_size);
455 else
457 if (_bfd_vms_get_record (abfd) <= 0)
458 return -1;
461 if (!PRIV (vms_rec) || !PRIV (vms_buf)
462 || PRIV (vms_rec) >= (PRIV (vms_buf) + PRIV (buf_size)))
463 return -1;
465 if (PRIV (is_vax))
467 PRIV (rec_type) = *(PRIV (vms_rec));
468 PRIV (rec_size) = PRIV (rec_length);
470 else
472 _bfd_vms_get_header_values (abfd, PRIV (vms_rec), &PRIV (rec_type),
473 &PRIV (rec_size));
475 PRIV (rec_length) -= PRIV (rec_size);
477 #if VMS_DEBUG
478 vms_debug (8, "_bfd_vms_next_record: rec %p, size %d, length %d, type %d\n",
479 PRIV (vms_rec), PRIV (rec_size), PRIV (rec_length),
480 PRIV (rec_type));
481 #endif
483 return PRIV (rec_type);
486 /* Copy sized string (string with fixed length) to new allocated area
487 size is string length (size of record) */
489 char *
490 _bfd_vms_save_sized_string (str, size)
491 unsigned char *str;
492 int size;
494 char *newstr = bfd_malloc ((bfd_size_type) size + 1);
496 if (newstr == NULL)
497 return 0;
498 strncpy (newstr, (char *) str, (size_t) size);
499 newstr[size] = 0;
501 return newstr;
504 /* Copy counted string (string with length at first byte) to new allocated area
505 ptr points to length byte on entry */
507 char *
508 _bfd_vms_save_counted_string (ptr)
509 unsigned char *ptr;
511 int len = *ptr++;
513 return _bfd_vms_save_sized_string (ptr, len);
516 /* stack routines for vms ETIR commands */
518 /* Push value and section index */
520 void
521 _bfd_vms_push (abfd, val, psect)
522 bfd *abfd;
523 uquad val;
524 int psect;
526 static int last_psect;
528 #if VMS_DEBUG
529 vms_debug (4, "<push %016lx(%d) at %d>\n", val, psect, PRIV (stackptr));
530 #endif
532 if (psect >= 0)
533 last_psect = psect;
535 PRIV (stack[PRIV (stackptr)]).value = val;
536 PRIV (stack[PRIV (stackptr)]).psect = last_psect;
537 PRIV (stackptr)++;
538 if (PRIV (stackptr) >= STACKSIZE)
540 bfd_set_error (bfd_error_bad_value);
541 (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
542 exit (1);
544 return;
547 /* Pop value and section index */
549 uquad
550 _bfd_vms_pop (abfd, psect)
551 bfd *abfd;
552 int *psect;
554 uquad value;
556 if (PRIV (stackptr) == 0)
558 bfd_set_error (bfd_error_bad_value);
559 (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
560 exit (1);
562 PRIV (stackptr)--;
563 value = PRIV (stack[PRIV (stackptr)]).value;
564 if ((psect != NULL) && (PRIV (stack[PRIV (stackptr)]).psect >= 0))
565 *psect = PRIV (stack[PRIV (stackptr)]).psect;
567 #if VMS_DEBUG
568 vms_debug (4, "<pop %016lx(%d)>\n", value, PRIV (stack[PRIV (stackptr)]).psect);
569 #endif
571 return value;
574 /* object file output functions */
576 /* GAS tends to write sections in little chunks (bfd_set_section_contents)
577 which we can't use directly. So we save the little chunks in linked
578 lists (one per section) and write them later. */
580 /* Add a new vms_section structure to vms_section_table
581 - forward chaining - */
583 static vms_section *
584 add_new_contents (abfd, section)
585 bfd *abfd;
586 sec_ptr section;
588 vms_section *sptr, *newptr;
590 sptr = PRIV (vms_section_table)[section->index];
591 if (sptr != NULL)
592 return sptr;
594 newptr = (vms_section *) bfd_alloc (abfd,
595 (bfd_size_type) sizeof (vms_section));
596 if (newptr == (vms_section *) NULL)
597 return NULL;
598 newptr->contents = (unsigned char *) bfd_alloc (abfd, section->_raw_size);
599 if (newptr->contents == (unsigned char *) NULL)
600 return NULL;
601 newptr->offset = 0;
602 newptr->size = section->_raw_size;
603 newptr->next = 0;
604 PRIV (vms_section_table)[section->index] = newptr;
605 return newptr;
608 /* Save section data & offset to a vms_section structure
609 vms_section_table[] holds the vms_section chain. */
611 bfd_boolean
612 _bfd_save_vms_section (abfd, section, data, offset, count)
613 bfd *abfd;
614 sec_ptr section;
615 PTR data;
616 file_ptr offset;
617 bfd_size_type count;
619 vms_section *sptr;
621 if (section->index >= VMS_SECTION_COUNT)
623 bfd_set_error (bfd_error_nonrepresentable_section);
624 return FALSE;
626 if (count == (bfd_size_type)0)
627 return TRUE;
628 sptr = add_new_contents (abfd, section);
629 if (sptr == NULL)
630 return FALSE;
631 memcpy (sptr->contents + offset, data, (size_t) count);
633 return TRUE;
636 /* Get vms_section pointer to saved contents for section # index */
638 vms_section *
639 _bfd_get_vms_section (abfd, index)
640 bfd *abfd;
641 int index;
643 if (index >= VMS_SECTION_COUNT)
645 bfd_set_error (bfd_error_nonrepresentable_section);
646 return NULL;
648 return PRIV (vms_section_table)[index];
651 /* Object output routines */
653 /* Begin new record or record header
654 write 2 bytes rectype
655 write 2 bytes record length (filled in at flush)
656 write 2 bytes header type (ommitted if rechead == -1) */
658 void
659 _bfd_vms_output_begin (abfd, rectype, rechead)
660 bfd *abfd;
661 int rectype;
662 int rechead;
664 #if VMS_DEBUG
665 vms_debug (6, "_bfd_vms_output_begin(type %d, head %d)\n", rectype,
666 rechead);
667 #endif
669 _bfd_vms_output_short (abfd, (unsigned int) rectype);
671 /* save current output position to fill in lenght later */
673 if (PRIV (push_level) > 0)
674 PRIV (length_pos) = PRIV (output_size);
676 #if VMS_DEBUG
677 vms_debug (6, "_bfd_vms_output_begin: length_pos = %d\n",
678 PRIV (length_pos));
679 #endif
681 _bfd_vms_output_short (abfd, 0); /* placeholder for length */
683 if (rechead != -1)
684 _bfd_vms_output_short (abfd, (unsigned int) rechead);
686 return;
689 /* Set record/subrecord alignment */
691 void
692 _bfd_vms_output_alignment (abfd, alignto)
693 bfd *abfd;
694 int alignto;
696 #if VMS_DEBUG
697 vms_debug (6, "_bfd_vms_output_alignment(%d)\n", alignto);
698 #endif
700 PRIV (output_alignment) = alignto;
701 return;
704 /* Prepare for subrecord fields */
706 void
707 _bfd_vms_output_push (abfd)
708 bfd *abfd;
710 #if VMS_DEBUG
711 vms_debug (6, "vms_output_push(pushed_size = %d)\n", PRIV (output_size));
712 #endif
714 PRIV (push_level)++;
715 PRIV (pushed_size) = PRIV (output_size);
716 return;
719 /* End of subrecord fields */
721 void
722 _bfd_vms_output_pop (abfd)
723 bfd *abfd;
725 #if VMS_DEBUG
726 vms_debug (6, "vms_output_pop(pushed_size = %d)\n", PRIV (pushed_size));
727 #endif
729 _bfd_vms_output_flush (abfd);
730 PRIV (length_pos) = 2;
732 #if VMS_DEBUG
733 vms_debug (6, "vms_output_pop: length_pos = %d\n", PRIV (length_pos));
734 #endif
736 PRIV (pushed_size) = 0;
737 PRIV (push_level)--;
738 return;
741 /* Flush unwritten output, ends current record */
743 void
744 _bfd_vms_output_flush (abfd)
745 bfd *abfd;
747 int real_size = PRIV (output_size);
748 int aligncount;
749 int length;
751 #if VMS_DEBUG
752 vms_debug (6, "_bfd_vms_output_flush(real_size = %d, pushed_size %d at lenpos %d)\n",
753 real_size, PRIV (pushed_size), PRIV (length_pos));
754 #endif
756 if (PRIV (push_level) > 0)
757 length = real_size - PRIV (pushed_size);
758 else
759 length = real_size;
761 if (length == 0)
762 return;
763 aligncount = (PRIV (output_alignment)
764 - (length % PRIV (output_alignment))) % PRIV (output_alignment);
766 #if VMS_DEBUG
767 vms_debug (6, "align: adding %d bytes\n", aligncount);
768 #endif
770 while (aligncount-- > 0)
772 PRIV (output_buf)[real_size++] = 0;
773 #if 0
774 /* this is why I *love* vms: inconsistency :-}
775 alignment is added to the subrecord length
776 but not to the record length */
777 if (PRIV (push_level) > 0)
778 #endif
779 length++;
782 /* put length to buffer */
783 PRIV (output_size) = PRIV (length_pos);
784 _bfd_vms_output_short (abfd, (unsigned int) length);
786 if (PRIV (push_level) == 0)
788 #ifndef VMS
789 /* write length first, see FF_FOREIGN in the input routines */
790 fwrite (PRIV (output_buf) + 2, 2, 1, (FILE *) abfd->iostream);
791 #endif
792 fwrite (PRIV (output_buf), (size_t) real_size, 1,
793 (FILE *) abfd->iostream);
795 PRIV (output_size) = 0;
797 else
799 PRIV (output_size) = real_size;
800 PRIV (pushed_size) = PRIV (output_size);
803 return;
806 /* End record output */
808 void
809 _bfd_vms_output_end (abfd)
810 bfd *abfd;
812 #if VMS_DEBUG
813 vms_debug (6, "_bfd_vms_output_end\n");
814 #endif
816 _bfd_vms_output_flush (abfd);
818 return;
821 /* check remaining buffer size
823 return what's left. */
826 _bfd_vms_output_check (abfd, size)
827 bfd *abfd;
828 int size;
830 #if VMS_DEBUG
831 vms_debug (6, "_bfd_vms_output_check(%d)\n", size);
832 #endif
834 return (MAX_OUTREC_SIZE - (PRIV (output_size) + size + MIN_OUTREC_LUFT));
837 /* Output byte (8 bit) value */
839 void
840 _bfd_vms_output_byte (abfd, value)
841 bfd *abfd;
842 unsigned int value;
844 #if VMS_DEBUG
845 vms_debug (6, "_bfd_vms_output_byte(%02x)\n", value);
846 #endif
848 bfd_put_8 (abfd, value & 0xff, PRIV (output_buf) + PRIV (output_size));
849 PRIV (output_size) += 1;
850 return;
853 /* Output short (16 bit) value */
855 void
856 _bfd_vms_output_short (abfd, value)
857 bfd *abfd;
858 unsigned int value;
860 #if VMS_DEBUG
861 vms_debug (6, "_bfd_vms_output_short (%04x)\n", value);
862 #endif
864 bfd_put_16 (abfd, (bfd_vma) value & 0xffff,
865 PRIV (output_buf) + PRIV (output_size));
866 PRIV (output_size) += 2;
867 return;
870 /* Output long (32 bit) value */
872 void
873 _bfd_vms_output_long (abfd, value)
874 bfd *abfd;
875 unsigned long value;
877 #if VMS_DEBUG
878 vms_debug (6, "_bfd_vms_output_long (%08lx)\n", value);
879 #endif
881 bfd_put_32 (abfd, (bfd_vma) value, PRIV (output_buf) + PRIV (output_size));
882 PRIV (output_size) += 4;
883 return;
886 /* Output quad (64 bit) value */
888 void
889 _bfd_vms_output_quad (abfd, value)
890 bfd *abfd;
891 uquad value;
893 #if VMS_DEBUG
894 vms_debug (6, "_bfd_vms_output_quad(%016lx)\n", value);
895 #endif
897 bfd_put_64(abfd, value, PRIV (output_buf) + PRIV (output_size));
898 PRIV (output_size) += 8;
899 return;
902 /* Output c-string as counted string */
904 void
905 _bfd_vms_output_counted (abfd, value)
906 bfd *abfd;
907 char *value;
909 int len;
911 #if VMS_DEBUG
912 vms_debug (6, "_bfd_vms_output_counted(%s)\n", value);
913 #endif
915 len = strlen (value);
916 if (len == 0)
918 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
919 return;
921 if (len > 255)
923 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
924 return;
926 _bfd_vms_output_byte (abfd, (unsigned int) len & 0xff);
927 _bfd_vms_output_dump (abfd, (unsigned char *)value, len);
930 /* Output character area */
932 void
933 _bfd_vms_output_dump (abfd, data, length)
934 bfd *abfd;
935 unsigned char *data;
936 int length;
938 #if VMS_DEBUG
939 vms_debug (6, "_bfd_vms_output_dump(%d)\n", length);
940 #endif
942 if (length == 0)
943 return;
945 memcpy (PRIV (output_buf) + PRIV (output_size), data, (size_t) length);
946 PRIV (output_size) += length;
948 return;
951 /* Output count bytes of value */
953 void
954 _bfd_vms_output_fill (abfd, value, count)
955 bfd *abfd;
956 int value;
957 int count;
959 #if VMS_DEBUG
960 vms_debug (6, "_bfd_vms_output_fill(val %02x times %d)\n", value, count);
961 #endif
963 if (count == 0)
964 return;
965 memset (PRIV (output_buf) + PRIV (output_size), value, (size_t) count);
966 PRIV (output_size) += count;
968 return;
971 /* this hash routine borrowed from GNU-EMACS, and strengthened slightly ERY*/
973 static int
974 hash_string (ptr)
975 const char *ptr;
977 register const unsigned char *p = (unsigned char *) ptr;
978 register const unsigned char *end = p + strlen (ptr);
979 register unsigned char c;
980 register int hash = 0;
982 while (p != end)
984 c = *p++;
985 hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
987 return hash;
990 /* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
992 char *
993 _bfd_vms_length_hash_symbol (abfd, in, maxlen)
994 bfd *abfd;
995 const char *in;
996 int maxlen;
998 long int result;
999 int in_len;
1000 char *new_name;
1001 const char *old_name;
1002 int i;
1003 static char outbuf[EOBJ_S_C_SYMSIZ+1];
1004 char *out = outbuf;
1006 #if VMS_DEBUG
1007 vms_debug(4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
1008 #endif
1010 if (maxlen > EOBJ_S_C_SYMSIZ)
1011 maxlen = EOBJ_S_C_SYMSIZ;
1013 new_name = out; /* save this for later. */
1015 /* We may need to truncate the symbol, save the hash for later. */
1017 in_len = strlen (in);
1019 result = (in_len > maxlen) ? hash_string (in) : 0;
1021 old_name = in;
1023 /* Do the length checking. */
1025 if (in_len <= maxlen)
1027 i = in_len;
1029 else
1031 if (PRIV (flag_hash_long_names))
1032 i = maxlen-9;
1033 else
1034 i = maxlen;
1037 strncpy (out, in, (size_t) i);
1038 in += i;
1039 out += i;
1041 if ((in_len > maxlen)
1042 && PRIV (flag_hash_long_names))
1043 sprintf (out, "_%08lx", result);
1044 else
1045 *out = 0;
1047 #if VMS_DEBUG
1048 vms_debug(4, "--> [%d]\"%s\"\n", strlen (outbuf), outbuf);
1049 #endif
1051 if (in_len > maxlen
1052 && PRIV (flag_hash_long_names)
1053 && PRIV (flag_show_after_trunc))
1054 printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
1056 return outbuf;
1059 /* Allocate and initialize a new symbol. */
1061 static asymbol *
1062 new_symbol (abfd, name)
1063 bfd *abfd;
1064 char *name;
1066 asymbol *symbol;
1068 #if VMS_DEBUG
1069 _bfd_vms_debug (7, "new_symbol %s\n", name);
1070 #endif
1072 symbol = bfd_make_empty_symbol (abfd);
1073 if (symbol == 0)
1074 return symbol;
1075 symbol->name = name;
1076 symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
1078 return symbol;
1081 /* Allocate and enter a new private symbol. */
1083 vms_symbol_entry *
1084 _bfd_vms_enter_symbol (abfd, name)
1085 bfd *abfd;
1086 char *name;
1088 vms_symbol_entry *entry;
1090 #if VMS_DEBUG
1091 _bfd_vms_debug (6, "_bfd_vms_enter_symbol %s\n", name);
1092 #endif
1094 entry = (vms_symbol_entry *)
1095 bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
1096 if (entry == 0)
1098 #if VMS_DEBUG
1099 _bfd_vms_debug (8, "creating hash entry for %s\n", name);
1100 #endif
1101 entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
1102 name, TRUE, FALSE);
1103 if (entry != 0)
1105 asymbol *symbol;
1106 symbol = new_symbol (abfd, name);
1107 if (symbol != 0)
1109 entry->symbol = symbol;
1110 PRIV (gsd_sym_count)++;
1111 abfd->symcount++;
1113 else
1114 entry = 0;
1116 else
1117 (*_bfd_error_handler) (_("failed to enter %s"), name);
1119 else
1121 #if VMS_DEBUG
1122 _bfd_vms_debug (8, "found hash entry for %s\n", name);
1123 #endif
1126 #if VMS_DEBUG
1127 _bfd_vms_debug (7, "-> entry %p, entry->symbol %p\n", entry, entry->symbol);
1128 #endif
1129 return entry;