1 /* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 Initial version written by Klaus Kaempf (kkaempf@rmi.de)
6 Major rewrite by Adacore.
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. */
26 o Generation of shared image
27 o Relocation optimizations
33 o protected sections (for messages)
51 #include "vms/eihvn.h"
52 #include "vms/eobjrec.h"
55 #include "vms/esgps.h"
64 #include "vms/esdfm.h"
65 #include "vms/esdfv.h"
71 #include "vms/internal.h"
74 #define MIN(a,b) ((a) < (b) ? (a) : (b))
76 /* The r_type field in a reloc is one of the following values. */
77 #define ALPHA_R_IGNORE 0
78 #define ALPHA_R_REFQUAD 1
79 #define ALPHA_R_BRADDR 2
80 #define ALPHA_R_HINT 3
81 #define ALPHA_R_SREL16 4
82 #define ALPHA_R_SREL32 5
83 #define ALPHA_R_SREL64 6
84 #define ALPHA_R_OP_PUSH 7
85 #define ALPHA_R_OP_STORE 8
86 #define ALPHA_R_OP_PSUB 9
87 #define ALPHA_R_OP_PRSHIFT 10
88 #define ALPHA_R_LINKAGE 11
89 #define ALPHA_R_REFLONG 12
90 #define ALPHA_R_CODEADDR 13
91 #define ALPHA_R_NOP 14
92 #define ALPHA_R_BSR 15
93 #define ALPHA_R_LDA 16
94 #define ALPHA_R_BOH 17
96 /* These are used with DST_S_C_LINE_NUM. */
97 #define DST_S_C_LINE_NUM_HEADER_SIZE 4
99 /* These are used with DST_S_C_SOURCE */
101 #define DST_S_B_PCLINE_UNSBYTE 1
102 #define DST_S_W_PCLINE_UNSWORD 1
103 #define DST_S_L_PCLINE_UNSLONG 1
105 #define DST_S_B_MODBEG_NAME 14
106 #define DST_S_L_RTNBEG_ADDRESS 5
107 #define DST_S_B_RTNBEG_NAME 13
108 #define DST_S_L_RTNEND_SIZE 5
110 /* These are used with DST_S_C_SOURCE. */
111 #define DST_S_C_SOURCE_HEADER_SIZE 4
113 #define DST_S_B_SRC_DF_LENGTH 1
114 #define DST_S_W_SRC_DF_FILEID 3
115 #define DST_S_B_SRC_DF_FILENAME 20
116 #define DST_S_B_SRC_UNSBYTE 1
117 #define DST_S_W_SRC_UNSWORD 1
118 #define DST_S_L_SRC_UNSLONG 1
120 /* Debugger symbol definitions. */
122 #define DBG_S_L_DMT_MODBEG 0
123 #define DBG_S_L_DST_SIZE 4
124 #define DBG_S_W_DMT_PSECT_COUNT 8
125 #define DBG_S_C_DMT_HEADER_SIZE 12
127 #define DBG_S_L_DMT_PSECT_START 0
128 #define DBG_S_L_DMT_PSECT_LENGTH 4
129 #define DBG_S_C_DMT_PSECT_SIZE 8
131 /* VMS module header. */
147 #define EMH_DATE_LENGTH 17
149 /* VMS End-Of-Module records (EOM/EEOM). */
153 unsigned int eom_l_total_lps;
154 unsigned short eom_w_comcod;
155 bfd_boolean eom_has_transfer;
156 unsigned char eom_b_tfrflg;
157 unsigned int eom_l_psindx;
158 unsigned int eom_l_tfradr;
161 struct vms_symbol_entry
167 unsigned char data_type;
168 unsigned short flags;
170 /* Section and offset/value of the symbol. */
174 /* Section and offset/value for the entry point (only for subprg). */
175 asection *code_section;
176 unsigned int code_value;
178 /* Symbol vector offset. */
179 unsigned int symbol_vector;
181 /* Length of the name. */
182 unsigned char namelen;
187 /* Stack value for push/pop commands. */
195 #define STACKSIZE 128
197 /* A minimal decoding of DST compilation units. We only decode
198 what's needed to get to the line number information. */
208 struct srecinfo *next;
216 struct lineinfo *next;
223 struct funcinfo *next;
231 /* Chain the previously read compilation unit. */
234 /* The module name. */
237 /* The start offset and size of debug info in the DST section. */
241 /* The lowest and highest addresses contained in this compilation
242 unit as specified in the compilation unit header. */
246 /* The listing line table. */
247 struct lineinfo *line_table;
249 /* The source record table. */
250 struct srecinfo *srec_table;
252 /* A list of the functions found in this module. */
253 struct funcinfo *func_table;
255 /* Current allocation of file_table. */
256 unsigned int file_table_count;
258 /* An array of the files making up this module. */
259 struct fileinfo *file_table;
262 /* BFD private data for alpha-vms. */
264 struct vms_private_data_struct
266 /* If true, relocs have been read. */
267 bfd_boolean reloc_done;
269 /* Record input buffer. */
270 struct vms_rec_rd recrd;
271 struct vms_rec_wr recwr;
273 struct hdr_struct hdr_data; /* data from HDR/EMH record */
274 struct eom_struct eom_data; /* data from EOM/EEOM record */
276 /* Transfer addresses (entry points). */
277 bfd_vma transfer_address[4];
279 /* Array of GSD sections to get the correspond BFD one. */
280 unsigned int section_max; /* Size of the sections array. */
281 unsigned int section_count; /* Number of GSD sections. */
284 /* Array of raw symbols. */
285 struct vms_symbol_entry **syms;
287 /* Canonicalized symbols. */
290 /* Number of symbols. */
291 unsigned int gsd_sym_count;
292 /* Size of the syms array. */
293 unsigned int max_sym_count;
294 /* Number of procedure symbols. */
295 unsigned int norm_sym_count;
297 /* Stack used to evaluate TIR/ETIR commands. */
298 struct stack_struct *stack;
301 /* Content reading. */
302 asection *image_section; /* section for image_ptr */
303 file_ptr image_offset; /* Offset for image_ptr. */
305 struct module *modules; /* list of all compilation units */
307 asection *dst_section;
309 unsigned int dst_ptr_offsets_count; /* # of offsets in following array */
310 unsigned int *dst_ptr_offsets; /* array of saved image_ptr offsets */
312 /* Shared library support */
313 bfd_vma symvva; /* relative virtual address of symbol vector */
315 unsigned char matchctl;
317 /* Shared library index. This is used for input bfd while linking. */
318 unsigned int shr_index;
320 /* Used to place structures in the file. */
323 /* Simply linked list of eisd. */
324 struct vms_internal_eisd_map *eisd_head;
325 struct vms_internal_eisd_map *eisd_tail;
327 /* Simply linked list of eisd for shared libraries. */
328 struct vms_internal_eisd_map *gbl_eisd_head;
329 struct vms_internal_eisd_map *gbl_eisd_tail;
331 /* linkage index counter used by conditional store commands */
332 int vms_linkage_index;
334 /* see tc-alpha.c of gas for a description. */
335 int flag_hash_long_names; /* -+, hash instead of truncate */
336 int flag_show_after_trunc; /* -H, show hashing/truncation */
339 #define PRIV2(abfd, name) \
340 (((struct vms_private_data_struct *)(abfd)->tdata.any)->name)
341 #define PRIV(name) PRIV2(abfd,name)
344 /* Used to keep extra VMS specific information for a given section.
346 reloc_size holds the size of the relocation stream, note this
347 is very different from the number of relocations as VMS relocations
350 reloc_stream is the actual stream of relocation entries. */
352 struct vms_section_data_struct
354 /* Maximnum number of entries in sec->relocation. */
357 /* Corresponding eisd. Used only while generating executables. */
358 struct vms_internal_eisd_map *eisd;
360 /* PSC flags to be clear. */
363 /* PSC flags to be set. */
367 #define vms_section_data(sec) \
368 ((struct vms_section_data_struct *)sec->used_by_bfd)
370 /* To be called from the debugger. */
371 struct vms_private_data_struct *bfd_vms_get_data (bfd *abfd);
373 static int vms_get_remaining_object_record (bfd *abfd, int read_so_far);
374 static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);
375 static void alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);
376 static void alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);
377 static void alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,
379 static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);
380 static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);
381 static void alpha_vms_add_lw_fixup (struct bfd_link_info *, unsigned int,
391 /* Number of elements in VEC. */
393 #define VEC_COUNT(VEC) ((VEC).nbr_el)
395 /* Get the address of the Nth element. */
397 #define VEC_EL(VEC, TYPE, N) (((TYPE *)((VEC).els))[N])
399 #define VEC_INIT(VEC) \
406 /* Be sure there is room for a new element. */
408 static void vector_grow1 (struct vector_type *vec, size_t elsz);
410 /* Allocate room for a new element and return its address. */
412 #define VEC_APPEND(VEC, TYPE) \
413 (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))
415 /* Append an element. */
417 #define VEC_APPEND_EL(VEC, TYPE, EL) \
418 (*(VEC_APPEND (VEC, TYPE)) = EL)
420 struct alpha_vms_vma_ref
422 bfd_vma vma; /* Vma in the output. */
423 bfd_vma ref; /* Reference in the input. */
426 struct alpha_vms_shlib_el
429 bfd_boolean has_fixups;
431 struct vector_type lp; /* Vector of bfd_vma. */
432 struct vector_type ca; /* Vector of bfd_vma. */
433 struct vector_type qr; /* Vector of struct alpha_vms_vma_ref. */
436 /* Alpha VMS linker hash table. */
438 struct alpha_vms_link_hash_table
440 struct bfd_link_hash_table root;
442 /* Vector of shared libaries. */
443 struct vector_type shrlibs;
448 /* Base address. Used by fixups. */
452 #define alpha_vms_link_hash(INFO) \
453 ((struct alpha_vms_link_hash_table *)(INFO->hash))
455 /* Alpha VMS linker hash table entry. */
457 struct alpha_vms_link_hash_entry
459 struct bfd_link_hash_entry root;
461 /* Pointer to the original vms symbol. */
462 struct vms_symbol_entry *sym;
467 /* Read & process EIHD record.
468 Return TRUE on success, FALSE on error. */
471 _bfd_vms_slurp_eihd (bfd *abfd, unsigned int *eisd_offset,
472 unsigned int *eihs_offset)
474 unsigned int imgtype, size;
476 struct vms_eihd *eihd = (struct vms_eihd *)PRIV (recrd.rec);
478 vms_debug2 ((8, "_bfd_vms_slurp_eihd\n"));
480 size = bfd_getl32 (eihd->size);
481 imgtype = bfd_getl32 (eihd->imgtype);
483 if (imgtype == EIHD__K_EXE || imgtype == EIHD__K_LIM)
484 abfd->flags |= EXEC_P;
486 symvva = bfd_getl64 (eihd->symvva);
489 PRIV (symvva) = symvva;
490 abfd->flags |= DYNAMIC;
493 PRIV (ident) = bfd_getl32 (eihd->ident);
494 PRIV (matchctl) = eihd->matchctl;
496 *eisd_offset = bfd_getl32 (eihd->isdoff);
497 *eihs_offset = bfd_getl32 (eihd->symdbgoff);
499 vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",
500 size, imgtype, (unsigned long)symvva,
501 *eisd_offset, *eihs_offset));
506 /* Read & process EISD record.
507 Return TRUE on success, FALSE on error. */
510 _bfd_vms_slurp_eisd (bfd *abfd, unsigned int offset)
512 int section_count = 0;
514 vms_debug2 ((8, "_bfd_vms_slurp_eisd\n"));
518 struct vms_eisd *eisd;
519 unsigned int rec_size;
521 unsigned long long vaddr;
528 eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
529 rec_size = bfd_getl32 (eisd->eisdsize);
534 /* Skip to next block if pad. */
535 if (rec_size == 0xffffffff)
537 offset = (offset + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
543 size = bfd_getl32 (eisd->secsize);
544 vaddr = bfd_getl64 (eisd->virt_addr);
545 flags = bfd_getl32 (eisd->flags);
546 vbn = bfd_getl32 (eisd->vbn);
548 vms_debug2 ((4, "EISD at 0x%x size 0x%x addr 0x%lx flags 0x%x blk %d\n",
549 offset, size, (unsigned long)vaddr, flags, vbn));
551 /* VMS combines psects from .obj files into isects in the .exe. This
552 process doesn't preserve enough information to reliably determine
553 what's in each section without examining the data. This is
554 especially true of DWARF debug sections. */
555 bfd_flags = SEC_ALLOC;
557 bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
559 if (flags & EISD__M_EXE)
560 bfd_flags |= SEC_CODE;
562 if (flags & EISD__M_NONSHRADR)
563 bfd_flags |= SEC_DATA;
565 if (!(flags & EISD__M_WRT))
566 bfd_flags |= SEC_READONLY;
568 if (flags & EISD__M_DZRO)
569 bfd_flags |= SEC_DATA;
571 if (flags & EISD__M_FIXUPVEC)
572 bfd_flags |= SEC_DATA;
574 if (flags & EISD__M_CRF)
575 bfd_flags |= SEC_DATA;
577 if (flags & EISD__M_GBL)
579 name = _bfd_vms_save_counted_string (eisd->gblnam);
580 bfd_flags |= SEC_COFF_SHARED_LIBRARY;
581 bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
583 else if (flags & EISD__M_FIXUPVEC)
585 else if (eisd->type == EISD__K_USRSTACK)
591 name = (char*) bfd_alloc (abfd, 32);
592 if (flags & EISD__M_DZRO)
594 else if (flags & EISD__M_EXE)
596 else if (!(flags & EISD__M_WRT))
600 BFD_ASSERT (section_count < 999);
601 sprintf (name, "$%s_%03d$", pfx, section_count++);
604 section = bfd_make_section (abfd, name);
609 section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : 0;
610 section->size = size;
611 section->vma = vaddr;
613 if (!bfd_set_section_flags (abfd, section, bfd_flags))
620 /* Read & process EIHS record.
621 Return TRUE on success, FALSE on error. */
624 _bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)
626 unsigned char *p = PRIV (recrd.rec) + offset;
627 unsigned int gstvbn = bfd_getl32 (p + EIHS__L_GSTVBN);
628 unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS__L_GSTSIZE);
629 unsigned int dstvbn = bfd_getl32 (p + EIHS__L_DSTVBN);
630 unsigned int dstsize = bfd_getl32 (p + EIHS__L_DSTSIZE);
631 unsigned int dmtvbn = bfd_getl32 (p + EIHS__L_DMTVBN);
632 unsigned int dmtbytes = bfd_getl32 (p + EIHS__L_DMTBYTES);
636 vms_debug (8, "_bfd_vms_slurp_ihs\n");
637 vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
638 gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
643 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
645 section = bfd_make_section (abfd, "$DST$");
649 section->size = dstsize;
650 section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
652 if (!bfd_set_section_flags (abfd, section, bfd_flags))
655 PRIV (dst_section) = section;
656 abfd->flags |= (HAS_DEBUG | HAS_LINENO);
661 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
663 section = bfd_make_section (abfd, "$DMT$");
667 section->size = dmtbytes;
668 section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
670 if (!bfd_set_section_flags (abfd, section, bfd_flags))
676 if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
678 bfd_set_error (bfd_error_file_truncated);
682 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
685 abfd->flags |= HAS_SYMS;
691 /* Object file reading. */
693 /* Object file input functions. */
695 /* Get next record from object file to vms_buf.
696 Set PRIV(buf_size) and return it
698 This is a little tricky since it should be portable.
700 The openVMS object file has 'variable length' which means that
701 read() returns data in chunks of (hopefully) correct and expected
702 size. The linker (and other tools on VMS) depend on that. Unix
703 doesn't know about 'formatted' files, so reading and writing such
704 an object file in a Unix environment is not trivial.
706 With the tool 'file' (available on all VMS FTP sites), one
707 can view and change the attributes of a file. Changing from
708 'variable length' to 'fixed length, 512 bytes' reveals the
709 record size at the first 2 bytes of every record. The same
710 may happen during the transfer of object files from VMS to Unix,
711 at least with UCX, the DEC implementation of TCP/IP.
713 The VMS format repeats the size at bytes 2 & 3 of every record.
715 On the first call (file_format == FF_UNKNOWN) we check if
716 the first and the third byte pair (!) of the record match.
717 If they do it's an object file in an Unix environment or with
718 wrong attributes (FF_FOREIGN), else we should be in a VMS
719 environment where read() returns the record size (FF_NATIVE).
721 Reading is always done in 2 steps:
722 1. first just the record header is read and the size extracted,
723 2. then the read buffer is adjusted and the remaining bytes are
726 All file I/O is done on even file positions. */
728 #define VMS_OBJECT_ADJUSTMENT 2
731 maybe_adjust_record_pointer_for_object (bfd *abfd)
733 /* Set the file format once for all on the first invocation. */
734 if (PRIV (recrd.file_format) == FF_UNKNOWN)
736 if (PRIV (recrd.rec)[0] == PRIV (recrd.rec)[4]
737 && PRIV (recrd.rec)[1] == PRIV (recrd.rec)[5])
738 PRIV (recrd.file_format) = FF_FOREIGN;
740 PRIV (recrd.file_format) = FF_NATIVE;
743 /* The adjustment is needed only in an Unix environment. */
744 if (PRIV (recrd.file_format) == FF_FOREIGN)
745 PRIV (recrd.rec) += VMS_OBJECT_ADJUSTMENT;
748 /* Implement step #1 of the object record reading procedure.
749 Return the record type or -1 on failure. */
752 _bfd_vms_get_object_record (bfd *abfd)
754 unsigned int test_len = 6;
757 vms_debug2 ((8, "_bfd_vms_get_obj_record\n"));
759 /* Skip alignment byte if the current position is odd. */
760 if (PRIV (recrd.file_format) == FF_FOREIGN && (bfd_tell (abfd) & 1))
762 if (bfd_bread (PRIV (recrd.buf), 1, abfd) != 1)
764 bfd_set_error (bfd_error_file_truncated);
769 /* Read the record header */
770 if (bfd_bread (PRIV (recrd.buf), test_len, abfd) != test_len)
772 bfd_set_error (bfd_error_file_truncated);
776 /* Reset the record pointer. */
777 PRIV (recrd.rec) = PRIV (recrd.buf);
778 maybe_adjust_record_pointer_for_object (abfd);
780 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
783 type = bfd_getl16 (PRIV (recrd.rec));
785 vms_debug2 ((8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",
786 PRIV (recrd.rec), PRIV (recrd.rec_size), type));
791 /* Implement step #2 of the object record reading procedure.
792 Return the size of the record or 0 on failure. */
795 vms_get_remaining_object_record (bfd *abfd, int read_so_far)
797 unsigned int to_read;
799 vms_debug2 ((8, "vms_get_remaining_obj_record\n"));
801 /* Extract record size. */
802 PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);
804 if (PRIV (recrd.rec_size) <= 0)
806 bfd_set_error (bfd_error_file_truncated);
810 /* That's what the linker manual says. */
811 if (PRIV (recrd.rec_size) > EOBJ__C_MAXRECSIZ)
813 bfd_set_error (bfd_error_file_truncated);
817 /* Take into account object adjustment. */
818 to_read = PRIV (recrd.rec_size);
819 if (PRIV (recrd.file_format) == FF_FOREIGN)
820 to_read += VMS_OBJECT_ADJUSTMENT;
822 /* Adjust the buffer. */
823 if (to_read > PRIV (recrd.buf_size))
826 = (unsigned char *) bfd_realloc (PRIV (recrd.buf), to_read);
827 if (PRIV (recrd.buf) == NULL)
829 PRIV (recrd.buf_size) = to_read;
832 /* Read the remaining record. */
833 to_read -= read_so_far;
835 vms_debug2 ((8, "vms_get_remaining_obj_record: to_read %d\n", to_read));
837 if (bfd_bread (PRIV (recrd.buf) + read_so_far, to_read, abfd) != to_read)
839 bfd_set_error (bfd_error_file_truncated);
843 /* Reset the record pointer. */
844 PRIV (recrd.rec) = PRIV (recrd.buf);
845 maybe_adjust_record_pointer_for_object (abfd);
847 vms_debug2 ((8, "vms_get_remaining_obj_record: size %d\n",
848 PRIV (recrd.rec_size)));
850 return PRIV (recrd.rec_size);
853 /* Read and process emh record.
854 Return TRUE on success, FALSE on error. */
857 _bfd_vms_slurp_ehdr (bfd *abfd)
860 unsigned char *vms_rec;
863 vms_rec = PRIV (recrd.rec);
865 vms_debug2 ((2, "HDR/EMH\n"));
867 subtype = bfd_getl16 (vms_rec + 4);
869 vms_debug2 ((3, "subtype %d\n", subtype));
875 PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
876 PRIV (hdr_data).hdr_l_arch1 = bfd_getl32 (vms_rec + 8);
877 PRIV (hdr_data).hdr_l_arch2 = bfd_getl32 (vms_rec + 12);
878 PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
879 PRIV (hdr_data).hdr_t_name = _bfd_vms_save_counted_string (vms_rec + 20);
880 ptr = vms_rec + 20 + vms_rec[20] + 1;
881 PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
883 PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
887 PRIV (hdr_data).hdr_c_lnm =
888 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
892 PRIV (hdr_data).hdr_c_src =
893 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
897 PRIV (hdr_data).hdr_c_ttl =
898 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
907 bfd_set_error (bfd_error_wrong_format);
914 /* Typical sections for evax object files. */
916 #define EVAX_ABS_NAME "$ABS$"
917 #define EVAX_CODE_NAME "$CODE$"
918 #define EVAX_LINK_NAME "$LINK$"
919 #define EVAX_DATA_NAME "$DATA$"
920 #define EVAX_BSS_NAME "$BSS$"
921 #define EVAX_READONLYADDR_NAME "$READONLY_ADDR$"
922 #define EVAX_READONLY_NAME "$READONLY$"
923 #define EVAX_LITERAL_NAME "$LITERAL$"
924 #define EVAX_LITERALS_NAME "$LITERALS"
925 #define EVAX_COMMON_NAME "$COMMON$"
926 #define EVAX_LOCAL_NAME "$LOCAL$"
928 struct sec_flags_struct
930 const char *name; /* Name of section. */
932 flagword flags_always; /* Flags we set always. */
934 flagword flags_hassize; /* Flags we set if the section has a size > 0. */
937 /* These flags are deccrtl/vaxcrtl (openVMS 6.2 Alpha) compatible. */
939 static const struct sec_flags_struct evax_section_flags[] =
945 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
947 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE),
949 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE),
950 (SEC_CODE | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
952 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD),
953 (SEC_DATA | SEC_READONLY),
954 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD),
955 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
957 (EGPS__V_REL | EGPS__V_RD),
958 (SEC_DATA | SEC_READONLY),
959 (EGPS__V_REL | EGPS__V_RD),
960 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
962 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
964 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
965 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
967 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
969 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
971 { EVAX_READONLYADDR_NAME,
972 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD),
973 (SEC_DATA | SEC_READONLY),
974 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD),
975 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
976 { EVAX_READONLY_NAME,
977 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD),
978 (SEC_DATA | SEC_READONLY),
979 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD),
980 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
982 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
984 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
985 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
986 { EVAX_LITERALS_NAME,
987 (EGPS__V_PIC | EGPS__V_OVR),
988 (SEC_DATA | SEC_READONLY),
989 (EGPS__V_PIC | EGPS__V_OVR),
990 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
992 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
994 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
995 (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) }
998 /* Retrieve BFD section flags by name and size. */
1001 vms_secflag_by_name (const struct sec_flags_struct *section_flags,
1007 while (section_flags[i].name != NULL)
1009 if (strcmp (name, section_flags[i].name) == 0)
1012 return section_flags[i].flags_hassize;
1014 return section_flags[i].flags_always;
1019 return section_flags[i].flags_hassize;
1020 return section_flags[i].flags_always;
1023 /* Retrieve VMS section flags by name and size. */
1026 vms_esecflag_by_name (const struct sec_flags_struct *section_flags,
1032 while (section_flags[i].name != NULL)
1034 if (strcmp (name, section_flags[i].name) == 0)
1037 return section_flags[i].vflags_hassize;
1039 return section_flags[i].vflags_always;
1044 return section_flags[i].vflags_hassize;
1045 return section_flags[i].vflags_always;
1048 /* Add SYM to the symbol table of ABFD.
1049 Return FALSE in case of error. */
1052 add_symbol_entry (bfd *abfd, struct vms_symbol_entry *sym)
1054 if (PRIV (gsd_sym_count) >= PRIV (max_sym_count))
1056 if (PRIV (max_sym_count) == 0)
1058 PRIV (max_sym_count) = 128;
1059 PRIV (syms) = bfd_malloc
1060 (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *));
1064 PRIV (max_sym_count) *= 2;
1065 PRIV (syms) = bfd_realloc
1067 (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *)));
1069 if (PRIV (syms) == NULL)
1073 PRIV (syms)[PRIV (gsd_sym_count)++] = sym;
1077 /* Create a symbol whose name is ASCIC and add it to ABFD.
1078 Return NULL in case of error. */
1080 static struct vms_symbol_entry *
1081 add_symbol (bfd *abfd, const unsigned char *ascic)
1083 struct vms_symbol_entry *entry;
1087 entry = (struct vms_symbol_entry *)bfd_zalloc (abfd, sizeof (*entry) + len);
1090 entry->namelen = len;
1091 memcpy (entry->name, ascic, len);
1092 entry->name[len] = 0;
1093 entry->owner = abfd;
1095 if (!add_symbol_entry (abfd, entry))
1100 /* Read and process EGSD. Return FALSE on failure. */
1103 _bfd_vms_slurp_egsd (bfd *abfd)
1105 int gsd_type, gsd_size;
1107 unsigned char *vms_rec;
1108 flagword new_flags, old_flags;
1110 unsigned long base_addr;
1111 unsigned long align_addr;
1113 vms_debug2 ((2, "EGSD\n"));
1115 PRIV (recrd.rec) += 8; /* Skip type, size, align pad. */
1116 PRIV (recrd.rec_size) -= 8;
1118 /* Calculate base address for each section. */
1121 while (PRIV (recrd.rec_size) > 0)
1123 vms_rec = PRIV (recrd.rec);
1125 gsd_type = bfd_getl16 (vms_rec);
1126 gsd_size = bfd_getl16 (vms_rec + 2);
1128 vms_debug2 ((3, "egsd_type %d\n", gsd_type));
1134 /* Program section definition. */
1135 struct vms_egps *egps = (struct vms_egps *)vms_rec;
1137 name = _bfd_vms_save_counted_string (&egps->namlng);
1138 section = bfd_make_section (abfd, name);
1142 old_flags = bfd_getl16 (egps->flags);
1143 vms_section_data (section)->flags = old_flags;
1144 vms_section_data (section)->no_flags = 0;
1145 section->size = bfd_getl32 (egps->alloc);
1146 new_flags = vms_secflag_by_name (evax_section_flags, name,
1148 if (!(old_flags & EGPS__V_NOMOD))
1150 new_flags |= SEC_HAS_CONTENTS;
1151 if (old_flags & EGPS__V_REL)
1152 new_flags |= SEC_RELOC;
1154 if (!bfd_set_section_flags (abfd, section, new_flags))
1156 section->alignment_power = egps->align;
1157 align_addr = (1 << section->alignment_power);
1158 if ((base_addr % align_addr) != 0)
1159 base_addr += (align_addr - (base_addr % align_addr));
1160 section->vma = (bfd_vma)base_addr;
1161 base_addr += section->size;
1162 section->filepos = (unsigned int)-1;
1164 /* Append it to the section array. */
1165 if (PRIV (section_count) >= PRIV (section_max))
1167 if (PRIV (section_max) == 0)
1168 PRIV (section_max) = 16;
1170 PRIV (section_max) *= 2;
1171 PRIV (sections) = bfd_realloc_or_free
1172 (PRIV (sections), PRIV (section_max) * sizeof (asection *));
1173 if (PRIV (sections) == NULL)
1177 PRIV (sections)[PRIV (section_count)] = section;
1178 PRIV (section_count)++;
1181 vms_debug (4, "EGSD P-section %d (%s, flags %04x) ",
1182 section->index, name, old_flags);
1183 vms_debug (4, "%lu bytes at 0x%08lx (mem %p)\n",
1184 (unsigned long)section->size,
1185 (unsigned long)section->vma, section->contents);
1193 struct vms_symbol_entry *entry;
1194 struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
1196 old_flags = bfd_getl16 (egsy->flags);
1197 if (old_flags & EGSY__V_DEF)
1198 nameoff = ESDF__B_NAMLNG;
1200 nameoff = ESRF__B_NAMLNG;
1202 entry = add_symbol (abfd, vms_rec + nameoff);
1206 /* Allow only duplicate reference. */
1207 if ((entry->flags & EGSY__V_DEF) && (old_flags & EGSY__V_DEF))
1210 if (entry->typ == 0)
1212 entry->typ = gsd_type;
1213 entry->data_type = egsy->datyp;
1214 entry->flags = old_flags;
1217 if (old_flags & EGSY__V_DEF)
1219 struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
1221 entry->value = bfd_getl64 (esdf->value);
1222 entry->section = PRIV (sections)[bfd_getl32 (esdf->psindx)];
1224 if (old_flags & EGSY__V_NORM)
1226 PRIV (norm_sym_count)++;
1228 entry->code_value = bfd_getl64 (esdf->code_address);
1229 entry->code_section =
1230 PRIV (sections)[bfd_getl32 (esdf->ca_psindx)];
1239 struct vms_symbol_entry *entry;
1240 struct vms_egst *egst = (struct vms_egst *)vms_rec;
1242 old_flags = bfd_getl16 (egst->header.flags);
1243 if (old_flags & EGSY__V_DEF)
1244 nameoff = ESDF__B_NAMLNG;
1246 nameoff = ESRF__B_NAMLNG;
1248 entry = add_symbol (abfd, &egst->namlng);
1253 entry->typ = gsd_type;
1254 entry->data_type = egst->header.datyp;
1255 entry->flags = old_flags;
1257 entry->symbol_vector = bfd_getl32 (egst->value);
1259 if (old_flags & EGSY__V_REL)
1260 entry->section = PRIV (sections)[bfd_getl32 (egst->psindx)];
1262 entry->section = bfd_abs_section_ptr;
1264 entry->value = bfd_getl64 (egst->lp_2);
1266 if (old_flags & EGSY__V_NORM)
1268 PRIV (norm_sym_count)++;
1270 entry->code_value = bfd_getl64 (egst->lp_1);
1271 entry->code_section = bfd_abs_section_ptr;
1278 /* Currently ignored. */
1283 (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
1284 bfd_set_error (bfd_error_bad_value);
1288 PRIV (recrd.rec_size) -= gsd_size;
1289 PRIV (recrd.rec) += gsd_size;
1292 if (PRIV (gsd_sym_count) > 0)
1293 abfd->flags |= HAS_SYMS;
1298 /* Stack routines for vms ETIR commands. */
1300 /* Push value and section index. */
1303 _bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
1305 vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
1306 (unsigned long)val, reloc, PRIV (stackptr)));
1308 PRIV (stack[PRIV (stackptr)]).value = val;
1309 PRIV (stack[PRIV (stackptr)]).reloc = reloc;
1311 if (PRIV (stackptr) >= STACKSIZE)
1313 bfd_set_error (bfd_error_bad_value);
1314 (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
1319 /* Pop value and section index. */
1322 _bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
1324 if (PRIV (stackptr) == 0)
1326 bfd_set_error (bfd_error_bad_value);
1327 (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
1331 *val = PRIV (stack[PRIV (stackptr)]).value;
1332 *rel = PRIV (stack[PRIV (stackptr)]).reloc;
1334 vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
1337 /* Routines to fill sections contents during tir/etir read. */
1339 /* Initialize image buffer pointer to be filled. */
1342 image_set_ptr (bfd *abfd, bfd_vma vma, int sect, struct bfd_link_info *info)
1346 vms_debug2 ((4, "image_set_ptr (0x%08x, sect=%d)\n", (unsigned)vma, sect));
1348 sec = PRIV (sections)[sect];
1352 /* Reading contents to an output bfd. */
1354 if (sec->output_section == NULL)
1356 /* Section discarded. */
1357 vms_debug2 ((5, " section %s discarded\n", sec->name));
1359 /* This is not used. */
1360 PRIV (image_section) = NULL;
1361 PRIV (image_offset) = 0;
1364 PRIV (image_offset) = sec->output_offset + vma;
1365 PRIV (image_section) = sec->output_section;
1369 PRIV (image_offset) = vma;
1370 PRIV (image_section) = sec;
1374 /* Increment image buffer pointer by offset. */
1377 image_inc_ptr (bfd *abfd, bfd_vma offset)
1379 vms_debug2 ((4, "image_inc_ptr (%u)\n", (unsigned)offset));
1381 PRIV (image_offset) += offset;
1384 /* Save current DST location counter under specified index. */
1387 dst_define_location (bfd *abfd, unsigned int loc)
1389 vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
1391 /* Grow the ptr offset table if necessary. */
1392 if (loc + 1 > PRIV (dst_ptr_offsets_count))
1394 PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
1395 (loc + 1) * sizeof (unsigned int));
1396 PRIV (dst_ptr_offsets_count) = loc + 1;
1399 PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
1402 /* Restore saved DST location counter from specified index. */
1405 dst_restore_location (bfd *abfd, unsigned int loc)
1407 vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
1409 PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
1412 /* Retrieve saved DST location counter from specified index. */
1415 dst_retrieve_location (bfd *abfd, unsigned int loc)
1417 vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
1419 return PRIV (dst_ptr_offsets)[loc];
1422 /* Write multiple bytes to section image. */
1425 image_write (bfd *abfd, unsigned char *ptr, int size)
1428 _bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
1429 (long)PRIV (image_offset));
1430 _bfd_hexdump (9, ptr, size, 0);
1433 if (PRIV (image_section)->contents != NULL)
1435 asection *sec = PRIV (image_section);
1436 file_ptr off = PRIV (image_offset);
1439 if (off > (file_ptr)sec->size
1440 || size > (file_ptr)sec->size
1441 || off + size > (file_ptr)sec->size)
1443 bfd_set_error (bfd_error_bad_value);
1447 memcpy (sec->contents + off, ptr, size);
1450 PRIV (image_offset) += size;
1454 /* Write byte to section image. */
1457 image_write_b (bfd * abfd, unsigned int value)
1459 unsigned char data[1];
1461 vms_debug2 ((6, "image_write_b (%02x)\n", (int) value));
1465 return image_write (abfd, data, sizeof (data));
1468 /* Write 2-byte word to image. */
1471 image_write_w (bfd * abfd, unsigned int value)
1473 unsigned char data[2];
1475 vms_debug2 ((6, "image_write_w (%04x)\n", (int) value));
1477 bfd_putl16 (value, data);
1478 return image_write (abfd, data, sizeof (data));
1481 /* Write 4-byte long to image. */
1484 image_write_l (bfd * abfd, unsigned long value)
1486 unsigned char data[4];
1488 vms_debug2 ((6, "image_write_l (%08lx)\n", value));
1490 bfd_putl32 (value, data);
1491 return image_write (abfd, data, sizeof (data));
1494 /* Write 8-byte quad to image. */
1497 image_write_q (bfd * abfd, bfd_vma value)
1499 unsigned char data[8];
1501 vms_debug2 ((6, "image_write_q (%08lx)\n", (unsigned long)value));
1503 bfd_putl64 (value, data);
1504 return image_write (abfd, data, sizeof (data));
1508 _bfd_vms_etir_name (int cmd)
1512 case ETIR__C_STA_GBL: return "ETIR__C_STA_GBL";
1513 case ETIR__C_STA_LW: return "ETIR__C_STA_LW";
1514 case ETIR__C_STA_QW: return "ETIR__C_STA_QW";
1515 case ETIR__C_STA_PQ: return "ETIR__C_STA_PQ";
1516 case ETIR__C_STA_LI: return "ETIR__C_STA_LI";
1517 case ETIR__C_STA_MOD: return "ETIR__C_STA_MOD";
1518 case ETIR__C_STA_CKARG: return "ETIR__C_STA_CKARG";
1519 case ETIR__C_STO_B: return "ETIR__C_STO_B";
1520 case ETIR__C_STO_W: return "ETIR__C_STO_W";
1521 case ETIR__C_STO_GBL: return "ETIR__C_STO_GBL";
1522 case ETIR__C_STO_CA: return "ETIR__C_STO_CA";
1523 case ETIR__C_STO_RB: return "ETIR__C_STO_RB";
1524 case ETIR__C_STO_AB: return "ETIR__C_STO_AB";
1525 case ETIR__C_STO_OFF: return "ETIR__C_STO_OFF";
1526 case ETIR__C_STO_IMM: return "ETIR__C_STO_IMM";
1527 case ETIR__C_STO_IMMR: return "ETIR__C_STO_IMMR";
1528 case ETIR__C_STO_LW: return "ETIR__C_STO_LW";
1529 case ETIR__C_STO_QW: return "ETIR__C_STO_QW";
1530 case ETIR__C_STO_GBL_LW: return "ETIR__C_STO_GBL_LW";
1531 case ETIR__C_STO_LP_PSB: return "ETIR__C_STO_LP_PSB";
1532 case ETIR__C_STO_HINT_GBL: return "ETIR__C_STO_HINT_GBL";
1533 case ETIR__C_STO_HINT_PS: return "ETIR__C_STO_HINT_PS";
1534 case ETIR__C_OPR_ADD: return "ETIR__C_OPR_ADD";
1535 case ETIR__C_OPR_SUB: return "ETIR__C_OPR_SUB";
1536 case ETIR__C_OPR_INSV: return "ETIR__C_OPR_INSV";
1537 case ETIR__C_OPR_USH: return "ETIR__C_OPR_USH";
1538 case ETIR__C_OPR_ROT: return "ETIR__C_OPR_ROT";
1539 case ETIR__C_OPR_REDEF: return "ETIR__C_OPR_REDEF";
1540 case ETIR__C_OPR_DFLIT: return "ETIR__C_OPR_DFLIT";
1541 case ETIR__C_STC_LP: return "ETIR__C_STC_LP";
1542 case ETIR__C_STC_GBL: return "ETIR__C_STC_GBL";
1543 case ETIR__C_STC_GCA: return "ETIR__C_STC_GCA";
1544 case ETIR__C_STC_PS: return "ETIR__C_STC_PS";
1545 case ETIR__C_STC_NBH_PS: return "ETIR__C_STC_NBH_PS";
1546 case ETIR__C_STC_NOP_GBL: return "ETIR__C_STC_NOP_GBL";
1547 case ETIR__C_STC_NOP_PS: return "ETIR__C_STC_NOP_PS";
1548 case ETIR__C_STC_BSR_GBL: return "ETIR__C_STC_BSR_GBL";
1549 case ETIR__C_STC_BSR_PS: return "ETIR__C_STC_BSR_PS";
1550 case ETIR__C_STC_LDA_GBL: return "ETIR__C_STC_LDA_GBL";
1551 case ETIR__C_STC_LDA_PS: return "ETIR__C_STC_LDA_PS";
1552 case ETIR__C_STC_BOH_GBL: return "ETIR__C_STC_BOH_GBL";
1553 case ETIR__C_STC_BOH_PS: return "ETIR__C_STC_BOH_PS";
1554 case ETIR__C_STC_NBH_GBL: return "ETIR__C_STC_NBH_GBL";
1555 case ETIR__C_STC_LP_PSB: return "ETIR__C_STC_LP_PSB";
1556 case ETIR__C_CTL_SETRB: return "ETIR__C_CTL_SETRB";
1557 case ETIR__C_CTL_AUGRB: return "ETIR__C_CTL_AUGRB";
1558 case ETIR__C_CTL_DFLOC: return "ETIR__C_CTL_DFLOC";
1559 case ETIR__C_CTL_STLOC: return "ETIR__C_CTL_STLOC";
1560 case ETIR__C_CTL_STKDL: return "ETIR__C_CTL_STKDL";
1563 /* These names have not yet been added to this switch statement. */
1564 (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
1569 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
1572 _bfd_vms_get_value (bfd *abfd, const unsigned char *ascic,
1573 struct bfd_link_info *info,
1575 struct alpha_vms_link_hash_entry **hp)
1580 struct alpha_vms_link_hash_entry *h;
1582 /* Not linking. Do not try to resolve the symbol. */
1591 for (i = 0; i < len; i++)
1592 name[i] = ascic[i + 1];
1595 h = (struct alpha_vms_link_hash_entry *)
1596 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
1601 && (h->root.type == bfd_link_hash_defined
1602 || h->root.type == bfd_link_hash_defweak))
1603 *vma = h->root.u.def.value
1604 + h->root.u.def.section->output_offset
1605 + h->root.u.def.section->output_section->vma;
1606 else if (h && h->root.type == bfd_link_hash_undefweak)
1610 if (!(*info->callbacks->undefined_symbol)
1611 (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
1619 #define RELC_SHR_BASE 0x10000
1620 #define RELC_SEC_BASE 0x20000
1621 #define RELC_MASK 0x0ffff
1624 alpha_vms_sym_to_ctxt (struct alpha_vms_link_hash_entry *h)
1626 /* Handle undefined symbols. */
1627 if (h == NULL || h->sym == NULL)
1630 if (h->sym->typ == EGSD__C_SYMG)
1632 if (h->sym->flags & EGSY__V_REL)
1633 return RELC_SHR_BASE + PRIV2 (h->sym->owner, shr_index);
1636 /* Can this happen (non-relocatable symg) ? I'd like to see
1641 if (h->sym->typ == EGSD__C_SYM)
1643 if (h->sym->flags & EGSY__V_REL)
1652 alpha_vms_get_sym_value (asection *sect, bfd_vma addr)
1654 return sect->output_section->vma + sect->output_offset + addr;
1658 alpha_vms_fix_sec_rel (bfd *abfd, struct bfd_link_info *info,
1659 unsigned int rel, bfd_vma vma)
1661 asection *sec = PRIV (sections)[rel & RELC_MASK];
1665 if (sec->output_section == NULL)
1667 return vma + sec->output_section->vma + sec->output_offset;
1670 return vma + sec->vma;
1673 /* Read an ETIR record from ABFD. If INFO is not null, put the content into
1674 the output section (used during linking).
1675 Return FALSE in case of error. */
1678 _bfd_vms_slurp_etir (bfd *abfd, struct bfd_link_info *info)
1681 unsigned int length;
1682 unsigned char *maxptr;
1687 struct alpha_vms_link_hash_entry *h;
1689 PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
1690 PRIV (recrd.rec_size) -= ETIR__C_HEADER_SIZE;
1692 ptr = PRIV (recrd.rec);
1693 length = PRIV (recrd.rec_size);
1694 maxptr = ptr + length;
1696 vms_debug2 ((2, "ETIR: %d bytes\n", length));
1698 while (ptr < maxptr)
1700 int cmd = bfd_getl16 (ptr);
1701 int cmd_length = bfd_getl16 (ptr + 2);
1706 _bfd_vms_debug (4, "etir: %s(%d)\n",
1707 _bfd_vms_etir_name (cmd), cmd);
1708 _bfd_hexdump (8, ptr, cmd_length - 4, (long) ptr);
1716 stack 32 bit value of symbol (high bits set to 0). */
1717 case ETIR__C_STA_GBL:
1718 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1719 _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
1725 stack 32 bit value, sign extend to 64 bit. */
1726 case ETIR__C_STA_LW:
1727 _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
1733 stack 64 bit value of symbol. */
1734 case ETIR__C_STA_QW:
1735 _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
1738 /* Stack psect base plus quadword offset
1739 arg: lw section index
1740 qw signed quadword offset (low 32 bits)
1742 Stack qw argument and section index
1743 (see ETIR__C_STO_OFF, ETIR__C_CTL_SETRB). */
1744 case ETIR__C_STA_PQ:
1748 psect = bfd_getl32 (ptr);
1749 if ((unsigned int) psect >= PRIV (section_count))
1751 (*_bfd_error_handler) (_("bad section index in %s"),
1752 _bfd_vms_etir_name (cmd));
1753 bfd_set_error (bfd_error_bad_value);
1756 op1 = bfd_getl64 (ptr + 4);
1757 _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
1761 case ETIR__C_STA_LI:
1762 case ETIR__C_STA_MOD:
1763 case ETIR__C_STA_CKARG:
1764 (*_bfd_error_handler) (_("unsupported STA cmd %s"),
1765 _bfd_vms_etir_name (cmd));
1769 /* Store byte: pop stack, write byte
1772 _bfd_vms_pop (abfd, &op1, &rel1);
1773 if (rel1 != RELC_NONE)
1775 image_write_b (abfd, (unsigned int) op1 & 0xff);
1778 /* Store word: pop stack, write word
1781 _bfd_vms_pop (abfd, &op1, &rel1);
1782 if (rel1 != RELC_NONE)
1784 image_write_w (abfd, (unsigned int) op1 & 0xffff);
1787 /* Store longword: pop stack, write longword
1789 case ETIR__C_STO_LW:
1790 _bfd_vms_pop (abfd, &op1, &rel1);
1791 if (rel1 & RELC_SEC_BASE)
1793 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1796 else if (rel1 & RELC_SHR_BASE)
1798 alpha_vms_add_lw_fixup (info, rel1 & RELC_MASK, op1);
1801 if (rel1 != RELC_NONE)
1803 if (rel1 != RELC_REL)
1805 alpha_vms_add_lw_reloc (info);
1807 image_write_l (abfd, op1);
1810 /* Store quadword: pop stack, write quadword
1812 case ETIR__C_STO_QW:
1813 _bfd_vms_pop (abfd, &op1, &rel1);
1814 if (rel1 & RELC_SEC_BASE)
1816 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1819 else if (rel1 & RELC_SHR_BASE)
1821 if (rel1 != RELC_NONE)
1823 if (rel1 != RELC_REL)
1825 alpha_vms_add_qw_reloc (info);
1827 image_write_q (abfd, op1);
1830 /* Store immediate repeated: pop stack for repeat count
1833 case ETIR__C_STO_IMMR:
1837 size = bfd_getl32 (ptr);
1838 _bfd_vms_pop (abfd, &op1, &rel1);
1839 if (rel1 != RELC_NONE)
1842 image_write (abfd, ptr + 4, size);
1846 /* Store global: write symbol value
1847 arg: cs global symbol name. */
1848 case ETIR__C_STO_GBL:
1849 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1852 if (h->sym->typ == EGSD__C_SYMG)
1854 alpha_vms_add_fixup_qr
1855 (info, abfd, h->sym->owner, h->sym->symbol_vector);
1860 op1 = alpha_vms_get_sym_value (h->sym->section,
1862 alpha_vms_add_qw_reloc (info);
1865 image_write_q (abfd, op1);
1868 /* Store code address: write address of entry point
1869 arg: cs global symbol name (procedure). */
1870 case ETIR__C_STO_CA:
1871 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1874 if (h->sym->flags & EGSY__V_NORM)
1876 /* That's really a procedure. */
1877 if (h->sym->typ == EGSD__C_SYMG)
1879 alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
1880 op1 = h->sym->symbol_vector;
1884 op1 = alpha_vms_get_sym_value (h->sym->code_section,
1885 h->sym->code_value);
1886 alpha_vms_add_qw_reloc (info);
1891 /* Symbol is not a procedure. */
1895 image_write_q (abfd, op1);
1898 /* Store offset to psect: pop stack, add low 32 bits to base of psect
1900 case ETIR__C_STO_OFF:
1901 _bfd_vms_pop (abfd, &op1, &rel1);
1903 if (!(rel1 & RELC_SEC_BASE))
1906 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1908 image_write_q (abfd, op1);
1912 arg: lw count of bytes
1914 case ETIR__C_STO_IMM:
1918 size = bfd_getl32 (ptr);
1919 image_write (abfd, ptr + 4, size);
1923 /* This code is 'reserved to digital' according to the openVMS
1924 linker manual, however it is generated by the DEC C compiler
1925 and defined in the include file.
1926 FIXME, since the following is just a guess
1927 store global longword: store 32bit value of symbol
1928 arg: cs symbol name. */
1929 case ETIR__C_STO_GBL_LW:
1930 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1934 image_write_l (abfd, op1);
1937 case ETIR__C_STO_RB:
1938 case ETIR__C_STO_AB:
1939 case ETIR__C_STO_LP_PSB:
1940 (*_bfd_error_handler) (_("%s: not supported"),
1941 _bfd_vms_etir_name (cmd));
1944 case ETIR__C_STO_HINT_GBL:
1945 case ETIR__C_STO_HINT_PS:
1946 (*_bfd_error_handler) (_("%s: not implemented"),
1947 _bfd_vms_etir_name (cmd));
1951 /* 200 Store-conditional Linkage Pair
1953 case ETIR__C_STC_LP:
1955 /* 202 Store-conditional Address at global address
1959 case ETIR__C_STC_GBL:
1961 /* 203 Store-conditional Code Address at global address
1963 cs procedure name. */
1964 case ETIR__C_STC_GCA:
1966 /* 204 Store-conditional Address at psect + offset
1970 case ETIR__C_STC_PS:
1971 (*_bfd_error_handler) (_("%s: not supported"),
1972 _bfd_vms_etir_name (cmd));
1976 /* 201 Store-conditional Linkage Pair with Procedure Signature
1982 case ETIR__C_STC_LP_PSB:
1983 _bfd_vms_get_value (abfd, ptr + 4, info, &op1, &h);
1986 if (h->sym->typ == EGSD__C_SYMG)
1988 alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
1989 op1 = h->sym->symbol_vector;
1994 op1 = alpha_vms_get_sym_value (h->sym->code_section,
1995 h->sym->code_value);
1996 op2 = alpha_vms_get_sym_value (h->sym->section,
2002 /* Undefined symbol. */
2006 image_write_q (abfd, op1);
2007 image_write_q (abfd, op2);
2010 /* 205 Store-conditional NOP at address of global
2012 case ETIR__C_STC_NOP_GBL:
2015 /* 207 Store-conditional BSR at global address
2018 case ETIR__C_STC_BSR_GBL:
2021 /* 209 Store-conditional LDA at global address
2024 case ETIR__C_STC_LDA_GBL:
2027 /* 211 Store-conditional BSR or Hint at global address
2030 case ETIR__C_STC_BOH_GBL:
2031 /* Currentl ignored. */
2034 /* 213 Store-conditional NOP,BSR or HINT at global address
2037 case ETIR__C_STC_NBH_GBL:
2039 /* 206 Store-conditional NOP at pect + offset
2042 case ETIR__C_STC_NOP_PS:
2044 /* 208 Store-conditional BSR at pect + offset
2047 case ETIR__C_STC_BSR_PS:
2049 /* 210 Store-conditional LDA at psect + offset
2052 case ETIR__C_STC_LDA_PS:
2054 /* 212 Store-conditional BSR or Hint at pect + offset
2057 case ETIR__C_STC_BOH_PS:
2059 /* 214 Store-conditional NOP, BSR or HINT at psect + offset
2061 case ETIR__C_STC_NBH_PS:
2062 (*_bfd_error_handler) ("%s: not supported",
2063 _bfd_vms_etir_name (cmd));
2067 /* Det relocation base: pop stack, set image location counter
2069 case ETIR__C_CTL_SETRB:
2070 _bfd_vms_pop (abfd, &op1, &rel1);
2071 if (!(rel1 & RELC_SEC_BASE))
2073 image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
2076 /* Augment relocation base: increment image location counter by offset
2077 arg: lw offset value. */
2078 case ETIR__C_CTL_AUGRB:
2079 op1 = bfd_getl32 (ptr);
2080 image_inc_ptr (abfd, op1);
2083 /* Define location: pop index, save location counter under index
2085 case ETIR__C_CTL_DFLOC:
2086 _bfd_vms_pop (abfd, &op1, &rel1);
2087 if (rel1 != RELC_NONE)
2089 dst_define_location (abfd, op1);
2092 /* Set location: pop index, restore location counter from index
2094 case ETIR__C_CTL_STLOC:
2095 _bfd_vms_pop (abfd, &op1, &rel1);
2096 if (rel1 != RELC_NONE)
2098 dst_restore_location (abfd, op1);
2101 /* Stack defined location: pop index, push location counter from index
2103 case ETIR__C_CTL_STKDL:
2104 _bfd_vms_pop (abfd, &op1, &rel1);
2105 if (rel1 != RELC_NONE)
2107 _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
2110 case ETIR__C_OPR_NOP: /* No-op. */
2113 case ETIR__C_OPR_ADD: /* Add. */
2114 _bfd_vms_pop (abfd, &op1, &rel1);
2115 _bfd_vms_pop (abfd, &op2, &rel2);
2116 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2118 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2120 _bfd_vms_push (abfd, op1 + op2, rel1);
2123 case ETIR__C_OPR_SUB: /* Subtract. */
2124 _bfd_vms_pop (abfd, &op1, &rel1);
2125 _bfd_vms_pop (abfd, &op2, &rel2);
2126 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2128 else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
2130 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
2131 op2 = alpha_vms_fix_sec_rel (abfd, info, rel2, op2);
2134 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2136 _bfd_vms_push (abfd, op2 - op1, rel1);
2139 case ETIR__C_OPR_MUL: /* Multiply. */
2140 _bfd_vms_pop (abfd, &op1, &rel1);
2141 _bfd_vms_pop (abfd, &op2, &rel2);
2142 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2144 _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
2147 case ETIR__C_OPR_DIV: /* Divide. */
2148 _bfd_vms_pop (abfd, &op1, &rel1);
2149 _bfd_vms_pop (abfd, &op2, &rel2);
2150 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2153 _bfd_vms_push (abfd, 0, RELC_NONE);
2155 _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
2158 case ETIR__C_OPR_AND: /* Logical AND. */
2159 _bfd_vms_pop (abfd, &op1, &rel1);
2160 _bfd_vms_pop (abfd, &op2, &rel2);
2161 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2163 _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
2166 case ETIR__C_OPR_IOR: /* Logical inclusive OR. */
2167 _bfd_vms_pop (abfd, &op1, &rel1);
2168 _bfd_vms_pop (abfd, &op2, &rel2);
2169 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2171 _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
2174 case ETIR__C_OPR_EOR: /* Logical exclusive OR. */
2175 _bfd_vms_pop (abfd, &op1, &rel1);
2176 _bfd_vms_pop (abfd, &op2, &rel2);
2177 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2179 _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
2182 case ETIR__C_OPR_NEG: /* Negate. */
2183 _bfd_vms_pop (abfd, &op1, &rel1);
2184 if (rel1 != RELC_NONE)
2186 _bfd_vms_push (abfd, -op1, RELC_NONE);
2189 case ETIR__C_OPR_COM: /* Complement. */
2190 _bfd_vms_pop (abfd, &op1, &rel1);
2191 if (rel1 != RELC_NONE)
2193 _bfd_vms_push (abfd, ~op1, RELC_NONE);
2196 case ETIR__C_OPR_ASH: /* Arithmetic shift. */
2197 _bfd_vms_pop (abfd, &op1, &rel1);
2198 _bfd_vms_pop (abfd, &op2, &rel2);
2199 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2202 (*_bfd_error_handler) (_("invalid use of %s with contexts"),
2203 _bfd_vms_etir_name (cmd));
2206 if ((int)op2 < 0) /* Shift right. */
2208 else /* Shift left. */
2210 _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym. */
2213 case ETIR__C_OPR_INSV: /* Insert field. */
2214 case ETIR__C_OPR_USH: /* Unsigned shift. */
2215 case ETIR__C_OPR_ROT: /* Rotate. */
2216 case ETIR__C_OPR_REDEF: /* Redefine symbol to current location. */
2217 case ETIR__C_OPR_DFLIT: /* Define a literal. */
2218 (*_bfd_error_handler) (_("%s: not supported"),
2219 _bfd_vms_etir_name (cmd));
2223 case ETIR__C_OPR_SEL: /* Select. */
2224 _bfd_vms_pop (abfd, &op1, &rel1);
2226 _bfd_vms_pop (abfd, &op1, &rel1);
2229 _bfd_vms_pop (abfd, &op1, &rel1);
2230 _bfd_vms_pop (abfd, &op2, &rel2);
2231 _bfd_vms_push (abfd, op1, rel1);
2236 (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
2241 ptr += cmd_length - 4;
2247 /* Process EDBG/ETBT record.
2248 Return TRUE on success, FALSE on error */
2251 vms_slurp_debug (bfd *abfd)
2253 asection *section = PRIV (dst_section);
2255 if (section == NULL)
2257 /* We have no way to find out beforehand how much debug info there
2258 is in an object file, so pick an initial amount and grow it as
2260 flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC
2263 section = bfd_make_section (abfd, "$DST$");
2266 if (!bfd_set_section_flags (abfd, section, flags))
2268 PRIV (dst_section) = section;
2271 PRIV (image_section) = section;
2272 PRIV (image_offset) = section->size;
2274 if (!_bfd_vms_slurp_etir (abfd, NULL))
2277 section->size = PRIV (image_offset);
2281 /* Process EDBG record.
2282 Return TRUE on success, FALSE on error. */
2285 _bfd_vms_slurp_edbg (bfd *abfd)
2287 vms_debug2 ((2, "EDBG\n"));
2289 abfd->flags |= HAS_DEBUG | HAS_LINENO;
2291 return vms_slurp_debug (abfd);
2294 /* Process ETBT record.
2295 Return TRUE on success, FALSE on error. */
2298 _bfd_vms_slurp_etbt (bfd *abfd)
2300 vms_debug2 ((2, "ETBT\n"));
2302 abfd->flags |= HAS_LINENO;
2304 return vms_slurp_debug (abfd);
2307 /* Process EEOM record.
2308 Return TRUE on success, FALSE on error. */
2311 _bfd_vms_slurp_eeom (bfd *abfd)
2313 struct vms_eeom *eeom = (struct vms_eeom *) PRIV (recrd.rec);
2315 vms_debug2 ((2, "EEOM\n"));
2317 PRIV (eom_data).eom_l_total_lps = bfd_getl32 (eeom->total_lps);
2318 PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
2319 if (PRIV (eom_data).eom_w_comcod > 1)
2321 (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
2322 bfd_set_error (bfd_error_bad_value);
2326 PRIV (eom_data).eom_has_transfer = FALSE;
2327 if (PRIV (recrd.rec_size) > 10)
2329 PRIV (eom_data).eom_has_transfer = TRUE;
2330 PRIV (eom_data).eom_b_tfrflg = eeom->tfrflg;
2331 PRIV (eom_data).eom_l_psindx = bfd_getl32 (eeom->psindx);
2332 PRIV (eom_data).eom_l_tfradr = bfd_getl32 (eeom->tfradr);
2334 abfd->start_address = PRIV (eom_data).eom_l_tfradr;
2339 /* Slurp an ordered set of VMS object records. Return FALSE on error. */
2342 _bfd_vms_slurp_object_records (bfd * abfd)
2349 vms_debug2 ((7, "reading at %08lx\n", (unsigned long)bfd_tell (abfd)));
2351 type = _bfd_vms_get_object_record (abfd);
2354 vms_debug2 ((2, "next_record failed\n"));
2361 err = _bfd_vms_slurp_ehdr (abfd);
2364 err = _bfd_vms_slurp_eeom (abfd);
2367 err = _bfd_vms_slurp_egsd (abfd);
2370 err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
2373 err = _bfd_vms_slurp_edbg (abfd);
2376 err = _bfd_vms_slurp_etbt (abfd);
2383 vms_debug2 ((2, "slurp type %d failed\n", type));
2387 while (type != EOBJ__C_EEOM);
2392 /* Initialize private data */
2394 vms_initialize (bfd * abfd)
2398 amt = sizeof (struct vms_private_data_struct);
2399 abfd->tdata.any = bfd_zalloc (abfd, amt);
2400 if (abfd->tdata.any == NULL)
2403 PRIV (recrd.file_format) = FF_UNKNOWN;
2405 amt = sizeof (struct stack_struct) * STACKSIZE;
2406 PRIV (stack) = bfd_alloc (abfd, amt);
2407 if (PRIV (stack) == NULL)
2413 bfd_release (abfd, abfd->tdata.any);
2414 abfd->tdata.any = NULL;
2418 /* Check the format for a file being read.
2419 Return a (bfd_target *) if it's an object file or zero if not. */
2421 static const struct bfd_target *
2422 alpha_vms_object_p (bfd *abfd)
2424 PTR tdata_save = abfd->tdata.any;
2425 unsigned int test_len;
2428 vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
2430 /* Allocate alpha-vms specific data. */
2431 if (!vms_initialize (abfd))
2434 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
2435 goto err_wrong_format;
2437 /* The first challenge with VMS is to discover the kind of the file.
2439 Image files (executable or shared images) are stored as a raw
2440 stream of bytes (like on UNIX), but there is no magic number.
2442 Object files are written with RMS (record management service), ie
2443 each records are preceeded by its length (on a word - 2 bytes), and
2444 padded for word-alignment. That would be simple but when files
2445 are transfered to a UNIX filesystem (using ftp), records are lost.
2446 Only the raw content of the records are transfered. Fortunately,
2447 the Alpha Object file format also store the length of the record
2448 in the records. Is that clear ? */
2450 /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
2451 2 bytes size repeated) and 12 bytes for images (4 bytes major id,
2452 4 bytes minor id, 4 bytes length). */
2455 /* Size the main buffer. */
2456 buf = (unsigned char *) bfd_malloc (test_len);
2459 PRIV (recrd.buf) = buf;
2460 PRIV (recrd.buf_size) = test_len;
2462 /* Initialize the record pointer. */
2463 PRIV (recrd.rec) = buf;
2465 if (bfd_bread (buf, test_len, abfd) != test_len)
2467 bfd_set_error (bfd_error_file_truncated);
2471 /* Is it an image? */
2472 if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
2473 && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
2475 unsigned int to_read;
2476 unsigned int read_so_far;
2477 unsigned int remaining;
2478 unsigned int eisd_offset, eihs_offset;
2480 /* Extract the header size. */
2481 PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
2483 /* The header size is 0 for DSF files. */
2484 if (PRIV (recrd.rec_size) == 0)
2485 PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
2487 if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
2489 buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
2493 PRIV (recrd.buf) = NULL;
2494 bfd_set_error (bfd_error_no_memory);
2497 PRIV (recrd.buf) = buf;
2498 PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
2501 /* Read the remaining record. */
2502 remaining = PRIV (recrd.rec_size) - test_len;
2503 to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
2504 read_so_far = test_len;
2506 while (remaining > 0)
2508 if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
2510 bfd_set_error (bfd_error_file_truncated);
2511 goto err_wrong_format;
2514 read_so_far += to_read;
2515 remaining -= to_read;
2517 to_read = MIN (VMS_BLOCK_SIZE, remaining);
2520 /* Reset the record pointer. */
2521 PRIV (recrd.rec) = buf;
2523 vms_debug2 ((2, "file type is image\n"));
2525 if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
2526 goto err_wrong_format;
2528 if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
2529 goto err_wrong_format;
2531 /* EIHS is optional. */
2532 if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
2533 goto err_wrong_format;
2539 /* Assume it's a module and adjust record pointer if necessary. */
2540 maybe_adjust_record_pointer_for_object (abfd);
2542 /* But is it really a module? */
2543 if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
2544 && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
2546 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
2547 goto err_wrong_format;
2549 vms_debug2 ((2, "file type is module\n"));
2551 type = bfd_getl16 (PRIV (recrd.rec));
2552 if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
2553 goto err_wrong_format;
2555 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
2556 goto err_wrong_format;
2559 goto err_wrong_format;
2562 /* Set arch_info to alpha. */
2564 if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
2565 goto err_wrong_format;
2570 bfd_set_error (bfd_error_wrong_format);
2573 if (PRIV (recrd.buf))
2574 free (PRIV (recrd.buf));
2575 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
2576 bfd_release (abfd, abfd->tdata.any);
2577 abfd->tdata.any = tdata_save;
2583 /* Write an EMH/MHD record. */
2586 _bfd_vms_write_emh (bfd *abfd)
2588 struct vms_rec_wr *recwr = &PRIV (recwr);
2590 _bfd_vms_output_alignment (recwr, 2);
2593 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2594 _bfd_vms_output_short (recwr, EMH__C_MHD);
2595 _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
2596 _bfd_vms_output_long (recwr, 0);
2597 _bfd_vms_output_long (recwr, 0);
2598 _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
2600 /* Create module name from filename. */
2601 if (bfd_get_filename (abfd) != 0)
2603 char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2604 _bfd_vms_output_counted (recwr, module);
2608 _bfd_vms_output_counted (recwr, "NONAME");
2610 _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
2611 _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
2612 _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
2613 _bfd_vms_output_end (abfd, recwr);
2616 /* Write an EMH/LMN record. */
2619 _bfd_vms_write_lmn (bfd *abfd, const char *name)
2622 struct vms_rec_wr *recwr = &PRIV (recwr);
2623 unsigned int ver = BFD_VERSION / 10000;
2626 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2627 _bfd_vms_output_short (recwr, EMH__C_LNM);
2628 snprintf (version, sizeof (version), "%s %d.%d.%d", name,
2629 ver / 10000, (ver / 100) % 100, ver % 100);
2630 _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
2631 _bfd_vms_output_end (abfd, recwr);
2635 /* Write eom record for bfd abfd. Return FALSE on error. */
2638 _bfd_vms_write_eeom (bfd *abfd)
2640 struct vms_rec_wr *recwr = &PRIV (recwr);
2642 vms_debug2 ((2, "vms_write_eeom\n"));
2644 _bfd_vms_output_alignment (recwr, 2);
2646 _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
2647 _bfd_vms_output_long (recwr, (unsigned long) (PRIV (vms_linkage_index) >> 1));
2648 _bfd_vms_output_byte (recwr, 0); /* Completion code. */
2649 _bfd_vms_output_byte (recwr, 0); /* Fill byte. */
2651 if ((abfd->flags & EXEC_P) == 0
2652 && bfd_get_start_address (abfd) != (bfd_vma)-1)
2656 section = bfd_get_section_by_name (abfd, ".link");
2659 bfd_set_error (bfd_error_nonrepresentable_section);
2662 _bfd_vms_output_short (recwr, 0);
2663 _bfd_vms_output_long (recwr, (unsigned long) (section->index));
2664 _bfd_vms_output_long (recwr,
2665 (unsigned long) bfd_get_start_address (abfd));
2666 _bfd_vms_output_long (recwr, 0);
2669 _bfd_vms_output_end (abfd, recwr);
2673 /* This hash routine borrowed from GNU-EMACS, and strengthened
2677 hash_string (const char *ptr)
2679 const unsigned char *p = (unsigned char *) ptr;
2680 const unsigned char *end = p + strlen (ptr);
2687 hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
2692 /* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
2695 _bfd_vms_length_hash_symbol (bfd *abfd, const char *in, int maxlen)
2697 unsigned long result;
2700 const char *old_name;
2702 static char outbuf[EOBJ__C_SYMSIZ + 1];
2706 vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
2709 if (maxlen > EOBJ__C_SYMSIZ)
2710 maxlen = EOBJ__C_SYMSIZ;
2712 /* Save this for later. */
2715 /* We may need to truncate the symbol, save the hash for later. */
2716 in_len = strlen (in);
2718 result = (in_len > maxlen) ? hash_string (in) : 0;
2722 /* Do the length checking. */
2723 if (in_len <= maxlen)
2727 if (PRIV (flag_hash_long_names))
2733 strncpy (out, in, (size_t) i);
2737 if ((in_len > maxlen)
2738 && PRIV (flag_hash_long_names))
2739 sprintf (out, "_%08lx", result);
2744 vms_debug (4, "--> [%d]\"%s\"\n", (int)strlen (outbuf), outbuf);
2748 && PRIV (flag_hash_long_names)
2749 && PRIV (flag_show_after_trunc))
2750 printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
2756 vector_grow1 (struct vector_type *vec, size_t elsz)
2758 if (vec->nbr_el + 1 < vec->max_el)
2761 if (vec->max_el == 0)
2764 vec->els = bfd_malloc2 (vec->max_el, elsz);
2769 vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
2773 /* Bump ABFD file position to next block. */
2776 alpha_vms_file_position_block (bfd *abfd)
2779 PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
2780 PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
2783 /* Convert from internal structure SRC to external structure DST. */
2786 alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
2787 struct vms_eisd *dst)
2789 bfd_putl32 (src->u.eisd.majorid, dst->majorid);
2790 bfd_putl32 (src->u.eisd.minorid, dst->minorid);
2791 bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
2792 if (src->u.eisd.eisdsize <= EISD__K_LENEND)
2794 bfd_putl32 (src->u.eisd.secsize, dst->secsize);
2795 bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
2796 bfd_putl32 (src->u.eisd.flags, dst->flags);
2797 bfd_putl32 (src->u.eisd.vbn, dst->vbn);
2798 dst->pfc = src->u.eisd.pfc;
2799 dst->matchctl = src->u.eisd.matchctl;
2800 dst->type = src->u.eisd.type;
2802 if (src->u.eisd.flags & EISD__M_GBL)
2804 bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
2805 memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
2806 src->u.gbl_eisd.gblnam[0] + 1);
2810 /* Append EISD to the list of extra eisd for ABFD. */
2813 alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
2816 if (PRIV (gbl_eisd_head) == NULL)
2817 PRIV (gbl_eisd_head) = eisd;
2819 PRIV (gbl_eisd_tail)->next = eisd;
2820 PRIV (gbl_eisd_tail) = eisd;
2823 /* Create an EISD for shared image SHRIMG.
2824 Return FALSE in case of error. */
2827 alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
2829 struct vms_internal_eisd_map *eisd;
2832 namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
2833 if (namlen + 5 > EISD__K_GBLNAMLEN)
2839 eisd = bfd_alloc (abfd, sizeof (*eisd));
2843 /* Fill the fields. */
2844 eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
2845 eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
2846 eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
2847 eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE; /* Must not be 0. */
2848 eisd->u.gbl_eisd.common.virt_addr = 0;
2849 eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
2850 eisd->u.gbl_eisd.common.vbn = 0;
2851 eisd->u.gbl_eisd.common.pfc = 0;
2852 eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
2853 eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
2855 eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
2856 eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
2857 memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
2859 memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
2861 /* Append it to the list. */
2862 alpha_vms_append_extra_eisd (abfd, eisd);
2867 /* Create an EISD for section SEC.
2868 Return FALSE in case of failure. */
2871 alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
2873 struct vms_internal_eisd_map *eisd;
2875 /* Only for allocating section. */
2876 if (!(sec->flags & SEC_ALLOC))
2879 BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
2880 eisd = bfd_alloc (abfd, sizeof (*eisd));
2883 vms_section_data (sec)->eisd = eisd;
2885 /* Fill the fields. */
2886 eisd->u.eisd.majorid = EISD__K_MAJORID;
2887 eisd->u.eisd.minorid = EISD__K_MINORID;
2888 eisd->u.eisd.eisdsize = EISD__K_LEN;
2889 eisd->u.eisd.secsize =
2890 (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
2891 eisd->u.eisd.virt_addr = sec->vma;
2892 eisd->u.eisd.flags = 0;
2893 eisd->u.eisd.vbn = 0; /* To be later defined. */
2894 eisd->u.eisd.pfc = 0; /* Default. */
2895 eisd->u.eisd.matchctl = EISD__K_MATALL;
2896 eisd->u.eisd.type = EISD__K_NORMAL;
2898 if (sec->flags & SEC_CODE)
2899 eisd->u.eisd.flags |= EISD__M_EXE;
2900 if (!(sec->flags & SEC_READONLY))
2901 eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2903 if (!(sec->flags & SEC_LOAD))
2905 eisd->u.eisd.flags |= EISD__M_DZRO;
2906 eisd->u.eisd.flags &= ~EISD__M_CRF;
2908 if (sec->flags & SEC_LINKER_CREATED)
2910 if (strcmp (sec->name, "$FIXUP$") == 0)
2911 eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
2914 /* Append it to the list. */
2916 if (PRIV (eisd_head) == NULL)
2917 PRIV (eisd_head) = eisd;
2919 PRIV (eisd_tail)->next = eisd;
2920 PRIV (eisd_tail) = eisd;
2925 /* Layout executable ABFD and write it to the disk.
2926 Return FALSE in case of failure. */
2929 alpha_vms_write_exec (bfd *abfd)
2931 struct vms_eihd eihd;
2932 struct vms_eiha *eiha;
2933 struct vms_eihi *eihi;
2934 struct vms_eihs *eihs = NULL;
2936 struct vms_internal_eisd_map *first_eisd;
2937 struct vms_internal_eisd_map *eisd;
2940 file_ptr gst_filepos = 0;
2941 unsigned int lnkflags = 0;
2943 /* Build the EIHD. */
2944 PRIV (file_pos) = EIHD__C_LENGTH;
2946 memset (&eihd, 0, sizeof (eihd));
2947 memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
2949 bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
2950 bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
2952 bfd_putl32 (sizeof (eihd), eihd.size);
2953 bfd_putl32 (0, eihd.isdoff);
2954 bfd_putl32 (0, eihd.activoff);
2955 bfd_putl32 (0, eihd.symdbgoff);
2956 bfd_putl32 (0, eihd.imgidoff);
2957 bfd_putl32 (0, eihd.patchoff);
2958 bfd_putl64 (0, eihd.iafva);
2959 bfd_putl32 (0, eihd.version_array_off);
2961 bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
2962 bfd_putl32 (0, eihd.subtype);
2964 bfd_putl32 (0, eihd.imgiocnt);
2965 bfd_putl32 (-1, eihd.privreqs);
2966 bfd_putl32 (-1, eihd.privreqs + 4);
2968 bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
2970 bfd_putl32 (0, eihd.ident);
2971 bfd_putl32 (0, eihd.sysver);
2974 bfd_putl32 (0, eihd.symvect_size);
2975 bfd_putl32 (16, eihd.virt_mem_block_size);
2976 bfd_putl32 (0, eihd.ext_fixup_off);
2977 bfd_putl32 (0, eihd.noopt_psect_off);
2978 bfd_putl32 (-1, eihd.alias);
2981 eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
2982 bfd_putl32 (PRIV (file_pos), eihd.activoff);
2983 PRIV (file_pos) += sizeof (struct vms_eiha);
2985 bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
2986 bfd_putl32 (0, eiha->spare);
2987 bfd_putl64 (PRIV (transfer_address[0]), eiha->tfradr1);
2988 bfd_putl64 (PRIV (transfer_address[1]), eiha->tfradr2);
2989 bfd_putl64 (PRIV (transfer_address[2]), eiha->tfradr3);
2990 bfd_putl64 (PRIV (transfer_address[3]), eiha->tfradr4);
2991 bfd_putl64 (0, eiha->inishr);
2994 eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
2995 bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
2996 PRIV (file_pos) += sizeof (struct vms_eihi);
2998 bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
2999 bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
3004 module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
3005 len = strlen (module);
3006 if (len > sizeof (eihi->imgnam) - 1)
3007 len = sizeof (eihi->imgnam) - 1;
3008 eihi->imgnam[0] = len;
3009 memcpy (eihi->imgnam + 1, module, len);
3012 bfd_putl32 (0, eihi->linktime + 0);
3013 bfd_putl32 (0, eihi->linktime + 4);
3015 eihi->linkid[0] = 0;
3016 eihi->imgbid[0] = 0;
3019 dst = PRIV (dst_section);
3020 dmt = bfd_get_section_by_name (abfd, "$DMT$");
3021 if (dst != NULL && dst->size != 0)
3023 eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
3024 bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
3025 PRIV (file_pos) += sizeof (struct vms_eihs);
3027 bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
3028 bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
3029 bfd_putl32 (0, eihs->dstvbn);
3030 bfd_putl32 (0, eihs->dstsize);
3031 bfd_putl32 (0, eihs->gstvbn);
3032 bfd_putl32 (0, eihs->gstsize);
3033 bfd_putl32 (0, eihs->dmtvbn);
3034 bfd_putl32 (0, eihs->dmtsize);
3037 /* One EISD per section. */
3038 for (sec = abfd->sections; sec; sec = sec->next)
3040 if (!alpha_vms_create_eisd_for_section (abfd, sec))
3044 /* Merge section EIDS which extra ones. */
3045 if (PRIV (eisd_tail))
3046 PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
3048 PRIV (eisd_head) = PRIV (gbl_eisd_head);
3049 if (PRIV (gbl_eisd_tail))
3050 PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
3052 first_eisd = PRIV (eisd_head);
3054 /* Add end of eisd. */
3057 eisd = bfd_zalloc (abfd, sizeof (*eisd));
3060 eisd->u.eisd.majorid = 0;
3061 eisd->u.eisd.minorid = 0;
3062 eisd->u.eisd.eisdsize = 0;
3063 alpha_vms_append_extra_eisd (abfd, eisd);
3066 /* Place EISD in the file. */
3067 for (eisd = first_eisd; eisd; eisd = eisd->next)
3069 file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
3071 /* First block is a little bit special: there is a word at the end. */
3072 if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
3074 if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
3075 alpha_vms_file_position_block (abfd);
3077 eisd->file_pos = PRIV (file_pos);
3078 PRIV (file_pos) += eisd->u.eisd.eisdsize;
3080 if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
3081 bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
3084 if (first_eisd != NULL)
3086 bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
3087 /* Real size of end of eisd marker. */
3088 PRIV (file_pos) += EISD__K_LENEND;
3091 bfd_putl32 (PRIV (file_pos), eihd.size);
3092 bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
3095 /* Place sections. */
3096 for (sec = abfd->sections; sec; sec = sec->next)
3098 if (!(sec->flags & SEC_HAS_CONTENTS))
3101 eisd = vms_section_data (sec)->eisd;
3103 /* Align on a block. */
3104 alpha_vms_file_position_block (abfd);
3105 sec->filepos = PRIV (file_pos);
3108 eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
3110 PRIV (file_pos) += sec->size;
3114 if (eihs != NULL && dst != NULL)
3116 bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
3117 bfd_putl32 (dst->size, eihs->dstsize);
3121 lnkflags |= EIHD__M_DBGDMT;
3122 bfd_putl32 ((dmt->filepos / VMS_BLOCK_SIZE) + 1, eihs->dmtvbn);
3123 bfd_putl32 (dmt->size, eihs->dmtsize);
3125 if (PRIV (gsd_sym_count) != 0)
3127 alpha_vms_file_position_block (abfd);
3128 gst_filepos = PRIV (file_pos);
3129 bfd_putl32 ((gst_filepos / VMS_BLOCK_SIZE) + 1, eihs->gstvbn);
3130 bfd_putl32 ((PRIV (gsd_sym_count) + 4) / 5 + 4, eihs->gstsize);
3134 /* Write EISD in hdr. */
3135 for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
3137 alpha_vms_swap_eisd_out
3138 (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
3140 /* Write first block. */
3141 bfd_putl32 (lnkflags, eihd.lnkflags);
3142 if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
3145 /* Write remaining eisd. */
3148 unsigned char blk[VMS_BLOCK_SIZE];
3149 struct vms_internal_eisd_map *next_eisd;
3151 memset (blk, 0xff, sizeof (blk));
3152 while (eisd != NULL)
3154 alpha_vms_swap_eisd_out
3156 (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
3158 next_eisd = eisd->next;
3159 if (next_eisd == NULL
3160 || (next_eisd->file_pos / VMS_BLOCK_SIZE
3161 != eisd->file_pos / VMS_BLOCK_SIZE))
3163 if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
3166 memset (blk, 0xff, sizeof (blk));
3172 /* Write sections. */
3173 for (sec = abfd->sections; sec; sec = sec->next)
3175 unsigned char blk[VMS_BLOCK_SIZE];
3178 if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
3180 if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
3184 len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
3185 if (len != VMS_BLOCK_SIZE)
3187 memset (blk, 0, len);
3188 if (bfd_bwrite (blk, len, abfd) != len)
3194 if (gst_filepos != 0)
3196 struct vms_rec_wr *recwr = &PRIV (recwr);
3199 _bfd_vms_write_emh (abfd);
3200 _bfd_vms_write_lmn (abfd, "GNU LD");
3202 /* PSC for the absolute section. */
3203 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3204 _bfd_vms_output_long (recwr, 0);
3205 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3206 _bfd_vms_output_short (recwr, 0);
3207 _bfd_vms_output_short (recwr, EGPS__V_PIC | EGPS__V_LIB | EGPS__V_RD);
3208 _bfd_vms_output_long (recwr, 0);
3209 _bfd_vms_output_counted (recwr, ".$$ABS$$.");
3210 _bfd_vms_output_end_subrec (recwr);
3211 _bfd_vms_output_end (abfd, recwr);
3213 for (i = 0; i < PRIV (gsd_sym_count); i++)
3215 struct vms_symbol_entry *sym = PRIV (syms)[i];
3222 _bfd_vms_output_alignment (recwr, 8);
3223 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3224 _bfd_vms_output_long (recwr, 0);
3226 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYMG);
3227 _bfd_vms_output_short (recwr, 0); /* Data type, alignment. */
3228 _bfd_vms_output_short (recwr, sym->flags);
3230 if (sym->code_section)
3231 ep = alpha_vms_get_sym_value (sym->code_section, sym->code_value);
3234 BFD_ASSERT (sym->code_value == 0);
3237 val = alpha_vms_get_sym_value (sym->section, sym->value);
3238 _bfd_vms_output_quad
3239 (recwr, sym->typ == EGSD__C_SYMG ? sym->symbol_vector : val);
3240 _bfd_vms_output_quad (recwr, ep);
3241 _bfd_vms_output_quad (recwr, val);
3242 _bfd_vms_output_long (recwr, 0);
3243 hash = _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ__C_SYMSIZ);
3244 _bfd_vms_output_counted (recwr, hash);
3245 _bfd_vms_output_end_subrec (recwr);
3247 _bfd_vms_output_end (abfd, recwr);
3250 _bfd_vms_output_end (abfd, recwr);
3252 if (!_bfd_vms_write_eeom (abfd))
3260 /* Write section and symbol directory of bfd abfd. Return FALSE on error. */
3263 _bfd_vms_write_egsd (bfd *abfd)
3267 unsigned int symnum;
3268 int last_index = -1;
3269 char dummy_name[10];
3271 flagword new_flags, old_flags;
3272 int abs_section_index = 0;
3273 struct vms_rec_wr *recwr = &PRIV (recwr);
3275 vms_debug2 ((2, "vms_write_gsd\n"));
3277 /* Output sections. */
3278 section = abfd->sections;
3279 vms_debug2 ((3, "%d sections found\n", abfd->section_count));
3281 /* Egsd is quadword aligned. */
3282 _bfd_vms_output_alignment (recwr, 8);
3284 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3285 _bfd_vms_output_long (recwr, 0);
3287 while (section != 0)
3289 vms_debug2 ((3, "Section #%d %s, %d bytes\n",
3290 section->index, section->name, (int)section->size));
3292 /* Don't write out the VMS debug info section since it is in the
3293 ETBT and EDBG sections in etir. */
3294 if (!strcmp (section->name, ".vmsdebug"))
3297 /* 13 bytes egsd, max 31 chars name -> should be 44 bytes. */
3298 if (_bfd_vms_output_check (recwr, 64) < 0)
3300 _bfd_vms_output_end (abfd, recwr);
3301 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3302 _bfd_vms_output_long (recwr, 0);
3305 /* Create dummy sections to keep consecutive indices. */
3306 while (section->index - last_index > 1)
3308 vms_debug2 ((3, "index %d, last %d\n", section->index, last_index));
3309 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3310 _bfd_vms_output_short (recwr, 0);
3311 _bfd_vms_output_short (recwr, 0);
3312 _bfd_vms_output_long (recwr, 0);
3313 sprintf (dummy_name, ".DUMMY%02d", last_index);
3314 _bfd_vms_output_counted (recwr, dummy_name);
3315 _bfd_vms_output_end_subrec (recwr);
3319 /* Don't know if this is necessary for the linker but for now it keeps
3320 vms_slurp_gsd happy. */
3321 sname = section->name;
3324 /* Remove leading dot. */
3326 if ((*sname == 't') && (strcmp (sname, "text") == 0))
3327 sname = EVAX_CODE_NAME;
3328 else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
3329 sname = EVAX_DATA_NAME;
3330 else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
3331 sname = EVAX_BSS_NAME;
3332 else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
3333 sname = EVAX_LINK_NAME;
3334 else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
3335 sname = EVAX_READONLY_NAME;
3336 else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
3337 sname = EVAX_LITERAL_NAME;
3338 else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
3340 sname = EVAX_LITERALS_NAME;
3341 abs_section_index = section->index;
3343 else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
3344 sname = EVAX_COMMON_NAME;
3345 else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
3346 sname = EVAX_LOCAL_NAME;
3349 sname = _bfd_vms_length_hash_symbol (abfd, sname, EOBJ__C_SECSIZ);
3351 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3352 _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
3354 if (bfd_is_com_section (section))
3355 new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
3356 | EGPS__V_WRT | EGPS__V_NOMOD | EGPS__V_COM);
3358 new_flags = vms_esecflag_by_name (evax_section_flags, sname,
3361 /* Modify them as directed. */
3362 if (section->flags & SEC_READONLY)
3363 new_flags &= ~EGPS__V_WRT;
3365 new_flags &= ~vms_section_data (section)->no_flags;
3366 new_flags |= vms_section_data (section)->flags;
3368 vms_debug2 ((3, "sec flags %x\n", section->flags));
3369 vms_debug2 ((3, "new_flags %x, _raw_size %lu\n",
3370 new_flags, (unsigned long)section->size));
3372 _bfd_vms_output_short (recwr, new_flags);
3373 _bfd_vms_output_long (recwr, (unsigned long) section->size);
3374 _bfd_vms_output_counted (recwr, sname);
3375 _bfd_vms_output_end_subrec (recwr);
3377 last_index = section->index;
3379 section = section->next;
3382 /* Output symbols. */
3383 vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
3385 bfd_set_start_address (abfd, (bfd_vma) -1);
3387 for (symnum = 0; symnum < abfd->symcount; symnum++)
3391 symbol = abfd->outsymbols[symnum];
3392 old_flags = symbol->flags;
3394 /* Work-around a missing feature: consider __main as the main entry point. */
3395 if (*(symbol->name) == '_')
3397 if (strcmp (symbol->name, "__main") == 0)
3398 bfd_set_start_address (abfd, (bfd_vma)symbol->value);
3401 /* Only put in the GSD the global and the undefined symbols. */
3402 if (old_flags & BSF_FILE)
3405 if ((old_flags & BSF_GLOBAL) == 0 && !bfd_is_und_section (symbol->section))
3407 /* If the LIB$INITIIALIZE section is present, add a reference to
3408 LIB$INITIALIZE symbol. FIXME: this should be done explicitely
3409 in the assembly file. */
3410 if (!((old_flags & BSF_SECTION_SYM) != 0
3411 && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
3415 /* 13 bytes egsd, max 64 chars name -> should be 77 bytes. */
3416 if (_bfd_vms_output_check (recwr, 80) < 0)
3418 _bfd_vms_output_end (abfd, recwr);
3419 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3420 _bfd_vms_output_long (recwr, 0);
3423 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
3425 /* Data type, alignment. */
3426 _bfd_vms_output_short (recwr, 0);
3430 if (old_flags & BSF_WEAK)
3431 new_flags |= EGSY__V_WEAK;
3432 if (bfd_is_com_section (symbol->section)) /* .comm */
3433 new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
3435 if (old_flags & BSF_FUNCTION)
3437 new_flags |= EGSY__V_NORM;
3438 new_flags |= EGSY__V_REL;
3440 if (old_flags & BSF_GLOBAL)
3442 new_flags |= EGSY__V_DEF;
3443 if (!bfd_is_abs_section (symbol->section))
3444 new_flags |= EGSY__V_REL;
3446 _bfd_vms_output_short (recwr, new_flags);
3448 if (old_flags & BSF_GLOBAL)
3450 /* Symbol definition. */
3451 bfd_vma code_address = 0;
3452 unsigned long ca_psindx = 0;
3453 unsigned long psindx;
3455 if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
3459 sym = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
3460 code_address = sym->value;
3461 ca_psindx = sym->section->index;
3463 if (bfd_is_abs_section (symbol->section))
3464 psindx = abs_section_index;
3466 psindx = symbol->section->index;
3468 _bfd_vms_output_quad (recwr, symbol->value);
3469 _bfd_vms_output_quad (recwr, code_address);
3470 _bfd_vms_output_long (recwr, ca_psindx);
3471 _bfd_vms_output_long (recwr, psindx);
3473 hash = _bfd_vms_length_hash_symbol (abfd, symbol->name, EOBJ__C_SYMSIZ);
3474 _bfd_vms_output_counted (recwr, hash);
3476 _bfd_vms_output_end_subrec (recwr);
3479 _bfd_vms_output_alignment (recwr, 8);
3480 _bfd_vms_output_end (abfd, recwr);
3485 /* Write object header for bfd abfd. Return FALSE on error. */
3488 _bfd_vms_write_ehdr (bfd *abfd)
3491 unsigned int symnum;
3494 struct vms_rec_wr *recwr = &PRIV (recwr);
3496 vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
3498 _bfd_vms_output_alignment (recwr, 2);
3500 _bfd_vms_write_emh (abfd);
3501 _bfd_vms_write_lmn (abfd, "GNU AS");
3504 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3505 _bfd_vms_output_short (recwr, EMH__C_SRC);
3507 for (symnum = 0; symnum < abfd->symcount; symnum++)
3509 symbol = abfd->outsymbols[symnum];
3511 if (symbol->flags & BSF_FILE)
3513 if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
3515 PRIV (flag_hash_long_names) = symbol->name[6] - '0';
3516 PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
3524 _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
3525 (int) strlen (symbol->name));
3532 if (symnum == abfd->symcount)
3533 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
3535 _bfd_vms_output_end (abfd, recwr);
3538 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3539 _bfd_vms_output_short (recwr, EMH__C_TTL);
3540 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
3541 _bfd_vms_output_end (abfd, recwr);
3544 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3545 _bfd_vms_output_short (recwr, EMH__C_CPR);
3546 _bfd_vms_output_dump (recwr,
3547 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
3549 _bfd_vms_output_end (abfd, recwr);
3554 /* Part 4.6, relocations. */
3557 /* WRITE ETIR SECTION
3559 This is still under construction and therefore not documented. */
3561 /* Close the etir/etbt record. */
3564 end_etir_record (bfd * abfd)
3566 struct vms_rec_wr *recwr = &PRIV (recwr);
3568 _bfd_vms_output_end (abfd, recwr);
3572 start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
3574 struct vms_rec_wr *recwr = &PRIV (recwr);
3576 if (section->name[0] == '.' && section->name[1] == 'v'
3577 && !strcmp (section->name, ".vmsdebug"))
3579 _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
3583 /* Push start offset. */
3584 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3585 _bfd_vms_output_long (recwr, (unsigned long) 0);
3586 _bfd_vms_output_end_subrec (recwr);
3589 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
3590 _bfd_vms_output_end_subrec (recwr);
3595 _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
3599 /* Push start offset. */
3600 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3601 _bfd_vms_output_long (recwr, (unsigned long) section->index);
3602 _bfd_vms_output_quad (recwr, offset);
3603 _bfd_vms_output_end_subrec (recwr);
3605 /* Start = pop (). */
3606 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
3607 _bfd_vms_output_end_subrec (recwr);
3612 /* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
3613 address VADDR in section specified by SEC_INDEX and NAME. */
3616 sto_imm (bfd *abfd, asection *section,
3617 bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
3620 struct vms_rec_wr *recwr = &PRIV (recwr);
3623 _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
3624 _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
3629 /* Try all the rest. */
3632 if (_bfd_vms_output_check (recwr, size) < 0)
3634 /* Doesn't fit, split ! */
3635 end_etir_record (abfd);
3637 start_etir_or_etbt_record (abfd, section, vaddr);
3639 size = _bfd_vms_output_check (recwr, 0); /* get max size */
3640 if (size > ssize) /* more than what's left ? */
3644 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
3645 _bfd_vms_output_long (recwr, (unsigned long) (size));
3646 _bfd_vms_output_dump (recwr, cptr, size);
3647 _bfd_vms_output_end_subrec (recwr);
3650 _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
3651 _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
3661 etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
3663 if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
3665 /* Not enough room in this record. Close it and open a new one. */
3666 end_etir_record (abfd);
3667 start_etir_or_etbt_record (abfd, section, vaddr);
3671 /* Return whether RELOC must be deferred till the end. */
3674 defer_reloc_p (arelent *reloc)
3676 switch (reloc->howto->type)
3689 /* Write section contents for bfd abfd. Return FALSE on error. */
3692 _bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
3695 struct vms_rec_wr *recwr = &PRIV (recwr);
3697 vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
3699 _bfd_vms_output_alignment (recwr, 4);
3701 PRIV (vms_linkage_index) = 1;
3703 for (section = abfd->sections; section; section = section->next)
3705 vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
3706 section->index, section->name, (int) (section->size)));
3708 if (!(section->flags & SEC_HAS_CONTENTS)
3709 || bfd_is_com_section (section))
3712 if (!section->contents)
3714 bfd_set_error (bfd_error_no_contents);
3718 start_etir_or_etbt_record (abfd, section, 0);
3720 if (section->flags & SEC_RELOC)
3722 bfd_vma curr_addr = 0;
3723 unsigned char *curr_data = section->contents;
3725 int pass2_needed = 0;
3726 int pass2_in_progress = 0;
3729 if (section->reloc_count <= 0)
3730 (*_bfd_error_handler)
3731 (_("SEC_RELOC with no relocs in section %s"), section->name);
3736 int i = section->reloc_count;
3737 arelent **rptr = section->orelocation;
3738 _bfd_vms_debug (4, "%d relocations:\n", i);
3741 _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
3742 "addr %08lx, off %08lx, len %d: %s\n",
3743 (*(*rptr)->sym_ptr_ptr)->name,
3744 (*(*rptr)->sym_ptr_ptr)->section->name,
3745 (long) (*(*rptr)->sym_ptr_ptr)->value,
3746 (unsigned long)(*rptr)->address,
3747 (unsigned long)(*rptr)->addend,
3748 bfd_get_reloc_size ((*rptr)->howto),
3749 ( *rptr)->howto->name);
3756 for (irel = 0; irel < section->reloc_count; irel++)
3758 struct evax_private_udata_struct *udata;
3759 arelent *rptr = section->orelocation [irel];
3760 bfd_vma addr = rptr->address;
3761 asymbol *sym = *rptr->sym_ptr_ptr;
3762 asection *sec = sym->section;
3763 bfd_boolean defer = defer_reloc_p (rptr);
3767 if (pass2_in_progress)
3769 /* Non-deferred relocs have already been output. */
3775 /* Deferred relocs must be output at the very end. */
3782 /* Regular relocs are intertwined with binary data. */
3783 if (curr_addr > addr)
3784 (*_bfd_error_handler) (_("Size error in section %s"),
3786 size = addr - curr_addr;
3787 sto_imm (abfd, section, size, curr_data, curr_addr);
3792 size = bfd_get_reloc_size (rptr->howto);
3794 switch (rptr->howto->type)
3796 case ALPHA_R_IGNORE:
3799 case ALPHA_R_REFLONG:
3800 if (bfd_is_und_section (sym->section))
3802 bfd_vma addend = rptr->addend;
3803 slen = strlen ((char *) sym->name);
3804 hash = _bfd_vms_length_hash_symbol
3805 (abfd, sym->name, EOBJ__C_SYMSIZ);
3806 etir_output_check (abfd, section, curr_addr, slen);
3809 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3810 _bfd_vms_output_counted (recwr, hash);
3811 _bfd_vms_output_end_subrec (recwr);
3812 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3813 _bfd_vms_output_long (recwr, (unsigned long) addend);
3814 _bfd_vms_output_end_subrec (recwr);
3815 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3816 _bfd_vms_output_end_subrec (recwr);
3817 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3818 _bfd_vms_output_end_subrec (recwr);
3822 _bfd_vms_output_begin_subrec
3823 (recwr, ETIR__C_STO_GBL_LW);
3824 _bfd_vms_output_counted (recwr, hash);
3825 _bfd_vms_output_end_subrec (recwr);
3828 else if (bfd_is_abs_section (sym->section))
3830 etir_output_check (abfd, section, curr_addr, 16);
3831 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3832 _bfd_vms_output_long (recwr, (unsigned long) sym->value);
3833 _bfd_vms_output_end_subrec (recwr);
3834 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3835 _bfd_vms_output_end_subrec (recwr);
3839 etir_output_check (abfd, section, curr_addr, 32);
3840 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3841 _bfd_vms_output_long (recwr, (unsigned long) sec->index);
3842 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3843 _bfd_vms_output_end_subrec (recwr);
3844 /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
3845 says that we should have a ETIR__C_STO_OFF here.
3846 But the relocation would not be BFD_RELOC_32 then.
3847 This case is very likely unreachable. */
3848 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3849 _bfd_vms_output_end_subrec (recwr);
3853 case ALPHA_R_REFQUAD:
3854 if (bfd_is_und_section (sym->section))
3856 bfd_vma addend = rptr->addend;
3857 slen = strlen ((char *) sym->name);
3858 hash = _bfd_vms_length_hash_symbol
3859 (abfd, sym->name, EOBJ__C_SYMSIZ);
3860 etir_output_check (abfd, section, curr_addr, slen);
3863 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3864 _bfd_vms_output_counted (recwr, hash);
3865 _bfd_vms_output_end_subrec (recwr);
3866 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3867 _bfd_vms_output_quad (recwr, addend);
3868 _bfd_vms_output_end_subrec (recwr);
3869 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3870 _bfd_vms_output_end_subrec (recwr);
3871 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3872 _bfd_vms_output_end_subrec (recwr);
3876 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
3877 _bfd_vms_output_counted (recwr, hash);
3878 _bfd_vms_output_end_subrec (recwr);
3881 else if (bfd_is_abs_section (sym->section))
3883 etir_output_check (abfd, section, curr_addr, 16);
3884 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3885 _bfd_vms_output_quad (recwr, sym->value);
3886 _bfd_vms_output_end_subrec (recwr);
3887 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3888 _bfd_vms_output_end_subrec (recwr);
3892 etir_output_check (abfd, section, curr_addr, 32);
3893 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3894 _bfd_vms_output_long (recwr, (unsigned long) sec->index);
3895 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3896 _bfd_vms_output_end_subrec (recwr);
3897 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
3898 _bfd_vms_output_end_subrec (recwr);
3903 sto_imm (abfd, section, size, curr_data, curr_addr);
3906 case ALPHA_R_LINKAGE:
3907 etir_output_check (abfd, section, curr_addr, 64);
3908 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
3909 _bfd_vms_output_long
3910 (recwr, (unsigned long) PRIV (vms_linkage_index));
3911 PRIV (vms_linkage_index) += 2;
3912 hash = _bfd_vms_length_hash_symbol
3913 (abfd, sym->name, EOBJ__C_SYMSIZ);
3914 _bfd_vms_output_counted (recwr, hash);
3915 _bfd_vms_output_byte (recwr, 0);
3916 _bfd_vms_output_end_subrec (recwr);
3919 case ALPHA_R_CODEADDR:
3920 slen = strlen ((char *) sym->name);
3921 hash = _bfd_vms_length_hash_symbol
3922 (abfd, sym->name, EOBJ__C_SYMSIZ);
3923 etir_output_check (abfd, section, curr_addr, slen);
3924 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
3925 _bfd_vms_output_counted (recwr, hash);
3926 _bfd_vms_output_end_subrec (recwr);
3931 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3932 etir_output_check (abfd, section, curr_addr,
3933 32 + 1 + strlen (udata->origname));
3934 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
3935 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3936 _bfd_vms_output_long
3937 (recwr, (unsigned long) udata->enbsym->section->index);
3938 _bfd_vms_output_quad (recwr, rptr->address);
3939 _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3940 _bfd_vms_output_long
3941 (recwr, (unsigned long) udata->enbsym->section->index);
3942 _bfd_vms_output_quad (recwr, rptr->addend);
3943 _bfd_vms_output_counted
3944 (recwr, _bfd_vms_length_hash_symbol
3945 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3946 _bfd_vms_output_end_subrec (recwr);
3950 (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3955 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3956 etir_output_check (abfd, section, curr_addr,
3957 32 + 1 + strlen (udata->origname));
3958 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
3959 _bfd_vms_output_long
3960 (recwr, (unsigned long) udata->lkindex + 1);
3961 _bfd_vms_output_long
3962 (recwr, (unsigned long) udata->enbsym->section->index);
3963 _bfd_vms_output_quad (recwr, rptr->address);
3964 _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
3965 _bfd_vms_output_long
3966 (recwr, (unsigned long) udata->bsym->section->index);
3967 _bfd_vms_output_quad (recwr, rptr->addend);
3968 _bfd_vms_output_counted
3969 (recwr, _bfd_vms_length_hash_symbol
3970 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3971 _bfd_vms_output_end_subrec (recwr);
3976 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3977 etir_output_check (abfd, section, curr_addr,
3978 32 + 1 + strlen (udata->origname));
3979 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
3980 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3981 _bfd_vms_output_long
3982 (recwr, (unsigned long) udata->enbsym->section->index);
3983 _bfd_vms_output_quad (recwr, rptr->address);
3984 _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
3985 _bfd_vms_output_long
3986 (recwr, (unsigned long) udata->enbsym->section->index);
3987 _bfd_vms_output_quad (recwr, rptr->addend);
3988 _bfd_vms_output_counted
3989 (recwr, _bfd_vms_length_hash_symbol
3990 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3991 _bfd_vms_output_end_subrec (recwr);
3995 (*_bfd_error_handler) (_("Unhandled relocation %s"),
4002 } /* End of relocs loop. */
4004 if (!pass2_in_progress)
4006 /* Output rest of section. */
4007 if (curr_addr > section->size)
4008 (*_bfd_error_handler) (_("Size error in section %s"),
4010 size = section->size - curr_addr;
4011 sto_imm (abfd, section, size, curr_data, curr_addr);
4017 pass2_in_progress = 1;
4023 else /* (section->flags & SEC_RELOC) */
4024 sto_imm (abfd, section, section->size, section->contents, 0);
4026 end_etir_record (abfd);
4029 _bfd_vms_output_alignment (recwr, 2);
4033 /* Write cached information into a file being written, at bfd_close. */
4036 alpha_vms_write_object_contents (bfd *abfd)
4038 vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
4040 if (abfd->flags & (EXEC_P | DYNAMIC))
4042 return alpha_vms_write_exec (abfd);
4046 if (abfd->section_count > 0) /* we have sections */
4048 if (_bfd_vms_write_ehdr (abfd) != TRUE)
4050 if (_bfd_vms_write_egsd (abfd) != TRUE)
4052 if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
4054 if (_bfd_vms_write_eeom (abfd) != TRUE)
4061 /* Debug stuff: nearest line. */
4063 #define SET_MODULE_PARSED(m) \
4064 do { if ((m)->name == NULL) (m)->name = ""; } while (0)
4065 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
4067 /* Build a new module for the specified BFD. */
4069 static struct module *
4070 new_module (bfd *abfd)
4072 struct module *module
4073 = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
4074 module->file_table_count = 16; /* Arbitrary. */
4076 = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
4080 /* Parse debug info for a module and internalize it. */
4083 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
4086 unsigned char *maxptr = ptr + length;
4087 unsigned char *src_ptr, *pcl_ptr;
4088 unsigned int prev_linum = 0, curr_linenum = 0;
4089 bfd_vma prev_pc = 0, curr_pc = 0;
4090 struct srecinfo *curr_srec, *srec;
4091 struct lineinfo *curr_line, *line;
4092 struct funcinfo *funcinfo;
4094 /* Initialize tables with zero element. */
4095 curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4096 module->srec_table = curr_srec;
4098 curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4099 module->line_table = curr_line;
4101 while (length == -1 || ptr < maxptr)
4103 /* The first byte is not counted in the recorded length. */
4104 int rec_length = bfd_getl16 (ptr) + 1;
4105 int rec_type = bfd_getl16 (ptr + 2);
4107 vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4109 if (length == -1 && rec_type == DST__K_MODEND)
4116 = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4123 vms_debug2 ((3, "module: %s\n", module->name));
4130 funcinfo = (struct funcinfo *)
4131 bfd_zalloc (abfd, sizeof (struct funcinfo));
4133 = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4134 funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4135 funcinfo->next = module->func_table;
4136 module->func_table = funcinfo;
4138 vms_debug2 ((3, "routine: %s at 0x%lx\n",
4139 funcinfo->name, (unsigned long) funcinfo->low));
4143 module->func_table->high = module->func_table->low
4144 + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4146 if (module->func_table->high > module->high)
4147 module->high = module->func_table->high;
4149 vms_debug2 ((3, "end routine\n"));
4153 vms_debug2 ((3, "prologue\n"));
4157 vms_debug2 ((3, "epilog\n"));
4161 vms_debug2 ((3, "block\n"));
4165 vms_debug2 ((3, "end block\n"));
4169 src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4171 vms_debug2 ((3, "source info\n"));
4173 while (src_ptr < ptr + rec_length)
4175 int cmd = src_ptr[0], cmd_length, data;
4179 case DST__K_SRC_DECLFILE:
4182 = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4184 = _bfd_vms_save_counted_string (src_ptr
4185 + DST_S_B_SRC_DF_FILENAME);
4187 while (fileid >= module->file_table_count)
4189 module->file_table_count *= 2;
4191 = bfd_realloc (module->file_table,
4192 module->file_table_count
4193 * sizeof (struct fileinfo));
4196 module->file_table [fileid].name = filename;
4197 module->file_table [fileid].srec = 1;
4198 cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4199 vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4200 fileid, module->file_table [fileid].name));
4204 case DST__K_SRC_DEFLINES_B:
4205 /* Perform the association and set the next higher index
4207 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4208 srec = (struct srecinfo *)
4209 bfd_zalloc (abfd, sizeof (struct srecinfo));
4210 srec->line = curr_srec->line + data;
4211 srec->srec = curr_srec->srec + data;
4212 srec->sfile = curr_srec->sfile;
4213 curr_srec->next = srec;
4216 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4219 case DST__K_SRC_DEFLINES_W:
4220 /* Perform the association and set the next higher index
4222 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4223 srec = (struct srecinfo *)
4224 bfd_zalloc (abfd, sizeof (struct srecinfo));
4225 srec->line = curr_srec->line + data;
4226 srec->srec = curr_srec->srec + data,
4227 srec->sfile = curr_srec->sfile;
4228 curr_srec->next = srec;
4231 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4234 case DST__K_SRC_INCRLNUM_B:
4235 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4236 curr_srec->line += data;
4238 vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4241 case DST__K_SRC_SETFILE:
4242 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4243 curr_srec->sfile = data;
4244 curr_srec->srec = module->file_table[data].srec;
4246 vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4249 case DST__K_SRC_SETLNUM_L:
4250 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4251 curr_srec->line = data;
4253 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4256 case DST__K_SRC_SETLNUM_W:
4257 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4258 curr_srec->line = data;
4260 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4263 case DST__K_SRC_SETREC_L:
4264 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4265 curr_srec->srec = data;
4266 module->file_table[curr_srec->sfile].srec = data;
4268 vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4271 case DST__K_SRC_SETREC_W:
4272 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4273 curr_srec->srec = data;
4274 module->file_table[curr_srec->sfile].srec = data;
4276 vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4279 case DST__K_SRC_FORMFEED:
4281 vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4285 (*_bfd_error_handler) (_("unknown source command %d"),
4291 src_ptr += cmd_length;
4295 case DST__K_LINE_NUM:
4296 pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4298 vms_debug2 ((3, "line info\n"));
4300 while (pcl_ptr < ptr + rec_length)
4302 /* The command byte is signed so we must sign-extend it. */
4303 int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4307 case DST__K_DELTA_PC_W:
4308 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4312 vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4315 case DST__K_DELTA_PC_L:
4316 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4320 vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4323 case DST__K_INCR_LINUM:
4324 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4325 curr_linenum += data;
4327 vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4330 case DST__K_INCR_LINUM_W:
4331 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4332 curr_linenum += data;
4334 vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4337 case DST__K_INCR_LINUM_L:
4338 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4339 curr_linenum += data;
4341 vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4344 case DST__K_SET_LINUM_INCR:
4345 (*_bfd_error_handler)
4346 (_("DST__K_SET_LINUM_INCR not implemented"));
4350 case DST__K_SET_LINUM_INCR_W:
4351 (*_bfd_error_handler)
4352 (_("DST__K_SET_LINUM_INCR_W not implemented"));
4356 case DST__K_RESET_LINUM_INCR:
4357 (*_bfd_error_handler)
4358 (_("DST__K_RESET_LINUM_INCR not implemented"));
4362 case DST__K_BEG_STMT_MODE:
4363 (*_bfd_error_handler)
4364 (_("DST__K_BEG_STMT_MODE not implemented"));
4368 case DST__K_END_STMT_MODE:
4369 (*_bfd_error_handler)
4370 (_("DST__K_END_STMT_MODE not implemented"));
4374 case DST__K_SET_LINUM_B:
4375 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4376 curr_linenum = data;
4378 vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4381 case DST__K_SET_LINUM:
4382 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4383 curr_linenum = data;
4385 vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4388 case DST__K_SET_LINUM_L:
4389 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4390 curr_linenum = data;
4392 vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4396 (*_bfd_error_handler)
4397 (_("DST__K_SET_PC not implemented"));
4401 case DST__K_SET_PC_W:
4402 (*_bfd_error_handler)
4403 (_("DST__K_SET_PC_W not implemented"));
4407 case DST__K_SET_PC_L:
4408 (*_bfd_error_handler)
4409 (_("DST__K_SET_PC_L not implemented"));
4413 case DST__K_SET_STMTNUM:
4414 (*_bfd_error_handler)
4415 (_("DST__K_SET_STMTNUM not implemented"));
4420 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4423 vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4427 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4430 vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4434 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4437 vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
4440 case DST__K_SET_ABS_PC:
4441 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4444 vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4453 vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4454 (unsigned long)curr_pc, curr_linenum));
4458 (*_bfd_error_handler) (_("unknown line command %d"),
4465 if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4467 || cmd == DST__K_DELTA_PC_L
4468 || cmd == DST__K_DELTA_PC_W)
4470 line = (struct lineinfo *)
4471 bfd_zalloc (abfd, sizeof (struct lineinfo));
4472 line->address = curr_pc;
4473 line->line = curr_linenum;
4475 curr_line->next = line;
4478 prev_linum = curr_linenum;
4480 vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4481 (unsigned long)curr_pc, curr_linenum));
4484 pcl_ptr += cmd_length;
4488 case 0x17: /* Undocumented type used by DEC C to declare equates. */
4489 vms_debug2 ((3, "undocumented type 0x17\n"));
4493 vms_debug2 ((3, "ignoring record\n"));
4501 /* Finalize tables with EOL marker. */
4502 srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4503 srec->line = (unsigned int) -1;
4504 srec->srec = (unsigned int) -1;
4505 curr_srec->next = srec;
4507 line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4508 line->line = (unsigned int) -1;
4509 line->address = (bfd_vma) -1;
4510 curr_line->next = line;
4512 /* Advertise that this module has been parsed. This is needed
4513 because parsing can be either performed at module creation
4514 or deferred until debug info is consumed. */
4515 SET_MODULE_PARSED (module);
4518 /* Build the list of modules for the specified BFD. */
4520 static struct module *
4521 build_module_list (bfd *abfd)
4523 struct module *module, *list = NULL;
4526 if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4528 /* We have a DMT section so this must be an image. Parse the
4529 section and build the list of modules. This is sufficient
4530 since we can compute the start address and the end address
4531 of every module from the section contents. */
4532 bfd_size_type size = bfd_get_section_size (dmt);
4533 unsigned char *ptr, *end;
4535 ptr = (unsigned char *) bfd_alloc (abfd, size);
4539 if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4542 vms_debug2 ((2, "DMT\n"));
4548 /* Each header declares a module with its start offset and size
4549 of debug info in the DST section, as well as the count of
4550 program sections (i.e. address spans) it contains. */
4551 int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4552 int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4553 int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4554 ptr += DBG_S_C_DMT_HEADER_SIZE;
4556 vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4557 modbeg, msize, count));
4559 /* We create a 'module' structure for each program section since
4560 we only support contiguous addresses in a 'module' structure.
4561 As a consequence, the actual debug info in the DST section is
4562 shared and can be parsed multiple times; that doesn't seem to
4563 cause problems in practice. */
4566 int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4567 int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4568 module = new_module (abfd);
4569 module->modbeg = modbeg;
4570 module->size = msize;
4571 module->low = start;
4572 module->high = start + length;
4573 module->next = list;
4575 ptr += DBG_S_C_DMT_PSECT_SIZE;
4577 vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4584 /* We don't have a DMT section so this must be an object. Parse
4585 the module right now in order to compute its start address and
4587 module = new_module (abfd);
4588 parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4595 /* Calculate and return the name of the source file and the line nearest
4596 to the wanted location in the specified module. */
4599 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4600 const char **file, const char **func,
4603 struct funcinfo *funcinfo;
4604 struct lineinfo *lineinfo;
4605 struct srecinfo *srecinfo;
4606 bfd_boolean ret = FALSE;
4608 /* Parse this module if that was not done at module creation. */
4609 if (! IS_MODULE_PARSED (module))
4611 unsigned int size = module->size;
4612 unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4613 unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4615 if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4616 || bfd_bread (buffer, size, abfd) != size)
4618 bfd_set_error (bfd_error_no_debug_section);
4622 parse_module (abfd, module, buffer, size);
4626 /* Find out the function (if any) that contains the address. */
4627 for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4628 if (addr >= funcinfo->low && addr <= funcinfo->high)
4630 *func = funcinfo->name;
4635 /* Find out the source file and the line nearest to the address. */
4636 for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4637 if (lineinfo->next && addr < lineinfo->next->address)
4639 for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4640 if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4642 if (srecinfo->sfile > 0)
4644 *file = module->file_table[srecinfo->sfile].name;
4645 *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4649 *file = module->name;
4650 *line = lineinfo->line;
4661 /* Provided a BFD, a section and an offset into the section, calculate and
4662 return the name of the source file and the line nearest to the wanted
4666 _bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
4667 asymbol **symbols ATTRIBUTE_UNUSED,
4668 bfd_vma offset, const char **file,
4669 const char **func, unsigned int *line)
4671 struct module *module;
4673 /* What address are we looking for? */
4674 bfd_vma addr = section->vma + offset;
4680 if (PRIV (dst_section) == NULL || !(abfd->flags & (EXEC_P | DYNAMIC)))
4683 if (PRIV (modules) == NULL)
4685 PRIV (modules) = build_module_list (abfd);
4686 if (PRIV (modules) == NULL)
4690 for (module = PRIV (modules); module; module = module->next)
4691 if (addr >= module->low && addr <= module->high)
4692 return module_find_nearest_line (abfd, module, addr, file, func, line);
4697 /* Canonicalizations. */
4698 /* Set name, value, section and flags of SYM from E. */
4701 alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4710 flags = BSF_NO_FLAGS;
4716 if (e->flags & EGSY__V_WEAK)
4719 if (e->flags & EGSY__V_DEF)
4721 /* Symbol definition. */
4722 flags |= BSF_GLOBAL;
4723 if (e->flags & EGSY__V_NORM)
4724 flags |= BSF_FUNCTION;
4730 /* Symbol reference. */
4731 sec = bfd_und_section_ptr;
4736 /* A universal symbol is by definition global... */
4737 flags |= BSF_GLOBAL;
4739 /* ...and dynamic in shared libraries. */
4740 if (abfd->flags & DYNAMIC)
4741 flags |= BSF_DYNAMIC;
4743 if (e->flags & EGSY__V_WEAK)
4746 if (!(e->flags & EGSY__V_DEF))
4749 if (e->flags & EGSY__V_NORM)
4750 flags |= BSF_FUNCTION;
4753 /* sec = e->section; */
4754 sec = bfd_abs_section_ptr;
4769 /* Return the number of bytes required to store a vector of pointers
4770 to asymbols for all the symbols in the BFD abfd, including a
4771 terminal NULL pointer. If there are no symbols in the BFD,
4772 then return 0. If an error occurs, return -1. */
4775 alpha_vms_get_symtab_upper_bound (bfd *abfd)
4777 vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4778 abfd, PRIV (gsd_sym_count)));
4780 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4783 /* Read the symbols from the BFD abfd, and fills in the vector
4784 location with pointers to the symbols and a trailing NULL.
4786 Return number of symbols read. */
4789 alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4793 vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4795 if (PRIV (csymbols) == NULL)
4797 PRIV (csymbols) = (asymbol **) bfd_alloc
4798 (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4800 /* Traverse table and fill symbols vector. */
4801 for (i = 0; i < PRIV (gsd_sym_count); i++)
4803 struct vms_symbol_entry *e = PRIV (syms)[i];
4806 sym = bfd_make_empty_symbol (abfd);
4807 if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4809 bfd_release (abfd, PRIV (csymbols));
4810 PRIV (csymbols) = NULL;
4814 PRIV (csymbols)[i] = sym;
4818 if (symbols != NULL)
4820 for (i = 0; i < PRIV (gsd_sym_count); i++)
4821 symbols[i] = PRIV (csymbols)[i];
4825 return PRIV (gsd_sym_count);
4828 /* Read and convert relocations from ETIR. We do it once for all sections. */
4831 alpha_vms_slurp_relocs (bfd *abfd)
4835 vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4837 /* We slurp relocs only once, for all sections. */
4838 if (PRIV (reloc_done))
4840 PRIV (reloc_done) = TRUE;
4842 if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4845 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4850 unsigned char *begin;
4853 bfd_reloc_code_real_type reloc_code;
4859 bfd_vma cur_address;
4861 unsigned char *cur_sym = NULL;
4863 bfd_vma cur_addend = 0;
4865 /* Skip non-ETIR records. */
4866 type = _bfd_vms_get_object_record (abfd);
4867 if (type == EOBJ__C_EEOM)
4869 if (type != EOBJ__C_ETIR)
4872 begin = PRIV (recrd.rec) + 4;
4873 end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4875 for (ptr = begin; ptr < end; ptr += length)
4879 cmd = bfd_getl16 (ptr);
4880 length = bfd_getl16 (ptr + 2);
4882 cur_address = vaddr;
4884 vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4885 _bfd_vms_etir_name (cmd)));
4889 case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4890 /* ALPHA_R_REFQUAD und_section, step 1 */
4895 case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4896 cur_psidx = bfd_getl32 (ptr + 4);
4897 cur_addend = bfd_getl64 (ptr + 8);
4901 case ETIR__C_CTL_SETRB:
4902 if (prev_cmd != ETIR__C_STA_PQ)
4904 (*_bfd_error_handler)
4905 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4906 _bfd_vms_etir_name (cmd));
4909 cur_psect = cur_psidx;
4915 case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4916 /* ALPHA_R_REFLONG und_section, step 2 */
4919 if (prev_cmd != ETIR__C_STA_GBL)
4921 (*_bfd_error_handler)
4922 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4923 _bfd_vms_etir_name (ETIR__C_STA_LW));
4927 cur_addend = bfd_getl32 (ptr + 4);
4931 case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4932 /* ALPHA_R_REFQUAD und_section, step 2 */
4933 if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4935 (*_bfd_error_handler)
4936 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4937 _bfd_vms_etir_name (ETIR__C_STA_QW));
4940 cur_addend = bfd_getl64 (ptr + 4);
4944 case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4945 /* ALPHA_R_REFLONG abs_section, step 2 */
4946 /* ALPHA_R_REFLONG others, step 2 */
4947 if (prev_cmd != ETIR__C_OPR_ADD
4948 && prev_cmd != ETIR__C_STA_LW
4949 && prev_cmd != ETIR__C_STA_PQ)
4951 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4952 _bfd_vms_etir_name (prev_cmd),
4953 _bfd_vms_etir_name (ETIR__C_STO_LW));
4956 reloc_code = BFD_RELOC_32;
4959 case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
4960 /* ALPHA_R_REFQUAD abs_section, step 2 */
4961 if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
4963 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4964 _bfd_vms_etir_name (prev_cmd),
4965 _bfd_vms_etir_name (ETIR__C_STO_QW));
4968 reloc_code = BFD_RELOC_64;
4971 case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
4972 if (prev_cmd != ETIR__C_STA_PQ)
4974 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4975 _bfd_vms_etir_name (prev_cmd),
4976 _bfd_vms_etir_name (ETIR__C_STO_OFF));
4979 reloc_code = BFD_RELOC_64;
4982 case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
4983 /* ALPHA_R_REFQUAD und_section, step 3 */
4984 if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
4986 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4987 _bfd_vms_etir_name (prev_cmd),
4988 _bfd_vms_etir_name (ETIR__C_OPR_ADD));
4991 prev_cmd = ETIR__C_OPR_ADD;
4994 case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
4995 reloc_code = BFD_RELOC_ALPHA_CODEADDR;
4999 case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
5000 reloc_code = BFD_RELOC_64;
5004 case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
5005 reloc_code = BFD_RELOC_32;
5009 case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
5010 reloc_code = BFD_RELOC_ALPHA_LINKAGE;
5014 case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
5015 reloc_code = BFD_RELOC_ALPHA_NOP;
5018 case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
5019 reloc_code = BFD_RELOC_ALPHA_BSR;
5022 case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
5023 reloc_code = BFD_RELOC_ALPHA_LDA;
5026 case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
5027 reloc_code = BFD_RELOC_ALPHA_BOH;
5031 cur_sym = ptr + 4 + 32;
5032 cur_address = bfd_getl64 (ptr + 4 + 8);
5033 cur_addend = bfd_getl64 (ptr + 4 + 24);
5036 case ETIR__C_STO_IMM:
5037 vaddr += bfd_getl32 (ptr + 4);
5041 (*_bfd_error_handler) (_("Unknown reloc %s"),
5042 _bfd_vms_etir_name (cmd));
5048 struct vms_section_data_struct *vms_sec;
5051 /* Get section to which the relocation applies. */
5052 if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
5054 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
5057 sec = PRIV (sections)[cur_psect];
5058 vms_sec = vms_section_data (sec);
5060 /* Allocate a reloc entry. */
5061 if (sec->reloc_count >= vms_sec->reloc_max)
5063 if (vms_sec->reloc_max == 0)
5065 vms_sec->reloc_max = 64;
5066 sec->relocation = bfd_zmalloc
5067 (vms_sec->reloc_max * sizeof (arelent));
5071 vms_sec->reloc_max *= 2;
5072 sec->relocation = bfd_realloc
5073 (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5076 reloc = &sec->relocation[sec->reloc_count];
5079 reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5081 if (cur_sym != NULL)
5084 unsigned int symlen = *cur_sym;
5087 /* Linear search. */
5092 for (j = 0; j < PRIV (gsd_sym_count); j++)
5093 if (PRIV (syms)[j]->namelen == symlen
5094 && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5096 sym = &PRIV (csymbols)[j];
5101 (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5102 _bfd_vms_etir_name (cmd));
5103 reloc->sym_ptr_ptr = NULL;
5106 reloc->sym_ptr_ptr = sym;
5108 else if (cur_psidx >= 0)
5109 reloc->sym_ptr_ptr =
5110 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5112 reloc->sym_ptr_ptr = NULL;
5114 reloc->address = cur_address;
5115 reloc->addend = cur_addend;
5117 vaddr += bfd_get_reloc_size (reloc->howto);
5126 vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5131 /* Return the number of bytes required to store the relocation
5132 information associated with the given section. */
5135 alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5137 alpha_vms_slurp_relocs (abfd);
5139 return (section->reloc_count + 1) * sizeof (arelent *);
5142 /* Convert relocations from VMS (external) form into BFD internal
5143 form. Return the number of relocations. */
5146 alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5147 asymbol **symbols ATTRIBUTE_UNUSED)
5152 if (!alpha_vms_slurp_relocs (abfd))
5155 count = section->reloc_count;
5156 tblptr = section->relocation;
5159 *relptr++ = tblptr++;
5161 *relptr = (arelent *) NULL;
5162 return section->reloc_count;
5165 /* This is just copied from ecoff-alpha, needs to be fixed probably. */
5167 /* How to process the various reloc types. */
5169 static bfd_reloc_status_type
5170 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5171 arelent *reloc ATTRIBUTE_UNUSED,
5172 asymbol *sym ATTRIBUTE_UNUSED,
5173 void * data ATTRIBUTE_UNUSED,
5174 asection *sec ATTRIBUTE_UNUSED,
5175 bfd *output_bfd ATTRIBUTE_UNUSED,
5176 char **error_message ATTRIBUTE_UNUSED)
5179 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5180 vms_debug (2, "In section %s, symbol %s\n",
5181 sec->name, sym->name);
5182 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5183 reloc->sym_ptr_ptr[0]->name,
5184 (unsigned long)reloc->address,
5185 (unsigned long)reloc->addend, reloc->howto->name);
5186 vms_debug (2, "data at %p\n", data);
5187 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5190 return bfd_reloc_ok;
5193 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5194 from smaller values. Start with zero, widen, *then* decrement. */
5195 #define MINUS_ONE (((bfd_vma)0) - 1)
5197 static reloc_howto_type alpha_howto_table[] =
5199 HOWTO (ALPHA_R_IGNORE, /* Type. */
5200 0, /* Rightshift. */
5201 0, /* Size (0 = byte, 1 = short, 2 = long). */
5203 TRUE, /* PC relative. */
5205 complain_overflow_dont,/* Complain_on_overflow. */
5206 reloc_nil, /* Special_function. */
5207 "IGNORE", /* Name. */
5208 TRUE, /* Partial_inplace. */
5209 0, /* Source mask */
5211 TRUE), /* PC rel offset. */
5213 /* A 64 bit reference to a symbol. */
5214 HOWTO (ALPHA_R_REFQUAD, /* Type. */
5215 0, /* Rightshift. */
5216 4, /* Size (0 = byte, 1 = short, 2 = long). */
5218 FALSE, /* PC relative. */
5220 complain_overflow_bitfield, /* Complain_on_overflow. */
5221 reloc_nil, /* Special_function. */
5222 "REFQUAD", /* Name. */
5223 TRUE, /* Partial_inplace. */
5224 MINUS_ONE, /* Source mask. */
5225 MINUS_ONE, /* Dest mask. */
5226 FALSE), /* PC rel offset. */
5228 /* A 21 bit branch. The native assembler generates these for
5229 branches within the text segment, and also fills in the PC
5230 relative offset in the instruction. */
5231 HOWTO (ALPHA_R_BRADDR, /* Type. */
5232 2, /* Rightshift. */
5233 2, /* Size (0 = byte, 1 = short, 2 = long). */
5235 TRUE, /* PC relative. */
5237 complain_overflow_signed, /* Complain_on_overflow. */
5238 reloc_nil, /* Special_function. */
5239 "BRADDR", /* Name. */
5240 TRUE, /* Partial_inplace. */
5241 0x1fffff, /* Source mask. */
5242 0x1fffff, /* Dest mask. */
5243 FALSE), /* PC rel offset. */
5245 /* A hint for a jump to a register. */
5246 HOWTO (ALPHA_R_HINT, /* Type. */
5247 2, /* Rightshift. */
5248 1, /* Size (0 = byte, 1 = short, 2 = long). */
5250 TRUE, /* PC relative. */
5252 complain_overflow_dont,/* Complain_on_overflow. */
5253 reloc_nil, /* Special_function. */
5255 TRUE, /* Partial_inplace. */
5256 0x3fff, /* Source mask. */
5257 0x3fff, /* Dest mask. */
5258 FALSE), /* PC rel offset. */
5260 /* 16 bit PC relative offset. */
5261 HOWTO (ALPHA_R_SREL16, /* Type. */
5262 0, /* Rightshift. */
5263 1, /* Size (0 = byte, 1 = short, 2 = long). */
5265 TRUE, /* PC relative. */
5267 complain_overflow_signed, /* Complain_on_overflow. */
5268 reloc_nil, /* Special_function. */
5269 "SREL16", /* Name. */
5270 TRUE, /* Partial_inplace. */
5271 0xffff, /* Source mask. */
5272 0xffff, /* Dest mask. */
5273 FALSE), /* PC rel offset. */
5275 /* 32 bit PC relative offset. */
5276 HOWTO (ALPHA_R_SREL32, /* Type. */
5277 0, /* Rightshift. */
5278 2, /* Size (0 = byte, 1 = short, 2 = long). */
5280 TRUE, /* PC relative. */
5282 complain_overflow_signed, /* Complain_on_overflow. */
5283 reloc_nil, /* Special_function. */
5284 "SREL32", /* Name. */
5285 TRUE, /* Partial_inplace. */
5286 0xffffffff, /* Source mask. */
5287 0xffffffff, /* Dest mask. */
5288 FALSE), /* PC rel offset. */
5290 /* A 64 bit PC relative offset. */
5291 HOWTO (ALPHA_R_SREL64, /* Type. */
5292 0, /* Rightshift. */
5293 4, /* Size (0 = byte, 1 = short, 2 = long). */
5295 TRUE, /* PC relative. */
5297 complain_overflow_signed, /* Complain_on_overflow. */
5298 reloc_nil, /* Special_function. */
5299 "SREL64", /* Name. */
5300 TRUE, /* Partial_inplace. */
5301 MINUS_ONE, /* Source mask. */
5302 MINUS_ONE, /* Dest mask. */
5303 FALSE), /* PC rel offset. */
5305 /* Push a value on the reloc evaluation stack. */
5306 HOWTO (ALPHA_R_OP_PUSH, /* Type. */
5307 0, /* Rightshift. */
5308 0, /* Size (0 = byte, 1 = short, 2 = long). */
5310 FALSE, /* PC relative. */
5312 complain_overflow_dont,/* Complain_on_overflow. */
5313 reloc_nil, /* Special_function. */
5314 "OP_PUSH", /* Name. */
5315 FALSE, /* Partial_inplace. */
5316 0, /* Source mask. */
5318 FALSE), /* PC rel offset. */
5320 /* Store the value from the stack at the given address. Store it in
5321 a bitfield of size r_size starting at bit position r_offset. */
5322 HOWTO (ALPHA_R_OP_STORE, /* Type. */
5323 0, /* Rightshift. */
5324 4, /* Size (0 = byte, 1 = short, 2 = long). */
5326 FALSE, /* PC relative. */
5328 complain_overflow_dont,/* Complain_on_overflow. */
5329 reloc_nil, /* Special_function. */
5330 "OP_STORE", /* Name. */
5331 FALSE, /* Partial_inplace. */
5332 0, /* Source mask. */
5333 MINUS_ONE, /* Dest mask. */
5334 FALSE), /* PC rel offset. */
5336 /* Subtract the reloc address from the value on the top of the
5337 relocation stack. */
5338 HOWTO (ALPHA_R_OP_PSUB, /* Type. */
5339 0, /* Rightshift. */
5340 0, /* Size (0 = byte, 1 = short, 2 = long). */
5342 FALSE, /* PC relative. */
5344 complain_overflow_dont,/* Complain_on_overflow. */
5345 reloc_nil, /* Special_function. */
5346 "OP_PSUB", /* Name. */
5347 FALSE, /* Partial_inplace. */
5348 0, /* Source mask. */
5350 FALSE), /* PC rel offset. */
5352 /* Shift the value on the top of the relocation stack right by the
5354 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */
5355 0, /* Rightshift. */
5356 0, /* Size (0 = byte, 1 = short, 2 = long). */
5358 FALSE, /* PC relative. */
5360 complain_overflow_dont,/* Complain_on_overflow. */
5361 reloc_nil, /* Special_function. */
5362 "OP_PRSHIFT", /* Name. */
5363 FALSE, /* Partial_inplace. */
5364 0, /* Source mask. */
5366 FALSE), /* PC rel offset. */
5368 /* Hack. Linkage is done by linker. */
5369 HOWTO (ALPHA_R_LINKAGE, /* Type. */
5370 0, /* Rightshift. */
5371 8, /* Size (0 = byte, 1 = short, 2 = long). */
5373 FALSE, /* PC relative. */
5375 complain_overflow_dont,/* Complain_on_overflow. */
5376 reloc_nil, /* Special_function. */
5377 "LINKAGE", /* Name. */
5378 FALSE, /* Partial_inplace. */
5379 0, /* Source mask. */
5381 FALSE), /* PC rel offset. */
5383 /* A 32 bit reference to a symbol. */
5384 HOWTO (ALPHA_R_REFLONG, /* Type. */
5385 0, /* Rightshift. */
5386 2, /* Size (0 = byte, 1 = short, 2 = long). */
5388 FALSE, /* PC relative. */
5390 complain_overflow_bitfield, /* Complain_on_overflow. */
5391 reloc_nil, /* Special_function. */
5392 "REFLONG", /* Name. */
5393 TRUE, /* Partial_inplace. */
5394 0xffffffff, /* Source mask. */
5395 0xffffffff, /* Dest mask. */
5396 FALSE), /* PC rel offset. */
5398 /* A 64 bit reference to a procedure, written as 32 bit value. */
5399 HOWTO (ALPHA_R_CODEADDR, /* Type. */
5400 0, /* Rightshift. */
5401 4, /* Size (0 = byte, 1 = short, 2 = long). */
5403 FALSE, /* PC relative. */
5405 complain_overflow_signed,/* Complain_on_overflow. */
5406 reloc_nil, /* Special_function. */
5407 "CODEADDR", /* Name. */
5408 FALSE, /* Partial_inplace. */
5409 0xffffffff, /* Source mask. */
5410 0xffffffff, /* Dest mask. */
5411 FALSE), /* PC rel offset. */
5413 HOWTO (ALPHA_R_NOP, /* Type. */
5414 0, /* Rightshift. */
5415 3, /* Size (0 = byte, 1 = short, 2 = long). */
5417 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5418 because the calculations for the 3 relocations are the same.
5419 See B.4.5.2 of the OpenVMS Linker Utility Manual. */
5420 TRUE, /* PC relative. */
5422 complain_overflow_dont,/* Complain_on_overflow. */
5423 reloc_nil, /* Special_function. */
5425 FALSE, /* Partial_inplace. */
5426 0xffffffff, /* Source mask. */
5427 0xffffffff, /* Dest mask. */
5428 FALSE), /* PC rel offset. */
5430 HOWTO (ALPHA_R_BSR, /* Type. */
5431 0, /* Rightshift. */
5432 3, /* Size (0 = byte, 1 = short, 2 = long). */
5434 TRUE, /* PC relative. */
5436 complain_overflow_dont,/* Complain_on_overflow. */
5437 reloc_nil, /* Special_function. */
5439 FALSE, /* Partial_inplace. */
5440 0xffffffff, /* Source mask. */
5441 0xffffffff, /* Dest mask. */
5442 FALSE), /* PC rel offset. */
5444 HOWTO (ALPHA_R_LDA, /* Type. */
5445 0, /* Rightshift. */
5446 3, /* Size (0 = byte, 1 = short, 2 = long). */
5448 FALSE, /* PC relative. */
5450 complain_overflow_dont,/* Complain_on_overflow. */
5451 reloc_nil, /* Special_function. */
5453 FALSE, /* Partial_inplace. */
5454 0xffffffff, /* Source mask. */
5455 0xffffffff, /* Dest mask. */
5456 FALSE), /* PC rel offset. */
5458 HOWTO (ALPHA_R_BOH, /* Type. */
5459 0, /* Rightshift. */
5460 3, /* Size (0 = byte, 1 = short, 2 = long, 3 = nil). */
5462 TRUE, /* PC relative. */
5464 complain_overflow_dont,/* Complain_on_overflow. */
5465 reloc_nil, /* Special_function. */
5467 FALSE, /* Partial_inplace. */
5468 0xffffffff, /* Source mask. */
5469 0xffffffff, /* Dest mask. */
5470 FALSE), /* PC rel offset. */
5473 /* Return a pointer to a howto structure which, when invoked, will perform
5474 the relocation code on data from the architecture noted. */
5476 static const struct reloc_howto_struct *
5477 alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5478 bfd_reloc_code_real_type code)
5482 vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5486 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break;
5487 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break;
5488 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break;
5489 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break;
5490 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break;
5491 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break;
5492 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break;
5493 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break;
5494 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break;
5495 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break;
5496 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break;
5497 case BFD_RELOC_ALPHA_NOP: alpha_type = ALPHA_R_NOP; break;
5498 case BFD_RELOC_ALPHA_BSR: alpha_type = ALPHA_R_BSR; break;
5499 case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
5500 case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
5502 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5505 vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5506 return & alpha_howto_table[alpha_type];
5509 static reloc_howto_type *
5510 alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5516 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5518 if (alpha_howto_table[i].name != NULL
5519 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5520 return &alpha_howto_table[i];
5526 alpha_vms_get_synthetic_symtab (bfd *abfd,
5527 long symcount ATTRIBUTE_UNUSED,
5528 asymbol **usyms ATTRIBUTE_UNUSED,
5529 long dynsymcount ATTRIBUTE_UNUSED,
5530 asymbol **dynsyms ATTRIBUTE_UNUSED,
5537 syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5542 for (i = 0; i < PRIV (gsd_sym_count); i++)
5544 struct vms_symbol_entry *e = PRIV (syms)[i];
5555 flags = BSF_LOCAL | BSF_SYNTHETIC;
5562 if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5564 value = e->code_value;
5565 sec = e->code_section;
5576 sname = bfd_alloc (abfd, l + 5);
5579 memcpy (sname, name, l);
5580 memcpy (sname + l, "..en", 5);
5587 sym->udata.p = NULL;
5596 vms_time_to_str (unsigned char *buf)
5598 time_t t = vms_rawtime_to_time_t (buf);
5599 char *res = ctime (&t);
5602 res = "*invalid time*";
5609 evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5611 struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5612 unsigned int subtype;
5614 subtype = (unsigned)bfd_getl16 (emh->subtyp);
5616 fprintf (file, _(" EMH %u (len=%u): "), subtype, rec_len);
5622 struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5625 fprintf (file, _("Module header\n"));
5626 fprintf (file, _(" structure level: %u\n"), mhd->strlvl);
5627 fprintf (file, _(" max record size: %u\n"),
5628 (unsigned)bfd_getl32 (mhd->recsiz));
5629 name = (char *)(mhd + 1);
5630 fprintf (file, _(" module name : %.*s\n"), name[0], name + 1);
5631 name += name[0] + 1;
5632 fprintf (file, _(" module version : %.*s\n"), name[0], name + 1);
5633 name += name[0] + 1;
5634 fprintf (file, _(" compile date : %.17s\n"), name);
5639 fprintf (file, _("Language Processor Name\n"));
5640 fprintf (file, _(" language name: %.*s\n"),
5641 (int)(rec_len - sizeof (struct vms_emh_common)),
5642 (char *)rec + sizeof (struct vms_emh_common));
5647 fprintf (file, _("Source Files Header\n"));
5648 fprintf (file, _(" file: %.*s\n"),
5649 (int)(rec_len - sizeof (struct vms_emh_common)),
5650 (char *)rec + sizeof (struct vms_emh_common));
5655 fprintf (file, _("Title Text Header\n"));
5656 fprintf (file, _(" title: %.*s\n"),
5657 (int)(rec_len - sizeof (struct vms_emh_common)),
5658 (char *)rec + sizeof (struct vms_emh_common));
5663 fprintf (file, _("Copyright Header\n"));
5664 fprintf (file, _(" copyright: %.*s\n"),
5665 (int)(rec_len - sizeof (struct vms_emh_common)),
5666 (char *)rec + sizeof (struct vms_emh_common));
5670 fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5676 evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5678 struct vms_eeom *eeom = (struct vms_eeom *)rec;
5680 fprintf (file, _(" EEOM (len=%u):\n"), rec_len);
5681 fprintf (file, _(" number of cond linkage pairs: %u\n"),
5682 (unsigned)bfd_getl32 (eeom->total_lps));
5683 fprintf (file, _(" completion code: %u\n"),
5684 (unsigned)bfd_getl16 (eeom->comcod));
5687 fprintf (file, _(" transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5688 fprintf (file, _(" transfer addr psect: %u\n"),
5689 (unsigned)bfd_getl32 (eeom->psindx));
5690 fprintf (file, _(" transfer address : 0x%08x\n"),
5691 (unsigned)bfd_getl32 (eeom->tfradr));
5696 exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5698 if (flags & EGSY__V_WEAK)
5699 fputs (_(" WEAK"), file);
5700 if (flags & EGSY__V_DEF)
5701 fputs (_(" DEF"), file);
5702 if (flags & EGSY__V_UNI)
5703 fputs (_(" UNI"), file);
5704 if (flags & EGSY__V_REL)
5705 fputs (_(" REL"), file);
5706 if (flags & EGSY__V_COMM)
5707 fputs (_(" COMM"), file);
5708 if (flags & EGSY__V_VECEP)
5709 fputs (_(" VECEP"), file);
5710 if (flags & EGSY__V_NORM)
5711 fputs (_(" NORM"), file);
5712 if (flags & EGSY__V_QUAD_VAL)
5713 fputs (_(" QVAL"), file);
5717 evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5719 if (flags & EGPS__V_PIC)
5720 fputs (_(" PIC"), file);
5721 if (flags & EGPS__V_LIB)
5722 fputs (_(" LIB"), file);
5723 if (flags & EGPS__V_OVR)
5724 fputs (_(" OVR"), file);
5725 if (flags & EGPS__V_REL)
5726 fputs (_(" REL"), file);
5727 if (flags & EGPS__V_GBL)
5728 fputs (_(" GBL"), file);
5729 if (flags & EGPS__V_SHR)
5730 fputs (_(" SHR"), file);
5731 if (flags & EGPS__V_EXE)
5732 fputs (_(" EXE"), file);
5733 if (flags & EGPS__V_RD)
5734 fputs (_(" RD"), file);
5735 if (flags & EGPS__V_WRT)
5736 fputs (_(" WRT"), file);
5737 if (flags & EGPS__V_VEC)
5738 fputs (_(" VEC"), file);
5739 if (flags & EGPS__V_NOMOD)
5740 fputs (_(" NOMOD"), file);
5741 if (flags & EGPS__V_COM)
5742 fputs (_(" COM"), file);
5743 if (flags & EGPS__V_ALLOC_64BIT)
5744 fputs (_(" 64B"), file);
5748 evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5750 unsigned int off = sizeof (struct vms_egsd);
5753 fprintf (file, _(" EGSD (len=%u):\n"), rec_len);
5756 for (off = sizeof (struct vms_egsd); off < rec_len; )
5758 struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5762 type = (unsigned)bfd_getl16 (e->gsdtyp);
5763 len = (unsigned)bfd_getl16 (e->gsdsiz);
5765 fprintf (file, _(" EGSD entry %2u (type: %u, len: %u): "),
5773 struct vms_egps *egps = (struct vms_egps *)e;
5774 unsigned int flags = bfd_getl16 (egps->flags);
5777 fprintf (file, _("PSC - Program section definition\n"));
5778 fprintf (file, _(" alignment : 2**%u\n"), egps->align);
5779 fprintf (file, _(" flags : 0x%04x"), flags);
5780 evax_bfd_print_egsd_flags (file, flags);
5782 l = bfd_getl32 (egps->alloc);
5783 fprintf (file, _(" alloc (len): %u (0x%08x)\n"), l, l);
5784 fprintf (file, _(" name : %.*s\n"),
5785 egps->namlng, egps->name);
5790 struct vms_esgps *esgps = (struct vms_esgps *)e;
5791 unsigned int flags = bfd_getl16 (esgps->flags);
5794 fprintf (file, _("SPSC - Shared Image Program section def\n"));
5795 fprintf (file, _(" alignment : 2**%u\n"), esgps->align);
5796 fprintf (file, _(" flags : 0x%04x"), flags);
5797 evax_bfd_print_egsd_flags (file, flags);
5799 l = bfd_getl32 (esgps->alloc);
5800 fprintf (file, _(" alloc (len) : %u (0x%08x)\n"), l, l);
5801 fprintf (file, _(" image offset : 0x%08x\n"),
5802 (unsigned int)bfd_getl32 (esgps->base));
5803 fprintf (file, _(" symvec offset : 0x%08x\n"),
5804 (unsigned int)bfd_getl32 (esgps->value));
5805 fprintf (file, _(" name : %.*s\n"),
5806 esgps->namlng, esgps->name);
5811 struct vms_egsy *egsy = (struct vms_egsy *)e;
5812 unsigned int flags = bfd_getl16 (egsy->flags);
5814 if (flags & EGSY__V_DEF)
5816 struct vms_esdf *esdf = (struct vms_esdf *)e;
5818 fprintf (file, _("SYM - Global symbol definition\n"));
5819 fprintf (file, _(" flags: 0x%04x"), flags);
5820 exav_bfd_print_egsy_flags (flags, file);
5822 fprintf (file, _(" psect offset: 0x%08x\n"),
5823 (unsigned)bfd_getl32 (esdf->value));
5824 if (flags & EGSY__V_NORM)
5826 fprintf (file, _(" code address: 0x%08x\n"),
5827 (unsigned)bfd_getl32 (esdf->code_address));
5828 fprintf (file, _(" psect index for entry point : %u\n"),
5829 (unsigned)bfd_getl32 (esdf->ca_psindx));
5831 fprintf (file, _(" psect index : %u\n"),
5832 (unsigned)bfd_getl32 (esdf->psindx));
5833 fprintf (file, _(" name : %.*s\n"),
5834 esdf->namlng, esdf->name);
5838 struct vms_esrf *esrf = (struct vms_esrf *)e;
5840 fprintf (file, _("SYM - Global symbol reference\n"));
5841 fprintf (file, _(" name : %.*s\n"),
5842 esrf->namlng, esrf->name);
5848 struct vms_eidc *eidc = (struct vms_eidc *)e;
5849 unsigned int flags = bfd_getl32 (eidc->flags);
5852 fprintf (file, _("IDC - Ident Consistency check\n"));
5853 fprintf (file, _(" flags : 0x%08x"), flags);
5854 if (flags & EIDC__V_BINIDENT)
5855 fputs (" BINDENT", file);
5857 fprintf (file, _(" id match : %x\n"),
5858 (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5859 fprintf (file, _(" error severity: %x\n"),
5860 (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5862 fprintf (file, _(" entity name : %.*s\n"), p[0], p + 1);
5864 fprintf (file, _(" object name : %.*s\n"), p[0], p + 1);
5866 if (flags & EIDC__V_BINIDENT)
5867 fprintf (file, _(" binary ident : 0x%08x\n"),
5868 (unsigned)bfd_getl32 (p + 1));
5870 fprintf (file, _(" ascii ident : %.*s\n"), p[0], p + 1);
5875 struct vms_egst *egst = (struct vms_egst *)e;
5876 unsigned int flags = bfd_getl16 (egst->header.flags);
5878 fprintf (file, _("SYMG - Universal symbol definition\n"));
5879 fprintf (file, _(" flags: 0x%04x"), flags);
5880 exav_bfd_print_egsy_flags (flags, file);
5882 fprintf (file, _(" symbol vector offset: 0x%08x\n"),
5883 (unsigned)bfd_getl32 (egst->value));
5884 fprintf (file, _(" entry point: 0x%08x\n"),
5885 (unsigned)bfd_getl32 (egst->lp_1));
5886 fprintf (file, _(" proc descr : 0x%08x\n"),
5887 (unsigned)bfd_getl32 (egst->lp_2));
5888 fprintf (file, _(" psect index: %u\n"),
5889 (unsigned)bfd_getl32 (egst->psindx));
5890 fprintf (file, _(" name : %.*s\n"),
5891 egst->namlng, egst->name);
5896 struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5897 unsigned int flags = bfd_getl16 (esdfv->flags);
5899 fprintf (file, _("SYMV - Vectored symbol definition\n"));
5900 fprintf (file, _(" flags: 0x%04x"), flags);
5901 exav_bfd_print_egsy_flags (flags, file);
5903 fprintf (file, _(" vector : 0x%08x\n"),
5904 (unsigned)bfd_getl32 (esdfv->vector));
5905 fprintf (file, _(" psect offset: %u\n"),
5906 (unsigned)bfd_getl32 (esdfv->value));
5907 fprintf (file, _(" psect index : %u\n"),
5908 (unsigned)bfd_getl32 (esdfv->psindx));
5909 fprintf (file, _(" name : %.*s\n"),
5910 esdfv->namlng, esdfv->name);
5915 struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5916 unsigned int flags = bfd_getl16 (esdfm->flags);
5918 fprintf (file, _("SYMM - Global symbol definition with version\n"));
5919 fprintf (file, _(" flags: 0x%04x"), flags);
5920 exav_bfd_print_egsy_flags (flags, file);
5922 fprintf (file, _(" version mask: 0x%08x\n"),
5923 (unsigned)bfd_getl32 (esdfm->version_mask));
5924 fprintf (file, _(" psect offset: %u\n"),
5925 (unsigned)bfd_getl32 (esdfm->value));
5926 fprintf (file, _(" psect index : %u\n"),
5927 (unsigned)bfd_getl32 (esdfm->psindx));
5928 fprintf (file, _(" name : %.*s\n"),
5929 esdfm->namlng, esdfm->name);
5933 fprintf (file, _("unhandled egsd entry type %u\n"), type);
5941 evax_bfd_print_hex (FILE *file, const char *pfx,
5942 const unsigned char *buf, unsigned int len)
5948 for (i = 0; i < len; i++)
5952 fprintf (file, " %02x", buf[i]);
5965 evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
5967 fprintf (file, _(" linkage index: %u, replacement insn: 0x%08x\n"),
5968 (unsigned)bfd_getl32 (buf),
5969 (unsigned)bfd_getl32 (buf + 16));
5970 fprintf (file, _(" psect idx 1: %u, offset 1: 0x%08x %08x\n"),
5971 (unsigned)bfd_getl32 (buf + 4),
5972 (unsigned)bfd_getl32 (buf + 12),
5973 (unsigned)bfd_getl32 (buf + 8));
5974 fprintf (file, _(" psect idx 2: %u, offset 2: 0x%08x %08x\n"),
5975 (unsigned)bfd_getl32 (buf + 20),
5976 (unsigned)bfd_getl32 (buf + 28),
5977 (unsigned)bfd_getl32 (buf + 24));
5979 fprintf (file, _(" psect idx 3: %u, offset 3: 0x%08x %08x\n"),
5980 (unsigned)bfd_getl32 (buf + 32),
5981 (unsigned)bfd_getl32 (buf + 40),
5982 (unsigned)bfd_getl32 (buf + 36));
5984 fprintf (file, _(" global name: %.*s\n"), buf[32], buf + 33);
5988 evax_bfd_print_etir (FILE *file, const char *name,
5989 unsigned char *rec, unsigned int rec_len)
5991 unsigned int off = sizeof (struct vms_egsd);
5992 unsigned int sec_len;
5994 fprintf (file, _(" %s (len=%u+%u):\n"), name,
5995 (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
5996 (unsigned)sizeof (struct vms_eobjrec));
5998 for (off = sizeof (struct vms_eobjrec); off < rec_len; )
6000 struct vms_etir *etir = (struct vms_etir *)(rec + off);
6005 type = bfd_getl16 (etir->rectyp);
6006 size = bfd_getl16 (etir->size);
6007 buf = rec + off + sizeof (struct vms_etir);
6009 fprintf (file, _(" (type: %3u, size: 4+%3u): "), type, size - 4);
6012 case ETIR__C_STA_GBL:
6013 fprintf (file, _("STA_GBL (stack global) %.*s\n"),
6016 case ETIR__C_STA_LW:
6017 fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
6018 (unsigned)bfd_getl32 (buf));
6020 case ETIR__C_STA_QW:
6021 fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
6022 (unsigned)bfd_getl32 (buf + 4),
6023 (unsigned)bfd_getl32 (buf + 0));
6025 case ETIR__C_STA_PQ:
6026 fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
6027 fprintf (file, _(" psect: %u, offset: 0x%08x %08x\n"),
6028 (unsigned)bfd_getl32 (buf + 0),
6029 (unsigned)bfd_getl32 (buf + 8),
6030 (unsigned)bfd_getl32 (buf + 4));
6032 case ETIR__C_STA_LI:
6033 fprintf (file, _("STA_LI (stack literal)\n"));
6035 case ETIR__C_STA_MOD:
6036 fprintf (file, _("STA_MOD (stack module)\n"));
6038 case ETIR__C_STA_CKARG:
6039 fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
6043 fprintf (file, _("STO_B (store byte)\n"));
6046 fprintf (file, _("STO_W (store word)\n"));
6048 case ETIR__C_STO_LW:
6049 fprintf (file, _("STO_LW (store longword)\n"));
6051 case ETIR__C_STO_QW:
6052 fprintf (file, _("STO_QW (store quadword)\n"));
6054 case ETIR__C_STO_IMMR:
6056 unsigned int len = bfd_getl32 (buf);
6058 _("STO_IMMR (store immediate repeat) %u bytes\n"),
6060 evax_bfd_print_hex (file, " ", buf + 4, len);
6064 case ETIR__C_STO_GBL:
6065 fprintf (file, _("STO_GBL (store global) %.*s\n"),
6068 case ETIR__C_STO_CA:
6069 fprintf (file, _("STO_CA (store code address) %.*s\n"),
6072 case ETIR__C_STO_RB:
6073 fprintf (file, _("STO_RB (store relative branch)\n"));
6075 case ETIR__C_STO_AB:
6076 fprintf (file, _("STO_AB (store absolute branch)\n"));
6078 case ETIR__C_STO_OFF:
6079 fprintf (file, _("STO_OFF (store offset to psect)\n"));
6081 case ETIR__C_STO_IMM:
6083 unsigned int len = bfd_getl32 (buf);
6085 _("STO_IMM (store immediate) %u bytes\n"),
6087 evax_bfd_print_hex (file, " ", buf + 4, len);
6091 case ETIR__C_STO_LP_PSB:
6092 fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6094 case ETIR__C_STO_HINT_GBL:
6095 fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6097 case ETIR__C_STO_HINT_PS:
6098 fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6101 case ETIR__C_OPR_NOP:
6102 fprintf (file, _("OPR_NOP (no-operation)\n"));
6104 case ETIR__C_OPR_ADD:
6105 fprintf (file, _("OPR_ADD (add)\n"));
6107 case ETIR__C_OPR_SUB:
6108 fprintf (file, _("OPR_SUB (substract)\n"));
6110 case ETIR__C_OPR_MUL:
6111 fprintf (file, _("OPR_MUL (multiply)\n"));
6113 case ETIR__C_OPR_DIV:
6114 fprintf (file, _("OPR_DIV (divide)\n"));
6116 case ETIR__C_OPR_AND:
6117 fprintf (file, _("OPR_AND (logical and)\n"));
6119 case ETIR__C_OPR_IOR:
6120 fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6122 case ETIR__C_OPR_EOR:
6123 fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6125 case ETIR__C_OPR_NEG:
6126 fprintf (file, _("OPR_NEG (negate)\n"));
6128 case ETIR__C_OPR_COM:
6129 fprintf (file, _("OPR_COM (complement)\n"));
6131 case ETIR__C_OPR_INSV:
6132 fprintf (file, _("OPR_INSV (insert field)\n"));
6134 case ETIR__C_OPR_ASH:
6135 fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6137 case ETIR__C_OPR_USH:
6138 fprintf (file, _("OPR_USH (unsigned shift)\n"));
6140 case ETIR__C_OPR_ROT:
6141 fprintf (file, _("OPR_ROT (rotate)\n"));
6143 case ETIR__C_OPR_SEL:
6144 fprintf (file, _("OPR_SEL (select)\n"));
6146 case ETIR__C_OPR_REDEF:
6147 fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6149 case ETIR__C_OPR_DFLIT:
6150 fprintf (file, _("OPR_REDEF (define a literal)\n"));
6153 case ETIR__C_STC_LP:
6154 fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6156 case ETIR__C_STC_LP_PSB:
6158 _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6159 fprintf (file, _(" linkage index: %u, procedure: %.*s\n"),
6160 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6161 buf += 4 + 1 + buf[4];
6162 fprintf (file, _(" signature: %.*s\n"), buf[0], buf + 1);
6164 case ETIR__C_STC_GBL:
6165 fprintf (file, _("STC_GBL (store cond global)\n"));
6166 fprintf (file, _(" linkage index: %u, global: %.*s\n"),
6167 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6169 case ETIR__C_STC_GCA:
6170 fprintf (file, _("STC_GCA (store cond code address)\n"));
6171 fprintf (file, _(" linkage index: %u, procedure name: %.*s\n"),
6172 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6174 case ETIR__C_STC_PS:
6175 fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6177 _(" linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6178 (unsigned)bfd_getl32 (buf),
6179 (unsigned)bfd_getl32 (buf + 4),
6180 (unsigned)bfd_getl32 (buf + 12),
6181 (unsigned)bfd_getl32 (buf + 8));
6183 case ETIR__C_STC_NOP_GBL:
6184 fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6185 evax_bfd_print_etir_stc_ir (file, buf, 0);
6187 case ETIR__C_STC_NOP_PS:
6188 fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6189 evax_bfd_print_etir_stc_ir (file, buf, 1);
6191 case ETIR__C_STC_BSR_GBL:
6192 fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6193 evax_bfd_print_etir_stc_ir (file, buf, 0);
6195 case ETIR__C_STC_BSR_PS:
6196 fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6197 evax_bfd_print_etir_stc_ir (file, buf, 1);
6199 case ETIR__C_STC_LDA_GBL:
6200 fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6201 evax_bfd_print_etir_stc_ir (file, buf, 0);
6203 case ETIR__C_STC_LDA_PS:
6204 fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6205 evax_bfd_print_etir_stc_ir (file, buf, 1);
6207 case ETIR__C_STC_BOH_GBL:
6208 fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6209 evax_bfd_print_etir_stc_ir (file, buf, 0);
6211 case ETIR__C_STC_BOH_PS:
6212 fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6213 evax_bfd_print_etir_stc_ir (file, buf, 1);
6215 case ETIR__C_STC_NBH_GBL:
6217 _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6219 case ETIR__C_STC_NBH_PS:
6221 _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6224 case ETIR__C_CTL_SETRB:
6225 fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6228 case ETIR__C_CTL_AUGRB:
6230 unsigned int val = bfd_getl32 (buf);
6231 fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6234 case ETIR__C_CTL_DFLOC:
6235 fprintf (file, _("CTL_DFLOC (define location)\n"));
6237 case ETIR__C_CTL_STLOC:
6238 fprintf (file, _("CTL_STLOC (set location)\n"));
6240 case ETIR__C_CTL_STKDL:
6241 fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6244 fprintf (file, _("*unhandled*\n"));
6252 evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6254 bfd_boolean is_first = TRUE;
6255 bfd_boolean has_records = FALSE;
6259 unsigned int rec_len;
6260 unsigned int pad_len;
6262 unsigned int hdr_size;
6267 unsigned char buf[6];
6272 if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6274 fprintf (file, _("cannot read GST record length\n"));
6277 rec_len = bfd_getl16 (buf + 0);
6278 if (rec_len == bfd_getl16 (buf + 4)
6279 && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6281 /* The format is raw: record-size, type, record-size. */
6283 pad_len = (rec_len + 1) & ~1U;
6286 else if (rec_len == EOBJ__C_EMH)
6288 has_records = FALSE;
6289 pad_len = bfd_getl16 (buf + 2);
6295 fprintf (file, _("cannot find EMH in first GST record\n"));
6298 rec = bfd_malloc (pad_len);
6299 memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6303 unsigned int rec_len2 = 0;
6304 unsigned char hdr[4];
6308 unsigned char buf_len[2];
6310 if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6311 != sizeof (buf_len))
6313 fprintf (file, _("cannot read GST record length\n"));
6316 rec_len2 = (unsigned)bfd_getl16 (buf_len);
6319 if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6321 fprintf (file, _("cannot read GST record header\n"));
6324 rec_len = (unsigned)bfd_getl16 (hdr + 2);
6326 pad_len = (rec_len + 1) & ~1U;
6329 rec = bfd_malloc (pad_len);
6330 memcpy (rec, hdr, sizeof (hdr));
6331 hdr_size = sizeof (hdr);
6332 if (has_records && rec_len2 != rec_len)
6334 fprintf (file, _(" corrupted GST\n"));
6339 if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6340 != pad_len - hdr_size)
6342 fprintf (file, _("cannot read GST record\n"));
6346 type = (unsigned)bfd_getl16 (rec);
6351 evax_bfd_print_emh (file, rec, rec_len);
6354 evax_bfd_print_egsd (file, rec, rec_len);
6357 evax_bfd_print_eeom (file, rec, rec_len);
6362 evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6365 evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6368 evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6371 fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6379 evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6380 unsigned int stride)
6388 count = bfd_getl32 (rel + 0);
6392 base = bfd_getl32 (rel + 4);
6394 fprintf (file, _(" bitcount: %u, base addr: 0x%08x\n"),
6398 for (j = 0; count > 0; j += 4, count -= 32)
6404 val = bfd_getl32 (rel);
6407 fprintf (file, _(" bitmap: 0x%08x (count: %u):\n"), val, count);
6409 for (k = 0; k < 32; k++)
6414 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6429 evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6436 count = bfd_getl32 (rel + 0);
6439 fprintf (file, _(" image %u (%u entries)\n"),
6440 (unsigned)bfd_getl32 (rel + 4), count);
6442 for (j = 0; j < count; j++)
6444 fprintf (file, _(" offset: 0x%08x, val: 0x%08x\n"),
6445 (unsigned)bfd_getl32 (rel + 0),
6446 (unsigned)bfd_getl32 (rel + 4));
6453 evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6462 count = bfd_getl32 (rel + 0);
6465 fprintf (file, _(" image %u (%u entries), offsets:\n"),
6466 (unsigned)bfd_getl32 (rel + 4), count);
6468 for (j = 0; j < count; j++)
6472 fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6487 evax_bfd_print_indent (int indent, FILE *file)
6489 for (; indent; indent--)
6494 evax_bfd_get_dsc_name (unsigned int v)
6498 case DSC__K_DTYPE_Z:
6499 return "Z (Unspecified)";
6500 case DSC__K_DTYPE_V:
6502 case DSC__K_DTYPE_BU:
6503 return "BU (Byte logical)";
6504 case DSC__K_DTYPE_WU:
6505 return "WU (Word logical)";
6506 case DSC__K_DTYPE_LU:
6507 return "LU (Longword logical)";
6508 case DSC__K_DTYPE_QU:
6509 return "QU (Quadword logical)";
6510 case DSC__K_DTYPE_B:
6511 return "B (Byte integer)";
6512 case DSC__K_DTYPE_W:
6513 return "W (Word integer)";
6514 case DSC__K_DTYPE_L:
6515 return "L (Longword integer)";
6516 case DSC__K_DTYPE_Q:
6517 return "Q (Quadword integer)";
6518 case DSC__K_DTYPE_F:
6519 return "F (Single-precision floating)";
6520 case DSC__K_DTYPE_D:
6521 return "D (Double-precision floating)";
6522 case DSC__K_DTYPE_FC:
6523 return "FC (Complex)";
6524 case DSC__K_DTYPE_DC:
6525 return "DC (Double-precision Complex)";
6526 case DSC__K_DTYPE_T:
6527 return "T (ASCII text string)";
6528 case DSC__K_DTYPE_NU:
6529 return "NU (Numeric string, unsigned)";
6530 case DSC__K_DTYPE_NL:
6531 return "NL (Numeric string, left separate sign)";
6532 case DSC__K_DTYPE_NLO:
6533 return "NLO (Numeric string, left overpunched sign)";
6534 case DSC__K_DTYPE_NR:
6535 return "NR (Numeric string, right separate sign)";
6536 case DSC__K_DTYPE_NRO:
6537 return "NRO (Numeric string, right overpunched sig)";
6538 case DSC__K_DTYPE_NZ:
6539 return "NZ (Numeric string, zoned sign)";
6540 case DSC__K_DTYPE_P:
6541 return "P (Packed decimal string)";
6542 case DSC__K_DTYPE_ZI:
6543 return "ZI (Sequence of instructions)";
6544 case DSC__K_DTYPE_ZEM:
6545 return "ZEM (Procedure entry mask)";
6546 case DSC__K_DTYPE_DSC:
6547 return "DSC (Descriptor, used for arrays of dyn strings)";
6548 case DSC__K_DTYPE_OU:
6549 return "OU (Octaword logical)";
6550 case DSC__K_DTYPE_O:
6551 return "O (Octaword integer)";
6552 case DSC__K_DTYPE_G:
6553 return "G (Double precision G floating, 64 bit)";
6554 case DSC__K_DTYPE_H:
6555 return "H (Quadruple precision floating, 128 bit)";
6556 case DSC__K_DTYPE_GC:
6557 return "GC (Double precision complex, G floating)";
6558 case DSC__K_DTYPE_HC:
6559 return "HC (Quadruple precision complex, H floating)";
6560 case DSC__K_DTYPE_CIT:
6561 return "CIT (COBOL intermediate temporary)";
6562 case DSC__K_DTYPE_BPV:
6563 return "BPV (Bound Procedure Value)";
6564 case DSC__K_DTYPE_BLV:
6565 return "BLV (Bound Label Value)";
6566 case DSC__K_DTYPE_VU:
6567 return "VU (Bit Unaligned)";
6568 case DSC__K_DTYPE_ADT:
6569 return "ADT (Absolute Date-Time)";
6570 case DSC__K_DTYPE_VT:
6571 return "VT (Varying Text)";
6572 case DSC__K_DTYPE_T2:
6573 return "T2 (16-bit char)";
6574 case DSC__K_DTYPE_VT2:
6575 return "VT2 (16-bit varying char)";
6577 return "?? (unknown)";
6582 evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6584 unsigned char bclass = buf[3];
6585 unsigned char dtype = buf[2];
6586 unsigned int len = (unsigned)bfd_getl16 (buf);
6587 unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6589 evax_bfd_print_indent (indent, file);
6591 if (len == 1 && pointer == 0xffffffffUL)
6594 fprintf (file, _("64 bits *unhandled*\n"));
6598 fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6599 bclass, dtype, len, pointer);
6602 case DSC__K_CLASS_NCA:
6604 const struct vms_dsc_nca *dsc = (const void *)buf;
6606 const unsigned char *b;
6608 evax_bfd_print_indent (indent, file);
6609 fprintf (file, _("non-contiguous array of %s\n"),
6610 evax_bfd_get_dsc_name (dsc->dtype));
6611 evax_bfd_print_indent (indent + 1, file);
6613 _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6614 dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6615 evax_bfd_print_indent (indent + 1, file);
6617 _("arsize: %u, a0: 0x%08x\n"),
6618 (unsigned)bfd_getl32 (dsc->arsize),
6619 (unsigned)bfd_getl32 (dsc->a0));
6620 evax_bfd_print_indent (indent + 1, file);
6621 fprintf (file, _("Strides:\n"));
6622 b = buf + sizeof (*dsc);
6623 for (i = 0; i < dsc->dimct; i++)
6625 evax_bfd_print_indent (indent + 2, file);
6626 fprintf (file, _("[%u]: %u\n"), i + 1,
6627 (unsigned)bfd_getl32 (b));
6630 evax_bfd_print_indent (indent + 1, file);
6631 fprintf (file, _("Bounds:\n"));
6632 b = buf + sizeof (*dsc);
6633 for (i = 0; i < dsc->dimct; i++)
6635 evax_bfd_print_indent (indent + 2, file);
6636 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6637 (unsigned)bfd_getl32 (b + 0),
6638 (unsigned)bfd_getl32 (b + 4));
6643 case DSC__K_CLASS_UBS:
6645 const struct vms_dsc_ubs *ubs = (const void *)buf;
6647 evax_bfd_print_indent (indent, file);
6648 fprintf (file, _("unaligned bit-string of %s\n"),
6649 evax_bfd_get_dsc_name (ubs->dtype));
6650 evax_bfd_print_indent (indent + 1, file);
6652 _("base: %u, pos: %u\n"),
6653 (unsigned)bfd_getl32 (ubs->base),
6654 (unsigned)bfd_getl32 (ubs->pos));
6658 fprintf (file, _("*unhandled*\n"));
6665 evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6667 unsigned int vflags = buf[0];
6668 unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6669 unsigned int len = 5;
6671 evax_bfd_print_indent (indent, file);
6672 fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6677 case DST__K_VFLAGS_NOVAL:
6678 fprintf (file, _("(no value)\n"));
6680 case DST__K_VFLAGS_NOTACTIVE:
6681 fprintf (file, _("(not active)\n"));
6683 case DST__K_VFLAGS_UNALLOC:
6684 fprintf (file, _("(not allocated)\n"));
6686 case DST__K_VFLAGS_DSC:
6687 fprintf (file, _("(descriptor)\n"));
6688 evax_bfd_print_desc (buf + value, indent + 1, file);
6690 case DST__K_VFLAGS_TVS:
6691 fprintf (file, _("(trailing value)\n"));
6693 case DST__K_VS_FOLLOWS:
6694 fprintf (file, _("(value spec follows)\n"));
6696 case DST__K_VFLAGS_BITOFFS:
6697 fprintf (file, _("(at bit offset %u)\n"), value);
6700 fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6701 (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6702 vflags & DST__K_DISP ? 1 : 0,
6703 vflags & DST__K_INDIR ? 1 : 0);
6704 switch (vflags & DST__K_VALKIND_MASK)
6706 case DST__K_VALKIND_LITERAL:
6707 fputs (_("literal"), file);
6709 case DST__K_VALKIND_ADDR:
6710 fputs (_("address"), file);
6712 case DST__K_VALKIND_DESC:
6713 fputs (_("desc"), file);
6715 case DST__K_VALKIND_REG:
6716 fputs (_("reg"), file);
6719 fputs (")\n", file);
6726 evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6728 unsigned char kind = buf[2];
6729 unsigned int len = (unsigned)bfd_getl16 (buf);
6731 evax_bfd_print_indent (indent, file);
6732 fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6736 case DST__K_TS_ATOM:
6737 fprintf (file, ("atomic, type=0x%02x %s\n"),
6738 buf[0], evax_bfd_get_dsc_name (buf[0]));
6741 fprintf (file, ("indirect, defined at 0x%08x\n"),
6742 (unsigned)bfd_getl32 (buf));
6744 case DST__K_TS_TPTR:
6745 fprintf (file, ("typed pointer\n"));
6746 evax_bfd_print_typspec (buf, indent + 1, file);
6749 fprintf (file, ("pointer\n"));
6751 case DST__K_TS_ARRAY:
6753 const unsigned char *vs;
6754 unsigned int vec_len;
6757 fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6758 vec_len = (buf[0] + 1 + 7) / 8;
6759 for (i = 0; i < vec_len; i++)
6760 fprintf (file, " %02x", buf[i + 1]);
6762 vs = buf + 1 + vec_len;
6763 evax_bfd_print_indent (indent, file);
6764 fprintf (file, ("array descriptor:\n"));
6765 vs += evax_bfd_print_valspec (vs, indent + 1, file);
6766 for (i = 0; i < buf[0] + 1U; i++)
6767 if (buf[1 + i / 8] & (1 << (i % 8)))
6769 evax_bfd_print_indent (indent, file);
6771 fprintf (file, ("type spec for element:\n"));
6773 fprintf (file, ("type spec for subscript %u:\n"), i);
6774 evax_bfd_print_typspec (vs, indent + 1, file);
6775 vs += bfd_getl16 (vs);
6780 fprintf (file, ("*unhandled*\n"));
6785 evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6787 unsigned int off = 0;
6788 unsigned int pc = 0;
6789 unsigned int line = 0;
6791 fprintf (file, _("Debug symbol table:\n"));
6793 while (dst_size > 0)
6795 struct vms_dst_header dsth;
6800 if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6802 fprintf (file, _("cannot read DST header\n"));
6805 len = bfd_getl16 (dsth.length);
6806 type = bfd_getl16 (dsth.type);
6807 fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6817 len -= sizeof (dsth);
6818 buf = bfd_malloc (len);
6819 if (bfd_bread (buf, len, abfd) != len)
6821 fprintf (file, _("cannot read DST symbol\n"));
6826 case DSC__K_DTYPE_V:
6827 case DSC__K_DTYPE_BU:
6828 case DSC__K_DTYPE_WU:
6829 case DSC__K_DTYPE_LU:
6830 case DSC__K_DTYPE_QU:
6831 case DSC__K_DTYPE_B:
6832 case DSC__K_DTYPE_W:
6833 case DSC__K_DTYPE_L:
6834 case DSC__K_DTYPE_Q:
6835 case DSC__K_DTYPE_F:
6836 case DSC__K_DTYPE_D:
6837 case DSC__K_DTYPE_FC:
6838 case DSC__K_DTYPE_DC:
6839 case DSC__K_DTYPE_T:
6840 case DSC__K_DTYPE_NU:
6841 case DSC__K_DTYPE_NL:
6842 case DSC__K_DTYPE_NLO:
6843 case DSC__K_DTYPE_NR:
6844 case DSC__K_DTYPE_NRO:
6845 case DSC__K_DTYPE_NZ:
6846 case DSC__K_DTYPE_P:
6847 case DSC__K_DTYPE_ZI:
6848 case DSC__K_DTYPE_ZEM:
6849 case DSC__K_DTYPE_DSC:
6850 case DSC__K_DTYPE_OU:
6851 case DSC__K_DTYPE_O:
6852 case DSC__K_DTYPE_G:
6853 case DSC__K_DTYPE_H:
6854 case DSC__K_DTYPE_GC:
6855 case DSC__K_DTYPE_HC:
6856 case DSC__K_DTYPE_CIT:
6857 case DSC__K_DTYPE_BPV:
6858 case DSC__K_DTYPE_BLV:
6859 case DSC__K_DTYPE_VU:
6860 case DSC__K_DTYPE_ADT:
6861 case DSC__K_DTYPE_VT:
6862 case DSC__K_DTYPE_T2:
6863 case DSC__K_DTYPE_VT2:
6864 fprintf (file, _("standard data: %s\n"),
6865 evax_bfd_get_dsc_name (type));
6866 evax_bfd_print_valspec (buf, 4, file);
6867 fprintf (file, _(" name: %.*s\n"), buf[5], buf + 6);
6871 struct vms_dst_modbeg *dst = (void *)buf;
6872 const char *name = (const char *)buf + sizeof (*dst);
6874 fprintf (file, _("modbeg\n"));
6875 fprintf (file, _(" flags: %d, language: %u, "
6876 "major: %u, minor: %u\n"),
6878 (unsigned)bfd_getl32 (dst->language),
6879 (unsigned)bfd_getl16 (dst->major),
6880 (unsigned)bfd_getl16 (dst->minor));
6881 fprintf (file, _(" module name: %.*s\n"),
6883 name += name[0] + 1;
6884 fprintf (file, _(" compiler : %.*s\n"),
6889 fprintf (file, _("modend\n"));
6893 struct vms_dst_rtnbeg *dst = (void *)buf;
6894 const char *name = (const char *)buf + sizeof (*dst);
6896 fputs (_("rtnbeg\n"), file);
6897 fprintf (file, _(" flags: %u, address: 0x%08x, "
6898 "pd-address: 0x%08x\n"),
6900 (unsigned)bfd_getl32 (dst->address),
6901 (unsigned)bfd_getl32 (dst->pd_address));
6902 fprintf (file, _(" routine name: %.*s\n"),
6908 struct vms_dst_rtnend *dst = (void *)buf;
6910 fprintf (file, _("rtnend: size 0x%08x\n"),
6911 (unsigned)bfd_getl32 (dst->size));
6916 struct vms_dst_prolog *dst = (void *)buf;
6918 fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6919 (unsigned)bfd_getl32 (dst->bkpt_addr));
6924 struct vms_dst_epilog *dst = (void *)buf;
6926 fprintf (file, _("epilog: flags: %u, count: %u\n"),
6927 dst->flags, (unsigned)bfd_getl32 (dst->count));
6932 struct vms_dst_blkbeg *dst = (void *)buf;
6933 const char *name = (const char *)buf + sizeof (*dst);
6935 fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6936 (unsigned)bfd_getl32 (dst->address),
6942 struct vms_dst_blkend *dst = (void *)buf;
6944 fprintf (file, _("blkend: size: 0x%08x\n"),
6945 (unsigned)bfd_getl32 (dst->size));
6948 case DST__K_TYPSPEC:
6950 fprintf (file, _("typspec (len: %u)\n"), len);
6951 fprintf (file, _(" name: %.*s\n"), buf[0], buf + 1);
6952 evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
6957 fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
6958 evax_bfd_print_valspec (buf, 4, file);
6963 struct vms_dst_recbeg *recbeg = (void *)buf;
6964 const char *name = (const char *)buf + sizeof (*recbeg);
6966 fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
6967 evax_bfd_print_valspec (buf, 4, file);
6968 fprintf (file, (" len: %u bits\n"),
6969 (unsigned)bfd_getl32 (name + 1 + name[0]));
6973 fprintf (file, _("recend\n"));
6975 case DST__K_ENUMBEG:
6976 fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
6977 buf[0], buf[1], buf + 2);
6979 case DST__K_ENUMELT:
6980 fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
6981 evax_bfd_print_valspec (buf, 4, file);
6983 case DST__K_ENUMEND:
6984 fprintf (file, _("enumend\n"));
6988 struct vms_dst_label *lab = (void *)buf;
6989 fprintf (file, ("label, name: %.*s\n"),
6990 lab->name[0], lab->name + 1);
6991 fprintf (file, (" address: 0x%08x\n"),
6992 (unsigned)bfd_getl32 (lab->value));
6995 case DST__K_DIS_RANGE:
6997 unsigned int cnt = bfd_getl32 (buf);
6998 unsigned char *rng = buf + 4;
7001 fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
7002 for (i = 0; i < cnt; i++, rng += 8)
7003 fprintf (file, _(" address: 0x%08x, size: %u\n"),
7004 (unsigned)bfd_getl32 (rng),
7005 (unsigned)bfd_getl32 (rng + 4));
7009 case DST__K_LINE_NUM:
7011 unsigned char *buf_orig = buf;
7013 fprintf (file, _("line num (len: %u)\n"), len);
7018 unsigned char cmdlen;
7028 case DST__K_DELTA_PC_W:
7029 val = bfd_getl16 (buf + 1);
7030 fprintf (file, _("delta_pc_w %u\n"), val);
7035 case DST__K_INCR_LINUM:
7037 fprintf (file, _("incr_linum(b): +%u\n"), val);
7041 case DST__K_INCR_LINUM_W:
7042 val = bfd_getl16 (buf + 1);
7043 fprintf (file, _("incr_linum_w: +%u\n"), val);
7047 case DST__K_INCR_LINUM_L:
7048 val = bfd_getl32 (buf + 1);
7049 fprintf (file, _("incr_linum_l: +%u\n"), val);
7053 case DST__K_SET_LINUM:
7054 line = bfd_getl16 (buf + 1);
7055 fprintf (file, _("set_line_num(w) %u\n"), line);
7058 case DST__K_SET_LINUM_B:
7060 fprintf (file, _("set_line_num_b %u\n"), line);
7063 case DST__K_SET_LINUM_L:
7064 line = bfd_getl32 (buf + 1);
7065 fprintf (file, _("set_line_num_l %u\n"), line);
7068 case DST__K_SET_ABS_PC:
7069 pc = bfd_getl32 (buf + 1);
7070 fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7073 case DST__K_DELTA_PC_L:
7074 fprintf (file, _("delta_pc_l: +0x%08x\n"),
7075 (unsigned)bfd_getl32 (buf + 1));
7079 fprintf (file, _("term(b): 0x%02x"), buf[1]);
7081 fprintf (file, _(" pc: 0x%08x\n"), pc);
7085 val = bfd_getl16 (buf + 1);
7086 fprintf (file, _("term_w: 0x%04x"), val);
7088 fprintf (file, _(" pc: 0x%08x\n"), pc);
7094 fprintf (file, _("delta pc +%-4d"), -cmd);
7095 line++; /* FIXME: curr increment. */
7097 fprintf (file, _(" pc: 0x%08x line: %5u\n"),
7102 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7115 unsigned char *buf_orig = buf;
7117 fprintf (file, _("source (len: %u)\n"), len);
7121 signed char cmd = buf[0];
7122 unsigned char cmdlen = 0;
7126 case DST__K_SRC_DECLFILE:
7128 struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7131 fprintf (file, _(" declfile: len: %u, flags: %u, "
7133 src->length, src->flags,
7134 (unsigned)bfd_getl16 (src->fileid));
7135 fprintf (file, _(" rms: cdt: 0x%08x %08x, "
7136 "ebk: 0x%08x, ffb: 0x%04x, "
7138 (unsigned)bfd_getl32 (src->rms_cdt + 4),
7139 (unsigned)bfd_getl32 (src->rms_cdt + 0),
7140 (unsigned)bfd_getl32 (src->rms_ebk),
7141 (unsigned)bfd_getl16 (src->rms_ffb),
7143 name = (const char *)buf + 1 + sizeof (*src);
7144 fprintf (file, _(" filename : %.*s\n"),
7146 name += name[0] + 1;
7147 fprintf (file, _(" module name: %.*s\n"),
7149 cmdlen = 2 + src->length;
7152 case DST__K_SRC_SETFILE:
7153 fprintf (file, _(" setfile %u\n"),
7154 (unsigned)bfd_getl16 (buf + 1));
7157 case DST__K_SRC_SETREC_W:
7158 fprintf (file, _(" setrec %u\n"),
7159 (unsigned)bfd_getl16 (buf + 1));
7162 case DST__K_SRC_SETREC_L:
7163 fprintf (file, _(" setrec %u\n"),
7164 (unsigned)bfd_getl32 (buf + 1));
7167 case DST__K_SRC_SETLNUM_W:
7168 fprintf (file, _(" setlnum %u\n"),
7169 (unsigned)bfd_getl16 (buf + 1));
7172 case DST__K_SRC_SETLNUM_L:
7173 fprintf (file, _(" setlnum %u\n"),
7174 (unsigned)bfd_getl32 (buf + 1));
7177 case DST__K_SRC_DEFLINES_W:
7178 fprintf (file, _(" deflines %u\n"),
7179 (unsigned)bfd_getl16 (buf + 1));
7182 case DST__K_SRC_DEFLINES_B:
7183 fprintf (file, _(" deflines %u\n"), buf[1]);
7186 case DST__K_SRC_FORMFEED:
7187 fprintf (file, _(" formfeed\n"));
7191 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7203 fprintf (file, _("*unhandled* dst type %u\n"), type);
7211 evax_bfd_print_image (bfd *abfd, FILE *file)
7213 struct vms_eihd eihd;
7216 unsigned int eiha_off;
7217 unsigned int eihi_off;
7218 unsigned int eihs_off;
7219 unsigned int eisd_off;
7220 unsigned int eihef_off = 0;
7221 unsigned int eihnp_off = 0;
7222 unsigned int dmt_vbn = 0;
7223 unsigned int dmt_size = 0;
7224 unsigned int dst_vbn = 0;
7225 unsigned int dst_size = 0;
7226 unsigned int gst_vbn = 0;
7227 unsigned int gst_size = 0;
7228 unsigned int eiaf_vbn = 0;
7229 unsigned int eiaf_size = 0;
7230 unsigned int eihvn_off;
7232 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7233 || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7235 fprintf (file, _("cannot read EIHD\n"));
7238 fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7239 (unsigned)bfd_getl32 (eihd.size),
7240 (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7241 fprintf (file, _(" majorid: %u, minorid: %u\n"),
7242 (unsigned)bfd_getl32 (eihd.majorid),
7243 (unsigned)bfd_getl32 (eihd.minorid));
7245 val = (unsigned)bfd_getl32 (eihd.imgtype);
7249 name = _("executable");
7252 name = _("linkable image");
7255 name = _("unknown");
7258 fprintf (file, _(" image type: %u (%s)"), val, name);
7260 val = (unsigned)bfd_getl32 (eihd.subtype);
7263 case EIHD__C_NATIVE:
7270 name = _("unknown");
7273 fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7275 eisd_off = bfd_getl32 (eihd.isdoff);
7276 eiha_off = bfd_getl32 (eihd.activoff);
7277 eihi_off = bfd_getl32 (eihd.imgidoff);
7278 eihs_off = bfd_getl32 (eihd.symdbgoff);
7279 fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7280 "imgid: %u, patch: %u\n"),
7281 eisd_off, eiha_off, eihs_off, eihi_off,
7282 (unsigned)bfd_getl32 (eihd.patchoff));
7283 fprintf (file, _(" fixup info rva: "));
7284 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7285 fprintf (file, _(", symbol vector rva: "));
7286 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7287 eihvn_off = bfd_getl32 (eihd.version_array_off);
7288 fprintf (file, _("\n"
7289 " version array off: %u\n"),
7292 _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7293 (unsigned)bfd_getl32 (eihd.imgiocnt),
7294 (unsigned)bfd_getl32 (eihd.iochancnt),
7295 (unsigned)bfd_getl32 (eihd.privreqs + 4),
7296 (unsigned)bfd_getl32 (eihd.privreqs + 0));
7297 val = (unsigned)bfd_getl32 (eihd.lnkflags);
7298 fprintf (file, _(" linker flags: %08x:"), val);
7299 if (val & EIHD__M_LNKDEBUG)
7300 fprintf (file, " LNKDEBUG");
7301 if (val & EIHD__M_LNKNOTFR)
7302 fprintf (file, " LNKNOTFR");
7303 if (val & EIHD__M_NOP0BUFS)
7304 fprintf (file, " NOP0BUFS");
7305 if (val & EIHD__M_PICIMG)
7306 fprintf (file, " PICIMG");
7307 if (val & EIHD__M_P0IMAGE)
7308 fprintf (file, " P0IMAGE");
7309 if (val & EIHD__M_DBGDMT)
7310 fprintf (file, " DBGDMT");
7311 if (val & EIHD__M_INISHR)
7312 fprintf (file, " INISHR");
7313 if (val & EIHD__M_XLATED)
7314 fprintf (file, " XLATED");
7315 if (val & EIHD__M_BIND_CODE_SEC)
7316 fprintf (file, " BIND_CODE_SEC");
7317 if (val & EIHD__M_BIND_DATA_SEC)
7318 fprintf (file, " BIND_DATA_SEC");
7319 if (val & EIHD__M_MKTHREADS)
7320 fprintf (file, " MKTHREADS");
7321 if (val & EIHD__M_UPCALLS)
7322 fprintf (file, " UPCALLS");
7323 if (val & EIHD__M_OMV_READY)
7324 fprintf (file, " OMV_READY");
7325 if (val & EIHD__M_EXT_BIND_SECT)
7326 fprintf (file, " EXT_BIND_SECT");
7327 fprintf (file, "\n");
7328 fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7329 "match ctrl: %u, symvect_size: %u\n"),
7330 (unsigned)bfd_getl32 (eihd.ident),
7331 (unsigned)bfd_getl32 (eihd.sysver),
7333 (unsigned)bfd_getl32 (eihd.symvect_size));
7334 fprintf (file, _(" BPAGE: %u"),
7335 (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7336 if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7338 eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7339 eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7340 fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7341 eihef_off, eihnp_off);
7343 fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7347 struct vms_eihvn eihvn;
7351 fprintf (file, _("system version array information:\n"));
7352 if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7353 || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7355 fprintf (file, _("cannot read EIHVN header\n"));
7358 mask = bfd_getl32 (eihvn.subsystem_mask);
7359 for (j = 0; j < 32; j++)
7360 if (mask & (1 << j))
7362 struct vms_eihvn_subversion ver;
7363 if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7365 fprintf (file, _("cannot read EIHVN version\n"));
7368 fprintf (file, _(" %02u "), j);
7371 case EIHVN__BASE_IMAGE_BIT:
7372 fputs (_("BASE_IMAGE "), file);
7374 case EIHVN__MEMORY_MANAGEMENT_BIT:
7375 fputs (_("MEMORY_MANAGEMENT"), file);
7378 fputs (_("IO "), file);
7380 case EIHVN__FILES_VOLUMES_BIT:
7381 fputs (_("FILES_VOLUMES "), file);
7383 case EIHVN__PROCESS_SCHED_BIT:
7384 fputs (_("PROCESS_SCHED "), file);
7386 case EIHVN__SYSGEN_BIT:
7387 fputs (_("SYSGEN "), file);
7389 case EIHVN__CLUSTERS_LOCKMGR_BIT:
7390 fputs (_("CLUSTERS_LOCKMGR "), file);
7392 case EIHVN__LOGICAL_NAMES_BIT:
7393 fputs (_("LOGICAL_NAMES "), file);
7395 case EIHVN__SECURITY_BIT:
7396 fputs (_("SECURITY "), file);
7398 case EIHVN__IMAGE_ACTIVATOR_BIT:
7399 fputs (_("IMAGE_ACTIVATOR "), file);
7401 case EIHVN__NETWORKS_BIT:
7402 fputs (_("NETWORKS "), file);
7404 case EIHVN__COUNTERS_BIT:
7405 fputs (_("COUNTERS "), file);
7407 case EIHVN__STABLE_BIT:
7408 fputs (_("STABLE "), file);
7410 case EIHVN__MISC_BIT:
7411 fputs (_("MISC "), file);
7413 case EIHVN__CPU_BIT:
7414 fputs (_("CPU "), file);
7416 case EIHVN__VOLATILE_BIT:
7417 fputs (_("VOLATILE "), file);
7419 case EIHVN__SHELL_BIT:
7420 fputs (_("SHELL "), file);
7422 case EIHVN__POSIX_BIT:
7423 fputs (_("POSIX "), file);
7425 case EIHVN__MULTI_PROCESSING_BIT:
7426 fputs (_("MULTI_PROCESSING "), file);
7428 case EIHVN__GALAXY_BIT:
7429 fputs (_("GALAXY "), file);
7432 fputs (_("*unknown* "), file);
7435 fprintf (file, _(": %u.%u\n"),
7436 (unsigned)bfd_getl16 (ver.major),
7437 (unsigned)bfd_getl16 (ver.minor));
7443 struct vms_eiha eiha;
7445 if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7446 || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7448 fprintf (file, _("cannot read EIHA\n"));
7451 fprintf (file, _("Image activation: (size=%u)\n"),
7452 (unsigned)bfd_getl32 (eiha.size));
7453 fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7454 (unsigned)bfd_getl32 (eiha.tfradr1_h),
7455 (unsigned)bfd_getl32 (eiha.tfradr1));
7456 fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7457 (unsigned)bfd_getl32 (eiha.tfradr2_h),
7458 (unsigned)bfd_getl32 (eiha.tfradr2));
7459 fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7460 (unsigned)bfd_getl32 (eiha.tfradr3_h),
7461 (unsigned)bfd_getl32 (eiha.tfradr3));
7462 fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7463 (unsigned)bfd_getl32 (eiha.tfradr4_h),
7464 (unsigned)bfd_getl32 (eiha.tfradr4));
7465 fprintf (file, _(" Shared image : 0x%08x 0x%08x\n"),
7466 (unsigned)bfd_getl32 (eiha.inishr_h),
7467 (unsigned)bfd_getl32 (eiha.inishr));
7471 struct vms_eihi eihi;
7473 if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7474 || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7476 fprintf (file, _("cannot read EIHI\n"));
7479 fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7480 (unsigned)bfd_getl32 (eihi.majorid),
7481 (unsigned)bfd_getl32 (eihi.minorid));
7482 fprintf (file, _(" image name : %.*s\n"),
7483 eihi.imgnam[0], eihi.imgnam + 1);
7484 fprintf (file, _(" link time : %s\n"),
7485 vms_time_to_str (eihi.linktime));
7486 fprintf (file, _(" image ident : %.*s\n"),
7487 eihi.imgid[0], eihi.imgid + 1);
7488 fprintf (file, _(" linker ident : %.*s\n"),
7489 eihi.linkid[0], eihi.linkid + 1);
7490 fprintf (file, _(" image build ident: %.*s\n"),
7491 eihi.imgbid[0], eihi.imgbid + 1);
7495 struct vms_eihs eihs;
7497 if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7498 || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7500 fprintf (file, _("cannot read EIHS\n"));
7503 fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7504 (unsigned)bfd_getl32 (eihs.majorid),
7505 (unsigned)bfd_getl32 (eihs.minorid));
7506 dst_vbn = bfd_getl32 (eihs.dstvbn);
7507 dst_size = bfd_getl32 (eihs.dstsize);
7508 fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7509 dst_vbn, dst_size, dst_size);
7510 gst_vbn = bfd_getl32 (eihs.gstvbn);
7511 gst_size = bfd_getl32 (eihs.gstsize);
7512 fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7514 dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7515 dmt_size = bfd_getl32 (eihs.dmtsize);
7516 fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7519 while (eisd_off != 0)
7521 struct vms_eisd eisd;
7526 if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7527 || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7529 fprintf (file, _("cannot read EISD\n"));
7532 len = (unsigned)bfd_getl32 (eisd.eisdsize);
7533 if (len != (unsigned)-1)
7537 eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7539 fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7540 "size: %u, offset: %u)\n"),
7541 (unsigned)bfd_getl32 (eisd.majorid),
7542 (unsigned)bfd_getl32 (eisd.minorid),
7546 fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7547 (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7548 (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7549 (unsigned)bfd_getl32 (eisd.secsize));
7550 val = (unsigned)bfd_getl32 (eisd.flags);
7551 fprintf (file, _(" flags: 0x%04x"), val);
7552 if (val & EISD__M_GBL)
7553 fprintf (file, " GBL");
7554 if (val & EISD__M_CRF)
7555 fprintf (file, " CRF");
7556 if (val & EISD__M_DZRO)
7557 fprintf (file, " DZRO");
7558 if (val & EISD__M_WRT)
7559 fprintf (file, " WRT");
7560 if (val & EISD__M_INITALCODE)
7561 fprintf (file, " INITALCODE");
7562 if (val & EISD__M_BASED)
7563 fprintf (file, " BASED");
7564 if (val & EISD__M_FIXUPVEC)
7565 fprintf (file, " FIXUPVEC");
7566 if (val & EISD__M_RESIDENT)
7567 fprintf (file, " RESIDENT");
7568 if (val & EISD__M_VECTOR)
7569 fprintf (file, " VECTOR");
7570 if (val & EISD__M_PROTECT)
7571 fprintf (file, " PROTECT");
7572 if (val & EISD__M_LASTCLU)
7573 fprintf (file, " LASTCLU");
7574 if (val & EISD__M_EXE)
7575 fprintf (file, " EXE");
7576 if (val & EISD__M_NONSHRADR)
7577 fprintf (file, " NONSHRADR");
7578 if (val & EISD__M_QUAD_LENGTH)
7579 fprintf (file, " QUAD_LENGTH");
7580 if (val & EISD__M_ALLOC_64BIT)
7581 fprintf (file, " ALLOC_64BIT");
7582 fprintf (file, "\n");
7583 if (val & EISD__M_FIXUPVEC)
7585 eiaf_vbn = bfd_getl32 (eisd.vbn);
7586 eiaf_size = bfd_getl32 (eisd.secsize);
7588 fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7589 (unsigned)bfd_getl32 (eisd.vbn),
7590 eisd.pfc, eisd.matchctl, eisd.type);
7593 case EISD__K_NORMAL:
7594 fputs (_("NORMAL"), file);
7596 case EISD__K_SHRFXD:
7597 fputs (_("SHRFXD"), file);
7599 case EISD__K_PRVFXD:
7600 fputs (_("PRVFXD"), file);
7602 case EISD__K_SHRPIC:
7603 fputs (_("SHRPIC"), file);
7605 case EISD__K_PRVPIC:
7606 fputs (_("PRVPIC"), file);
7608 case EISD__K_USRSTACK:
7609 fputs (_("USRSTACK"), file);
7612 fputs (_("*unknown*"), file);
7615 fputs (_(")\n"), file);
7616 if (val & EISD__M_GBL)
7617 fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7618 (unsigned)bfd_getl32 (eisd.ident),
7619 eisd.gblnam[0], eisd.gblnam + 1);
7625 if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7627 fprintf (file, _("cannot read DMT\n"));
7631 fprintf (file, _("Debug module table:\n"));
7633 while (dmt_size > 0)
7635 struct vms_dmt_header dmth;
7638 if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7640 fprintf (file, _("cannot read DMT header\n"));
7643 count = bfd_getl16 (dmth.psect_count);
7645 _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
7646 (unsigned)bfd_getl32 (dmth.modbeg),
7647 (unsigned)bfd_getl32 (dmth.size), count);
7648 dmt_size -= sizeof (dmth);
7651 struct vms_dmt_psect dmtp;
7653 if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7655 fprintf (file, _("cannot read DMT psect\n"));
7658 fprintf (file, _(" psect start: 0x%08x, length: %u\n"),
7659 (unsigned)bfd_getl32 (dmtp.start),
7660 (unsigned)bfd_getl32 (dmtp.length));
7662 dmt_size -= sizeof (dmtp);
7669 if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7671 fprintf (file, _("cannot read DST\n"));
7675 evax_bfd_print_dst (abfd, dst_size, file);
7679 if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7681 fprintf (file, _("cannot read GST\n"));
7685 fprintf (file, _("Global symbol table:\n"));
7686 evax_bfd_print_eobj (abfd, file);
7691 struct vms_eiaf *eiaf;
7692 unsigned int qrelfixoff;
7693 unsigned int lrelfixoff;
7694 unsigned int qdotadroff;
7695 unsigned int ldotadroff;
7696 unsigned int shrimgcnt;
7697 unsigned int shlstoff;
7698 unsigned int codeadroff;
7699 unsigned int lpfixoff;
7700 unsigned int chgprtoff;
7702 buf = bfd_malloc (eiaf_size);
7704 if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7705 || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7707 fprintf (file, _("cannot read EIHA\n"));
7711 eiaf = (struct vms_eiaf *)buf;
7713 _("Image activator fixup: (major: %u, minor: %u)\n"),
7714 (unsigned)bfd_getl32 (eiaf->majorid),
7715 (unsigned)bfd_getl32 (eiaf->minorid));
7716 fprintf (file, _(" iaflink : 0x%08x %08x\n"),
7717 (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7718 (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7719 fprintf (file, _(" fixuplnk: 0x%08x %08x\n"),
7720 (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7721 (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7722 fprintf (file, _(" size : %u\n"),
7723 (unsigned)bfd_getl32 (eiaf->size));
7724 fprintf (file, _(" flags: 0x%08x\n"),
7725 (unsigned)bfd_getl32 (eiaf->flags));
7726 qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7727 lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7728 fprintf (file, _(" qrelfixoff: %5u, lrelfixoff: %5u\n"),
7729 qrelfixoff, lrelfixoff);
7730 qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7731 ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7732 fprintf (file, _(" qdotadroff: %5u, ldotadroff: %5u\n"),
7733 qdotadroff, ldotadroff);
7734 codeadroff = bfd_getl32 (eiaf->codeadroff);
7735 lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7736 fprintf (file, _(" codeadroff: %5u, lpfixoff : %5u\n"),
7737 codeadroff, lpfixoff);
7738 chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7739 fprintf (file, _(" chgprtoff : %5u\n"), chgprtoff);
7740 shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7741 shlstoff = bfd_getl32 (eiaf->shlstoff);
7742 fprintf (file, _(" shlstoff : %5u, shrimgcnt : %5u\n"),
7743 shlstoff, shrimgcnt);
7744 fprintf (file, _(" shlextra : %5u, permctx : %5u\n"),
7745 (unsigned)bfd_getl32 (eiaf->shlextra),
7746 (unsigned)bfd_getl32 (eiaf->permctx));
7747 fprintf (file, _(" base_va : 0x%08x\n"),
7748 (unsigned)bfd_getl32 (eiaf->base_va));
7749 fprintf (file, _(" lppsbfixoff: %5u\n"),
7750 (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7754 struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7757 fprintf (file, _(" Shareable images:\n"));
7758 for (j = 0; j < shrimgcnt; j++, shl++)
7761 _(" %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7762 j, shl->size, shl->flags,
7763 shl->imgnam[0], shl->imgnam + 1);
7766 if (qrelfixoff != 0)
7768 fprintf (file, _(" quad-word relocation fixups:\n"));
7769 evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7771 if (lrelfixoff != 0)
7773 fprintf (file, _(" long-word relocation fixups:\n"));
7774 evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7776 if (qdotadroff != 0)
7778 fprintf (file, _(" quad-word .address reference fixups:\n"));
7779 evax_bfd_print_address_fixups (file, buf + qdotadroff);
7781 if (ldotadroff != 0)
7783 fprintf (file, _(" long-word .address reference fixups:\n"));
7784 evax_bfd_print_address_fixups (file, buf + ldotadroff);
7786 if (codeadroff != 0)
7788 fprintf (file, _(" Code Address Reference Fixups:\n"));
7789 evax_bfd_print_reference_fixups (file, buf + codeadroff);
7793 fprintf (file, _(" Linkage Pairs Referece Fixups:\n"));
7794 evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7798 unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7799 struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7802 fprintf (file, _(" Change Protection (%u entries):\n"), count);
7803 for (j = 0; j < count; j++, eicp++)
7805 unsigned int prot = bfd_getl32 (eicp->newprt);
7807 _(" base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7808 (unsigned)bfd_getl32 (eicp->baseva + 4),
7809 (unsigned)bfd_getl32 (eicp->baseva + 0),
7810 (unsigned)bfd_getl32 (eicp->size),
7811 (unsigned)bfd_getl32 (eicp->newprt));
7815 fprintf (file, "NA");
7817 case PRT__C_RESERVED:
7818 fprintf (file, "RES");
7821 fprintf (file, "KW");
7824 fprintf (file, "KR");
7827 fprintf (file, "UW");
7830 fprintf (file, "EW");
7833 fprintf (file, "ERKW");
7836 fprintf (file, "ER");
7839 fprintf (file, "SW");
7842 fprintf (file, "SREW");
7845 fprintf (file, "SRKW");
7848 fprintf (file, "SR");
7851 fprintf (file, "URSW");
7854 fprintf (file, "UREW");
7857 fprintf (file, "URKW");
7860 fprintf (file, "UR");
7874 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7876 FILE *file = (FILE *)ptr;
7878 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7879 evax_bfd_print_image (abfd, file);
7882 if (bfd_seek (abfd, 0, SEEK_SET))
7884 evax_bfd_print_eobj (abfd, file);
7891 /* Slurp ETIR/EDBG/ETBT VMS object records. */
7894 alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7896 asection *cur_section;
7897 file_ptr cur_offset;
7898 asection *dst_section;
7899 file_ptr dst_offset;
7901 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7907 dst_section = PRIV (dst_section);
7911 if (info->strip == strip_all || info->strip == strip_debugger)
7913 /* Discard the DST section. */
7917 else if (dst_section)
7919 dst_offset = dst_section->output_offset;
7920 dst_section = dst_section->output_section;
7929 type = _bfd_vms_get_object_record (abfd);
7932 vms_debug2 ((2, "next_record failed\n"));
7938 PRIV (image_section) = cur_section;
7939 PRIV (image_offset) = cur_offset;
7940 res = _bfd_vms_slurp_etir (abfd, info);
7941 cur_section = PRIV (image_section);
7942 cur_offset = PRIV (image_offset);
7946 if (dst_section == NULL)
7948 PRIV (image_section) = dst_section;
7949 PRIV (image_offset) = dst_offset;
7950 res = _bfd_vms_slurp_etir (abfd, info);
7951 dst_offset = PRIV (image_offset);
7960 vms_debug2 ((2, "slurp eobj type %d failed\n", type));
7967 alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
7968 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7973 /* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
7976 alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
7978 struct alpha_vms_shlib_el *sl;
7979 asection *sect = PRIV2 (src, image_section);
7980 file_ptr offset = PRIV2 (src, image_offset);
7982 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7983 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7984 sl->has_fixups = TRUE;
7985 VEC_APPEND_EL (sl->lp, bfd_vma,
7986 sect->output_section->vma + sect->output_offset + offset);
7990 alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
7992 struct alpha_vms_shlib_el *sl;
7993 asection *sect = PRIV2 (src, image_section);
7994 file_ptr offset = PRIV2 (src, image_offset);
7996 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7997 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7998 sl->has_fixups = TRUE;
7999 VEC_APPEND_EL (sl->ca, bfd_vma,
8000 sect->output_section->vma + sect->output_offset + offset);
8004 alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
8005 bfd *shlib, bfd_vma vec)
8007 struct alpha_vms_shlib_el *sl;
8008 struct alpha_vms_vma_ref *r;
8009 asection *sect = PRIV2 (src, image_section);
8010 file_ptr offset = PRIV2 (src, image_offset);
8012 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8013 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8014 sl->has_fixups = TRUE;
8015 r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
8016 r->vma = sect->output_section->vma + sect->output_offset + offset;
8021 alpha_vms_add_lw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8022 unsigned int shr ATTRIBUTE_UNUSED,
8023 bfd_vma vec ATTRIBUTE_UNUSED)
8030 alpha_vms_add_qw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8031 unsigned int shr ATTRIBUTE_UNUSED,
8032 bfd_vma vec ATTRIBUTE_UNUSED)
8039 alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8044 alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8048 static struct bfd_hash_entry *
8049 alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
8050 struct bfd_hash_table *table,
8053 struct alpha_vms_link_hash_entry *ret =
8054 (struct alpha_vms_link_hash_entry *) entry;
8056 /* Allocate the structure if it has not already been allocated by a
8059 ret = ((struct alpha_vms_link_hash_entry *)
8060 bfd_hash_allocate (table,
8061 sizeof (struct alpha_vms_link_hash_entry)));
8065 /* Call the allocation method of the superclass. */
8066 ret = ((struct alpha_vms_link_hash_entry *)
8067 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
8072 return (struct bfd_hash_entry *) ret;
8075 /* Create an Alpha/VMS link hash table. */
8077 static struct bfd_link_hash_table *
8078 alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8080 struct alpha_vms_link_hash_table *ret;
8081 bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8083 ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8086 if (!_bfd_link_hash_table_init (&ret->root, abfd,
8087 alpha_vms_link_hash_newfunc,
8088 sizeof (struct alpha_vms_link_hash_entry)))
8094 VEC_INIT (ret->shrlibs);
8101 alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8105 for (i = 0; i < PRIV (gsd_sym_count); i++)
8107 struct vms_symbol_entry *e = PRIV (syms)[i];
8108 struct alpha_vms_link_hash_entry *h;
8109 struct bfd_link_hash_entry *h_root;
8112 if (!alpha_vms_convert_symbol (abfd, e, &sym))
8115 if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8117 /* In selective_search mode, only add definition that are
8119 h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8120 (info->hash, sym.name, FALSE, FALSE, FALSE);
8121 if (h == NULL || h->root.type != bfd_link_hash_undefined)
8127 h_root = (struct bfd_link_hash_entry *) h;
8128 if (_bfd_generic_link_add_one_symbol
8129 (info, abfd, sym.name, sym.flags, sym.section, sym.value,
8130 NULL, FALSE, FALSE, &h_root) == FALSE)
8132 h = (struct alpha_vms_link_hash_entry *) h_root;
8134 if ((e->flags & EGSY__V_DEF)
8136 && abfd->xvec == info->output_bfd->xvec)
8140 if (abfd->flags & DYNAMIC)
8142 struct alpha_vms_shlib_el *shlib;
8144 /* We do not want to include any of the sections in a dynamic
8145 object in the output file. See comment in elflink.c. */
8146 bfd_section_list_clear (abfd);
8148 shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8149 struct alpha_vms_shlib_el);
8151 VEC_INIT (shlib->ca);
8152 VEC_INIT (shlib->lp);
8153 VEC_INIT (shlib->qr);
8154 PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8161 alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8164 struct bfd_link_hash_entry **pundef;
8165 struct bfd_link_hash_entry **next_pundef;
8167 /* We only accept VMS libraries. */
8168 if (info->output_bfd->xvec != abfd->xvec)
8170 bfd_set_error (bfd_error_wrong_format);
8174 /* The archive_pass field in the archive itself is used to
8175 initialize PASS, since we may search the same archive multiple
8177 pass = ++abfd->archive_pass;
8179 /* Look through the list of undefined symbols. */
8180 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8182 struct bfd_link_hash_entry *h;
8188 next_pundef = &(*pundef)->u.undef.next;
8190 /* When a symbol is defined, it is not necessarily removed from
8192 if (h->type != bfd_link_hash_undefined
8193 && h->type != bfd_link_hash_common)
8195 /* Remove this entry from the list, for general cleanliness
8196 and because we are going to look through the list again
8197 if we search any more libraries. We can't remove the
8198 entry if it is the tail, because that would lose any
8199 entries we add to the list later on. */
8200 if (*pundef != info->hash->undefs_tail)
8202 *pundef = *next_pundef;
8203 next_pundef = pundef;
8208 /* Look for this symbol in the archive hash table. */
8209 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8210 if (symidx == BFD_NO_MORE_SYMBOLS)
8212 /* Nothing in this slot. */
8216 element = bfd_get_elt_at_index (abfd, symidx);
8217 if (element == NULL)
8220 if (element->archive_pass == -1 || element->archive_pass == pass)
8223 if (! bfd_check_format (element, bfd_object))
8225 element->archive_pass = -1;
8229 orig_element = element;
8230 if (bfd_is_thin_archive (abfd))
8232 element = _bfd_vms_lib_get_imagelib_file (element);
8233 if (element == NULL || !bfd_check_format (element, bfd_object))
8235 orig_element->archive_pass = -1;
8240 /* Unlike the generic linker, we know that this element provides
8241 a definition for an undefined symbol and we know that we want
8242 to include it. We don't need to check anything. */
8243 if (! (*info->callbacks->add_archive_element) (info, element,
8246 if (! alpha_vms_link_add_object_symbols (element, info))
8249 orig_element->archive_pass = pass;
8256 alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8258 switch (bfd_get_format (abfd))
8261 vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8263 return alpha_vms_link_add_object_symbols (abfd, info);
8266 vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8268 return alpha_vms_link_add_archive_symbols (abfd, info);
8271 bfd_set_error (bfd_error_wrong_format);
8277 alpha_vms_build_fixups (struct bfd_link_info *info)
8279 struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8280 unsigned char *content;
8282 unsigned int sz = 0;
8283 unsigned int lp_sz = 0;
8284 unsigned int ca_sz = 0;
8285 unsigned int qr_sz = 0;
8286 unsigned int shrimg_cnt = 0;
8287 struct vms_eiaf *eiaf;
8291 /* Shared libraries. */
8292 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8294 struct alpha_vms_shlib_el *shlib;
8296 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8298 if (!shlib->has_fixups)
8303 if (VEC_COUNT (shlib->ca) > 0)
8305 /* Header + entries. */
8307 ca_sz += VEC_COUNT (shlib->ca) * 4;
8309 if (VEC_COUNT (shlib->lp) > 0)
8311 /* Header + entries. */
8313 lp_sz += VEC_COUNT (shlib->lp) * 4;
8315 if (VEC_COUNT (shlib->qr) > 0)
8317 /* Header + entries. */
8319 qr_sz += VEC_COUNT (shlib->qr) * 8;
8330 /* Finish now if there is no content. */
8331 if (ca_sz + lp_sz + qr_sz == 0)
8334 /* Allocate section content (round-up size) */
8335 sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8336 + ca_sz + lp_sz + qr_sz;
8337 sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8338 content = bfd_zalloc (info->output_bfd, sz);
8339 if (content == NULL)
8342 sec = alpha_vms_link_hash (info)->fixup;
8343 sec->contents = content;
8346 eiaf = (struct vms_eiaf *)content;
8347 off = sizeof (struct vms_eiaf);
8348 bfd_putl32 (0, eiaf->majorid);
8349 bfd_putl32 (0, eiaf->minorid);
8350 bfd_putl32 (0, eiaf->iaflink);
8351 bfd_putl32 (0, eiaf->fixuplnk);
8352 bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8353 bfd_putl32 (0, eiaf->flags);
8354 bfd_putl32 (0, eiaf->qrelfixoff);
8355 bfd_putl32 (0, eiaf->lrelfixoff);
8356 bfd_putl32 (0, eiaf->qdotadroff);
8357 bfd_putl32 (0, eiaf->ldotadroff);
8358 bfd_putl32 (0, eiaf->codeadroff);
8359 bfd_putl32 (0, eiaf->lpfixoff);
8360 bfd_putl32 (0, eiaf->chgprtoff);
8361 bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8362 bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8363 bfd_putl32 (0, eiaf->shlextra);
8364 bfd_putl32 (0, eiaf->permctx);
8365 bfd_putl32 (0, eiaf->base_va);
8366 bfd_putl32 (0, eiaf->lppsbfixoff);
8373 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8375 struct alpha_vms_shlib_el *shlib;
8376 struct vms_shl *shl;
8378 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8380 if (!shlib->has_fixups)
8383 /* Renumber shared images. */
8384 PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8386 shl = (struct vms_shl *)(content + off);
8387 bfd_putl32 (0, shl->baseva);
8388 bfd_putl32 (0, shl->shlptr);
8389 bfd_putl32 (0, shl->ident);
8390 bfd_putl32 (0, shl->permctx);
8391 shl->size = sizeof (struct vms_shl);
8392 bfd_putl16 (0, shl->fill_1);
8394 bfd_putl32 (0, shl->icb);
8395 shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8396 memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8399 off += sizeof (struct vms_shl);
8405 bfd_putl32 (off, eiaf->codeadroff);
8407 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8409 struct alpha_vms_shlib_el *shlib;
8412 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8414 if (VEC_COUNT (shlib->ca) == 0)
8417 bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8418 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8421 for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8423 bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8429 bfd_putl32 (0, content + off);
8430 bfd_putl32 (0, content + off + 4);
8437 bfd_putl32 (off, eiaf->lpfixoff);
8439 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8441 struct alpha_vms_shlib_el *shlib;
8444 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8446 if (VEC_COUNT (shlib->lp) == 0)
8449 bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8450 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8453 for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8455 bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8461 bfd_putl32 (0, content + off);
8462 bfd_putl32 (0, content + off + 4);
8469 bfd_putl32 (off, eiaf->qdotadroff);
8471 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8473 struct alpha_vms_shlib_el *shlib;
8476 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8478 if (VEC_COUNT (shlib->qr) == 0)
8481 bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8482 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8485 for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8487 struct alpha_vms_vma_ref *r;
8488 r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8489 bfd_putl32 (r->vma - t->base_addr, content + off);
8490 bfd_putl32 (r->ref, content + off + 4);
8495 bfd_putl32 (0, content + off);
8496 bfd_putl32 (0, content + off + 4);
8506 /* Called by bfd_link_hash_traverse to fill the symbol table.
8507 Return FALSE in case of failure. */
8510 alpha_vms_link_output_symbol (struct bfd_link_hash_entry *hc, void *infov)
8512 struct bfd_link_info *info = (struct bfd_link_info *)infov;
8513 struct alpha_vms_link_hash_entry *h = (struct alpha_vms_link_hash_entry *)hc;
8514 struct vms_symbol_entry *sym;
8516 switch (h->root.type)
8518 case bfd_link_hash_new:
8519 case bfd_link_hash_undefined:
8521 case bfd_link_hash_undefweak:
8523 case bfd_link_hash_defined:
8524 case bfd_link_hash_defweak:
8526 asection *sec = h->root.u.def.section;
8528 /* FIXME: this is certainly a symbol from a dynamic library. */
8529 if (bfd_is_abs_section (sec))
8532 if (sec->owner->flags & DYNAMIC)
8536 case bfd_link_hash_common:
8538 case bfd_link_hash_indirect:
8539 case bfd_link_hash_warning:
8543 /* Do not write not kept symbols. */
8544 if (info->strip == strip_some
8545 && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8546 FALSE, FALSE) != NULL)
8551 /* This symbol doesn't come from a VMS object. So we suppose it is
8553 int len = strlen (h->root.root.string);
8555 sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8556 sizeof (*sym) + len);
8560 memcpy (sym->name, h->root.root.string, len);
8562 sym->owner = info->output_bfd;
8564 sym->typ = EGSD__C_SYMG;
8566 sym->flags = EGSY__V_DEF | EGSY__V_REL;
8567 sym->symbol_vector = h->root.u.def.value;
8568 sym->section = h->root.u.def.section;
8569 sym->value = h->root.u.def.value;
8574 if (!add_symbol_entry (info->output_bfd, sym))
8581 alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8584 struct bfd_link_order *p;
8592 bfd_get_outsymbols (abfd) = NULL;
8593 bfd_get_symcount (abfd) = 0;
8595 /* Mark all sections which will be included in the output file. */
8596 for (o = abfd->sections; o != NULL; o = o->next)
8597 for (p = o->map_head.link_order; p != NULL; p = p->next)
8598 if (p->type == bfd_indirect_link_order)
8599 p->u.indirect.section->linker_mark = TRUE;
8602 /* Handle all the link order information for the sections. */
8603 for (o = abfd->sections; o != NULL; o = o->next)
8605 printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8606 o->name, (unsigned)o->vma, (unsigned)o->flags);
8608 for (p = o->map_head.link_order; p != NULL; p = p->next)
8610 printf (" at 0x%08x - 0x%08x: ",
8611 (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8614 case bfd_section_reloc_link_order:
8615 case bfd_symbol_reloc_link_order:
8616 printf (" section/symbol reloc\n");
8618 case bfd_indirect_link_order:
8619 printf (" section %s of %s\n",
8620 p->u.indirect.section->name,
8621 p->u.indirect.section->owner->filename);
8623 case bfd_data_link_order:
8624 printf (" explicit data\n");
8627 printf (" *unknown* type %u\n", p->type);
8634 /* Generate the symbol table. */
8635 BFD_ASSERT (PRIV (syms) == NULL);
8636 if (info->strip != strip_all)
8637 bfd_link_hash_traverse (info->hash, alpha_vms_link_output_symbol, info);
8639 /* Find the entry point. */
8640 if (bfd_get_start_address (abfd) == 0)
8642 bfd *startbfd = NULL;
8644 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8646 /* Consider only VMS object files. */
8647 if (sub->xvec != abfd->xvec)
8650 if (!PRIV2 (sub, eom_data).eom_has_transfer)
8652 if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8654 if (startbfd != NULL
8655 && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8657 (*info->callbacks->einfo)
8658 (_("%P: multiple entry points: in modules %B and %B\n"),
8667 unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8668 bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8671 sec = PRIV2 (startbfd, sections)[ps_idx];
8673 bfd_set_start_address
8674 (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8678 /* Set transfer addresses. */
8681 struct bfd_link_hash_entry *h;
8684 PRIV (transfer_address[i++]) = 0xffffffff00000340ULL; /* SYS$IMGACT */
8685 h = bfd_link_hash_lookup (info->hash, "LIB$INITIALIZE", FALSE, FALSE, TRUE);
8686 if (h != NULL && h->type == bfd_link_hash_defined)
8687 PRIV (transfer_address[i++]) =
8688 alpha_vms_get_sym_value (h->u.def.section, h->u.def.value);
8689 PRIV (transfer_address[i++]) = bfd_get_start_address (abfd);
8691 PRIV (transfer_address[i++]) = 0;
8694 /* Allocate contents. */
8695 base_addr = (bfd_vma)-1;
8697 for (o = abfd->sections; o != NULL; o = o->next)
8699 if (o->flags & SEC_HAS_CONTENTS)
8701 o->contents = bfd_alloc (abfd, o->size);
8702 if (o->contents == NULL)
8705 if (o->flags & SEC_LOAD)
8707 if (o->vma < base_addr)
8709 if (o->vma + o->size > last_addr)
8710 last_addr = o->vma + o->size;
8714 /* Create the fixup section. */
8715 fixupsec = bfd_make_section_anyway_with_flags
8716 (info->output_bfd, "$FIXUP$",
8717 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8718 if (fixupsec == NULL)
8720 last_addr = (last_addr + 0xffff) & ~0xffff;
8721 fixupsec->vma = last_addr;
8723 alpha_vms_link_hash (info)->fixup = fixupsec;
8724 alpha_vms_link_hash (info)->base_addr = base_addr;
8726 /* Create the DMT section, if necessary. */
8727 BFD_ASSERT (PRIV (dst_section) == NULL);
8728 dst = bfd_get_section_by_name (abfd, "$DST$");
8729 if (dst != NULL && dst->size == 0)
8733 PRIV (dst_section) = dst;
8734 dmt = bfd_make_section_anyway_with_flags
8735 (info->output_bfd, "$DMT$",
8736 SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8743 /* Read all sections from the inputs. */
8744 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8746 if (sub->flags & DYNAMIC)
8748 alpha_vms_create_eisd_for_shared (abfd, sub);
8752 if (!alpha_vms_read_sections_content (sub, info))
8756 /* Handle all the link order information for the sections.
8757 Note: past this point, it is not possible to create new sections. */
8758 for (o = abfd->sections; o != NULL; o = o->next)
8760 for (p = o->map_head.link_order; p != NULL; p = p->next)
8764 case bfd_section_reloc_link_order:
8765 case bfd_symbol_reloc_link_order:
8768 case bfd_indirect_link_order:
8772 if (! _bfd_default_link_order (abfd, info, o, p))
8779 /* Compute fixups. */
8780 if (!alpha_vms_build_fixups (info))
8783 /* Compute the DMT. */
8787 unsigned char *contents = NULL;
8789 /* In pass 1, compute the size. In pass 2, write the DMT contents. */
8790 for (pass = 0; pass < 2; pass++)
8792 unsigned int off = 0;
8794 /* For each object file (ie for each module). */
8795 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8798 struct vms_dmt_header *dmth = NULL;
8799 unsigned int psect_count;
8801 /* Skip this module if it has no DST. */
8802 sub_dst = PRIV2 (sub, dst_section);
8803 if (sub_dst == NULL || sub_dst->size == 0)
8808 /* Write the header. */
8809 dmth = (struct vms_dmt_header *)(contents + off);
8810 bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8811 bfd_putl32 (sub_dst->size, dmth->size);
8814 off += sizeof (struct vms_dmt_header);
8817 /* For each section (ie for each psect). */
8818 for (o = sub->sections; o != NULL; o = o->next)
8820 /* Only consider interesting sections. */
8821 if (!(o->flags & SEC_ALLOC))
8823 if (o->flags & SEC_LINKER_CREATED)
8828 /* Write an entry. */
8829 struct vms_dmt_psect *dmtp;
8831 dmtp = (struct vms_dmt_psect *)(contents + off);
8832 bfd_putl32 (o->output_offset + o->output_section->vma,
8834 bfd_putl32 (o->size, dmtp->length);
8837 off += sizeof (struct vms_dmt_psect);
8840 bfd_putl32 (psect_count, dmth->psect_count);
8845 contents = bfd_zalloc (info->output_bfd, off);
8846 if (contents == NULL)
8848 dmt->contents = contents;
8853 BFD_ASSERT (off == dmt->size);
8861 /* Read the contents of a section.
8862 buf points to a buffer of buf_size bytes to be filled with
8863 section data (starting at offset into section) */
8866 alpha_vms_get_section_contents (bfd *abfd, asection *section,
8867 void *buf, file_ptr offset,
8868 bfd_size_type count)
8872 /* Image are easy. */
8873 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8874 return _bfd_generic_get_section_contents (abfd, section,
8875 buf, offset, count);
8878 if (offset + count < count
8879 || offset + count > section->size)
8881 bfd_set_error (bfd_error_invalid_operation);
8885 /* Alloc in memory and read ETIRs. */
8886 BFD_ASSERT (section->contents == NULL);
8888 for (sec = abfd->sections; sec; sec = sec->next)
8890 BFD_ASSERT (sec->contents == NULL);
8892 if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
8894 sec->contents = bfd_alloc (abfd, sec->size);
8895 if (sec->contents == NULL)
8899 if (!alpha_vms_read_sections_content (abfd, NULL))
8901 for (sec = abfd->sections; sec; sec = sec->next)
8902 if (section->contents)
8903 section->flags |= SEC_IN_MEMORY;
8904 memcpy (buf, section->contents + offset, count);
8909 /* Set the format of a file being written. */
8912 alpha_vms_mkobject (bfd * abfd)
8914 const bfd_arch_info_type *arch;
8916 vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
8918 if (!vms_initialize (abfd))
8921 PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
8922 if (PRIV (recwr.buf) == NULL)
8925 arch = bfd_scan_arch ("alpha");
8929 bfd_set_error (bfd_error_wrong_format);
8933 abfd->arch_info = arch;
8940 /* Called when the BFD is being closed to do any necessary cleanup. */
8943 vms_close_and_cleanup (bfd * abfd)
8945 vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
8947 if (abfd == NULL || abfd->tdata.any == NULL)
8950 if (abfd->format == bfd_archive)
8952 bfd_release (abfd, abfd->tdata.any);
8953 abfd->tdata.any = NULL;
8957 if (PRIV (recrd.buf) != NULL)
8958 free (PRIV (recrd.buf));
8960 if (PRIV (sections) != NULL)
8961 free (PRIV (sections));
8963 bfd_release (abfd, abfd->tdata.any);
8964 abfd->tdata.any = NULL;
8967 if (abfd->direction == write_direction)
8969 /* Last step on VMS is to convert the file to variable record length
8971 if (bfd_cache_close (abfd) != TRUE)
8973 if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
8981 /* Called when a new section is created. */
8984 vms_new_section_hook (bfd * abfd, asection *section)
8988 vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
8989 abfd, section->index, section->name));
8991 bfd_set_section_alignment (abfd, section, 0);
8993 vms_debug2 ((7, "%d: %s\n", section->index, section->name));
8995 amt = sizeof (struct vms_section_data_struct);
8996 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
8997 if (section->used_by_bfd == NULL)
9000 /* Create the section symbol. */
9001 return _bfd_generic_new_section_hook (abfd, section);
9004 /* Part 4.5, symbols. */
9006 /* Print symbol to file according to how. how is one of
9007 bfd_print_symbol_name just print the name
9008 bfd_print_symbol_more print more (???)
9009 bfd_print_symbol_all print all we know, which is not much right now :-). */
9012 vms_print_symbol (bfd * abfd,
9015 bfd_print_symbol_type how)
9017 vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
9018 abfd, file, symbol, how));
9022 case bfd_print_symbol_name:
9023 case bfd_print_symbol_more:
9024 fprintf ((FILE *)file," %s", symbol->name);
9027 case bfd_print_symbol_all:
9029 const char *section_name = symbol->section->name;
9031 bfd_print_symbol_vandf (abfd, file, symbol);
9033 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9039 /* Return information about symbol in ret.
9041 fill type, value and name
9044 B bss segment symbol
9046 D data segment symbol
9048 t a static function symbol
9049 T text segment symbol
9054 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9060 vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9062 sec = symbol->section;
9069 else if (bfd_is_com_section (sec))
9071 else if (bfd_is_abs_section (sec))
9073 else if (bfd_is_und_section (sec))
9075 else if (bfd_is_ind_section (sec))
9077 else if ((symbol->flags & BSF_FUNCTION)
9078 || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
9080 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9082 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9087 if (ret->type != 'U')
9088 ret->value = symbol->value + symbol->section->vma;
9091 ret->name = symbol->name;
9094 /* Return TRUE if the given symbol sym in the BFD abfd is
9095 a compiler generated local label, else return FALSE. */
9098 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9101 vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
9102 return name[0] == '$';
9105 /* Part 4.7, writing an object file. */
9107 /* Sets the contents of the section section in BFD abfd to the data starting
9108 in memory at LOCATION. The data is written to the output section starting
9109 at offset offset for count bytes.
9111 Normally TRUE is returned, else FALSE. Possible error returns are:
9112 o bfd_error_no_contents - The output section does not have the
9113 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9114 o and some more too */
9117 _bfd_vms_set_section_contents (bfd * abfd,
9119 const void * location,
9121 bfd_size_type count)
9123 if (section->contents == NULL)
9125 section->contents = bfd_alloc (abfd, section->size);
9126 if (section->contents == NULL)
9129 memcpy (section->contents + offset, location, (size_t) count);
9135 /* Set the architecture and machine type in BFD abfd to arch and mach.
9136 Find the correct pointer to a structure and insert it into the arch_info
9140 alpha_vms_set_arch_mach (bfd *abfd,
9141 enum bfd_architecture arch, unsigned long mach)
9143 if (arch != bfd_arch_alpha
9144 && arch != bfd_arch_unknown)
9147 return bfd_default_set_arch_mach (abfd, arch, mach);
9150 /* Set section VMS flags. Clear NO_FLAGS and set FLAGS. */
9153 bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9154 asection *sec, flagword no_flags, flagword flags)
9156 vms_section_data (sec)->no_flags = no_flags;
9157 vms_section_data (sec)->flags = flags;
9160 struct vms_private_data_struct *
9161 bfd_vms_get_data (bfd *abfd)
9163 return (struct vms_private_data_struct *)abfd->tdata.any;
9166 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9167 #define vms_bfd_link_just_syms _bfd_generic_link_just_syms
9168 #define vms_bfd_copy_link_hash_symbol_type \
9169 _bfd_generic_copy_link_hash_symbol_type
9170 #define vms_bfd_is_group_section bfd_generic_is_group_section
9171 #define vms_bfd_discard_group bfd_generic_discard_group
9172 #define vms_section_already_linked _bfd_generic_section_already_linked
9173 #define vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9174 #define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
9176 #define vms_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
9177 #define vms_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
9178 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9179 #define vms_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
9180 #define vms_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
9181 #define vms_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
9183 /* Symbols table. */
9184 #define alpha_vms_make_empty_symbol _bfd_generic_make_empty_symbol
9185 #define alpha_vms_bfd_is_target_special_symbol \
9186 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9187 #define alpha_vms_print_symbol vms_print_symbol
9188 #define alpha_vms_get_symbol_info vms_get_symbol_info
9189 #define alpha_vms_read_minisymbols _bfd_generic_read_minisymbols
9190 #define alpha_vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
9191 #define alpha_vms_get_lineno _bfd_nosymbols_get_lineno
9192 #define alpha_vms_find_inliner_info _bfd_nosymbols_find_inliner_info
9193 #define alpha_vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
9194 #define alpha_vms_find_nearest_line _bfd_vms_find_nearest_dst_line
9195 #define alpha_vms_bfd_is_local_label_name vms_bfd_is_local_label_name
9197 /* Generic table. */
9198 #define alpha_vms_close_and_cleanup vms_close_and_cleanup
9199 #define alpha_vms_bfd_free_cached_info vms_bfd_free_cached_info
9200 #define alpha_vms_new_section_hook vms_new_section_hook
9201 #define alpha_vms_set_section_contents _bfd_vms_set_section_contents
9202 #define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9204 #define alpha_vms_bfd_get_relocated_section_contents \
9205 bfd_generic_get_relocated_section_contents
9207 #define alpha_vms_bfd_relax_section bfd_generic_relax_section
9208 #define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9209 #define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9210 #define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9211 #define alpha_vms_bfd_discard_group bfd_generic_discard_group
9212 #define alpha_vms_section_already_linked \
9213 _bfd_generic_section_already_linked
9215 #define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9216 #define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
9217 #define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9218 #define alpha_vms_bfd_copy_link_hash_symbol_type \
9219 _bfd_generic_copy_link_hash_symbol_type
9221 #define alpha_vms_bfd_link_split_section _bfd_generic_link_split_section
9223 #define alpha_vms_get_dynamic_symtab_upper_bound \
9224 _bfd_nodynamic_get_dynamic_symtab_upper_bound
9225 #define alpha_vms_canonicalize_dynamic_symtab \
9226 _bfd_nodynamic_canonicalize_dynamic_symtab
9227 #define alpha_vms_get_dynamic_reloc_upper_bound \
9228 _bfd_nodynamic_get_dynamic_reloc_upper_bound
9229 #define alpha_vms_canonicalize_dynamic_reloc \
9230 _bfd_nodynamic_canonicalize_dynamic_reloc
9232 const bfd_target vms_alpha_vec =
9234 "vms-alpha", /* Name. */
9235 bfd_target_evax_flavour,
9236 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
9237 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
9239 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9240 | WP_TEXT | D_PAGED), /* Object flags. */
9241 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9242 | SEC_READONLY | SEC_CODE | SEC_DATA
9243 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
9244 0, /* symbol_leading_char. */
9245 ' ', /* ar_pad_char. */
9246 15, /* ar_max_namelen. */
9247 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9248 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9249 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9250 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9251 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9252 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9254 {_bfd_dummy_target, alpha_vms_object_p, /* bfd_check_format. */
9255 _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9256 {bfd_false, alpha_vms_mkobject, /* bfd_set_format. */
9257 _bfd_vms_lib_alpha_mkarchive, bfd_false},
9258 {bfd_false, alpha_vms_write_object_contents, /* bfd_write_contents. */
9259 _bfd_vms_lib_write_archive_contents, bfd_false},
9261 BFD_JUMP_TABLE_GENERIC (alpha_vms),
9262 BFD_JUMP_TABLE_COPY (vms),
9263 BFD_JUMP_TABLE_CORE (_bfd_nocore),
9264 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9265 BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9266 BFD_JUMP_TABLE_RELOCS (alpha_vms),
9267 BFD_JUMP_TABLE_WRITE (alpha_vms),
9268 BFD_JUMP_TABLE_LINK (alpha_vms),
9269 BFD_JUMP_TABLE_DYNAMIC (alpha_vms),