Add Daniel Jacobwitz to the blanket write privileges list.
[binutils.git] / bfd / vms-misc.c
blobac9476ffd223780088479fb768e3a8e5f6e9be4e
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.
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 indentation 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->size);
599 if (newptr->contents == (unsigned char *) NULL)
600 return NULL;
601 newptr->offset = 0;
602 newptr->size = section->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 const 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 length 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 length++;
776 /* put length to buffer */
777 PRIV (output_size) = PRIV (length_pos);
778 _bfd_vms_output_short (abfd, (unsigned int) length);
780 if (PRIV (push_level) == 0)
782 #ifndef VMS
783 /* write length first, see FF_FOREIGN in the input routines */
784 fwrite (PRIV (output_buf) + 2, 2, 1, (FILE *) abfd->iostream);
785 #endif
786 fwrite (PRIV (output_buf), (size_t) real_size, 1,
787 (FILE *) abfd->iostream);
789 PRIV (output_size) = 0;
791 else
793 PRIV (output_size) = real_size;
794 PRIV (pushed_size) = PRIV (output_size);
797 return;
800 /* End record output */
802 void
803 _bfd_vms_output_end (abfd)
804 bfd *abfd;
806 #if VMS_DEBUG
807 vms_debug (6, "_bfd_vms_output_end\n");
808 #endif
810 _bfd_vms_output_flush (abfd);
812 return;
815 /* check remaining buffer size
817 return what's left. */
820 _bfd_vms_output_check (abfd, size)
821 bfd *abfd;
822 int size;
824 #if VMS_DEBUG
825 vms_debug (6, "_bfd_vms_output_check(%d)\n", size);
826 #endif
828 return (MAX_OUTREC_SIZE - (PRIV (output_size) + size + MIN_OUTREC_LUFT));
831 /* Output byte (8 bit) value */
833 void
834 _bfd_vms_output_byte (abfd, value)
835 bfd *abfd;
836 unsigned int value;
838 #if VMS_DEBUG
839 vms_debug (6, "_bfd_vms_output_byte(%02x)\n", value);
840 #endif
842 bfd_put_8 (abfd, value & 0xff, PRIV (output_buf) + PRIV (output_size));
843 PRIV (output_size) += 1;
844 return;
847 /* Output short (16 bit) value */
849 void
850 _bfd_vms_output_short (abfd, value)
851 bfd *abfd;
852 unsigned int value;
854 #if VMS_DEBUG
855 vms_debug (6, "_bfd_vms_output_short (%04x)\n", value);
856 #endif
858 bfd_put_16 (abfd, (bfd_vma) value & 0xffff,
859 PRIV (output_buf) + PRIV (output_size));
860 PRIV (output_size) += 2;
861 return;
864 /* Output long (32 bit) value */
866 void
867 _bfd_vms_output_long (abfd, value)
868 bfd *abfd;
869 unsigned long value;
871 #if VMS_DEBUG
872 vms_debug (6, "_bfd_vms_output_long (%08lx)\n", value);
873 #endif
875 bfd_put_32 (abfd, (bfd_vma) value, PRIV (output_buf) + PRIV (output_size));
876 PRIV (output_size) += 4;
877 return;
880 /* Output quad (64 bit) value */
882 void
883 _bfd_vms_output_quad (abfd, value)
884 bfd *abfd;
885 uquad value;
887 #if VMS_DEBUG
888 vms_debug (6, "_bfd_vms_output_quad(%016lx)\n", value);
889 #endif
891 bfd_put_64(abfd, value, PRIV (output_buf) + PRIV (output_size));
892 PRIV (output_size) += 8;
893 return;
896 /* Output c-string as counted string */
898 void
899 _bfd_vms_output_counted (abfd, value)
900 bfd *abfd;
901 char *value;
903 int len;
905 #if VMS_DEBUG
906 vms_debug (6, "_bfd_vms_output_counted(%s)\n", value);
907 #endif
909 len = strlen (value);
910 if (len == 0)
912 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
913 return;
915 if (len > 255)
917 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
918 return;
920 _bfd_vms_output_byte (abfd, (unsigned int) len & 0xff);
921 _bfd_vms_output_dump (abfd, (unsigned char *)value, len);
924 /* Output character area */
926 void
927 _bfd_vms_output_dump (abfd, data, length)
928 bfd *abfd;
929 unsigned char *data;
930 int length;
932 #if VMS_DEBUG
933 vms_debug (6, "_bfd_vms_output_dump(%d)\n", length);
934 #endif
936 if (length == 0)
937 return;
939 memcpy (PRIV (output_buf) + PRIV (output_size), data, (size_t) length);
940 PRIV (output_size) += length;
942 return;
945 /* Output count bytes of value */
947 void
948 _bfd_vms_output_fill (abfd, value, count)
949 bfd *abfd;
950 int value;
951 int count;
953 #if VMS_DEBUG
954 vms_debug (6, "_bfd_vms_output_fill(val %02x times %d)\n", value, count);
955 #endif
957 if (count == 0)
958 return;
959 memset (PRIV (output_buf) + PRIV (output_size), value, (size_t) count);
960 PRIV (output_size) += count;
962 return;
965 /* this hash routine borrowed from GNU-EMACS, and strengthened slightly ERY*/
967 static int
968 hash_string (ptr)
969 const char *ptr;
971 register const unsigned char *p = (unsigned char *) ptr;
972 register const unsigned char *end = p + strlen (ptr);
973 register unsigned char c;
974 register int hash = 0;
976 while (p != end)
978 c = *p++;
979 hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
981 return hash;
984 /* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
986 char *
987 _bfd_vms_length_hash_symbol (abfd, in, maxlen)
988 bfd *abfd;
989 const char *in;
990 int maxlen;
992 long int result;
993 int in_len;
994 char *new_name;
995 const char *old_name;
996 int i;
997 static char outbuf[EOBJ_S_C_SYMSIZ+1];
998 char *out = outbuf;
1000 #if VMS_DEBUG
1001 vms_debug(4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
1002 #endif
1004 if (maxlen > EOBJ_S_C_SYMSIZ)
1005 maxlen = EOBJ_S_C_SYMSIZ;
1007 new_name = out; /* save this for later. */
1009 /* We may need to truncate the symbol, save the hash for later. */
1011 in_len = strlen (in);
1013 result = (in_len > maxlen) ? hash_string (in) : 0;
1015 old_name = in;
1017 /* Do the length checking. */
1019 if (in_len <= maxlen)
1021 i = in_len;
1023 else
1025 if (PRIV (flag_hash_long_names))
1026 i = maxlen-9;
1027 else
1028 i = maxlen;
1031 strncpy (out, in, (size_t) i);
1032 in += i;
1033 out += i;
1035 if ((in_len > maxlen)
1036 && PRIV (flag_hash_long_names))
1037 sprintf (out, "_%08lx", result);
1038 else
1039 *out = 0;
1041 #if VMS_DEBUG
1042 vms_debug(4, "--> [%d]\"%s\"\n", strlen (outbuf), outbuf);
1043 #endif
1045 if (in_len > maxlen
1046 && PRIV (flag_hash_long_names)
1047 && PRIV (flag_show_after_trunc))
1048 printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
1050 return outbuf;
1053 /* Allocate and initialize a new symbol. */
1055 static asymbol *
1056 new_symbol (abfd, name)
1057 bfd *abfd;
1058 char *name;
1060 asymbol *symbol;
1062 #if VMS_DEBUG
1063 _bfd_vms_debug (7, "new_symbol %s\n", name);
1064 #endif
1066 symbol = bfd_make_empty_symbol (abfd);
1067 if (symbol == 0)
1068 return symbol;
1069 symbol->name = name;
1070 symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
1072 return symbol;
1075 /* Allocate and enter a new private symbol. */
1077 vms_symbol_entry *
1078 _bfd_vms_enter_symbol (abfd, name)
1079 bfd *abfd;
1080 char *name;
1082 vms_symbol_entry *entry;
1084 #if VMS_DEBUG
1085 _bfd_vms_debug (6, "_bfd_vms_enter_symbol %s\n", name);
1086 #endif
1088 entry = (vms_symbol_entry *)
1089 bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
1090 if (entry == 0)
1092 #if VMS_DEBUG
1093 _bfd_vms_debug (8, "creating hash entry for %s\n", name);
1094 #endif
1095 entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
1096 name, TRUE, FALSE);
1097 if (entry != 0)
1099 asymbol *symbol;
1100 symbol = new_symbol (abfd, name);
1101 if (symbol != 0)
1103 entry->symbol = symbol;
1104 PRIV (gsd_sym_count)++;
1105 abfd->symcount++;
1107 else
1108 entry = 0;
1110 else
1111 (*_bfd_error_handler) (_("failed to enter %s"), name);
1113 else
1115 #if VMS_DEBUG
1116 _bfd_vms_debug (8, "found hash entry for %s\n", name);
1117 #endif
1120 #if VMS_DEBUG
1121 _bfd_vms_debug (7, "-> entry %p, entry->symbol %p\n", entry, entry->symbol);
1122 #endif
1123 return entry;