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_fixup_lr (struct bfd_link_info *, unsigned int,
381 static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);
382 static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);
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[] =
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;
1106 unsigned char *vms_rec;
1107 unsigned long base_addr;
1109 vms_debug2 ((2, "EGSD\n"));
1111 PRIV (recrd.rec) += 8; /* Skip type, size, align pad. */
1112 PRIV (recrd.rec_size) -= 8;
1114 /* Calculate base address for each section. */
1117 while (PRIV (recrd.rec_size) > 0)
1119 vms_rec = PRIV (recrd.rec);
1121 gsd_type = bfd_getl16 (vms_rec);
1122 gsd_size = bfd_getl16 (vms_rec + 2);
1124 vms_debug2 ((3, "egsd_type %d\n", gsd_type));
1129 /* Program section definition. */
1131 struct vms_egps *egps = (struct vms_egps *)vms_rec;
1132 flagword new_flags, old_flags;
1135 old_flags = bfd_getl16 (egps->flags);
1137 if ((old_flags & EGPS__V_REL) == 0)
1139 /* Use the global absolute section for all absolute sections. */
1140 section = bfd_abs_section_ptr;
1145 unsigned long align_addr;
1147 name = _bfd_vms_save_counted_string (&egps->namlng);
1149 section = bfd_make_section (abfd, name);
1153 section->filepos = 0;
1154 section->size = bfd_getl32 (egps->alloc);
1155 section->alignment_power = egps->align;
1157 vms_section_data (section)->flags = old_flags;
1158 vms_section_data (section)->no_flags = 0;
1160 new_flags = vms_secflag_by_name (evax_section_flags, name,
1162 if (!(old_flags & EGPS__V_NOMOD) && section->size > 0)
1164 new_flags |= SEC_HAS_CONTENTS;
1165 if (old_flags & EGPS__V_REL)
1166 new_flags |= SEC_RELOC;
1168 if (!bfd_set_section_flags (abfd, section, new_flags))
1171 /* Give a non-overlapping vma to non absolute sections. */
1172 align_addr = (1 << section->alignment_power);
1173 if ((base_addr % align_addr) != 0)
1174 base_addr += (align_addr - (base_addr % align_addr));
1175 section->vma = (bfd_vma)base_addr;
1176 base_addr += section->size;
1179 /* Append it to the section array. */
1180 if (PRIV (section_count) >= PRIV (section_max))
1182 if (PRIV (section_max) == 0)
1183 PRIV (section_max) = 16;
1185 PRIV (section_max) *= 2;
1186 PRIV (sections) = bfd_realloc_or_free
1187 (PRIV (sections), PRIV (section_max) * sizeof (asection *));
1188 if (PRIV (sections) == NULL)
1192 PRIV (sections)[PRIV (section_count)] = section;
1193 PRIV (section_count)++;
1200 struct vms_symbol_entry *entry;
1201 struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
1204 old_flags = bfd_getl16 (egsy->flags);
1205 if (old_flags & EGSY__V_DEF)
1206 nameoff = ESDF__B_NAMLNG;
1208 nameoff = ESRF__B_NAMLNG;
1210 entry = add_symbol (abfd, vms_rec + nameoff);
1214 /* Allow only duplicate reference. */
1215 if ((entry->flags & EGSY__V_DEF) && (old_flags & EGSY__V_DEF))
1218 if (entry->typ == 0)
1220 entry->typ = gsd_type;
1221 entry->data_type = egsy->datyp;
1222 entry->flags = old_flags;
1225 if (old_flags & EGSY__V_DEF)
1227 struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
1229 entry->value = bfd_getl64 (esdf->value);
1230 entry->section = PRIV (sections)[bfd_getl32 (esdf->psindx)];
1232 if (old_flags & EGSY__V_NORM)
1234 PRIV (norm_sym_count)++;
1236 entry->code_value = bfd_getl64 (esdf->code_address);
1237 entry->code_section =
1238 PRIV (sections)[bfd_getl32 (esdf->ca_psindx)];
1246 struct vms_symbol_entry *entry;
1247 struct vms_egst *egst = (struct vms_egst *)vms_rec;
1250 old_flags = bfd_getl16 (egst->header.flags);
1252 entry = add_symbol (abfd, &egst->namlng);
1257 entry->typ = gsd_type;
1258 entry->data_type = egst->header.datyp;
1259 entry->flags = old_flags;
1261 entry->symbol_vector = bfd_getl32 (egst->value);
1263 if (old_flags & EGSY__V_REL)
1264 entry->section = PRIV (sections)[bfd_getl32 (egst->psindx)];
1266 entry->section = bfd_abs_section_ptr;
1268 entry->value = bfd_getl64 (egst->lp_2);
1270 if (old_flags & EGSY__V_NORM)
1272 PRIV (norm_sym_count)++;
1274 entry->code_value = bfd_getl64 (egst->lp_1);
1275 entry->code_section = bfd_abs_section_ptr;
1282 /* Currently ignored. */
1287 (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
1288 bfd_set_error (bfd_error_bad_value);
1292 PRIV (recrd.rec_size) -= gsd_size;
1293 PRIV (recrd.rec) += gsd_size;
1296 if (PRIV (gsd_sym_count) > 0)
1297 abfd->flags |= HAS_SYMS;
1302 /* Stack routines for vms ETIR commands. */
1304 /* Push value and section index. */
1307 _bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
1309 vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
1310 (unsigned long)val, reloc, PRIV (stackptr)));
1312 PRIV (stack[PRIV (stackptr)]).value = val;
1313 PRIV (stack[PRIV (stackptr)]).reloc = reloc;
1315 if (PRIV (stackptr) >= STACKSIZE)
1317 bfd_set_error (bfd_error_bad_value);
1318 (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
1323 /* Pop value and section index. */
1326 _bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
1328 if (PRIV (stackptr) == 0)
1330 bfd_set_error (bfd_error_bad_value);
1331 (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
1335 *val = PRIV (stack[PRIV (stackptr)]).value;
1336 *rel = PRIV (stack[PRIV (stackptr)]).reloc;
1338 vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
1341 /* Routines to fill sections contents during tir/etir read. */
1343 /* Initialize image buffer pointer to be filled. */
1346 image_set_ptr (bfd *abfd, bfd_vma vma, int sect, struct bfd_link_info *info)
1350 vms_debug2 ((4, "image_set_ptr (0x%08x, sect=%d)\n", (unsigned)vma, sect));
1352 sec = PRIV (sections)[sect];
1356 /* Reading contents to an output bfd. */
1358 if (sec->output_section == NULL)
1360 /* Section discarded. */
1361 vms_debug2 ((5, " section %s discarded\n", sec->name));
1363 /* This is not used. */
1364 PRIV (image_section) = NULL;
1365 PRIV (image_offset) = 0;
1368 PRIV (image_offset) = sec->output_offset + vma;
1369 PRIV (image_section) = sec->output_section;
1373 PRIV (image_offset) = vma;
1374 PRIV (image_section) = sec;
1378 /* Increment image buffer pointer by offset. */
1381 image_inc_ptr (bfd *abfd, bfd_vma offset)
1383 vms_debug2 ((4, "image_inc_ptr (%u)\n", (unsigned)offset));
1385 PRIV (image_offset) += offset;
1388 /* Save current DST location counter under specified index. */
1391 dst_define_location (bfd *abfd, unsigned int loc)
1393 vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
1395 /* Grow the ptr offset table if necessary. */
1396 if (loc + 1 > PRIV (dst_ptr_offsets_count))
1398 PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
1399 (loc + 1) * sizeof (unsigned int));
1400 PRIV (dst_ptr_offsets_count) = loc + 1;
1403 PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
1406 /* Restore saved DST location counter from specified index. */
1409 dst_restore_location (bfd *abfd, unsigned int loc)
1411 vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
1413 PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
1416 /* Retrieve saved DST location counter from specified index. */
1419 dst_retrieve_location (bfd *abfd, unsigned int loc)
1421 vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
1423 return PRIV (dst_ptr_offsets)[loc];
1426 /* Write multiple bytes to section image. */
1429 image_write (bfd *abfd, unsigned char *ptr, int size)
1432 _bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
1433 (long)PRIV (image_offset));
1434 _bfd_hexdump (9, ptr, size, 0);
1437 if (PRIV (image_section)->contents != NULL)
1439 asection *sec = PRIV (image_section);
1440 file_ptr off = PRIV (image_offset);
1443 if (off > (file_ptr)sec->size
1444 || size > (file_ptr)sec->size
1445 || off + size > (file_ptr)sec->size)
1447 bfd_set_error (bfd_error_bad_value);
1451 memcpy (sec->contents + off, ptr, size);
1454 PRIV (image_offset) += size;
1458 /* Write byte to section image. */
1461 image_write_b (bfd * abfd, unsigned int value)
1463 unsigned char data[1];
1465 vms_debug2 ((6, "image_write_b (%02x)\n", (int) value));
1469 return image_write (abfd, data, sizeof (data));
1472 /* Write 2-byte word to image. */
1475 image_write_w (bfd * abfd, unsigned int value)
1477 unsigned char data[2];
1479 vms_debug2 ((6, "image_write_w (%04x)\n", (int) value));
1481 bfd_putl16 (value, data);
1482 return image_write (abfd, data, sizeof (data));
1485 /* Write 4-byte long to image. */
1488 image_write_l (bfd * abfd, unsigned long value)
1490 unsigned char data[4];
1492 vms_debug2 ((6, "image_write_l (%08lx)\n", value));
1494 bfd_putl32 (value, data);
1495 return image_write (abfd, data, sizeof (data));
1498 /* Write 8-byte quad to image. */
1501 image_write_q (bfd * abfd, bfd_vma value)
1503 unsigned char data[8];
1505 vms_debug2 ((6, "image_write_q (%08lx)\n", (unsigned long)value));
1507 bfd_putl64 (value, data);
1508 return image_write (abfd, data, sizeof (data));
1512 _bfd_vms_etir_name (int cmd)
1516 case ETIR__C_STA_GBL: return "ETIR__C_STA_GBL";
1517 case ETIR__C_STA_LW: return "ETIR__C_STA_LW";
1518 case ETIR__C_STA_QW: return "ETIR__C_STA_QW";
1519 case ETIR__C_STA_PQ: return "ETIR__C_STA_PQ";
1520 case ETIR__C_STA_LI: return "ETIR__C_STA_LI";
1521 case ETIR__C_STA_MOD: return "ETIR__C_STA_MOD";
1522 case ETIR__C_STA_CKARG: return "ETIR__C_STA_CKARG";
1523 case ETIR__C_STO_B: return "ETIR__C_STO_B";
1524 case ETIR__C_STO_W: return "ETIR__C_STO_W";
1525 case ETIR__C_STO_GBL: return "ETIR__C_STO_GBL";
1526 case ETIR__C_STO_CA: return "ETIR__C_STO_CA";
1527 case ETIR__C_STO_RB: return "ETIR__C_STO_RB";
1528 case ETIR__C_STO_AB: return "ETIR__C_STO_AB";
1529 case ETIR__C_STO_OFF: return "ETIR__C_STO_OFF";
1530 case ETIR__C_STO_IMM: return "ETIR__C_STO_IMM";
1531 case ETIR__C_STO_IMMR: return "ETIR__C_STO_IMMR";
1532 case ETIR__C_STO_LW: return "ETIR__C_STO_LW";
1533 case ETIR__C_STO_QW: return "ETIR__C_STO_QW";
1534 case ETIR__C_STO_GBL_LW: return "ETIR__C_STO_GBL_LW";
1535 case ETIR__C_STO_LP_PSB: return "ETIR__C_STO_LP_PSB";
1536 case ETIR__C_STO_HINT_GBL: return "ETIR__C_STO_HINT_GBL";
1537 case ETIR__C_STO_HINT_PS: return "ETIR__C_STO_HINT_PS";
1538 case ETIR__C_OPR_ADD: return "ETIR__C_OPR_ADD";
1539 case ETIR__C_OPR_SUB: return "ETIR__C_OPR_SUB";
1540 case ETIR__C_OPR_INSV: return "ETIR__C_OPR_INSV";
1541 case ETIR__C_OPR_USH: return "ETIR__C_OPR_USH";
1542 case ETIR__C_OPR_ROT: return "ETIR__C_OPR_ROT";
1543 case ETIR__C_OPR_REDEF: return "ETIR__C_OPR_REDEF";
1544 case ETIR__C_OPR_DFLIT: return "ETIR__C_OPR_DFLIT";
1545 case ETIR__C_STC_LP: return "ETIR__C_STC_LP";
1546 case ETIR__C_STC_GBL: return "ETIR__C_STC_GBL";
1547 case ETIR__C_STC_GCA: return "ETIR__C_STC_GCA";
1548 case ETIR__C_STC_PS: return "ETIR__C_STC_PS";
1549 case ETIR__C_STC_NBH_PS: return "ETIR__C_STC_NBH_PS";
1550 case ETIR__C_STC_NOP_GBL: return "ETIR__C_STC_NOP_GBL";
1551 case ETIR__C_STC_NOP_PS: return "ETIR__C_STC_NOP_PS";
1552 case ETIR__C_STC_BSR_GBL: return "ETIR__C_STC_BSR_GBL";
1553 case ETIR__C_STC_BSR_PS: return "ETIR__C_STC_BSR_PS";
1554 case ETIR__C_STC_LDA_GBL: return "ETIR__C_STC_LDA_GBL";
1555 case ETIR__C_STC_LDA_PS: return "ETIR__C_STC_LDA_PS";
1556 case ETIR__C_STC_BOH_GBL: return "ETIR__C_STC_BOH_GBL";
1557 case ETIR__C_STC_BOH_PS: return "ETIR__C_STC_BOH_PS";
1558 case ETIR__C_STC_NBH_GBL: return "ETIR__C_STC_NBH_GBL";
1559 case ETIR__C_STC_LP_PSB: return "ETIR__C_STC_LP_PSB";
1560 case ETIR__C_CTL_SETRB: return "ETIR__C_CTL_SETRB";
1561 case ETIR__C_CTL_AUGRB: return "ETIR__C_CTL_AUGRB";
1562 case ETIR__C_CTL_DFLOC: return "ETIR__C_CTL_DFLOC";
1563 case ETIR__C_CTL_STLOC: return "ETIR__C_CTL_STLOC";
1564 case ETIR__C_CTL_STKDL: return "ETIR__C_CTL_STKDL";
1567 /* These names have not yet been added to this switch statement. */
1568 (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
1573 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
1576 _bfd_vms_get_value (bfd *abfd, const unsigned char *ascic,
1577 struct bfd_link_info *info,
1579 struct alpha_vms_link_hash_entry **hp)
1584 struct alpha_vms_link_hash_entry *h;
1586 /* Not linking. Do not try to resolve the symbol. */
1595 for (i = 0; i < len; i++)
1596 name[i] = ascic[i + 1];
1599 h = (struct alpha_vms_link_hash_entry *)
1600 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
1605 && (h->root.type == bfd_link_hash_defined
1606 || h->root.type == bfd_link_hash_defweak))
1607 *vma = h->root.u.def.value
1608 + h->root.u.def.section->output_offset
1609 + h->root.u.def.section->output_section->vma;
1610 else if (h && h->root.type == bfd_link_hash_undefweak)
1614 if (!(*info->callbacks->undefined_symbol)
1615 (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
1623 #define RELC_SHR_BASE 0x10000
1624 #define RELC_SEC_BASE 0x20000
1625 #define RELC_MASK 0x0ffff
1628 alpha_vms_sym_to_ctxt (struct alpha_vms_link_hash_entry *h)
1630 /* Handle undefined symbols. */
1631 if (h == NULL || h->sym == NULL)
1634 if (h->sym->typ == EGSD__C_SYMG)
1636 if (h->sym->flags & EGSY__V_REL)
1637 return RELC_SHR_BASE + PRIV2 (h->sym->owner, shr_index);
1640 /* Can this happen (non-relocatable symg) ? I'd like to see
1645 if (h->sym->typ == EGSD__C_SYM)
1647 if (h->sym->flags & EGSY__V_REL)
1656 alpha_vms_get_sym_value (asection *sect, bfd_vma addr)
1658 return sect->output_section->vma + sect->output_offset + addr;
1662 alpha_vms_fix_sec_rel (bfd *abfd, struct bfd_link_info *info,
1663 unsigned int rel, bfd_vma vma)
1665 asection *sec = PRIV (sections)[rel & RELC_MASK];
1669 if (sec->output_section == NULL)
1671 return vma + sec->output_section->vma + sec->output_offset;
1674 return vma + sec->vma;
1677 /* Read an ETIR record from ABFD. If INFO is not null, put the content into
1678 the output section (used during linking).
1679 Return FALSE in case of error. */
1682 _bfd_vms_slurp_etir (bfd *abfd, struct bfd_link_info *info)
1685 unsigned int length;
1686 unsigned char *maxptr;
1691 struct alpha_vms_link_hash_entry *h;
1693 PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
1694 PRIV (recrd.rec_size) -= ETIR__C_HEADER_SIZE;
1696 ptr = PRIV (recrd.rec);
1697 length = PRIV (recrd.rec_size);
1698 maxptr = ptr + length;
1700 vms_debug2 ((2, "ETIR: %d bytes\n", length));
1702 while (ptr < maxptr)
1704 int cmd = bfd_getl16 (ptr);
1705 int cmd_length = bfd_getl16 (ptr + 2);
1710 _bfd_vms_debug (4, "etir: %s(%d)\n",
1711 _bfd_vms_etir_name (cmd), cmd);
1712 _bfd_hexdump (8, ptr, cmd_length - 4, (long) ptr);
1720 stack 32 bit value of symbol (high bits set to 0). */
1721 case ETIR__C_STA_GBL:
1722 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1723 _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
1729 stack 32 bit value, sign extend to 64 bit. */
1730 case ETIR__C_STA_LW:
1731 _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
1737 stack 64 bit value of symbol. */
1738 case ETIR__C_STA_QW:
1739 _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
1742 /* Stack psect base plus quadword offset
1743 arg: lw section index
1744 qw signed quadword offset (low 32 bits)
1746 Stack qw argument and section index
1747 (see ETIR__C_STO_OFF, ETIR__C_CTL_SETRB). */
1748 case ETIR__C_STA_PQ:
1752 psect = bfd_getl32 (ptr);
1753 if ((unsigned int) psect >= PRIV (section_count))
1755 (*_bfd_error_handler) (_("bad section index in %s"),
1756 _bfd_vms_etir_name (cmd));
1757 bfd_set_error (bfd_error_bad_value);
1760 op1 = bfd_getl64 (ptr + 4);
1761 _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
1765 case ETIR__C_STA_LI:
1766 case ETIR__C_STA_MOD:
1767 case ETIR__C_STA_CKARG:
1768 (*_bfd_error_handler) (_("unsupported STA cmd %s"),
1769 _bfd_vms_etir_name (cmd));
1773 /* Store byte: pop stack, write byte
1776 _bfd_vms_pop (abfd, &op1, &rel1);
1777 if (rel1 != RELC_NONE)
1779 image_write_b (abfd, (unsigned int) op1 & 0xff);
1782 /* Store word: pop stack, write word
1785 _bfd_vms_pop (abfd, &op1, &rel1);
1786 if (rel1 != RELC_NONE)
1788 image_write_w (abfd, (unsigned int) op1 & 0xffff);
1791 /* Store longword: pop stack, write longword
1793 case ETIR__C_STO_LW:
1794 _bfd_vms_pop (abfd, &op1, &rel1);
1795 if (rel1 & RELC_SEC_BASE)
1797 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1800 else if (rel1 & RELC_SHR_BASE)
1802 alpha_vms_add_fixup_lr (info, rel1 & RELC_MASK, op1);
1805 if (rel1 != RELC_NONE)
1807 if (rel1 != RELC_REL)
1809 alpha_vms_add_lw_reloc (info);
1811 image_write_l (abfd, op1);
1814 /* Store quadword: pop stack, write quadword
1816 case ETIR__C_STO_QW:
1817 _bfd_vms_pop (abfd, &op1, &rel1);
1818 if (rel1 & RELC_SEC_BASE)
1820 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1823 else if (rel1 & RELC_SHR_BASE)
1825 if (rel1 != RELC_NONE)
1827 if (rel1 != RELC_REL)
1829 alpha_vms_add_qw_reloc (info);
1831 image_write_q (abfd, op1);
1834 /* Store immediate repeated: pop stack for repeat count
1837 case ETIR__C_STO_IMMR:
1841 size = bfd_getl32 (ptr);
1842 _bfd_vms_pop (abfd, &op1, &rel1);
1843 if (rel1 != RELC_NONE)
1846 image_write (abfd, ptr + 4, size);
1850 /* Store global: write symbol value
1851 arg: cs global symbol name. */
1852 case ETIR__C_STO_GBL:
1853 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1856 if (h->sym->typ == EGSD__C_SYMG)
1858 alpha_vms_add_fixup_qr
1859 (info, abfd, h->sym->owner, h->sym->symbol_vector);
1864 op1 = alpha_vms_get_sym_value (h->sym->section,
1866 alpha_vms_add_qw_reloc (info);
1869 image_write_q (abfd, op1);
1872 /* Store code address: write address of entry point
1873 arg: cs global symbol name (procedure). */
1874 case ETIR__C_STO_CA:
1875 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1878 if (h->sym->flags & EGSY__V_NORM)
1880 /* That's really a procedure. */
1881 if (h->sym->typ == EGSD__C_SYMG)
1883 alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
1884 op1 = h->sym->symbol_vector;
1888 op1 = alpha_vms_get_sym_value (h->sym->code_section,
1889 h->sym->code_value);
1890 alpha_vms_add_qw_reloc (info);
1895 /* Symbol is not a procedure. */
1899 image_write_q (abfd, op1);
1902 /* Store offset to psect: pop stack, add low 32 bits to base of psect
1904 case ETIR__C_STO_OFF:
1905 _bfd_vms_pop (abfd, &op1, &rel1);
1907 if (!(rel1 & RELC_SEC_BASE))
1910 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1912 image_write_q (abfd, op1);
1916 arg: lw count of bytes
1918 case ETIR__C_STO_IMM:
1922 size = bfd_getl32 (ptr);
1923 image_write (abfd, ptr + 4, size);
1927 /* This code is 'reserved to digital' according to the openVMS
1928 linker manual, however it is generated by the DEC C compiler
1929 and defined in the include file.
1930 FIXME, since the following is just a guess
1931 store global longword: store 32bit value of symbol
1932 arg: cs symbol name. */
1933 case ETIR__C_STO_GBL_LW:
1934 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1938 image_write_l (abfd, op1);
1941 case ETIR__C_STO_RB:
1942 case ETIR__C_STO_AB:
1943 case ETIR__C_STO_LP_PSB:
1944 (*_bfd_error_handler) (_("%s: not supported"),
1945 _bfd_vms_etir_name (cmd));
1948 case ETIR__C_STO_HINT_GBL:
1949 case ETIR__C_STO_HINT_PS:
1950 (*_bfd_error_handler) (_("%s: not implemented"),
1951 _bfd_vms_etir_name (cmd));
1955 /* 200 Store-conditional Linkage Pair
1957 case ETIR__C_STC_LP:
1959 /* 202 Store-conditional Address at global address
1963 case ETIR__C_STC_GBL:
1965 /* 203 Store-conditional Code Address at global address
1967 cs procedure name. */
1968 case ETIR__C_STC_GCA:
1970 /* 204 Store-conditional Address at psect + offset
1974 case ETIR__C_STC_PS:
1975 (*_bfd_error_handler) (_("%s: not supported"),
1976 _bfd_vms_etir_name (cmd));
1980 /* 201 Store-conditional Linkage Pair with Procedure Signature
1986 case ETIR__C_STC_LP_PSB:
1987 _bfd_vms_get_value (abfd, ptr + 4, info, &op1, &h);
1990 if (h->sym->typ == EGSD__C_SYMG)
1992 alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
1993 op1 = h->sym->symbol_vector;
1998 op1 = alpha_vms_get_sym_value (h->sym->code_section,
1999 h->sym->code_value);
2000 op2 = alpha_vms_get_sym_value (h->sym->section,
2006 /* Undefined symbol. */
2010 image_write_q (abfd, op1);
2011 image_write_q (abfd, op2);
2014 /* 205 Store-conditional NOP at address of global
2016 case ETIR__C_STC_NOP_GBL:
2019 /* 207 Store-conditional BSR at global address
2022 case ETIR__C_STC_BSR_GBL:
2025 /* 209 Store-conditional LDA at global address
2028 case ETIR__C_STC_LDA_GBL:
2031 /* 211 Store-conditional BSR or Hint at global address
2034 case ETIR__C_STC_BOH_GBL:
2035 /* Currentl ignored. */
2038 /* 213 Store-conditional NOP,BSR or HINT at global address
2041 case ETIR__C_STC_NBH_GBL:
2043 /* 206 Store-conditional NOP at pect + offset
2046 case ETIR__C_STC_NOP_PS:
2048 /* 208 Store-conditional BSR at pect + offset
2051 case ETIR__C_STC_BSR_PS:
2053 /* 210 Store-conditional LDA at psect + offset
2056 case ETIR__C_STC_LDA_PS:
2058 /* 212 Store-conditional BSR or Hint at pect + offset
2061 case ETIR__C_STC_BOH_PS:
2063 /* 214 Store-conditional NOP, BSR or HINT at psect + offset
2065 case ETIR__C_STC_NBH_PS:
2066 (*_bfd_error_handler) ("%s: not supported",
2067 _bfd_vms_etir_name (cmd));
2071 /* Det relocation base: pop stack, set image location counter
2073 case ETIR__C_CTL_SETRB:
2074 _bfd_vms_pop (abfd, &op1, &rel1);
2075 if (!(rel1 & RELC_SEC_BASE))
2077 image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
2080 /* Augment relocation base: increment image location counter by offset
2081 arg: lw offset value. */
2082 case ETIR__C_CTL_AUGRB:
2083 op1 = bfd_getl32 (ptr);
2084 image_inc_ptr (abfd, op1);
2087 /* Define location: pop index, save location counter under index
2089 case ETIR__C_CTL_DFLOC:
2090 _bfd_vms_pop (abfd, &op1, &rel1);
2091 if (rel1 != RELC_NONE)
2093 dst_define_location (abfd, op1);
2096 /* Set location: pop index, restore location counter from index
2098 case ETIR__C_CTL_STLOC:
2099 _bfd_vms_pop (abfd, &op1, &rel1);
2100 if (rel1 != RELC_NONE)
2102 dst_restore_location (abfd, op1);
2105 /* Stack defined location: pop index, push location counter from index
2107 case ETIR__C_CTL_STKDL:
2108 _bfd_vms_pop (abfd, &op1, &rel1);
2109 if (rel1 != RELC_NONE)
2111 _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
2114 case ETIR__C_OPR_NOP: /* No-op. */
2117 case ETIR__C_OPR_ADD: /* Add. */
2118 _bfd_vms_pop (abfd, &op1, &rel1);
2119 _bfd_vms_pop (abfd, &op2, &rel2);
2120 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2122 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2124 _bfd_vms_push (abfd, op1 + op2, rel1);
2127 case ETIR__C_OPR_SUB: /* Subtract. */
2128 _bfd_vms_pop (abfd, &op1, &rel1);
2129 _bfd_vms_pop (abfd, &op2, &rel2);
2130 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2132 else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
2134 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
2135 op2 = alpha_vms_fix_sec_rel (abfd, info, rel2, op2);
2138 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2140 _bfd_vms_push (abfd, op2 - op1, rel1);
2143 case ETIR__C_OPR_MUL: /* Multiply. */
2144 _bfd_vms_pop (abfd, &op1, &rel1);
2145 _bfd_vms_pop (abfd, &op2, &rel2);
2146 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2148 _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
2151 case ETIR__C_OPR_DIV: /* Divide. */
2152 _bfd_vms_pop (abfd, &op1, &rel1);
2153 _bfd_vms_pop (abfd, &op2, &rel2);
2154 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2157 _bfd_vms_push (abfd, 0, RELC_NONE);
2159 _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
2162 case ETIR__C_OPR_AND: /* Logical AND. */
2163 _bfd_vms_pop (abfd, &op1, &rel1);
2164 _bfd_vms_pop (abfd, &op2, &rel2);
2165 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2167 _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
2170 case ETIR__C_OPR_IOR: /* Logical inclusive OR. */
2171 _bfd_vms_pop (abfd, &op1, &rel1);
2172 _bfd_vms_pop (abfd, &op2, &rel2);
2173 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2175 _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
2178 case ETIR__C_OPR_EOR: /* Logical exclusive OR. */
2179 _bfd_vms_pop (abfd, &op1, &rel1);
2180 _bfd_vms_pop (abfd, &op2, &rel2);
2181 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2183 _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
2186 case ETIR__C_OPR_NEG: /* Negate. */
2187 _bfd_vms_pop (abfd, &op1, &rel1);
2188 if (rel1 != RELC_NONE)
2190 _bfd_vms_push (abfd, -op1, RELC_NONE);
2193 case ETIR__C_OPR_COM: /* Complement. */
2194 _bfd_vms_pop (abfd, &op1, &rel1);
2195 if (rel1 != RELC_NONE)
2197 _bfd_vms_push (abfd, ~op1, RELC_NONE);
2200 case ETIR__C_OPR_ASH: /* Arithmetic shift. */
2201 _bfd_vms_pop (abfd, &op1, &rel1);
2202 _bfd_vms_pop (abfd, &op2, &rel2);
2203 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2206 (*_bfd_error_handler) (_("invalid use of %s with contexts"),
2207 _bfd_vms_etir_name (cmd));
2210 if ((int)op2 < 0) /* Shift right. */
2212 else /* Shift left. */
2214 _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym. */
2217 case ETIR__C_OPR_INSV: /* Insert field. */
2218 case ETIR__C_OPR_USH: /* Unsigned shift. */
2219 case ETIR__C_OPR_ROT: /* Rotate. */
2220 case ETIR__C_OPR_REDEF: /* Redefine symbol to current location. */
2221 case ETIR__C_OPR_DFLIT: /* Define a literal. */
2222 (*_bfd_error_handler) (_("%s: not supported"),
2223 _bfd_vms_etir_name (cmd));
2227 case ETIR__C_OPR_SEL: /* Select. */
2228 _bfd_vms_pop (abfd, &op1, &rel1);
2230 _bfd_vms_pop (abfd, &op1, &rel1);
2233 _bfd_vms_pop (abfd, &op1, &rel1);
2234 _bfd_vms_pop (abfd, &op2, &rel2);
2235 _bfd_vms_push (abfd, op1, rel1);
2240 (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
2245 ptr += cmd_length - 4;
2251 /* Process EDBG/ETBT record.
2252 Return TRUE on success, FALSE on error */
2255 vms_slurp_debug (bfd *abfd)
2257 asection *section = PRIV (dst_section);
2259 if (section == NULL)
2261 /* We have no way to find out beforehand how much debug info there
2262 is in an object file, so pick an initial amount and grow it as
2264 flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC
2267 section = bfd_make_section (abfd, "$DST$");
2270 if (!bfd_set_section_flags (abfd, section, flags))
2272 PRIV (dst_section) = section;
2275 PRIV (image_section) = section;
2276 PRIV (image_offset) = section->size;
2278 if (!_bfd_vms_slurp_etir (abfd, NULL))
2281 section->size = PRIV (image_offset);
2285 /* Process EDBG record.
2286 Return TRUE on success, FALSE on error. */
2289 _bfd_vms_slurp_edbg (bfd *abfd)
2291 vms_debug2 ((2, "EDBG\n"));
2293 abfd->flags |= HAS_DEBUG | HAS_LINENO;
2295 return vms_slurp_debug (abfd);
2298 /* Process ETBT record.
2299 Return TRUE on success, FALSE on error. */
2302 _bfd_vms_slurp_etbt (bfd *abfd)
2304 vms_debug2 ((2, "ETBT\n"));
2306 abfd->flags |= HAS_LINENO;
2308 return vms_slurp_debug (abfd);
2311 /* Process EEOM record.
2312 Return TRUE on success, FALSE on error. */
2315 _bfd_vms_slurp_eeom (bfd *abfd)
2317 struct vms_eeom *eeom = (struct vms_eeom *) PRIV (recrd.rec);
2319 vms_debug2 ((2, "EEOM\n"));
2321 PRIV (eom_data).eom_l_total_lps = bfd_getl32 (eeom->total_lps);
2322 PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
2323 if (PRIV (eom_data).eom_w_comcod > 1)
2325 (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
2326 bfd_set_error (bfd_error_bad_value);
2330 PRIV (eom_data).eom_has_transfer = FALSE;
2331 if (PRIV (recrd.rec_size) > 10)
2333 PRIV (eom_data).eom_has_transfer = TRUE;
2334 PRIV (eom_data).eom_b_tfrflg = eeom->tfrflg;
2335 PRIV (eom_data).eom_l_psindx = bfd_getl32 (eeom->psindx);
2336 PRIV (eom_data).eom_l_tfradr = bfd_getl32 (eeom->tfradr);
2338 abfd->start_address = PRIV (eom_data).eom_l_tfradr;
2343 /* Slurp an ordered set of VMS object records. Return FALSE on error. */
2346 _bfd_vms_slurp_object_records (bfd * abfd)
2353 vms_debug2 ((7, "reading at %08lx\n", (unsigned long)bfd_tell (abfd)));
2355 type = _bfd_vms_get_object_record (abfd);
2358 vms_debug2 ((2, "next_record failed\n"));
2365 err = _bfd_vms_slurp_ehdr (abfd);
2368 err = _bfd_vms_slurp_eeom (abfd);
2371 err = _bfd_vms_slurp_egsd (abfd);
2374 err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
2377 err = _bfd_vms_slurp_edbg (abfd);
2380 err = _bfd_vms_slurp_etbt (abfd);
2387 vms_debug2 ((2, "slurp type %d failed\n", type));
2391 while (type != EOBJ__C_EEOM);
2396 /* Initialize private data */
2398 vms_initialize (bfd * abfd)
2402 amt = sizeof (struct vms_private_data_struct);
2403 abfd->tdata.any = bfd_zalloc (abfd, amt);
2404 if (abfd->tdata.any == NULL)
2407 PRIV (recrd.file_format) = FF_UNKNOWN;
2409 amt = sizeof (struct stack_struct) * STACKSIZE;
2410 PRIV (stack) = bfd_alloc (abfd, amt);
2411 if (PRIV (stack) == NULL)
2417 bfd_release (abfd, abfd->tdata.any);
2418 abfd->tdata.any = NULL;
2422 /* Check the format for a file being read.
2423 Return a (bfd_target *) if it's an object file or zero if not. */
2425 static const struct bfd_target *
2426 alpha_vms_object_p (bfd *abfd)
2428 PTR tdata_save = abfd->tdata.any;
2429 unsigned int test_len;
2432 vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
2434 /* Allocate alpha-vms specific data. */
2435 if (!vms_initialize (abfd))
2438 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
2439 goto err_wrong_format;
2441 /* The first challenge with VMS is to discover the kind of the file.
2443 Image files (executable or shared images) are stored as a raw
2444 stream of bytes (like on UNIX), but there is no magic number.
2446 Object files are written with RMS (record management service), ie
2447 each records are preceeded by its length (on a word - 2 bytes), and
2448 padded for word-alignment. That would be simple but when files
2449 are transfered to a UNIX filesystem (using ftp), records are lost.
2450 Only the raw content of the records are transfered. Fortunately,
2451 the Alpha Object file format also store the length of the record
2452 in the records. Is that clear ? */
2454 /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
2455 2 bytes size repeated) and 12 bytes for images (4 bytes major id,
2456 4 bytes minor id, 4 bytes length). */
2459 /* Size the main buffer. */
2460 buf = (unsigned char *) bfd_malloc (test_len);
2463 PRIV (recrd.buf) = buf;
2464 PRIV (recrd.buf_size) = test_len;
2466 /* Initialize the record pointer. */
2467 PRIV (recrd.rec) = buf;
2469 if (bfd_bread (buf, test_len, abfd) != test_len)
2471 bfd_set_error (bfd_error_file_truncated);
2475 /* Is it an image? */
2476 if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
2477 && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
2479 unsigned int to_read;
2480 unsigned int read_so_far;
2481 unsigned int remaining;
2482 unsigned int eisd_offset, eihs_offset;
2484 /* Extract the header size. */
2485 PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
2487 /* The header size is 0 for DSF files. */
2488 if (PRIV (recrd.rec_size) == 0)
2489 PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
2491 if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
2493 buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
2497 PRIV (recrd.buf) = NULL;
2498 bfd_set_error (bfd_error_no_memory);
2501 PRIV (recrd.buf) = buf;
2502 PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
2505 /* Read the remaining record. */
2506 remaining = PRIV (recrd.rec_size) - test_len;
2507 to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
2508 read_so_far = test_len;
2510 while (remaining > 0)
2512 if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
2514 bfd_set_error (bfd_error_file_truncated);
2515 goto err_wrong_format;
2518 read_so_far += to_read;
2519 remaining -= to_read;
2521 to_read = MIN (VMS_BLOCK_SIZE, remaining);
2524 /* Reset the record pointer. */
2525 PRIV (recrd.rec) = buf;
2527 vms_debug2 ((2, "file type is image\n"));
2529 if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
2530 goto err_wrong_format;
2532 if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
2533 goto err_wrong_format;
2535 /* EIHS is optional. */
2536 if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
2537 goto err_wrong_format;
2543 /* Assume it's a module and adjust record pointer if necessary. */
2544 maybe_adjust_record_pointer_for_object (abfd);
2546 /* But is it really a module? */
2547 if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
2548 && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
2550 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
2551 goto err_wrong_format;
2553 vms_debug2 ((2, "file type is module\n"));
2555 type = bfd_getl16 (PRIV (recrd.rec));
2556 if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
2557 goto err_wrong_format;
2559 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
2560 goto err_wrong_format;
2563 goto err_wrong_format;
2566 /* Set arch_info to alpha. */
2568 if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
2569 goto err_wrong_format;
2574 bfd_set_error (bfd_error_wrong_format);
2577 if (PRIV (recrd.buf))
2578 free (PRIV (recrd.buf));
2579 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
2580 bfd_release (abfd, abfd->tdata.any);
2581 abfd->tdata.any = tdata_save;
2587 /* Write an EMH/MHD record. */
2590 _bfd_vms_write_emh (bfd *abfd)
2592 struct vms_rec_wr *recwr = &PRIV (recwr);
2594 _bfd_vms_output_alignment (recwr, 2);
2597 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2598 _bfd_vms_output_short (recwr, EMH__C_MHD);
2599 _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
2600 _bfd_vms_output_long (recwr, 0);
2601 _bfd_vms_output_long (recwr, 0);
2602 _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
2604 /* Create module name from filename. */
2605 if (bfd_get_filename (abfd) != 0)
2607 char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2608 _bfd_vms_output_counted (recwr, module);
2612 _bfd_vms_output_counted (recwr, "NONAME");
2614 _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
2615 _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
2616 _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
2617 _bfd_vms_output_end (abfd, recwr);
2620 /* Write an EMH/LMN record. */
2623 _bfd_vms_write_lmn (bfd *abfd, const char *name)
2626 struct vms_rec_wr *recwr = &PRIV (recwr);
2627 unsigned int ver = BFD_VERSION / 10000;
2630 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2631 _bfd_vms_output_short (recwr, EMH__C_LNM);
2632 snprintf (version, sizeof (version), "%s %d.%d.%d", name,
2633 ver / 10000, (ver / 100) % 100, ver % 100);
2634 _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
2635 _bfd_vms_output_end (abfd, recwr);
2639 /* Write eom record for bfd abfd. Return FALSE on error. */
2642 _bfd_vms_write_eeom (bfd *abfd)
2644 struct vms_rec_wr *recwr = &PRIV (recwr);
2646 vms_debug2 ((2, "vms_write_eeom\n"));
2648 _bfd_vms_output_alignment (recwr, 2);
2650 _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
2651 _bfd_vms_output_long (recwr, (unsigned long) (PRIV (vms_linkage_index) >> 1));
2652 _bfd_vms_output_byte (recwr, 0); /* Completion code. */
2653 _bfd_vms_output_byte (recwr, 0); /* Fill byte. */
2655 if ((abfd->flags & EXEC_P) == 0
2656 && bfd_get_start_address (abfd) != (bfd_vma)-1)
2660 section = bfd_get_section_by_name (abfd, ".link");
2663 bfd_set_error (bfd_error_nonrepresentable_section);
2666 _bfd_vms_output_short (recwr, 0);
2667 _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
2668 _bfd_vms_output_long (recwr,
2669 (unsigned long) bfd_get_start_address (abfd));
2670 _bfd_vms_output_long (recwr, 0);
2673 _bfd_vms_output_end (abfd, recwr);
2677 /* This hash routine borrowed from GNU-EMACS, and strengthened
2681 hash_string (const char *ptr)
2683 const unsigned char *p = (unsigned char *) ptr;
2684 const unsigned char *end = p + strlen (ptr);
2691 hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
2696 /* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
2699 _bfd_vms_length_hash_symbol (bfd *abfd, const char *in, int maxlen)
2701 unsigned long result;
2704 const char *old_name;
2706 static char outbuf[EOBJ__C_SYMSIZ + 1];
2710 vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
2713 if (maxlen > EOBJ__C_SYMSIZ)
2714 maxlen = EOBJ__C_SYMSIZ;
2716 /* Save this for later. */
2719 /* We may need to truncate the symbol, save the hash for later. */
2720 in_len = strlen (in);
2722 result = (in_len > maxlen) ? hash_string (in) : 0;
2726 /* Do the length checking. */
2727 if (in_len <= maxlen)
2731 if (PRIV (flag_hash_long_names))
2737 strncpy (out, in, (size_t) i);
2741 if ((in_len > maxlen)
2742 && PRIV (flag_hash_long_names))
2743 sprintf (out, "_%08lx", result);
2748 vms_debug (4, "--> [%d]\"%s\"\n", (int)strlen (outbuf), outbuf);
2752 && PRIV (flag_hash_long_names)
2753 && PRIV (flag_show_after_trunc))
2754 printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
2760 vector_grow1 (struct vector_type *vec, size_t elsz)
2762 if (vec->nbr_el + 1 < vec->max_el)
2765 if (vec->max_el == 0)
2768 vec->els = bfd_malloc2 (vec->max_el, elsz);
2773 vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
2777 /* Bump ABFD file position to next block. */
2780 alpha_vms_file_position_block (bfd *abfd)
2783 PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
2784 PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
2787 /* Convert from internal structure SRC to external structure DST. */
2790 alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
2791 struct vms_eisd *dst)
2793 bfd_putl32 (src->u.eisd.majorid, dst->majorid);
2794 bfd_putl32 (src->u.eisd.minorid, dst->minorid);
2795 bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
2796 if (src->u.eisd.eisdsize <= EISD__K_LENEND)
2798 bfd_putl32 (src->u.eisd.secsize, dst->secsize);
2799 bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
2800 bfd_putl32 (src->u.eisd.flags, dst->flags);
2801 bfd_putl32 (src->u.eisd.vbn, dst->vbn);
2802 dst->pfc = src->u.eisd.pfc;
2803 dst->matchctl = src->u.eisd.matchctl;
2804 dst->type = src->u.eisd.type;
2806 if (src->u.eisd.flags & EISD__M_GBL)
2808 bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
2809 memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
2810 src->u.gbl_eisd.gblnam[0] + 1);
2814 /* Append EISD to the list of extra eisd for ABFD. */
2817 alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
2820 if (PRIV (gbl_eisd_head) == NULL)
2821 PRIV (gbl_eisd_head) = eisd;
2823 PRIV (gbl_eisd_tail)->next = eisd;
2824 PRIV (gbl_eisd_tail) = eisd;
2827 /* Create an EISD for shared image SHRIMG.
2828 Return FALSE in case of error. */
2831 alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
2833 struct vms_internal_eisd_map *eisd;
2836 namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
2837 if (namlen + 5 > EISD__K_GBLNAMLEN)
2843 eisd = bfd_alloc (abfd, sizeof (*eisd));
2847 /* Fill the fields. */
2848 eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
2849 eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
2850 eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
2851 eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE; /* Must not be 0. */
2852 eisd->u.gbl_eisd.common.virt_addr = 0;
2853 eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
2854 eisd->u.gbl_eisd.common.vbn = 0;
2855 eisd->u.gbl_eisd.common.pfc = 0;
2856 eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
2857 eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
2859 eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
2860 eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
2861 memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
2863 memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
2865 /* Append it to the list. */
2866 alpha_vms_append_extra_eisd (abfd, eisd);
2871 /* Create an EISD for section SEC.
2872 Return FALSE in case of failure. */
2875 alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
2877 struct vms_internal_eisd_map *eisd;
2879 /* Only for allocating section. */
2880 if (!(sec->flags & SEC_ALLOC))
2883 BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
2884 eisd = bfd_alloc (abfd, sizeof (*eisd));
2887 vms_section_data (sec)->eisd = eisd;
2889 /* Fill the fields. */
2890 eisd->u.eisd.majorid = EISD__K_MAJORID;
2891 eisd->u.eisd.minorid = EISD__K_MINORID;
2892 eisd->u.eisd.eisdsize = EISD__K_LEN;
2893 eisd->u.eisd.secsize =
2894 (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
2895 eisd->u.eisd.virt_addr = sec->vma;
2896 eisd->u.eisd.flags = 0;
2897 eisd->u.eisd.vbn = 0; /* To be later defined. */
2898 eisd->u.eisd.pfc = 0; /* Default. */
2899 eisd->u.eisd.matchctl = EISD__K_MATALL;
2900 eisd->u.eisd.type = EISD__K_NORMAL;
2902 if (sec->flags & SEC_CODE)
2903 eisd->u.eisd.flags |= EISD__M_EXE;
2904 if (!(sec->flags & SEC_READONLY))
2905 eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2907 if (!(sec->flags & SEC_LOAD))
2909 eisd->u.eisd.flags |= EISD__M_DZRO;
2910 eisd->u.eisd.flags &= ~EISD__M_CRF;
2912 if (sec->flags & SEC_LINKER_CREATED)
2914 if (strcmp (sec->name, "$FIXUP$") == 0)
2915 eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
2918 /* Append it to the list. */
2920 if (PRIV (eisd_head) == NULL)
2921 PRIV (eisd_head) = eisd;
2923 PRIV (eisd_tail)->next = eisd;
2924 PRIV (eisd_tail) = eisd;
2929 /* Layout executable ABFD and write it to the disk.
2930 Return FALSE in case of failure. */
2933 alpha_vms_write_exec (bfd *abfd)
2935 struct vms_eihd eihd;
2936 struct vms_eiha *eiha;
2937 struct vms_eihi *eihi;
2938 struct vms_eihs *eihs = NULL;
2940 struct vms_internal_eisd_map *first_eisd;
2941 struct vms_internal_eisd_map *eisd;
2944 file_ptr gst_filepos = 0;
2945 unsigned int lnkflags = 0;
2947 /* Build the EIHD. */
2948 PRIV (file_pos) = EIHD__C_LENGTH;
2950 memset (&eihd, 0, sizeof (eihd));
2951 memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
2953 bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
2954 bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
2956 bfd_putl32 (sizeof (eihd), eihd.size);
2957 bfd_putl32 (0, eihd.isdoff);
2958 bfd_putl32 (0, eihd.activoff);
2959 bfd_putl32 (0, eihd.symdbgoff);
2960 bfd_putl32 (0, eihd.imgidoff);
2961 bfd_putl32 (0, eihd.patchoff);
2962 bfd_putl64 (0, eihd.iafva);
2963 bfd_putl32 (0, eihd.version_array_off);
2965 bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
2966 bfd_putl32 (0, eihd.subtype);
2968 bfd_putl32 (0, eihd.imgiocnt);
2969 bfd_putl32 (-1, eihd.privreqs);
2970 bfd_putl32 (-1, eihd.privreqs + 4);
2972 bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
2974 bfd_putl32 (0, eihd.ident);
2975 bfd_putl32 (0, eihd.sysver);
2978 bfd_putl32 (0, eihd.symvect_size);
2979 bfd_putl32 (16, eihd.virt_mem_block_size);
2980 bfd_putl32 (0, eihd.ext_fixup_off);
2981 bfd_putl32 (0, eihd.noopt_psect_off);
2982 bfd_putl32 (-1, eihd.alias);
2985 eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
2986 bfd_putl32 (PRIV (file_pos), eihd.activoff);
2987 PRIV (file_pos) += sizeof (struct vms_eiha);
2989 bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
2990 bfd_putl32 (0, eiha->spare);
2991 bfd_putl64 (PRIV (transfer_address[0]), eiha->tfradr1);
2992 bfd_putl64 (PRIV (transfer_address[1]), eiha->tfradr2);
2993 bfd_putl64 (PRIV (transfer_address[2]), eiha->tfradr3);
2994 bfd_putl64 (PRIV (transfer_address[3]), eiha->tfradr4);
2995 bfd_putl64 (0, eiha->inishr);
2998 eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
2999 bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
3000 PRIV (file_pos) += sizeof (struct vms_eihi);
3002 bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
3003 bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
3008 /* Set module name. */
3009 module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
3010 len = strlen (module);
3011 if (len > sizeof (eihi->imgnam) - 1)
3012 len = sizeof (eihi->imgnam) - 1;
3013 eihi->imgnam[0] = len;
3014 memcpy (eihi->imgnam + 1, module, len);
3022 vms_get_time (&hi, &lo);
3023 bfd_putl32 (lo, eihi->linktime + 0);
3024 bfd_putl32 (hi, eihi->linktime + 4);
3027 eihi->linkid[0] = 0;
3028 eihi->imgbid[0] = 0;
3031 dst = PRIV (dst_section);
3032 dmt = bfd_get_section_by_name (abfd, "$DMT$");
3033 if (dst != NULL && dst->size != 0)
3035 eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
3036 bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
3037 PRIV (file_pos) += sizeof (struct vms_eihs);
3039 bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
3040 bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
3041 bfd_putl32 (0, eihs->dstvbn);
3042 bfd_putl32 (0, eihs->dstsize);
3043 bfd_putl32 (0, eihs->gstvbn);
3044 bfd_putl32 (0, eihs->gstsize);
3045 bfd_putl32 (0, eihs->dmtvbn);
3046 bfd_putl32 (0, eihs->dmtsize);
3049 /* One EISD per section. */
3050 for (sec = abfd->sections; sec; sec = sec->next)
3052 if (!alpha_vms_create_eisd_for_section (abfd, sec))
3056 /* Merge section EIDS which extra ones. */
3057 if (PRIV (eisd_tail))
3058 PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
3060 PRIV (eisd_head) = PRIV (gbl_eisd_head);
3061 if (PRIV (gbl_eisd_tail))
3062 PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
3064 first_eisd = PRIV (eisd_head);
3066 /* Add end of eisd. */
3069 eisd = bfd_zalloc (abfd, sizeof (*eisd));
3072 eisd->u.eisd.majorid = 0;
3073 eisd->u.eisd.minorid = 0;
3074 eisd->u.eisd.eisdsize = 0;
3075 alpha_vms_append_extra_eisd (abfd, eisd);
3078 /* Place EISD in the file. */
3079 for (eisd = first_eisd; eisd; eisd = eisd->next)
3081 file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
3083 /* First block is a little bit special: there is a word at the end. */
3084 if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
3086 if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
3087 alpha_vms_file_position_block (abfd);
3089 eisd->file_pos = PRIV (file_pos);
3090 PRIV (file_pos) += eisd->u.eisd.eisdsize;
3092 if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
3093 bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
3096 if (first_eisd != NULL)
3098 bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
3099 /* Real size of end of eisd marker. */
3100 PRIV (file_pos) += EISD__K_LENEND;
3103 bfd_putl32 (PRIV (file_pos), eihd.size);
3104 bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
3107 /* Place sections. */
3108 for (sec = abfd->sections; sec; sec = sec->next)
3110 if (!(sec->flags & SEC_HAS_CONTENTS))
3113 eisd = vms_section_data (sec)->eisd;
3115 /* Align on a block. */
3116 alpha_vms_file_position_block (abfd);
3117 sec->filepos = PRIV (file_pos);
3120 eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
3122 PRIV (file_pos) += sec->size;
3126 if (eihs != NULL && dst != NULL)
3128 bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
3129 bfd_putl32 (dst->size, eihs->dstsize);
3133 lnkflags |= EIHD__M_DBGDMT;
3134 bfd_putl32 ((dmt->filepos / VMS_BLOCK_SIZE) + 1, eihs->dmtvbn);
3135 bfd_putl32 (dmt->size, eihs->dmtsize);
3137 if (PRIV (gsd_sym_count) != 0)
3139 alpha_vms_file_position_block (abfd);
3140 gst_filepos = PRIV (file_pos);
3141 bfd_putl32 ((gst_filepos / VMS_BLOCK_SIZE) + 1, eihs->gstvbn);
3142 bfd_putl32 ((PRIV (gsd_sym_count) + 4) / 5 + 4, eihs->gstsize);
3146 /* Write EISD in hdr. */
3147 for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
3149 alpha_vms_swap_eisd_out
3150 (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
3152 /* Write first block. */
3153 bfd_putl32 (lnkflags, eihd.lnkflags);
3154 if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
3157 /* Write remaining eisd. */
3160 unsigned char blk[VMS_BLOCK_SIZE];
3161 struct vms_internal_eisd_map *next_eisd;
3163 memset (blk, 0xff, sizeof (blk));
3164 while (eisd != NULL)
3166 alpha_vms_swap_eisd_out
3168 (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
3170 next_eisd = eisd->next;
3171 if (next_eisd == NULL
3172 || (next_eisd->file_pos / VMS_BLOCK_SIZE
3173 != eisd->file_pos / VMS_BLOCK_SIZE))
3175 if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
3178 memset (blk, 0xff, sizeof (blk));
3184 /* Write sections. */
3185 for (sec = abfd->sections; sec; sec = sec->next)
3187 unsigned char blk[VMS_BLOCK_SIZE];
3190 if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
3192 if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
3196 len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
3197 if (len != VMS_BLOCK_SIZE)
3199 memset (blk, 0, len);
3200 if (bfd_bwrite (blk, len, abfd) != len)
3206 if (gst_filepos != 0)
3208 struct vms_rec_wr *recwr = &PRIV (recwr);
3211 _bfd_vms_write_emh (abfd);
3212 _bfd_vms_write_lmn (abfd, "GNU LD");
3214 /* PSC for the absolute section. */
3215 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3216 _bfd_vms_output_long (recwr, 0);
3217 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3218 _bfd_vms_output_short (recwr, 0);
3219 _bfd_vms_output_short (recwr, EGPS__V_PIC | EGPS__V_LIB | EGPS__V_RD);
3220 _bfd_vms_output_long (recwr, 0);
3221 _bfd_vms_output_counted (recwr, ".$$ABS$$.");
3222 _bfd_vms_output_end_subrec (recwr);
3223 _bfd_vms_output_end (abfd, recwr);
3225 for (i = 0; i < PRIV (gsd_sym_count); i++)
3227 struct vms_symbol_entry *sym = PRIV (syms)[i];
3234 _bfd_vms_output_alignment (recwr, 8);
3235 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3236 _bfd_vms_output_long (recwr, 0);
3238 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYMG);
3239 _bfd_vms_output_short (recwr, 0); /* Data type, alignment. */
3240 _bfd_vms_output_short (recwr, sym->flags);
3242 if (sym->code_section)
3243 ep = alpha_vms_get_sym_value (sym->code_section, sym->code_value);
3246 BFD_ASSERT (sym->code_value == 0);
3249 val = alpha_vms_get_sym_value (sym->section, sym->value);
3250 _bfd_vms_output_quad
3251 (recwr, sym->typ == EGSD__C_SYMG ? sym->symbol_vector : val);
3252 _bfd_vms_output_quad (recwr, ep);
3253 _bfd_vms_output_quad (recwr, val);
3254 _bfd_vms_output_long (recwr, 0);
3255 hash = _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ__C_SYMSIZ);
3256 _bfd_vms_output_counted (recwr, hash);
3257 _bfd_vms_output_end_subrec (recwr);
3259 _bfd_vms_output_end (abfd, recwr);
3262 _bfd_vms_output_end (abfd, recwr);
3264 if (!_bfd_vms_write_eeom (abfd))
3272 /* Write section and symbol directory of bfd abfd. Return FALSE on error. */
3275 _bfd_vms_write_egsd (bfd *abfd)
3279 unsigned int symnum;
3281 flagword new_flags, old_flags;
3282 int abs_section_index = -1;
3283 unsigned int target_index = 0;
3284 struct vms_rec_wr *recwr = &PRIV (recwr);
3286 vms_debug2 ((2, "vms_write_egsd\n"));
3288 /* Egsd is quadword aligned. */
3289 _bfd_vms_output_alignment (recwr, 8);
3291 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3292 _bfd_vms_output_long (recwr, 0);
3294 /* Number sections. */
3295 for (section = abfd->sections; section != NULL; section = section->next)
3297 if (section->flags & SEC_DEBUGGING)
3299 if (!strcmp (section->name, ".vmsdebug"))
3301 section->flags |= SEC_DEBUGGING;
3304 section->target_index = target_index++;
3307 for (section = abfd->sections; section != NULL; section = section->next)
3309 vms_debug2 ((3, "Section #%d %s, %d bytes\n",
3310 section->target_index, section->name, (int)section->size));
3312 /* Don't write out the VMS debug info section since it is in the
3313 ETBT and EDBG sections in etir. */
3314 if (section->flags & SEC_DEBUGGING)
3317 /* 13 bytes egsd, max 31 chars name -> should be 44 bytes. */
3318 if (_bfd_vms_output_check (recwr, 64) < 0)
3320 _bfd_vms_output_end (abfd, recwr);
3321 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3322 _bfd_vms_output_long (recwr, 0);
3325 /* Don't know if this is necessary for the linker but for now it keeps
3326 vms_slurp_gsd happy. */
3327 sname = section->name;
3330 /* Remove leading dot. */
3332 if ((*sname == 't') && (strcmp (sname, "text") == 0))
3333 sname = EVAX_CODE_NAME;
3334 else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
3335 sname = EVAX_DATA_NAME;
3336 else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
3337 sname = EVAX_BSS_NAME;
3338 else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
3339 sname = EVAX_LINK_NAME;
3340 else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
3341 sname = EVAX_READONLY_NAME;
3342 else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
3343 sname = EVAX_LITERAL_NAME;
3344 else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
3345 sname = EVAX_LITERALS_NAME;
3346 else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
3347 sname = EVAX_COMMON_NAME;
3348 else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
3349 sname = EVAX_LOCAL_NAME;
3352 sname = _bfd_vms_length_hash_symbol (abfd, sname, EOBJ__C_SECSIZ);
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_begin_subrec (recwr, EGSD__C_PSC);
3373 _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
3374 _bfd_vms_output_short (recwr, new_flags);
3375 _bfd_vms_output_long (recwr, (unsigned long) section->size);
3376 _bfd_vms_output_counted (recwr, sname);
3377 _bfd_vms_output_end_subrec (recwr);
3379 /* If the section is an obsolute one, remind its index as it will be
3380 used later for absolute symbols. */
3381 if ((new_flags & EGPS__V_REL) == 0 && abs_section_index < 0)
3382 abs_section_index = section->target_index;
3385 /* Output symbols. */
3386 vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
3388 bfd_set_start_address (abfd, (bfd_vma) -1);
3390 for (symnum = 0; symnum < abfd->symcount; symnum++)
3394 symbol = abfd->outsymbols[symnum];
3395 old_flags = symbol->flags;
3397 /* Work-around a missing feature: consider __main as the main entry
3399 if (*(symbol->name) == '_')
3401 if (strcmp (symbol->name, "__main") == 0)
3402 bfd_set_start_address (abfd, (bfd_vma)symbol->value);
3405 /* Only put in the GSD the global and the undefined symbols. */
3406 if (old_flags & BSF_FILE)
3409 if ((old_flags & BSF_GLOBAL) == 0 && !bfd_is_und_section (symbol->section))
3411 /* If the LIB$INITIIALIZE section is present, add a reference to
3412 LIB$INITIALIZE symbol. FIXME: this should be done explicitely
3413 in the assembly file. */
3414 if (!((old_flags & BSF_SECTION_SYM) != 0
3415 && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
3419 /* 13 bytes egsd, max 64 chars name -> should be 77 bytes. Add 16 more
3420 bytes for a possible ABS section. */
3421 if (_bfd_vms_output_check (recwr, 80 + 16) < 0)
3423 _bfd_vms_output_end (abfd, recwr);
3424 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3425 _bfd_vms_output_long (recwr, 0);
3428 if ((old_flags & BSF_GLOBAL) != 0
3429 && bfd_is_abs_section (symbol->section)
3430 && abs_section_index <= 0)
3432 /* Create an absolute section if none was defined. It is highly
3433 unlikely that the name $ABS$ clashes with a user defined
3434 non-absolute section name. */
3435 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3436 _bfd_vms_output_short (recwr, 4);
3437 _bfd_vms_output_short (recwr, EGPS__V_SHR);
3438 _bfd_vms_output_long (recwr, 0);
3439 _bfd_vms_output_counted (recwr, "$ABS$");
3440 _bfd_vms_output_end_subrec (recwr);
3442 abs_section_index = target_index++;
3445 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
3447 /* Data type, alignment. */
3448 _bfd_vms_output_short (recwr, 0);
3452 if (old_flags & BSF_WEAK)
3453 new_flags |= EGSY__V_WEAK;
3454 if (bfd_is_com_section (symbol->section)) /* .comm */
3455 new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
3457 if (old_flags & BSF_FUNCTION)
3459 new_flags |= EGSY__V_NORM;
3460 new_flags |= EGSY__V_REL;
3462 if (old_flags & BSF_GLOBAL)
3464 new_flags |= EGSY__V_DEF;
3465 if (!bfd_is_abs_section (symbol->section))
3466 new_flags |= EGSY__V_REL;
3468 _bfd_vms_output_short (recwr, new_flags);
3470 if (old_flags & BSF_GLOBAL)
3472 /* Symbol definition. */
3473 bfd_vma code_address = 0;
3474 unsigned long ca_psindx = 0;
3475 unsigned long psindx;
3477 if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
3482 ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
3483 code_address = sym->value;
3484 ca_psindx = sym->section->target_index;
3486 if (bfd_is_abs_section (symbol->section))
3487 psindx = abs_section_index;
3489 psindx = symbol->section->target_index;
3491 _bfd_vms_output_quad (recwr, symbol->value);
3492 _bfd_vms_output_quad (recwr, code_address);
3493 _bfd_vms_output_long (recwr, ca_psindx);
3494 _bfd_vms_output_long (recwr, psindx);
3496 hash = _bfd_vms_length_hash_symbol (abfd, symbol->name, EOBJ__C_SYMSIZ);
3497 _bfd_vms_output_counted (recwr, hash);
3499 _bfd_vms_output_end_subrec (recwr);
3502 _bfd_vms_output_alignment (recwr, 8);
3503 _bfd_vms_output_end (abfd, recwr);
3508 /* Write object header for bfd abfd. Return FALSE on error. */
3511 _bfd_vms_write_ehdr (bfd *abfd)
3514 unsigned int symnum;
3517 struct vms_rec_wr *recwr = &PRIV (recwr);
3519 vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
3521 _bfd_vms_output_alignment (recwr, 2);
3523 _bfd_vms_write_emh (abfd);
3524 _bfd_vms_write_lmn (abfd, "GNU AS");
3527 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3528 _bfd_vms_output_short (recwr, EMH__C_SRC);
3530 for (symnum = 0; symnum < abfd->symcount; symnum++)
3532 symbol = abfd->outsymbols[symnum];
3534 if (symbol->flags & BSF_FILE)
3536 if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
3538 PRIV (flag_hash_long_names) = symbol->name[6] - '0';
3539 PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
3547 _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
3548 (int) strlen (symbol->name));
3555 if (symnum == abfd->symcount)
3556 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
3558 _bfd_vms_output_end (abfd, recwr);
3561 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3562 _bfd_vms_output_short (recwr, EMH__C_TTL);
3563 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
3564 _bfd_vms_output_end (abfd, recwr);
3567 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3568 _bfd_vms_output_short (recwr, EMH__C_CPR);
3569 _bfd_vms_output_dump (recwr,
3570 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
3572 _bfd_vms_output_end (abfd, recwr);
3577 /* Part 4.6, relocations. */
3580 /* WRITE ETIR SECTION
3582 This is still under construction and therefore not documented. */
3584 /* Close the etir/etbt record. */
3587 end_etir_record (bfd * abfd)
3589 struct vms_rec_wr *recwr = &PRIV (recwr);
3591 _bfd_vms_output_end (abfd, recwr);
3595 start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
3597 struct vms_rec_wr *recwr = &PRIV (recwr);
3599 if (section->flags & SEC_DEBUGGING)
3601 _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
3605 /* Push start offset. */
3606 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3607 _bfd_vms_output_long (recwr, (unsigned long) 0);
3608 _bfd_vms_output_end_subrec (recwr);
3611 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
3612 _bfd_vms_output_end_subrec (recwr);
3617 _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
3621 /* Push start offset. */
3622 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3623 _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
3624 _bfd_vms_output_quad (recwr, offset);
3625 _bfd_vms_output_end_subrec (recwr);
3627 /* Start = pop (). */
3628 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
3629 _bfd_vms_output_end_subrec (recwr);
3634 /* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
3635 address VADDR in section specified by SEC_INDEX and NAME. */
3638 sto_imm (bfd *abfd, asection *section,
3639 bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
3642 struct vms_rec_wr *recwr = &PRIV (recwr);
3645 _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
3646 _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
3651 /* Try all the rest. */
3654 if (_bfd_vms_output_check (recwr, size) < 0)
3656 /* Doesn't fit, split ! */
3657 end_etir_record (abfd);
3659 start_etir_or_etbt_record (abfd, section, vaddr);
3661 size = _bfd_vms_output_check (recwr, 0); /* get max size */
3662 if (size > ssize) /* more than what's left ? */
3666 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
3667 _bfd_vms_output_long (recwr, (unsigned long) (size));
3668 _bfd_vms_output_dump (recwr, cptr, size);
3669 _bfd_vms_output_end_subrec (recwr);
3672 _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
3673 _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
3683 etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
3685 if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
3687 /* Not enough room in this record. Close it and open a new one. */
3688 end_etir_record (abfd);
3689 start_etir_or_etbt_record (abfd, section, vaddr);
3693 /* Return whether RELOC must be deferred till the end. */
3696 defer_reloc_p (arelent *reloc)
3698 switch (reloc->howto->type)
3711 /* Write section contents for bfd abfd. Return FALSE on error. */
3714 _bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
3717 struct vms_rec_wr *recwr = &PRIV (recwr);
3719 vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
3721 _bfd_vms_output_alignment (recwr, 4);
3723 PRIV (vms_linkage_index) = 1;
3725 for (section = abfd->sections; section; section = section->next)
3727 vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
3728 section->target_index, section->name, (int) (section->size)));
3730 if (!(section->flags & SEC_HAS_CONTENTS)
3731 || bfd_is_com_section (section))
3734 if (!section->contents)
3736 bfd_set_error (bfd_error_no_contents);
3740 start_etir_or_etbt_record (abfd, section, 0);
3742 if (section->flags & SEC_RELOC)
3744 bfd_vma curr_addr = 0;
3745 unsigned char *curr_data = section->contents;
3747 int pass2_needed = 0;
3748 int pass2_in_progress = 0;
3751 if (section->reloc_count <= 0)
3752 (*_bfd_error_handler)
3753 (_("SEC_RELOC with no relocs in section %s"), section->name);
3758 int i = section->reloc_count;
3759 arelent **rptr = section->orelocation;
3760 _bfd_vms_debug (4, "%d relocations:\n", i);
3763 _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
3764 "addr %08lx, off %08lx, len %d: %s\n",
3765 (*(*rptr)->sym_ptr_ptr)->name,
3766 (*(*rptr)->sym_ptr_ptr)->section->name,
3767 (long) (*(*rptr)->sym_ptr_ptr)->value,
3768 (unsigned long)(*rptr)->address,
3769 (unsigned long)(*rptr)->addend,
3770 bfd_get_reloc_size ((*rptr)->howto),
3771 ( *rptr)->howto->name);
3778 for (irel = 0; irel < section->reloc_count; irel++)
3780 struct evax_private_udata_struct *udata;
3781 arelent *rptr = section->orelocation [irel];
3782 bfd_vma addr = rptr->address;
3783 asymbol *sym = *rptr->sym_ptr_ptr;
3784 asection *sec = sym->section;
3785 bfd_boolean defer = defer_reloc_p (rptr);
3789 if (pass2_in_progress)
3791 /* Non-deferred relocs have already been output. */
3797 /* Deferred relocs must be output at the very end. */
3804 /* Regular relocs are intertwined with binary data. */
3805 if (curr_addr > addr)
3806 (*_bfd_error_handler) (_("Size error in section %s"),
3808 size = addr - curr_addr;
3809 sto_imm (abfd, section, size, curr_data, curr_addr);
3814 size = bfd_get_reloc_size (rptr->howto);
3816 switch (rptr->howto->type)
3818 case ALPHA_R_IGNORE:
3821 case ALPHA_R_REFLONG:
3822 if (bfd_is_und_section (sym->section))
3824 bfd_vma addend = rptr->addend;
3825 slen = strlen ((char *) sym->name);
3826 hash = _bfd_vms_length_hash_symbol
3827 (abfd, sym->name, EOBJ__C_SYMSIZ);
3828 etir_output_check (abfd, section, curr_addr, slen);
3831 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3832 _bfd_vms_output_counted (recwr, hash);
3833 _bfd_vms_output_end_subrec (recwr);
3834 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3835 _bfd_vms_output_long (recwr, (unsigned long) addend);
3836 _bfd_vms_output_end_subrec (recwr);
3837 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3838 _bfd_vms_output_end_subrec (recwr);
3839 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3840 _bfd_vms_output_end_subrec (recwr);
3844 _bfd_vms_output_begin_subrec
3845 (recwr, ETIR__C_STO_GBL_LW);
3846 _bfd_vms_output_counted (recwr, hash);
3847 _bfd_vms_output_end_subrec (recwr);
3850 else if (bfd_is_abs_section (sym->section))
3852 etir_output_check (abfd, section, curr_addr, 16);
3853 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3854 _bfd_vms_output_long (recwr, (unsigned long) sym->value);
3855 _bfd_vms_output_end_subrec (recwr);
3856 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3857 _bfd_vms_output_end_subrec (recwr);
3861 etir_output_check (abfd, section, curr_addr, 32);
3862 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3863 _bfd_vms_output_long (recwr,
3864 (unsigned long) sec->target_index);
3865 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3866 _bfd_vms_output_end_subrec (recwr);
3867 /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
3868 says that we should have a ETIR__C_STO_OFF here.
3869 But the relocation would not be BFD_RELOC_32 then.
3870 This case is very likely unreachable. */
3871 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3872 _bfd_vms_output_end_subrec (recwr);
3876 case ALPHA_R_REFQUAD:
3877 if (bfd_is_und_section (sym->section))
3879 bfd_vma addend = rptr->addend;
3880 slen = strlen ((char *) sym->name);
3881 hash = _bfd_vms_length_hash_symbol
3882 (abfd, sym->name, EOBJ__C_SYMSIZ);
3883 etir_output_check (abfd, section, curr_addr, slen);
3886 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3887 _bfd_vms_output_counted (recwr, hash);
3888 _bfd_vms_output_end_subrec (recwr);
3889 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3890 _bfd_vms_output_quad (recwr, addend);
3891 _bfd_vms_output_end_subrec (recwr);
3892 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3893 _bfd_vms_output_end_subrec (recwr);
3894 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3895 _bfd_vms_output_end_subrec (recwr);
3899 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
3900 _bfd_vms_output_counted (recwr, hash);
3901 _bfd_vms_output_end_subrec (recwr);
3904 else if (bfd_is_abs_section (sym->section))
3906 etir_output_check (abfd, section, curr_addr, 16);
3907 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3908 _bfd_vms_output_quad (recwr, sym->value);
3909 _bfd_vms_output_end_subrec (recwr);
3910 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3911 _bfd_vms_output_end_subrec (recwr);
3915 etir_output_check (abfd, section, curr_addr, 32);
3916 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3917 _bfd_vms_output_long (recwr,
3918 (unsigned long) sec->target_index);
3919 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3920 _bfd_vms_output_end_subrec (recwr);
3921 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
3922 _bfd_vms_output_end_subrec (recwr);
3927 sto_imm (abfd, section, size, curr_data, curr_addr);
3930 case ALPHA_R_LINKAGE:
3931 etir_output_check (abfd, section, curr_addr, 64);
3932 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
3933 _bfd_vms_output_long
3934 (recwr, (unsigned long) PRIV (vms_linkage_index));
3935 PRIV (vms_linkage_index) += 2;
3936 hash = _bfd_vms_length_hash_symbol
3937 (abfd, sym->name, EOBJ__C_SYMSIZ);
3938 _bfd_vms_output_counted (recwr, hash);
3939 _bfd_vms_output_byte (recwr, 0);
3940 _bfd_vms_output_end_subrec (recwr);
3943 case ALPHA_R_CODEADDR:
3944 slen = strlen ((char *) sym->name);
3945 hash = _bfd_vms_length_hash_symbol
3946 (abfd, sym->name, EOBJ__C_SYMSIZ);
3947 etir_output_check (abfd, section, curr_addr, slen);
3948 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
3949 _bfd_vms_output_counted (recwr, hash);
3950 _bfd_vms_output_end_subrec (recwr);
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_NOP_GBL);
3959 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3960 _bfd_vms_output_long
3962 (unsigned long) udata->enbsym->section->target_index);
3963 _bfd_vms_output_quad (recwr, rptr->address);
3964 _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3965 _bfd_vms_output_long
3967 (unsigned long) udata->enbsym->section->target_index);
3968 _bfd_vms_output_quad (recwr, rptr->addend);
3969 _bfd_vms_output_counted
3970 (recwr, _bfd_vms_length_hash_symbol
3971 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3972 _bfd_vms_output_end_subrec (recwr);
3976 (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3981 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3982 etir_output_check (abfd, section, curr_addr,
3983 32 + 1 + strlen (udata->origname));
3984 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
3985 _bfd_vms_output_long
3986 (recwr, (unsigned long) udata->lkindex + 1);
3987 _bfd_vms_output_long
3989 (unsigned long) udata->enbsym->section->target_index);
3990 _bfd_vms_output_quad (recwr, rptr->address);
3991 _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
3992 _bfd_vms_output_long
3993 (recwr, (unsigned long) udata->bsym->section->target_index);
3994 _bfd_vms_output_quad (recwr, rptr->addend);
3995 _bfd_vms_output_counted
3996 (recwr, _bfd_vms_length_hash_symbol
3997 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3998 _bfd_vms_output_end_subrec (recwr);
4003 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
4004 etir_output_check (abfd, section, curr_addr,
4005 32 + 1 + strlen (udata->origname));
4006 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
4007 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
4008 _bfd_vms_output_long
4010 (unsigned long) udata->enbsym->section->target_index);
4011 _bfd_vms_output_quad (recwr, rptr->address);
4012 _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
4013 _bfd_vms_output_long
4015 (unsigned long) udata->enbsym->section->target_index);
4016 _bfd_vms_output_quad (recwr, rptr->addend);
4017 _bfd_vms_output_counted
4018 (recwr, _bfd_vms_length_hash_symbol
4019 (abfd, udata->origname, EOBJ__C_SYMSIZ));
4020 _bfd_vms_output_end_subrec (recwr);
4024 (*_bfd_error_handler) (_("Unhandled relocation %s"),
4031 } /* End of relocs loop. */
4033 if (!pass2_in_progress)
4035 /* Output rest of section. */
4036 if (curr_addr > section->size)
4037 (*_bfd_error_handler) (_("Size error in section %s"),
4039 size = section->size - curr_addr;
4040 sto_imm (abfd, section, size, curr_data, curr_addr);
4046 pass2_in_progress = 1;
4052 else /* (section->flags & SEC_RELOC) */
4053 sto_imm (abfd, section, section->size, section->contents, 0);
4055 end_etir_record (abfd);
4058 _bfd_vms_output_alignment (recwr, 2);
4062 /* Write cached information into a file being written, at bfd_close. */
4065 alpha_vms_write_object_contents (bfd *abfd)
4067 vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
4069 if (abfd->flags & (EXEC_P | DYNAMIC))
4071 return alpha_vms_write_exec (abfd);
4075 if (abfd->section_count > 0) /* we have sections */
4077 if (_bfd_vms_write_ehdr (abfd) != TRUE)
4079 if (_bfd_vms_write_egsd (abfd) != TRUE)
4081 if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
4083 if (_bfd_vms_write_eeom (abfd) != TRUE)
4090 /* Debug stuff: nearest line. */
4092 #define SET_MODULE_PARSED(m) \
4093 do { if ((m)->name == NULL) (m)->name = ""; } while (0)
4094 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
4096 /* Build a new module for the specified BFD. */
4098 static struct module *
4099 new_module (bfd *abfd)
4101 struct module *module
4102 = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
4103 module->file_table_count = 16; /* Arbitrary. */
4105 = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
4109 /* Parse debug info for a module and internalize it. */
4112 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
4115 unsigned char *maxptr = ptr + length;
4116 unsigned char *src_ptr, *pcl_ptr;
4117 unsigned int prev_linum = 0, curr_linenum = 0;
4118 bfd_vma prev_pc = 0, curr_pc = 0;
4119 struct srecinfo *curr_srec, *srec;
4120 struct lineinfo *curr_line, *line;
4121 struct funcinfo *funcinfo;
4123 /* Initialize tables with zero element. */
4124 curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4125 module->srec_table = curr_srec;
4127 curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4128 module->line_table = curr_line;
4130 while (length == -1 || ptr < maxptr)
4132 /* The first byte is not counted in the recorded length. */
4133 int rec_length = bfd_getl16 (ptr) + 1;
4134 int rec_type = bfd_getl16 (ptr + 2);
4136 vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4138 if (length == -1 && rec_type == DST__K_MODEND)
4145 = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4152 vms_debug2 ((3, "module: %s\n", module->name));
4159 funcinfo = (struct funcinfo *)
4160 bfd_zalloc (abfd, sizeof (struct funcinfo));
4162 = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4163 funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4164 funcinfo->next = module->func_table;
4165 module->func_table = funcinfo;
4167 vms_debug2 ((3, "routine: %s at 0x%lx\n",
4168 funcinfo->name, (unsigned long) funcinfo->low));
4172 module->func_table->high = module->func_table->low
4173 + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4175 if (module->func_table->high > module->high)
4176 module->high = module->func_table->high;
4178 vms_debug2 ((3, "end routine\n"));
4182 vms_debug2 ((3, "prologue\n"));
4186 vms_debug2 ((3, "epilog\n"));
4190 vms_debug2 ((3, "block\n"));
4194 vms_debug2 ((3, "end block\n"));
4198 src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4200 vms_debug2 ((3, "source info\n"));
4202 while (src_ptr < ptr + rec_length)
4204 int cmd = src_ptr[0], cmd_length, data;
4208 case DST__K_SRC_DECLFILE:
4211 = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4213 = _bfd_vms_save_counted_string (src_ptr
4214 + DST_S_B_SRC_DF_FILENAME);
4216 while (fileid >= module->file_table_count)
4218 module->file_table_count *= 2;
4220 = bfd_realloc (module->file_table,
4221 module->file_table_count
4222 * sizeof (struct fileinfo));
4225 module->file_table [fileid].name = filename;
4226 module->file_table [fileid].srec = 1;
4227 cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4228 vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4229 fileid, module->file_table [fileid].name));
4233 case DST__K_SRC_DEFLINES_B:
4234 /* Perform the association and set the next higher index
4236 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4237 srec = (struct srecinfo *)
4238 bfd_zalloc (abfd, sizeof (struct srecinfo));
4239 srec->line = curr_srec->line + data;
4240 srec->srec = curr_srec->srec + data;
4241 srec->sfile = curr_srec->sfile;
4242 curr_srec->next = srec;
4245 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4248 case DST__K_SRC_DEFLINES_W:
4249 /* Perform the association and set the next higher index
4251 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4252 srec = (struct srecinfo *)
4253 bfd_zalloc (abfd, sizeof (struct srecinfo));
4254 srec->line = curr_srec->line + data;
4255 srec->srec = curr_srec->srec + data,
4256 srec->sfile = curr_srec->sfile;
4257 curr_srec->next = srec;
4260 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4263 case DST__K_SRC_INCRLNUM_B:
4264 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4265 curr_srec->line += data;
4267 vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4270 case DST__K_SRC_SETFILE:
4271 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4272 curr_srec->sfile = data;
4273 curr_srec->srec = module->file_table[data].srec;
4275 vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4278 case DST__K_SRC_SETLNUM_L:
4279 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4280 curr_srec->line = data;
4282 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4285 case DST__K_SRC_SETLNUM_W:
4286 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4287 curr_srec->line = data;
4289 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4292 case DST__K_SRC_SETREC_L:
4293 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4294 curr_srec->srec = data;
4295 module->file_table[curr_srec->sfile].srec = data;
4297 vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4300 case DST__K_SRC_SETREC_W:
4301 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4302 curr_srec->srec = data;
4303 module->file_table[curr_srec->sfile].srec = data;
4305 vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4308 case DST__K_SRC_FORMFEED:
4310 vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4314 (*_bfd_error_handler) (_("unknown source command %d"),
4320 src_ptr += cmd_length;
4324 case DST__K_LINE_NUM:
4325 pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4327 vms_debug2 ((3, "line info\n"));
4329 while (pcl_ptr < ptr + rec_length)
4331 /* The command byte is signed so we must sign-extend it. */
4332 int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4336 case DST__K_DELTA_PC_W:
4337 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4341 vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4344 case DST__K_DELTA_PC_L:
4345 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4349 vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4352 case DST__K_INCR_LINUM:
4353 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4354 curr_linenum += data;
4356 vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4359 case DST__K_INCR_LINUM_W:
4360 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4361 curr_linenum += data;
4363 vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4366 case DST__K_INCR_LINUM_L:
4367 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4368 curr_linenum += data;
4370 vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4373 case DST__K_SET_LINUM_INCR:
4374 (*_bfd_error_handler)
4375 (_("DST__K_SET_LINUM_INCR not implemented"));
4379 case DST__K_SET_LINUM_INCR_W:
4380 (*_bfd_error_handler)
4381 (_("DST__K_SET_LINUM_INCR_W not implemented"));
4385 case DST__K_RESET_LINUM_INCR:
4386 (*_bfd_error_handler)
4387 (_("DST__K_RESET_LINUM_INCR not implemented"));
4391 case DST__K_BEG_STMT_MODE:
4392 (*_bfd_error_handler)
4393 (_("DST__K_BEG_STMT_MODE not implemented"));
4397 case DST__K_END_STMT_MODE:
4398 (*_bfd_error_handler)
4399 (_("DST__K_END_STMT_MODE not implemented"));
4403 case DST__K_SET_LINUM_B:
4404 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4405 curr_linenum = data;
4407 vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4410 case DST__K_SET_LINUM:
4411 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4412 curr_linenum = data;
4414 vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4417 case DST__K_SET_LINUM_L:
4418 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4419 curr_linenum = data;
4421 vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4425 (*_bfd_error_handler)
4426 (_("DST__K_SET_PC not implemented"));
4430 case DST__K_SET_PC_W:
4431 (*_bfd_error_handler)
4432 (_("DST__K_SET_PC_W not implemented"));
4436 case DST__K_SET_PC_L:
4437 (*_bfd_error_handler)
4438 (_("DST__K_SET_PC_L not implemented"));
4442 case DST__K_SET_STMTNUM:
4443 (*_bfd_error_handler)
4444 (_("DST__K_SET_STMTNUM not implemented"));
4449 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4452 vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4456 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4459 vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4463 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4466 vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
4469 case DST__K_SET_ABS_PC:
4470 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4473 vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4482 vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4483 (unsigned long)curr_pc, curr_linenum));
4487 (*_bfd_error_handler) (_("unknown line command %d"),
4494 if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4496 || cmd == DST__K_DELTA_PC_L
4497 || cmd == DST__K_DELTA_PC_W)
4499 line = (struct lineinfo *)
4500 bfd_zalloc (abfd, sizeof (struct lineinfo));
4501 line->address = curr_pc;
4502 line->line = curr_linenum;
4504 curr_line->next = line;
4507 prev_linum = curr_linenum;
4509 vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4510 (unsigned long)curr_pc, curr_linenum));
4513 pcl_ptr += cmd_length;
4517 case 0x17: /* Undocumented type used by DEC C to declare equates. */
4518 vms_debug2 ((3, "undocumented type 0x17\n"));
4522 vms_debug2 ((3, "ignoring record\n"));
4530 /* Finalize tables with EOL marker. */
4531 srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4532 srec->line = (unsigned int) -1;
4533 srec->srec = (unsigned int) -1;
4534 curr_srec->next = srec;
4536 line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4537 line->line = (unsigned int) -1;
4538 line->address = (bfd_vma) -1;
4539 curr_line->next = line;
4541 /* Advertise that this module has been parsed. This is needed
4542 because parsing can be either performed at module creation
4543 or deferred until debug info is consumed. */
4544 SET_MODULE_PARSED (module);
4547 /* Build the list of modules for the specified BFD. */
4549 static struct module *
4550 build_module_list (bfd *abfd)
4552 struct module *module, *list = NULL;
4555 if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4557 /* We have a DMT section so this must be an image. Parse the
4558 section and build the list of modules. This is sufficient
4559 since we can compute the start address and the end address
4560 of every module from the section contents. */
4561 bfd_size_type size = bfd_get_section_size (dmt);
4562 unsigned char *ptr, *end;
4564 ptr = (unsigned char *) bfd_alloc (abfd, size);
4568 if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4571 vms_debug2 ((2, "DMT\n"));
4577 /* Each header declares a module with its start offset and size
4578 of debug info in the DST section, as well as the count of
4579 program sections (i.e. address spans) it contains. */
4580 int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4581 int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4582 int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4583 ptr += DBG_S_C_DMT_HEADER_SIZE;
4585 vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4586 modbeg, msize, count));
4588 /* We create a 'module' structure for each program section since
4589 we only support contiguous addresses in a 'module' structure.
4590 As a consequence, the actual debug info in the DST section is
4591 shared and can be parsed multiple times; that doesn't seem to
4592 cause problems in practice. */
4595 int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4596 int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4597 module = new_module (abfd);
4598 module->modbeg = modbeg;
4599 module->size = msize;
4600 module->low = start;
4601 module->high = start + length;
4602 module->next = list;
4604 ptr += DBG_S_C_DMT_PSECT_SIZE;
4606 vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4613 /* We don't have a DMT section so this must be an object. Parse
4614 the module right now in order to compute its start address and
4616 module = new_module (abfd);
4617 parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4624 /* Calculate and return the name of the source file and the line nearest
4625 to the wanted location in the specified module. */
4628 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4629 const char **file, const char **func,
4632 struct funcinfo *funcinfo;
4633 struct lineinfo *lineinfo;
4634 struct srecinfo *srecinfo;
4635 bfd_boolean ret = FALSE;
4637 /* Parse this module if that was not done at module creation. */
4638 if (! IS_MODULE_PARSED (module))
4640 unsigned int size = module->size;
4641 unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4642 unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4644 if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4645 || bfd_bread (buffer, size, abfd) != size)
4647 bfd_set_error (bfd_error_no_debug_section);
4651 parse_module (abfd, module, buffer, size);
4655 /* Find out the function (if any) that contains the address. */
4656 for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4657 if (addr >= funcinfo->low && addr <= funcinfo->high)
4659 *func = funcinfo->name;
4664 /* Find out the source file and the line nearest to the address. */
4665 for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4666 if (lineinfo->next && addr < lineinfo->next->address)
4668 for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4669 if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4671 if (srecinfo->sfile > 0)
4673 *file = module->file_table[srecinfo->sfile].name;
4674 *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4678 *file = module->name;
4679 *line = lineinfo->line;
4690 /* Provided a BFD, a section and an offset into the section, calculate and
4691 return the name of the source file and the line nearest to the wanted
4695 _bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
4696 asymbol **symbols ATTRIBUTE_UNUSED,
4697 bfd_vma offset, const char **file,
4698 const char **func, unsigned int *line)
4700 struct module *module;
4702 /* What address are we looking for? */
4703 bfd_vma addr = section->vma + offset;
4709 if (PRIV (dst_section) == NULL || !(abfd->flags & (EXEC_P | DYNAMIC)))
4712 if (PRIV (modules) == NULL)
4714 PRIV (modules) = build_module_list (abfd);
4715 if (PRIV (modules) == NULL)
4719 for (module = PRIV (modules); module; module = module->next)
4720 if (addr >= module->low && addr <= module->high)
4721 return module_find_nearest_line (abfd, module, addr, file, func, line);
4726 /* Canonicalizations. */
4727 /* Set name, value, section and flags of SYM from E. */
4730 alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4739 flags = BSF_NO_FLAGS;
4745 if (e->flags & EGSY__V_WEAK)
4748 if (e->flags & EGSY__V_DEF)
4750 /* Symbol definition. */
4751 flags |= BSF_GLOBAL;
4752 if (e->flags & EGSY__V_NORM)
4753 flags |= BSF_FUNCTION;
4759 /* Symbol reference. */
4760 sec = bfd_und_section_ptr;
4765 /* A universal symbol is by definition global... */
4766 flags |= BSF_GLOBAL;
4768 /* ...and dynamic in shared libraries. */
4769 if (abfd->flags & DYNAMIC)
4770 flags |= BSF_DYNAMIC;
4772 if (e->flags & EGSY__V_WEAK)
4775 if (!(e->flags & EGSY__V_DEF))
4778 if (e->flags & EGSY__V_NORM)
4779 flags |= BSF_FUNCTION;
4782 /* sec = e->section; */
4783 sec = bfd_abs_section_ptr;
4798 /* Return the number of bytes required to store a vector of pointers
4799 to asymbols for all the symbols in the BFD abfd, including a
4800 terminal NULL pointer. If there are no symbols in the BFD,
4801 then return 0. If an error occurs, return -1. */
4804 alpha_vms_get_symtab_upper_bound (bfd *abfd)
4806 vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4807 abfd, PRIV (gsd_sym_count)));
4809 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4812 /* Read the symbols from the BFD abfd, and fills in the vector
4813 location with pointers to the symbols and a trailing NULL.
4815 Return number of symbols read. */
4818 alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4822 vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4824 if (PRIV (csymbols) == NULL)
4826 PRIV (csymbols) = (asymbol **) bfd_alloc
4827 (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4829 /* Traverse table and fill symbols vector. */
4830 for (i = 0; i < PRIV (gsd_sym_count); i++)
4832 struct vms_symbol_entry *e = PRIV (syms)[i];
4835 sym = bfd_make_empty_symbol (abfd);
4836 if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4838 bfd_release (abfd, PRIV (csymbols));
4839 PRIV (csymbols) = NULL;
4843 PRIV (csymbols)[i] = sym;
4847 if (symbols != NULL)
4849 for (i = 0; i < PRIV (gsd_sym_count); i++)
4850 symbols[i] = PRIV (csymbols)[i];
4854 return PRIV (gsd_sym_count);
4857 /* Read and convert relocations from ETIR. We do it once for all sections. */
4860 alpha_vms_slurp_relocs (bfd *abfd)
4864 vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4866 /* We slurp relocs only once, for all sections. */
4867 if (PRIV (reloc_done))
4869 PRIV (reloc_done) = TRUE;
4871 if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4874 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4879 unsigned char *begin;
4882 bfd_reloc_code_real_type reloc_code;
4888 bfd_vma cur_address;
4890 unsigned char *cur_sym = NULL;
4892 bfd_vma cur_addend = 0;
4894 /* Skip non-ETIR records. */
4895 type = _bfd_vms_get_object_record (abfd);
4896 if (type == EOBJ__C_EEOM)
4898 if (type != EOBJ__C_ETIR)
4901 begin = PRIV (recrd.rec) + 4;
4902 end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4904 for (ptr = begin; ptr < end; ptr += length)
4908 cmd = bfd_getl16 (ptr);
4909 length = bfd_getl16 (ptr + 2);
4911 cur_address = vaddr;
4913 vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4914 _bfd_vms_etir_name (cmd)));
4918 case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4919 /* ALPHA_R_REFQUAD und_section, step 1 */
4924 case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4925 cur_psidx = bfd_getl32 (ptr + 4);
4926 cur_addend = bfd_getl64 (ptr + 8);
4930 case ETIR__C_CTL_SETRB:
4931 if (prev_cmd != ETIR__C_STA_PQ)
4933 (*_bfd_error_handler)
4934 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4935 _bfd_vms_etir_name (cmd));
4938 cur_psect = cur_psidx;
4944 case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4945 /* ALPHA_R_REFLONG und_section, step 2 */
4948 if (prev_cmd != ETIR__C_STA_GBL)
4950 (*_bfd_error_handler)
4951 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4952 _bfd_vms_etir_name (ETIR__C_STA_LW));
4956 cur_addend = bfd_getl32 (ptr + 4);
4960 case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4961 /* ALPHA_R_REFQUAD und_section, step 2 */
4962 if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4964 (*_bfd_error_handler)
4965 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4966 _bfd_vms_etir_name (ETIR__C_STA_QW));
4969 cur_addend = bfd_getl64 (ptr + 4);
4973 case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4974 /* ALPHA_R_REFLONG abs_section, step 2 */
4975 /* ALPHA_R_REFLONG others, step 2 */
4976 if (prev_cmd != ETIR__C_OPR_ADD
4977 && prev_cmd != ETIR__C_STA_LW
4978 && prev_cmd != ETIR__C_STA_PQ)
4980 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4981 _bfd_vms_etir_name (prev_cmd),
4982 _bfd_vms_etir_name (ETIR__C_STO_LW));
4985 reloc_code = BFD_RELOC_32;
4988 case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
4989 /* ALPHA_R_REFQUAD abs_section, step 2 */
4990 if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
4992 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4993 _bfd_vms_etir_name (prev_cmd),
4994 _bfd_vms_etir_name (ETIR__C_STO_QW));
4997 reloc_code = BFD_RELOC_64;
5000 case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
5001 if (prev_cmd != ETIR__C_STA_PQ)
5003 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
5004 _bfd_vms_etir_name (prev_cmd),
5005 _bfd_vms_etir_name (ETIR__C_STO_OFF));
5008 reloc_code = BFD_RELOC_64;
5011 case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
5012 /* ALPHA_R_REFQUAD und_section, step 3 */
5013 if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
5015 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
5016 _bfd_vms_etir_name (prev_cmd),
5017 _bfd_vms_etir_name (ETIR__C_OPR_ADD));
5020 prev_cmd = ETIR__C_OPR_ADD;
5023 case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
5024 reloc_code = BFD_RELOC_ALPHA_CODEADDR;
5028 case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
5029 reloc_code = BFD_RELOC_64;
5033 case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
5034 reloc_code = BFD_RELOC_32;
5038 case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
5039 reloc_code = BFD_RELOC_ALPHA_LINKAGE;
5043 case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
5044 reloc_code = BFD_RELOC_ALPHA_NOP;
5047 case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
5048 reloc_code = BFD_RELOC_ALPHA_BSR;
5051 case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
5052 reloc_code = BFD_RELOC_ALPHA_LDA;
5055 case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
5056 reloc_code = BFD_RELOC_ALPHA_BOH;
5060 cur_sym = ptr + 4 + 32;
5061 cur_address = bfd_getl64 (ptr + 4 + 8);
5062 cur_addend = bfd_getl64 (ptr + 4 + 24);
5065 case ETIR__C_STO_IMM:
5066 vaddr += bfd_getl32 (ptr + 4);
5070 (*_bfd_error_handler) (_("Unknown reloc %s"),
5071 _bfd_vms_etir_name (cmd));
5077 struct vms_section_data_struct *vms_sec;
5080 /* Get section to which the relocation applies. */
5081 if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
5083 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
5086 sec = PRIV (sections)[cur_psect];
5087 vms_sec = vms_section_data (sec);
5089 /* Allocate a reloc entry. */
5090 if (sec->reloc_count >= vms_sec->reloc_max)
5092 if (vms_sec->reloc_max == 0)
5094 vms_sec->reloc_max = 64;
5095 sec->relocation = bfd_zmalloc
5096 (vms_sec->reloc_max * sizeof (arelent));
5100 vms_sec->reloc_max *= 2;
5101 sec->relocation = bfd_realloc
5102 (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5105 reloc = &sec->relocation[sec->reloc_count];
5108 reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5110 if (cur_sym != NULL)
5113 unsigned int symlen = *cur_sym;
5116 /* Linear search. */
5121 for (j = 0; j < PRIV (gsd_sym_count); j++)
5122 if (PRIV (syms)[j]->namelen == symlen
5123 && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5125 sym = &PRIV (csymbols)[j];
5130 (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5131 _bfd_vms_etir_name (cmd));
5132 reloc->sym_ptr_ptr = NULL;
5135 reloc->sym_ptr_ptr = sym;
5137 else if (cur_psidx >= 0)
5138 reloc->sym_ptr_ptr =
5139 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5141 reloc->sym_ptr_ptr = NULL;
5143 reloc->address = cur_address;
5144 reloc->addend = cur_addend;
5146 vaddr += bfd_get_reloc_size (reloc->howto);
5155 vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5160 /* Return the number of bytes required to store the relocation
5161 information associated with the given section. */
5164 alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5166 alpha_vms_slurp_relocs (abfd);
5168 return (section->reloc_count + 1) * sizeof (arelent *);
5171 /* Convert relocations from VMS (external) form into BFD internal
5172 form. Return the number of relocations. */
5175 alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5176 asymbol **symbols ATTRIBUTE_UNUSED)
5181 if (!alpha_vms_slurp_relocs (abfd))
5184 count = section->reloc_count;
5185 tblptr = section->relocation;
5188 *relptr++ = tblptr++;
5190 *relptr = (arelent *) NULL;
5191 return section->reloc_count;
5194 /* This is just copied from ecoff-alpha, needs to be fixed probably. */
5196 /* How to process the various reloc types. */
5198 static bfd_reloc_status_type
5199 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5200 arelent *reloc ATTRIBUTE_UNUSED,
5201 asymbol *sym ATTRIBUTE_UNUSED,
5202 void * data ATTRIBUTE_UNUSED,
5203 asection *sec ATTRIBUTE_UNUSED,
5204 bfd *output_bfd ATTRIBUTE_UNUSED,
5205 char **error_message ATTRIBUTE_UNUSED)
5208 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5209 vms_debug (2, "In section %s, symbol %s\n",
5210 sec->name, sym->name);
5211 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5212 reloc->sym_ptr_ptr[0]->name,
5213 (unsigned long)reloc->address,
5214 (unsigned long)reloc->addend, reloc->howto->name);
5215 vms_debug (2, "data at %p\n", data);
5216 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5219 return bfd_reloc_ok;
5222 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5223 from smaller values. Start with zero, widen, *then* decrement. */
5224 #define MINUS_ONE (((bfd_vma)0) - 1)
5226 static reloc_howto_type alpha_howto_table[] =
5228 HOWTO (ALPHA_R_IGNORE, /* Type. */
5229 0, /* Rightshift. */
5230 0, /* Size (0 = byte, 1 = short, 2 = long). */
5232 TRUE, /* PC relative. */
5234 complain_overflow_dont,/* Complain_on_overflow. */
5235 reloc_nil, /* Special_function. */
5236 "IGNORE", /* Name. */
5237 TRUE, /* Partial_inplace. */
5238 0, /* Source mask */
5240 TRUE), /* PC rel offset. */
5242 /* A 64 bit reference to a symbol. */
5243 HOWTO (ALPHA_R_REFQUAD, /* Type. */
5244 0, /* Rightshift. */
5245 4, /* Size (0 = byte, 1 = short, 2 = long). */
5247 FALSE, /* PC relative. */
5249 complain_overflow_bitfield, /* Complain_on_overflow. */
5250 reloc_nil, /* Special_function. */
5251 "REFQUAD", /* Name. */
5252 TRUE, /* Partial_inplace. */
5253 MINUS_ONE, /* Source mask. */
5254 MINUS_ONE, /* Dest mask. */
5255 FALSE), /* PC rel offset. */
5257 /* A 21 bit branch. The native assembler generates these for
5258 branches within the text segment, and also fills in the PC
5259 relative offset in the instruction. */
5260 HOWTO (ALPHA_R_BRADDR, /* Type. */
5261 2, /* Rightshift. */
5262 2, /* Size (0 = byte, 1 = short, 2 = long). */
5264 TRUE, /* PC relative. */
5266 complain_overflow_signed, /* Complain_on_overflow. */
5267 reloc_nil, /* Special_function. */
5268 "BRADDR", /* Name. */
5269 TRUE, /* Partial_inplace. */
5270 0x1fffff, /* Source mask. */
5271 0x1fffff, /* Dest mask. */
5272 FALSE), /* PC rel offset. */
5274 /* A hint for a jump to a register. */
5275 HOWTO (ALPHA_R_HINT, /* Type. */
5276 2, /* Rightshift. */
5277 1, /* Size (0 = byte, 1 = short, 2 = long). */
5279 TRUE, /* PC relative. */
5281 complain_overflow_dont,/* Complain_on_overflow. */
5282 reloc_nil, /* Special_function. */
5284 TRUE, /* Partial_inplace. */
5285 0x3fff, /* Source mask. */
5286 0x3fff, /* Dest mask. */
5287 FALSE), /* PC rel offset. */
5289 /* 16 bit PC relative offset. */
5290 HOWTO (ALPHA_R_SREL16, /* Type. */
5291 0, /* Rightshift. */
5292 1, /* Size (0 = byte, 1 = short, 2 = long). */
5294 TRUE, /* PC relative. */
5296 complain_overflow_signed, /* Complain_on_overflow. */
5297 reloc_nil, /* Special_function. */
5298 "SREL16", /* Name. */
5299 TRUE, /* Partial_inplace. */
5300 0xffff, /* Source mask. */
5301 0xffff, /* Dest mask. */
5302 FALSE), /* PC rel offset. */
5304 /* 32 bit PC relative offset. */
5305 HOWTO (ALPHA_R_SREL32, /* Type. */
5306 0, /* Rightshift. */
5307 2, /* Size (0 = byte, 1 = short, 2 = long). */
5309 TRUE, /* PC relative. */
5311 complain_overflow_signed, /* Complain_on_overflow. */
5312 reloc_nil, /* Special_function. */
5313 "SREL32", /* Name. */
5314 TRUE, /* Partial_inplace. */
5315 0xffffffff, /* Source mask. */
5316 0xffffffff, /* Dest mask. */
5317 FALSE), /* PC rel offset. */
5319 /* A 64 bit PC relative offset. */
5320 HOWTO (ALPHA_R_SREL64, /* Type. */
5321 0, /* Rightshift. */
5322 4, /* Size (0 = byte, 1 = short, 2 = long). */
5324 TRUE, /* PC relative. */
5326 complain_overflow_signed, /* Complain_on_overflow. */
5327 reloc_nil, /* Special_function. */
5328 "SREL64", /* Name. */
5329 TRUE, /* Partial_inplace. */
5330 MINUS_ONE, /* Source mask. */
5331 MINUS_ONE, /* Dest mask. */
5332 FALSE), /* PC rel offset. */
5334 /* Push a value on the reloc evaluation stack. */
5335 HOWTO (ALPHA_R_OP_PUSH, /* Type. */
5336 0, /* Rightshift. */
5337 0, /* Size (0 = byte, 1 = short, 2 = long). */
5339 FALSE, /* PC relative. */
5341 complain_overflow_dont,/* Complain_on_overflow. */
5342 reloc_nil, /* Special_function. */
5343 "OP_PUSH", /* Name. */
5344 FALSE, /* Partial_inplace. */
5345 0, /* Source mask. */
5347 FALSE), /* PC rel offset. */
5349 /* Store the value from the stack at the given address. Store it in
5350 a bitfield of size r_size starting at bit position r_offset. */
5351 HOWTO (ALPHA_R_OP_STORE, /* Type. */
5352 0, /* Rightshift. */
5353 4, /* Size (0 = byte, 1 = short, 2 = long). */
5355 FALSE, /* PC relative. */
5357 complain_overflow_dont,/* Complain_on_overflow. */
5358 reloc_nil, /* Special_function. */
5359 "OP_STORE", /* Name. */
5360 FALSE, /* Partial_inplace. */
5361 0, /* Source mask. */
5362 MINUS_ONE, /* Dest mask. */
5363 FALSE), /* PC rel offset. */
5365 /* Subtract the reloc address from the value on the top of the
5366 relocation stack. */
5367 HOWTO (ALPHA_R_OP_PSUB, /* Type. */
5368 0, /* Rightshift. */
5369 0, /* Size (0 = byte, 1 = short, 2 = long). */
5371 FALSE, /* PC relative. */
5373 complain_overflow_dont,/* Complain_on_overflow. */
5374 reloc_nil, /* Special_function. */
5375 "OP_PSUB", /* Name. */
5376 FALSE, /* Partial_inplace. */
5377 0, /* Source mask. */
5379 FALSE), /* PC rel offset. */
5381 /* Shift the value on the top of the relocation stack right by the
5383 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */
5384 0, /* Rightshift. */
5385 0, /* Size (0 = byte, 1 = short, 2 = long). */
5387 FALSE, /* PC relative. */
5389 complain_overflow_dont,/* Complain_on_overflow. */
5390 reloc_nil, /* Special_function. */
5391 "OP_PRSHIFT", /* Name. */
5392 FALSE, /* Partial_inplace. */
5393 0, /* Source mask. */
5395 FALSE), /* PC rel offset. */
5397 /* Hack. Linkage is done by linker. */
5398 HOWTO (ALPHA_R_LINKAGE, /* Type. */
5399 0, /* Rightshift. */
5400 8, /* Size (0 = byte, 1 = short, 2 = long). */
5402 FALSE, /* PC relative. */
5404 complain_overflow_dont,/* Complain_on_overflow. */
5405 reloc_nil, /* Special_function. */
5406 "LINKAGE", /* Name. */
5407 FALSE, /* Partial_inplace. */
5408 0, /* Source mask. */
5410 FALSE), /* PC rel offset. */
5412 /* A 32 bit reference to a symbol. */
5413 HOWTO (ALPHA_R_REFLONG, /* Type. */
5414 0, /* Rightshift. */
5415 2, /* Size (0 = byte, 1 = short, 2 = long). */
5417 FALSE, /* PC relative. */
5419 complain_overflow_bitfield, /* Complain_on_overflow. */
5420 reloc_nil, /* Special_function. */
5421 "REFLONG", /* Name. */
5422 TRUE, /* Partial_inplace. */
5423 0xffffffff, /* Source mask. */
5424 0xffffffff, /* Dest mask. */
5425 FALSE), /* PC rel offset. */
5427 /* A 64 bit reference to a procedure, written as 32 bit value. */
5428 HOWTO (ALPHA_R_CODEADDR, /* Type. */
5429 0, /* Rightshift. */
5430 4, /* Size (0 = byte, 1 = short, 2 = long). */
5432 FALSE, /* PC relative. */
5434 complain_overflow_signed,/* Complain_on_overflow. */
5435 reloc_nil, /* Special_function. */
5436 "CODEADDR", /* Name. */
5437 FALSE, /* Partial_inplace. */
5438 0xffffffff, /* Source mask. */
5439 0xffffffff, /* Dest mask. */
5440 FALSE), /* PC rel offset. */
5442 HOWTO (ALPHA_R_NOP, /* Type. */
5443 0, /* Rightshift. */
5444 3, /* Size (0 = byte, 1 = short, 2 = long). */
5446 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5447 because the calculations for the 3 relocations are the same.
5448 See B.4.5.2 of the OpenVMS Linker Utility Manual. */
5449 TRUE, /* PC relative. */
5451 complain_overflow_dont,/* Complain_on_overflow. */
5452 reloc_nil, /* Special_function. */
5454 FALSE, /* Partial_inplace. */
5455 0xffffffff, /* Source mask. */
5456 0xffffffff, /* Dest mask. */
5457 FALSE), /* PC rel offset. */
5459 HOWTO (ALPHA_R_BSR, /* Type. */
5460 0, /* Rightshift. */
5461 3, /* Size (0 = byte, 1 = short, 2 = long). */
5463 TRUE, /* PC relative. */
5465 complain_overflow_dont,/* Complain_on_overflow. */
5466 reloc_nil, /* Special_function. */
5468 FALSE, /* Partial_inplace. */
5469 0xffffffff, /* Source mask. */
5470 0xffffffff, /* Dest mask. */
5471 FALSE), /* PC rel offset. */
5473 HOWTO (ALPHA_R_LDA, /* Type. */
5474 0, /* Rightshift. */
5475 3, /* Size (0 = byte, 1 = short, 2 = long). */
5477 FALSE, /* PC relative. */
5479 complain_overflow_dont,/* Complain_on_overflow. */
5480 reloc_nil, /* Special_function. */
5482 FALSE, /* Partial_inplace. */
5483 0xffffffff, /* Source mask. */
5484 0xffffffff, /* Dest mask. */
5485 FALSE), /* PC rel offset. */
5487 HOWTO (ALPHA_R_BOH, /* Type. */
5488 0, /* Rightshift. */
5489 3, /* Size (0 = byte, 1 = short, 2 = long, 3 = nil). */
5491 TRUE, /* PC relative. */
5493 complain_overflow_dont,/* Complain_on_overflow. */
5494 reloc_nil, /* Special_function. */
5496 FALSE, /* Partial_inplace. */
5497 0xffffffff, /* Source mask. */
5498 0xffffffff, /* Dest mask. */
5499 FALSE), /* PC rel offset. */
5502 /* Return a pointer to a howto structure which, when invoked, will perform
5503 the relocation code on data from the architecture noted. */
5505 static const struct reloc_howto_struct *
5506 alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5507 bfd_reloc_code_real_type code)
5511 vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5515 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break;
5516 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break;
5517 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break;
5518 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break;
5519 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break;
5520 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break;
5521 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break;
5522 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break;
5523 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break;
5524 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break;
5525 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break;
5526 case BFD_RELOC_ALPHA_NOP: alpha_type = ALPHA_R_NOP; break;
5527 case BFD_RELOC_ALPHA_BSR: alpha_type = ALPHA_R_BSR; break;
5528 case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
5529 case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
5531 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5534 vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5535 return & alpha_howto_table[alpha_type];
5538 static reloc_howto_type *
5539 alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5545 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5547 if (alpha_howto_table[i].name != NULL
5548 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5549 return &alpha_howto_table[i];
5555 alpha_vms_get_synthetic_symtab (bfd *abfd,
5556 long symcount ATTRIBUTE_UNUSED,
5557 asymbol **usyms ATTRIBUTE_UNUSED,
5558 long dynsymcount ATTRIBUTE_UNUSED,
5559 asymbol **dynsyms ATTRIBUTE_UNUSED,
5566 syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5571 for (i = 0; i < PRIV (gsd_sym_count); i++)
5573 struct vms_symbol_entry *e = PRIV (syms)[i];
5584 flags = BSF_LOCAL | BSF_SYNTHETIC;
5591 if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5593 value = e->code_value;
5594 sec = e->code_section;
5605 sname = bfd_alloc (abfd, l + 5);
5608 memcpy (sname, name, l);
5609 memcpy (sname + l, "..en", 5);
5616 sym->udata.p = NULL;
5625 vms_time_to_str (unsigned char *buf)
5627 time_t t = vms_rawtime_to_time_t (buf);
5628 char *res = ctime (&t);
5631 res = "*invalid time*";
5638 evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5640 struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5641 unsigned int subtype;
5643 subtype = (unsigned)bfd_getl16 (emh->subtyp);
5645 fprintf (file, _(" EMH %u (len=%u): "), subtype, rec_len);
5651 struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5654 fprintf (file, _("Module header\n"));
5655 fprintf (file, _(" structure level: %u\n"), mhd->strlvl);
5656 fprintf (file, _(" max record size: %u\n"),
5657 (unsigned)bfd_getl32 (mhd->recsiz));
5658 name = (char *)(mhd + 1);
5659 fprintf (file, _(" module name : %.*s\n"), name[0], name + 1);
5660 name += name[0] + 1;
5661 fprintf (file, _(" module version : %.*s\n"), name[0], name + 1);
5662 name += name[0] + 1;
5663 fprintf (file, _(" compile date : %.17s\n"), name);
5668 fprintf (file, _("Language Processor Name\n"));
5669 fprintf (file, _(" language name: %.*s\n"),
5670 (int)(rec_len - sizeof (struct vms_emh_common)),
5671 (char *)rec + sizeof (struct vms_emh_common));
5676 fprintf (file, _("Source Files Header\n"));
5677 fprintf (file, _(" file: %.*s\n"),
5678 (int)(rec_len - sizeof (struct vms_emh_common)),
5679 (char *)rec + sizeof (struct vms_emh_common));
5684 fprintf (file, _("Title Text Header\n"));
5685 fprintf (file, _(" title: %.*s\n"),
5686 (int)(rec_len - sizeof (struct vms_emh_common)),
5687 (char *)rec + sizeof (struct vms_emh_common));
5692 fprintf (file, _("Copyright Header\n"));
5693 fprintf (file, _(" copyright: %.*s\n"),
5694 (int)(rec_len - sizeof (struct vms_emh_common)),
5695 (char *)rec + sizeof (struct vms_emh_common));
5699 fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5705 evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5707 struct vms_eeom *eeom = (struct vms_eeom *)rec;
5709 fprintf (file, _(" EEOM (len=%u):\n"), rec_len);
5710 fprintf (file, _(" number of cond linkage pairs: %u\n"),
5711 (unsigned)bfd_getl32 (eeom->total_lps));
5712 fprintf (file, _(" completion code: %u\n"),
5713 (unsigned)bfd_getl16 (eeom->comcod));
5716 fprintf (file, _(" transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5717 fprintf (file, _(" transfer addr psect: %u\n"),
5718 (unsigned)bfd_getl32 (eeom->psindx));
5719 fprintf (file, _(" transfer address : 0x%08x\n"),
5720 (unsigned)bfd_getl32 (eeom->tfradr));
5725 exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5727 if (flags & EGSY__V_WEAK)
5728 fputs (_(" WEAK"), file);
5729 if (flags & EGSY__V_DEF)
5730 fputs (_(" DEF"), file);
5731 if (flags & EGSY__V_UNI)
5732 fputs (_(" UNI"), file);
5733 if (flags & EGSY__V_REL)
5734 fputs (_(" REL"), file);
5735 if (flags & EGSY__V_COMM)
5736 fputs (_(" COMM"), file);
5737 if (flags & EGSY__V_VECEP)
5738 fputs (_(" VECEP"), file);
5739 if (flags & EGSY__V_NORM)
5740 fputs (_(" NORM"), file);
5741 if (flags & EGSY__V_QUAD_VAL)
5742 fputs (_(" QVAL"), file);
5746 evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5748 if (flags & EGPS__V_PIC)
5749 fputs (_(" PIC"), file);
5750 if (flags & EGPS__V_LIB)
5751 fputs (_(" LIB"), file);
5752 if (flags & EGPS__V_OVR)
5753 fputs (_(" OVR"), file);
5754 if (flags & EGPS__V_REL)
5755 fputs (_(" REL"), file);
5756 if (flags & EGPS__V_GBL)
5757 fputs (_(" GBL"), file);
5758 if (flags & EGPS__V_SHR)
5759 fputs (_(" SHR"), file);
5760 if (flags & EGPS__V_EXE)
5761 fputs (_(" EXE"), file);
5762 if (flags & EGPS__V_RD)
5763 fputs (_(" RD"), file);
5764 if (flags & EGPS__V_WRT)
5765 fputs (_(" WRT"), file);
5766 if (flags & EGPS__V_VEC)
5767 fputs (_(" VEC"), file);
5768 if (flags & EGPS__V_NOMOD)
5769 fputs (_(" NOMOD"), file);
5770 if (flags & EGPS__V_COM)
5771 fputs (_(" COM"), file);
5772 if (flags & EGPS__V_ALLOC_64BIT)
5773 fputs (_(" 64B"), file);
5777 evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5779 unsigned int off = sizeof (struct vms_egsd);
5782 fprintf (file, _(" EGSD (len=%u):\n"), rec_len);
5785 for (off = sizeof (struct vms_egsd); off < rec_len; )
5787 struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5791 type = (unsigned)bfd_getl16 (e->gsdtyp);
5792 len = (unsigned)bfd_getl16 (e->gsdsiz);
5794 fprintf (file, _(" EGSD entry %2u (type: %u, len: %u): "),
5802 struct vms_egps *egps = (struct vms_egps *)e;
5803 unsigned int flags = bfd_getl16 (egps->flags);
5806 fprintf (file, _("PSC - Program section definition\n"));
5807 fprintf (file, _(" alignment : 2**%u\n"), egps->align);
5808 fprintf (file, _(" flags : 0x%04x"), flags);
5809 evax_bfd_print_egsd_flags (file, flags);
5811 l = bfd_getl32 (egps->alloc);
5812 fprintf (file, _(" alloc (len): %u (0x%08x)\n"), l, l);
5813 fprintf (file, _(" name : %.*s\n"),
5814 egps->namlng, egps->name);
5819 struct vms_esgps *esgps = (struct vms_esgps *)e;
5820 unsigned int flags = bfd_getl16 (esgps->flags);
5823 fprintf (file, _("SPSC - Shared Image Program section def\n"));
5824 fprintf (file, _(" alignment : 2**%u\n"), esgps->align);
5825 fprintf (file, _(" flags : 0x%04x"), flags);
5826 evax_bfd_print_egsd_flags (file, flags);
5828 l = bfd_getl32 (esgps->alloc);
5829 fprintf (file, _(" alloc (len) : %u (0x%08x)\n"), l, l);
5830 fprintf (file, _(" image offset : 0x%08x\n"),
5831 (unsigned int)bfd_getl32 (esgps->base));
5832 fprintf (file, _(" symvec offset : 0x%08x\n"),
5833 (unsigned int)bfd_getl32 (esgps->value));
5834 fprintf (file, _(" name : %.*s\n"),
5835 esgps->namlng, esgps->name);
5840 struct vms_egsy *egsy = (struct vms_egsy *)e;
5841 unsigned int flags = bfd_getl16 (egsy->flags);
5843 if (flags & EGSY__V_DEF)
5845 struct vms_esdf *esdf = (struct vms_esdf *)e;
5847 fprintf (file, _("SYM - Global symbol definition\n"));
5848 fprintf (file, _(" flags: 0x%04x"), flags);
5849 exav_bfd_print_egsy_flags (flags, file);
5851 fprintf (file, _(" psect offset: 0x%08x\n"),
5852 (unsigned)bfd_getl32 (esdf->value));
5853 if (flags & EGSY__V_NORM)
5855 fprintf (file, _(" code address: 0x%08x\n"),
5856 (unsigned)bfd_getl32 (esdf->code_address));
5857 fprintf (file, _(" psect index for entry point : %u\n"),
5858 (unsigned)bfd_getl32 (esdf->ca_psindx));
5860 fprintf (file, _(" psect index : %u\n"),
5861 (unsigned)bfd_getl32 (esdf->psindx));
5862 fprintf (file, _(" name : %.*s\n"),
5863 esdf->namlng, esdf->name);
5867 struct vms_esrf *esrf = (struct vms_esrf *)e;
5869 fprintf (file, _("SYM - Global symbol reference\n"));
5870 fprintf (file, _(" name : %.*s\n"),
5871 esrf->namlng, esrf->name);
5877 struct vms_eidc *eidc = (struct vms_eidc *)e;
5878 unsigned int flags = bfd_getl32 (eidc->flags);
5881 fprintf (file, _("IDC - Ident Consistency check\n"));
5882 fprintf (file, _(" flags : 0x%08x"), flags);
5883 if (flags & EIDC__V_BINIDENT)
5884 fputs (" BINDENT", file);
5886 fprintf (file, _(" id match : %x\n"),
5887 (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5888 fprintf (file, _(" error severity: %x\n"),
5889 (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5891 fprintf (file, _(" entity name : %.*s\n"), p[0], p + 1);
5893 fprintf (file, _(" object name : %.*s\n"), p[0], p + 1);
5895 if (flags & EIDC__V_BINIDENT)
5896 fprintf (file, _(" binary ident : 0x%08x\n"),
5897 (unsigned)bfd_getl32 (p + 1));
5899 fprintf (file, _(" ascii ident : %.*s\n"), p[0], p + 1);
5904 struct vms_egst *egst = (struct vms_egst *)e;
5905 unsigned int flags = bfd_getl16 (egst->header.flags);
5907 fprintf (file, _("SYMG - Universal symbol definition\n"));
5908 fprintf (file, _(" flags: 0x%04x"), flags);
5909 exav_bfd_print_egsy_flags (flags, file);
5911 fprintf (file, _(" symbol vector offset: 0x%08x\n"),
5912 (unsigned)bfd_getl32 (egst->value));
5913 fprintf (file, _(" entry point: 0x%08x\n"),
5914 (unsigned)bfd_getl32 (egst->lp_1));
5915 fprintf (file, _(" proc descr : 0x%08x\n"),
5916 (unsigned)bfd_getl32 (egst->lp_2));
5917 fprintf (file, _(" psect index: %u\n"),
5918 (unsigned)bfd_getl32 (egst->psindx));
5919 fprintf (file, _(" name : %.*s\n"),
5920 egst->namlng, egst->name);
5925 struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5926 unsigned int flags = bfd_getl16 (esdfv->flags);
5928 fprintf (file, _("SYMV - Vectored symbol definition\n"));
5929 fprintf (file, _(" flags: 0x%04x"), flags);
5930 exav_bfd_print_egsy_flags (flags, file);
5932 fprintf (file, _(" vector : 0x%08x\n"),
5933 (unsigned)bfd_getl32 (esdfv->vector));
5934 fprintf (file, _(" psect offset: %u\n"),
5935 (unsigned)bfd_getl32 (esdfv->value));
5936 fprintf (file, _(" psect index : %u\n"),
5937 (unsigned)bfd_getl32 (esdfv->psindx));
5938 fprintf (file, _(" name : %.*s\n"),
5939 esdfv->namlng, esdfv->name);
5944 struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5945 unsigned int flags = bfd_getl16 (esdfm->flags);
5947 fprintf (file, _("SYMM - Global symbol definition with version\n"));
5948 fprintf (file, _(" flags: 0x%04x"), flags);
5949 exav_bfd_print_egsy_flags (flags, file);
5951 fprintf (file, _(" version mask: 0x%08x\n"),
5952 (unsigned)bfd_getl32 (esdfm->version_mask));
5953 fprintf (file, _(" psect offset: %u\n"),
5954 (unsigned)bfd_getl32 (esdfm->value));
5955 fprintf (file, _(" psect index : %u\n"),
5956 (unsigned)bfd_getl32 (esdfm->psindx));
5957 fprintf (file, _(" name : %.*s\n"),
5958 esdfm->namlng, esdfm->name);
5962 fprintf (file, _("unhandled egsd entry type %u\n"), type);
5970 evax_bfd_print_hex (FILE *file, const char *pfx,
5971 const unsigned char *buf, unsigned int len)
5977 for (i = 0; i < len; i++)
5981 fprintf (file, " %02x", buf[i]);
5994 evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
5996 fprintf (file, _(" linkage index: %u, replacement insn: 0x%08x\n"),
5997 (unsigned)bfd_getl32 (buf),
5998 (unsigned)bfd_getl32 (buf + 16));
5999 fprintf (file, _(" psect idx 1: %u, offset 1: 0x%08x %08x\n"),
6000 (unsigned)bfd_getl32 (buf + 4),
6001 (unsigned)bfd_getl32 (buf + 12),
6002 (unsigned)bfd_getl32 (buf + 8));
6003 fprintf (file, _(" psect idx 2: %u, offset 2: 0x%08x %08x\n"),
6004 (unsigned)bfd_getl32 (buf + 20),
6005 (unsigned)bfd_getl32 (buf + 28),
6006 (unsigned)bfd_getl32 (buf + 24));
6008 fprintf (file, _(" psect idx 3: %u, offset 3: 0x%08x %08x\n"),
6009 (unsigned)bfd_getl32 (buf + 32),
6010 (unsigned)bfd_getl32 (buf + 40),
6011 (unsigned)bfd_getl32 (buf + 36));
6013 fprintf (file, _(" global name: %.*s\n"), buf[32], buf + 33);
6017 evax_bfd_print_etir (FILE *file, const char *name,
6018 unsigned char *rec, unsigned int rec_len)
6020 unsigned int off = sizeof (struct vms_egsd);
6021 unsigned int sec_len;
6023 fprintf (file, _(" %s (len=%u+%u):\n"), name,
6024 (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
6025 (unsigned)sizeof (struct vms_eobjrec));
6027 for (off = sizeof (struct vms_eobjrec); off < rec_len; )
6029 struct vms_etir *etir = (struct vms_etir *)(rec + off);
6034 type = bfd_getl16 (etir->rectyp);
6035 size = bfd_getl16 (etir->size);
6036 buf = rec + off + sizeof (struct vms_etir);
6038 fprintf (file, _(" (type: %3u, size: 4+%3u): "), type, size - 4);
6041 case ETIR__C_STA_GBL:
6042 fprintf (file, _("STA_GBL (stack global) %.*s\n"),
6045 case ETIR__C_STA_LW:
6046 fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
6047 (unsigned)bfd_getl32 (buf));
6049 case ETIR__C_STA_QW:
6050 fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
6051 (unsigned)bfd_getl32 (buf + 4),
6052 (unsigned)bfd_getl32 (buf + 0));
6054 case ETIR__C_STA_PQ:
6055 fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
6056 fprintf (file, _(" psect: %u, offset: 0x%08x %08x\n"),
6057 (unsigned)bfd_getl32 (buf + 0),
6058 (unsigned)bfd_getl32 (buf + 8),
6059 (unsigned)bfd_getl32 (buf + 4));
6061 case ETIR__C_STA_LI:
6062 fprintf (file, _("STA_LI (stack literal)\n"));
6064 case ETIR__C_STA_MOD:
6065 fprintf (file, _("STA_MOD (stack module)\n"));
6067 case ETIR__C_STA_CKARG:
6068 fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
6072 fprintf (file, _("STO_B (store byte)\n"));
6075 fprintf (file, _("STO_W (store word)\n"));
6077 case ETIR__C_STO_LW:
6078 fprintf (file, _("STO_LW (store longword)\n"));
6080 case ETIR__C_STO_QW:
6081 fprintf (file, _("STO_QW (store quadword)\n"));
6083 case ETIR__C_STO_IMMR:
6085 unsigned int len = bfd_getl32 (buf);
6087 _("STO_IMMR (store immediate repeat) %u bytes\n"),
6089 evax_bfd_print_hex (file, " ", buf + 4, len);
6093 case ETIR__C_STO_GBL:
6094 fprintf (file, _("STO_GBL (store global) %.*s\n"),
6097 case ETIR__C_STO_CA:
6098 fprintf (file, _("STO_CA (store code address) %.*s\n"),
6101 case ETIR__C_STO_RB:
6102 fprintf (file, _("STO_RB (store relative branch)\n"));
6104 case ETIR__C_STO_AB:
6105 fprintf (file, _("STO_AB (store absolute branch)\n"));
6107 case ETIR__C_STO_OFF:
6108 fprintf (file, _("STO_OFF (store offset to psect)\n"));
6110 case ETIR__C_STO_IMM:
6112 unsigned int len = bfd_getl32 (buf);
6114 _("STO_IMM (store immediate) %u bytes\n"),
6116 evax_bfd_print_hex (file, " ", buf + 4, len);
6120 case ETIR__C_STO_GBL_LW:
6121 fprintf (file, _("STO_GBL_LW (store global longword) %.*s\n"),
6124 case ETIR__C_STO_LP_PSB:
6125 fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6127 case ETIR__C_STO_HINT_GBL:
6128 fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6130 case ETIR__C_STO_HINT_PS:
6131 fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6134 case ETIR__C_OPR_NOP:
6135 fprintf (file, _("OPR_NOP (no-operation)\n"));
6137 case ETIR__C_OPR_ADD:
6138 fprintf (file, _("OPR_ADD (add)\n"));
6140 case ETIR__C_OPR_SUB:
6141 fprintf (file, _("OPR_SUB (substract)\n"));
6143 case ETIR__C_OPR_MUL:
6144 fprintf (file, _("OPR_MUL (multiply)\n"));
6146 case ETIR__C_OPR_DIV:
6147 fprintf (file, _("OPR_DIV (divide)\n"));
6149 case ETIR__C_OPR_AND:
6150 fprintf (file, _("OPR_AND (logical and)\n"));
6152 case ETIR__C_OPR_IOR:
6153 fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6155 case ETIR__C_OPR_EOR:
6156 fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6158 case ETIR__C_OPR_NEG:
6159 fprintf (file, _("OPR_NEG (negate)\n"));
6161 case ETIR__C_OPR_COM:
6162 fprintf (file, _("OPR_COM (complement)\n"));
6164 case ETIR__C_OPR_INSV:
6165 fprintf (file, _("OPR_INSV (insert field)\n"));
6167 case ETIR__C_OPR_ASH:
6168 fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6170 case ETIR__C_OPR_USH:
6171 fprintf (file, _("OPR_USH (unsigned shift)\n"));
6173 case ETIR__C_OPR_ROT:
6174 fprintf (file, _("OPR_ROT (rotate)\n"));
6176 case ETIR__C_OPR_SEL:
6177 fprintf (file, _("OPR_SEL (select)\n"));
6179 case ETIR__C_OPR_REDEF:
6180 fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6182 case ETIR__C_OPR_DFLIT:
6183 fprintf (file, _("OPR_REDEF (define a literal)\n"));
6186 case ETIR__C_STC_LP:
6187 fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6189 case ETIR__C_STC_LP_PSB:
6191 _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6192 fprintf (file, _(" linkage index: %u, procedure: %.*s\n"),
6193 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6194 buf += 4 + 1 + buf[4];
6195 fprintf (file, _(" signature: %.*s\n"), buf[0], buf + 1);
6197 case ETIR__C_STC_GBL:
6198 fprintf (file, _("STC_GBL (store cond global)\n"));
6199 fprintf (file, _(" linkage index: %u, global: %.*s\n"),
6200 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6202 case ETIR__C_STC_GCA:
6203 fprintf (file, _("STC_GCA (store cond code address)\n"));
6204 fprintf (file, _(" linkage index: %u, procedure name: %.*s\n"),
6205 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6207 case ETIR__C_STC_PS:
6208 fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6210 _(" linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6211 (unsigned)bfd_getl32 (buf),
6212 (unsigned)bfd_getl32 (buf + 4),
6213 (unsigned)bfd_getl32 (buf + 12),
6214 (unsigned)bfd_getl32 (buf + 8));
6216 case ETIR__C_STC_NOP_GBL:
6217 fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6218 evax_bfd_print_etir_stc_ir (file, buf, 0);
6220 case ETIR__C_STC_NOP_PS:
6221 fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6222 evax_bfd_print_etir_stc_ir (file, buf, 1);
6224 case ETIR__C_STC_BSR_GBL:
6225 fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6226 evax_bfd_print_etir_stc_ir (file, buf, 0);
6228 case ETIR__C_STC_BSR_PS:
6229 fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6230 evax_bfd_print_etir_stc_ir (file, buf, 1);
6232 case ETIR__C_STC_LDA_GBL:
6233 fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6234 evax_bfd_print_etir_stc_ir (file, buf, 0);
6236 case ETIR__C_STC_LDA_PS:
6237 fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6238 evax_bfd_print_etir_stc_ir (file, buf, 1);
6240 case ETIR__C_STC_BOH_GBL:
6241 fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6242 evax_bfd_print_etir_stc_ir (file, buf, 0);
6244 case ETIR__C_STC_BOH_PS:
6245 fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6246 evax_bfd_print_etir_stc_ir (file, buf, 1);
6248 case ETIR__C_STC_NBH_GBL:
6250 _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6252 case ETIR__C_STC_NBH_PS:
6254 _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6257 case ETIR__C_CTL_SETRB:
6258 fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6261 case ETIR__C_CTL_AUGRB:
6263 unsigned int val = bfd_getl32 (buf);
6264 fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6267 case ETIR__C_CTL_DFLOC:
6268 fprintf (file, _("CTL_DFLOC (define location)\n"));
6270 case ETIR__C_CTL_STLOC:
6271 fprintf (file, _("CTL_STLOC (set location)\n"));
6273 case ETIR__C_CTL_STKDL:
6274 fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6277 fprintf (file, _("*unhandled*\n"));
6285 evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6287 bfd_boolean is_first = TRUE;
6288 bfd_boolean has_records = FALSE;
6292 unsigned int rec_len;
6293 unsigned int pad_len;
6295 unsigned int hdr_size;
6300 unsigned char buf[6];
6305 if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6307 fprintf (file, _("cannot read GST record length\n"));
6310 rec_len = bfd_getl16 (buf + 0);
6311 if (rec_len == bfd_getl16 (buf + 4)
6312 && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6314 /* The format is raw: record-size, type, record-size. */
6316 pad_len = (rec_len + 1) & ~1U;
6319 else if (rec_len == EOBJ__C_EMH)
6321 has_records = FALSE;
6322 pad_len = bfd_getl16 (buf + 2);
6328 fprintf (file, _("cannot find EMH in first GST record\n"));
6331 rec = bfd_malloc (pad_len);
6332 memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6336 unsigned int rec_len2 = 0;
6337 unsigned char hdr[4];
6341 unsigned char buf_len[2];
6343 if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6344 != sizeof (buf_len))
6346 fprintf (file, _("cannot read GST record length\n"));
6349 rec_len2 = (unsigned)bfd_getl16 (buf_len);
6352 if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6354 fprintf (file, _("cannot read GST record header\n"));
6357 rec_len = (unsigned)bfd_getl16 (hdr + 2);
6359 pad_len = (rec_len + 1) & ~1U;
6362 rec = bfd_malloc (pad_len);
6363 memcpy (rec, hdr, sizeof (hdr));
6364 hdr_size = sizeof (hdr);
6365 if (has_records && rec_len2 != rec_len)
6367 fprintf (file, _(" corrupted GST\n"));
6372 if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6373 != pad_len - hdr_size)
6375 fprintf (file, _("cannot read GST record\n"));
6379 type = (unsigned)bfd_getl16 (rec);
6384 evax_bfd_print_emh (file, rec, rec_len);
6387 evax_bfd_print_egsd (file, rec, rec_len);
6390 evax_bfd_print_eeom (file, rec, rec_len);
6395 evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6398 evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6401 evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6404 fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6412 evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6413 unsigned int stride)
6421 count = bfd_getl32 (rel + 0);
6425 base = bfd_getl32 (rel + 4);
6427 fprintf (file, _(" bitcount: %u, base addr: 0x%08x\n"),
6431 for (j = 0; count > 0; j += 4, count -= 32)
6437 val = bfd_getl32 (rel);
6440 fprintf (file, _(" bitmap: 0x%08x (count: %u):\n"), val, count);
6442 for (k = 0; k < 32; k++)
6447 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6462 evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6469 count = bfd_getl32 (rel + 0);
6472 fprintf (file, _(" image %u (%u entries)\n"),
6473 (unsigned)bfd_getl32 (rel + 4), count);
6475 for (j = 0; j < count; j++)
6477 fprintf (file, _(" offset: 0x%08x, val: 0x%08x\n"),
6478 (unsigned)bfd_getl32 (rel + 0),
6479 (unsigned)bfd_getl32 (rel + 4));
6486 evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6495 count = bfd_getl32 (rel + 0);
6498 fprintf (file, _(" image %u (%u entries), offsets:\n"),
6499 (unsigned)bfd_getl32 (rel + 4), count);
6501 for (j = 0; j < count; j++)
6505 fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6520 evax_bfd_print_indent (int indent, FILE *file)
6522 for (; indent; indent--)
6527 evax_bfd_get_dsc_name (unsigned int v)
6531 case DSC__K_DTYPE_Z:
6532 return "Z (Unspecified)";
6533 case DSC__K_DTYPE_V:
6535 case DSC__K_DTYPE_BU:
6536 return "BU (Byte logical)";
6537 case DSC__K_DTYPE_WU:
6538 return "WU (Word logical)";
6539 case DSC__K_DTYPE_LU:
6540 return "LU (Longword logical)";
6541 case DSC__K_DTYPE_QU:
6542 return "QU (Quadword logical)";
6543 case DSC__K_DTYPE_B:
6544 return "B (Byte integer)";
6545 case DSC__K_DTYPE_W:
6546 return "W (Word integer)";
6547 case DSC__K_DTYPE_L:
6548 return "L (Longword integer)";
6549 case DSC__K_DTYPE_Q:
6550 return "Q (Quadword integer)";
6551 case DSC__K_DTYPE_F:
6552 return "F (Single-precision floating)";
6553 case DSC__K_DTYPE_D:
6554 return "D (Double-precision floating)";
6555 case DSC__K_DTYPE_FC:
6556 return "FC (Complex)";
6557 case DSC__K_DTYPE_DC:
6558 return "DC (Double-precision Complex)";
6559 case DSC__K_DTYPE_T:
6560 return "T (ASCII text string)";
6561 case DSC__K_DTYPE_NU:
6562 return "NU (Numeric string, unsigned)";
6563 case DSC__K_DTYPE_NL:
6564 return "NL (Numeric string, left separate sign)";
6565 case DSC__K_DTYPE_NLO:
6566 return "NLO (Numeric string, left overpunched sign)";
6567 case DSC__K_DTYPE_NR:
6568 return "NR (Numeric string, right separate sign)";
6569 case DSC__K_DTYPE_NRO:
6570 return "NRO (Numeric string, right overpunched sig)";
6571 case DSC__K_DTYPE_NZ:
6572 return "NZ (Numeric string, zoned sign)";
6573 case DSC__K_DTYPE_P:
6574 return "P (Packed decimal string)";
6575 case DSC__K_DTYPE_ZI:
6576 return "ZI (Sequence of instructions)";
6577 case DSC__K_DTYPE_ZEM:
6578 return "ZEM (Procedure entry mask)";
6579 case DSC__K_DTYPE_DSC:
6580 return "DSC (Descriptor, used for arrays of dyn strings)";
6581 case DSC__K_DTYPE_OU:
6582 return "OU (Octaword logical)";
6583 case DSC__K_DTYPE_O:
6584 return "O (Octaword integer)";
6585 case DSC__K_DTYPE_G:
6586 return "G (Double precision G floating, 64 bit)";
6587 case DSC__K_DTYPE_H:
6588 return "H (Quadruple precision floating, 128 bit)";
6589 case DSC__K_DTYPE_GC:
6590 return "GC (Double precision complex, G floating)";
6591 case DSC__K_DTYPE_HC:
6592 return "HC (Quadruple precision complex, H floating)";
6593 case DSC__K_DTYPE_CIT:
6594 return "CIT (COBOL intermediate temporary)";
6595 case DSC__K_DTYPE_BPV:
6596 return "BPV (Bound Procedure Value)";
6597 case DSC__K_DTYPE_BLV:
6598 return "BLV (Bound Label Value)";
6599 case DSC__K_DTYPE_VU:
6600 return "VU (Bit Unaligned)";
6601 case DSC__K_DTYPE_ADT:
6602 return "ADT (Absolute Date-Time)";
6603 case DSC__K_DTYPE_VT:
6604 return "VT (Varying Text)";
6605 case DSC__K_DTYPE_T2:
6606 return "T2 (16-bit char)";
6607 case DSC__K_DTYPE_VT2:
6608 return "VT2 (16-bit varying char)";
6610 return "?? (unknown)";
6615 evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6617 unsigned char bclass = buf[3];
6618 unsigned char dtype = buf[2];
6619 unsigned int len = (unsigned)bfd_getl16 (buf);
6620 unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6622 evax_bfd_print_indent (indent, file);
6624 if (len == 1 && pointer == 0xffffffffUL)
6627 fprintf (file, _("64 bits *unhandled*\n"));
6631 fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6632 bclass, dtype, len, pointer);
6635 case DSC__K_CLASS_NCA:
6637 const struct vms_dsc_nca *dsc = (const void *)buf;
6639 const unsigned char *b;
6641 evax_bfd_print_indent (indent, file);
6642 fprintf (file, _("non-contiguous array of %s\n"),
6643 evax_bfd_get_dsc_name (dsc->dtype));
6644 evax_bfd_print_indent (indent + 1, file);
6646 _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6647 dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6648 evax_bfd_print_indent (indent + 1, file);
6650 _("arsize: %u, a0: 0x%08x\n"),
6651 (unsigned)bfd_getl32 (dsc->arsize),
6652 (unsigned)bfd_getl32 (dsc->a0));
6653 evax_bfd_print_indent (indent + 1, file);
6654 fprintf (file, _("Strides:\n"));
6655 b = buf + sizeof (*dsc);
6656 for (i = 0; i < dsc->dimct; i++)
6658 evax_bfd_print_indent (indent + 2, file);
6659 fprintf (file, _("[%u]: %u\n"), i + 1,
6660 (unsigned)bfd_getl32 (b));
6663 evax_bfd_print_indent (indent + 1, file);
6664 fprintf (file, _("Bounds:\n"));
6665 b = buf + sizeof (*dsc);
6666 for (i = 0; i < dsc->dimct; i++)
6668 evax_bfd_print_indent (indent + 2, file);
6669 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6670 (unsigned)bfd_getl32 (b + 0),
6671 (unsigned)bfd_getl32 (b + 4));
6676 case DSC__K_CLASS_UBS:
6678 const struct vms_dsc_ubs *ubs = (const void *)buf;
6680 evax_bfd_print_indent (indent, file);
6681 fprintf (file, _("unaligned bit-string of %s\n"),
6682 evax_bfd_get_dsc_name (ubs->dtype));
6683 evax_bfd_print_indent (indent + 1, file);
6685 _("base: %u, pos: %u\n"),
6686 (unsigned)bfd_getl32 (ubs->base),
6687 (unsigned)bfd_getl32 (ubs->pos));
6691 fprintf (file, _("*unhandled*\n"));
6698 evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6700 unsigned int vflags = buf[0];
6701 unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6702 unsigned int len = 5;
6704 evax_bfd_print_indent (indent, file);
6705 fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6710 case DST__K_VFLAGS_NOVAL:
6711 fprintf (file, _("(no value)\n"));
6713 case DST__K_VFLAGS_NOTACTIVE:
6714 fprintf (file, _("(not active)\n"));
6716 case DST__K_VFLAGS_UNALLOC:
6717 fprintf (file, _("(not allocated)\n"));
6719 case DST__K_VFLAGS_DSC:
6720 fprintf (file, _("(descriptor)\n"));
6721 evax_bfd_print_desc (buf + value, indent + 1, file);
6723 case DST__K_VFLAGS_TVS:
6724 fprintf (file, _("(trailing value)\n"));
6726 case DST__K_VS_FOLLOWS:
6727 fprintf (file, _("(value spec follows)\n"));
6729 case DST__K_VFLAGS_BITOFFS:
6730 fprintf (file, _("(at bit offset %u)\n"), value);
6733 fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6734 (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6735 vflags & DST__K_DISP ? 1 : 0,
6736 vflags & DST__K_INDIR ? 1 : 0);
6737 switch (vflags & DST__K_VALKIND_MASK)
6739 case DST__K_VALKIND_LITERAL:
6740 fputs (_("literal"), file);
6742 case DST__K_VALKIND_ADDR:
6743 fputs (_("address"), file);
6745 case DST__K_VALKIND_DESC:
6746 fputs (_("desc"), file);
6748 case DST__K_VALKIND_REG:
6749 fputs (_("reg"), file);
6752 fputs (")\n", file);
6759 evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6761 unsigned char kind = buf[2];
6762 unsigned int len = (unsigned)bfd_getl16 (buf);
6764 evax_bfd_print_indent (indent, file);
6765 fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6769 case DST__K_TS_ATOM:
6770 fprintf (file, ("atomic, type=0x%02x %s\n"),
6771 buf[0], evax_bfd_get_dsc_name (buf[0]));
6774 fprintf (file, ("indirect, defined at 0x%08x\n"),
6775 (unsigned)bfd_getl32 (buf));
6777 case DST__K_TS_TPTR:
6778 fprintf (file, ("typed pointer\n"));
6779 evax_bfd_print_typspec (buf, indent + 1, file);
6782 fprintf (file, ("pointer\n"));
6784 case DST__K_TS_ARRAY:
6786 const unsigned char *vs;
6787 unsigned int vec_len;
6790 fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6791 vec_len = (buf[0] + 1 + 7) / 8;
6792 for (i = 0; i < vec_len; i++)
6793 fprintf (file, " %02x", buf[i + 1]);
6795 vs = buf + 1 + vec_len;
6796 evax_bfd_print_indent (indent, file);
6797 fprintf (file, ("array descriptor:\n"));
6798 vs += evax_bfd_print_valspec (vs, indent + 1, file);
6799 for (i = 0; i < buf[0] + 1U; i++)
6800 if (buf[1 + i / 8] & (1 << (i % 8)))
6802 evax_bfd_print_indent (indent, file);
6804 fprintf (file, ("type spec for element:\n"));
6806 fprintf (file, ("type spec for subscript %u:\n"), i);
6807 evax_bfd_print_typspec (vs, indent + 1, file);
6808 vs += bfd_getl16 (vs);
6813 fprintf (file, ("*unhandled*\n"));
6818 evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6820 unsigned int off = 0;
6821 unsigned int pc = 0;
6822 unsigned int line = 0;
6824 fprintf (file, _("Debug symbol table:\n"));
6826 while (dst_size > 0)
6828 struct vms_dst_header dsth;
6833 if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6835 fprintf (file, _("cannot read DST header\n"));
6838 len = bfd_getl16 (dsth.length);
6839 type = bfd_getl16 (dsth.type);
6840 fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6850 len -= sizeof (dsth);
6851 buf = bfd_malloc (len);
6852 if (bfd_bread (buf, len, abfd) != len)
6854 fprintf (file, _("cannot read DST symbol\n"));
6859 case DSC__K_DTYPE_V:
6860 case DSC__K_DTYPE_BU:
6861 case DSC__K_DTYPE_WU:
6862 case DSC__K_DTYPE_LU:
6863 case DSC__K_DTYPE_QU:
6864 case DSC__K_DTYPE_B:
6865 case DSC__K_DTYPE_W:
6866 case DSC__K_DTYPE_L:
6867 case DSC__K_DTYPE_Q:
6868 case DSC__K_DTYPE_F:
6869 case DSC__K_DTYPE_D:
6870 case DSC__K_DTYPE_FC:
6871 case DSC__K_DTYPE_DC:
6872 case DSC__K_DTYPE_T:
6873 case DSC__K_DTYPE_NU:
6874 case DSC__K_DTYPE_NL:
6875 case DSC__K_DTYPE_NLO:
6876 case DSC__K_DTYPE_NR:
6877 case DSC__K_DTYPE_NRO:
6878 case DSC__K_DTYPE_NZ:
6879 case DSC__K_DTYPE_P:
6880 case DSC__K_DTYPE_ZI:
6881 case DSC__K_DTYPE_ZEM:
6882 case DSC__K_DTYPE_DSC:
6883 case DSC__K_DTYPE_OU:
6884 case DSC__K_DTYPE_O:
6885 case DSC__K_DTYPE_G:
6886 case DSC__K_DTYPE_H:
6887 case DSC__K_DTYPE_GC:
6888 case DSC__K_DTYPE_HC:
6889 case DSC__K_DTYPE_CIT:
6890 case DSC__K_DTYPE_BPV:
6891 case DSC__K_DTYPE_BLV:
6892 case DSC__K_DTYPE_VU:
6893 case DSC__K_DTYPE_ADT:
6894 case DSC__K_DTYPE_VT:
6895 case DSC__K_DTYPE_T2:
6896 case DSC__K_DTYPE_VT2:
6897 fprintf (file, _("standard data: %s\n"),
6898 evax_bfd_get_dsc_name (type));
6899 evax_bfd_print_valspec (buf, 4, file);
6900 fprintf (file, _(" name: %.*s\n"), buf[5], buf + 6);
6904 struct vms_dst_modbeg *dst = (void *)buf;
6905 const char *name = (const char *)buf + sizeof (*dst);
6907 fprintf (file, _("modbeg\n"));
6908 fprintf (file, _(" flags: %d, language: %u, "
6909 "major: %u, minor: %u\n"),
6911 (unsigned)bfd_getl32 (dst->language),
6912 (unsigned)bfd_getl16 (dst->major),
6913 (unsigned)bfd_getl16 (dst->minor));
6914 fprintf (file, _(" module name: %.*s\n"),
6916 name += name[0] + 1;
6917 fprintf (file, _(" compiler : %.*s\n"),
6922 fprintf (file, _("modend\n"));
6926 struct vms_dst_rtnbeg *dst = (void *)buf;
6927 const char *name = (const char *)buf + sizeof (*dst);
6929 fputs (_("rtnbeg\n"), file);
6930 fprintf (file, _(" flags: %u, address: 0x%08x, "
6931 "pd-address: 0x%08x\n"),
6933 (unsigned)bfd_getl32 (dst->address),
6934 (unsigned)bfd_getl32 (dst->pd_address));
6935 fprintf (file, _(" routine name: %.*s\n"),
6941 struct vms_dst_rtnend *dst = (void *)buf;
6943 fprintf (file, _("rtnend: size 0x%08x\n"),
6944 (unsigned)bfd_getl32 (dst->size));
6949 struct vms_dst_prolog *dst = (void *)buf;
6951 fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6952 (unsigned)bfd_getl32 (dst->bkpt_addr));
6957 struct vms_dst_epilog *dst = (void *)buf;
6959 fprintf (file, _("epilog: flags: %u, count: %u\n"),
6960 dst->flags, (unsigned)bfd_getl32 (dst->count));
6965 struct vms_dst_blkbeg *dst = (void *)buf;
6966 const char *name = (const char *)buf + sizeof (*dst);
6968 fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6969 (unsigned)bfd_getl32 (dst->address),
6975 struct vms_dst_blkend *dst = (void *)buf;
6977 fprintf (file, _("blkend: size: 0x%08x\n"),
6978 (unsigned)bfd_getl32 (dst->size));
6981 case DST__K_TYPSPEC:
6983 fprintf (file, _("typspec (len: %u)\n"), len);
6984 fprintf (file, _(" name: %.*s\n"), buf[0], buf + 1);
6985 evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
6990 fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
6991 evax_bfd_print_valspec (buf, 4, file);
6996 struct vms_dst_recbeg *recbeg = (void *)buf;
6997 const char *name = (const char *)buf + sizeof (*recbeg);
6999 fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
7000 evax_bfd_print_valspec (buf, 4, file);
7001 fprintf (file, (" len: %u bits\n"),
7002 (unsigned)bfd_getl32 (name + 1 + name[0]));
7006 fprintf (file, _("recend\n"));
7008 case DST__K_ENUMBEG:
7009 fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
7010 buf[0], buf[1], buf + 2);
7012 case DST__K_ENUMELT:
7013 fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
7014 evax_bfd_print_valspec (buf, 4, file);
7016 case DST__K_ENUMEND:
7017 fprintf (file, _("enumend\n"));
7021 struct vms_dst_label *lab = (void *)buf;
7022 fprintf (file, ("label, name: %.*s\n"),
7023 lab->name[0], lab->name + 1);
7024 fprintf (file, (" address: 0x%08x\n"),
7025 (unsigned)bfd_getl32 (lab->value));
7028 case DST__K_DIS_RANGE:
7030 unsigned int cnt = bfd_getl32 (buf);
7031 unsigned char *rng = buf + 4;
7034 fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
7035 for (i = 0; i < cnt; i++, rng += 8)
7036 fprintf (file, _(" address: 0x%08x, size: %u\n"),
7037 (unsigned)bfd_getl32 (rng),
7038 (unsigned)bfd_getl32 (rng + 4));
7042 case DST__K_LINE_NUM:
7044 unsigned char *buf_orig = buf;
7046 fprintf (file, _("line num (len: %u)\n"), len);
7051 unsigned char cmdlen;
7061 case DST__K_DELTA_PC_W:
7062 val = bfd_getl16 (buf + 1);
7063 fprintf (file, _("delta_pc_w %u\n"), val);
7068 case DST__K_INCR_LINUM:
7070 fprintf (file, _("incr_linum(b): +%u\n"), val);
7074 case DST__K_INCR_LINUM_W:
7075 val = bfd_getl16 (buf + 1);
7076 fprintf (file, _("incr_linum_w: +%u\n"), val);
7080 case DST__K_INCR_LINUM_L:
7081 val = bfd_getl32 (buf + 1);
7082 fprintf (file, _("incr_linum_l: +%u\n"), val);
7086 case DST__K_SET_LINUM:
7087 line = bfd_getl16 (buf + 1);
7088 fprintf (file, _("set_line_num(w) %u\n"), line);
7091 case DST__K_SET_LINUM_B:
7093 fprintf (file, _("set_line_num_b %u\n"), line);
7096 case DST__K_SET_LINUM_L:
7097 line = bfd_getl32 (buf + 1);
7098 fprintf (file, _("set_line_num_l %u\n"), line);
7101 case DST__K_SET_ABS_PC:
7102 pc = bfd_getl32 (buf + 1);
7103 fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7106 case DST__K_DELTA_PC_L:
7107 fprintf (file, _("delta_pc_l: +0x%08x\n"),
7108 (unsigned)bfd_getl32 (buf + 1));
7112 fprintf (file, _("term(b): 0x%02x"), buf[1]);
7114 fprintf (file, _(" pc: 0x%08x\n"), pc);
7118 val = bfd_getl16 (buf + 1);
7119 fprintf (file, _("term_w: 0x%04x"), val);
7121 fprintf (file, _(" pc: 0x%08x\n"), pc);
7127 fprintf (file, _("delta pc +%-4d"), -cmd);
7128 line++; /* FIXME: curr increment. */
7130 fprintf (file, _(" pc: 0x%08x line: %5u\n"),
7135 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7148 unsigned char *buf_orig = buf;
7150 fprintf (file, _("source (len: %u)\n"), len);
7154 signed char cmd = buf[0];
7155 unsigned char cmdlen = 0;
7159 case DST__K_SRC_DECLFILE:
7161 struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7164 fprintf (file, _(" declfile: len: %u, flags: %u, "
7166 src->length, src->flags,
7167 (unsigned)bfd_getl16 (src->fileid));
7168 fprintf (file, _(" rms: cdt: 0x%08x %08x, "
7169 "ebk: 0x%08x, ffb: 0x%04x, "
7171 (unsigned)bfd_getl32 (src->rms_cdt + 4),
7172 (unsigned)bfd_getl32 (src->rms_cdt + 0),
7173 (unsigned)bfd_getl32 (src->rms_ebk),
7174 (unsigned)bfd_getl16 (src->rms_ffb),
7176 name = (const char *)buf + 1 + sizeof (*src);
7177 fprintf (file, _(" filename : %.*s\n"),
7179 name += name[0] + 1;
7180 fprintf (file, _(" module name: %.*s\n"),
7182 cmdlen = 2 + src->length;
7185 case DST__K_SRC_SETFILE:
7186 fprintf (file, _(" setfile %u\n"),
7187 (unsigned)bfd_getl16 (buf + 1));
7190 case DST__K_SRC_SETREC_W:
7191 fprintf (file, _(" setrec %u\n"),
7192 (unsigned)bfd_getl16 (buf + 1));
7195 case DST__K_SRC_SETREC_L:
7196 fprintf (file, _(" setrec %u\n"),
7197 (unsigned)bfd_getl32 (buf + 1));
7200 case DST__K_SRC_SETLNUM_W:
7201 fprintf (file, _(" setlnum %u\n"),
7202 (unsigned)bfd_getl16 (buf + 1));
7205 case DST__K_SRC_SETLNUM_L:
7206 fprintf (file, _(" setlnum %u\n"),
7207 (unsigned)bfd_getl32 (buf + 1));
7210 case DST__K_SRC_DEFLINES_W:
7211 fprintf (file, _(" deflines %u\n"),
7212 (unsigned)bfd_getl16 (buf + 1));
7215 case DST__K_SRC_DEFLINES_B:
7216 fprintf (file, _(" deflines %u\n"), buf[1]);
7219 case DST__K_SRC_FORMFEED:
7220 fprintf (file, _(" formfeed\n"));
7224 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7236 fprintf (file, _("*unhandled* dst type %u\n"), type);
7244 evax_bfd_print_image (bfd *abfd, FILE *file)
7246 struct vms_eihd eihd;
7249 unsigned int eiha_off;
7250 unsigned int eihi_off;
7251 unsigned int eihs_off;
7252 unsigned int eisd_off;
7253 unsigned int eihef_off = 0;
7254 unsigned int eihnp_off = 0;
7255 unsigned int dmt_vbn = 0;
7256 unsigned int dmt_size = 0;
7257 unsigned int dst_vbn = 0;
7258 unsigned int dst_size = 0;
7259 unsigned int gst_vbn = 0;
7260 unsigned int gst_size = 0;
7261 unsigned int eiaf_vbn = 0;
7262 unsigned int eiaf_size = 0;
7263 unsigned int eihvn_off;
7265 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7266 || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7268 fprintf (file, _("cannot read EIHD\n"));
7271 fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7272 (unsigned)bfd_getl32 (eihd.size),
7273 (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7274 fprintf (file, _(" majorid: %u, minorid: %u\n"),
7275 (unsigned)bfd_getl32 (eihd.majorid),
7276 (unsigned)bfd_getl32 (eihd.minorid));
7278 val = (unsigned)bfd_getl32 (eihd.imgtype);
7282 name = _("executable");
7285 name = _("linkable image");
7288 name = _("unknown");
7291 fprintf (file, _(" image type: %u (%s)"), val, name);
7293 val = (unsigned)bfd_getl32 (eihd.subtype);
7296 case EIHD__C_NATIVE:
7303 name = _("unknown");
7306 fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7308 eisd_off = bfd_getl32 (eihd.isdoff);
7309 eiha_off = bfd_getl32 (eihd.activoff);
7310 eihi_off = bfd_getl32 (eihd.imgidoff);
7311 eihs_off = bfd_getl32 (eihd.symdbgoff);
7312 fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7313 "imgid: %u, patch: %u\n"),
7314 eisd_off, eiha_off, eihs_off, eihi_off,
7315 (unsigned)bfd_getl32 (eihd.patchoff));
7316 fprintf (file, _(" fixup info rva: "));
7317 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7318 fprintf (file, _(", symbol vector rva: "));
7319 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7320 eihvn_off = bfd_getl32 (eihd.version_array_off);
7321 fprintf (file, _("\n"
7322 " version array off: %u\n"),
7325 _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7326 (unsigned)bfd_getl32 (eihd.imgiocnt),
7327 (unsigned)bfd_getl32 (eihd.iochancnt),
7328 (unsigned)bfd_getl32 (eihd.privreqs + 4),
7329 (unsigned)bfd_getl32 (eihd.privreqs + 0));
7330 val = (unsigned)bfd_getl32 (eihd.lnkflags);
7331 fprintf (file, _(" linker flags: %08x:"), val);
7332 if (val & EIHD__M_LNKDEBUG)
7333 fprintf (file, " LNKDEBUG");
7334 if (val & EIHD__M_LNKNOTFR)
7335 fprintf (file, " LNKNOTFR");
7336 if (val & EIHD__M_NOP0BUFS)
7337 fprintf (file, " NOP0BUFS");
7338 if (val & EIHD__M_PICIMG)
7339 fprintf (file, " PICIMG");
7340 if (val & EIHD__M_P0IMAGE)
7341 fprintf (file, " P0IMAGE");
7342 if (val & EIHD__M_DBGDMT)
7343 fprintf (file, " DBGDMT");
7344 if (val & EIHD__M_INISHR)
7345 fprintf (file, " INISHR");
7346 if (val & EIHD__M_XLATED)
7347 fprintf (file, " XLATED");
7348 if (val & EIHD__M_BIND_CODE_SEC)
7349 fprintf (file, " BIND_CODE_SEC");
7350 if (val & EIHD__M_BIND_DATA_SEC)
7351 fprintf (file, " BIND_DATA_SEC");
7352 if (val & EIHD__M_MKTHREADS)
7353 fprintf (file, " MKTHREADS");
7354 if (val & EIHD__M_UPCALLS)
7355 fprintf (file, " UPCALLS");
7356 if (val & EIHD__M_OMV_READY)
7357 fprintf (file, " OMV_READY");
7358 if (val & EIHD__M_EXT_BIND_SECT)
7359 fprintf (file, " EXT_BIND_SECT");
7360 fprintf (file, "\n");
7361 fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7362 "match ctrl: %u, symvect_size: %u\n"),
7363 (unsigned)bfd_getl32 (eihd.ident),
7364 (unsigned)bfd_getl32 (eihd.sysver),
7366 (unsigned)bfd_getl32 (eihd.symvect_size));
7367 fprintf (file, _(" BPAGE: %u"),
7368 (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7369 if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7371 eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7372 eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7373 fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7374 eihef_off, eihnp_off);
7376 fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7380 struct vms_eihvn eihvn;
7384 fprintf (file, _("system version array information:\n"));
7385 if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7386 || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7388 fprintf (file, _("cannot read EIHVN header\n"));
7391 mask = bfd_getl32 (eihvn.subsystem_mask);
7392 for (j = 0; j < 32; j++)
7393 if (mask & (1 << j))
7395 struct vms_eihvn_subversion ver;
7396 if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7398 fprintf (file, _("cannot read EIHVN version\n"));
7401 fprintf (file, _(" %02u "), j);
7404 case EIHVN__BASE_IMAGE_BIT:
7405 fputs (_("BASE_IMAGE "), file);
7407 case EIHVN__MEMORY_MANAGEMENT_BIT:
7408 fputs (_("MEMORY_MANAGEMENT"), file);
7411 fputs (_("IO "), file);
7413 case EIHVN__FILES_VOLUMES_BIT:
7414 fputs (_("FILES_VOLUMES "), file);
7416 case EIHVN__PROCESS_SCHED_BIT:
7417 fputs (_("PROCESS_SCHED "), file);
7419 case EIHVN__SYSGEN_BIT:
7420 fputs (_("SYSGEN "), file);
7422 case EIHVN__CLUSTERS_LOCKMGR_BIT:
7423 fputs (_("CLUSTERS_LOCKMGR "), file);
7425 case EIHVN__LOGICAL_NAMES_BIT:
7426 fputs (_("LOGICAL_NAMES "), file);
7428 case EIHVN__SECURITY_BIT:
7429 fputs (_("SECURITY "), file);
7431 case EIHVN__IMAGE_ACTIVATOR_BIT:
7432 fputs (_("IMAGE_ACTIVATOR "), file);
7434 case EIHVN__NETWORKS_BIT:
7435 fputs (_("NETWORKS "), file);
7437 case EIHVN__COUNTERS_BIT:
7438 fputs (_("COUNTERS "), file);
7440 case EIHVN__STABLE_BIT:
7441 fputs (_("STABLE "), file);
7443 case EIHVN__MISC_BIT:
7444 fputs (_("MISC "), file);
7446 case EIHVN__CPU_BIT:
7447 fputs (_("CPU "), file);
7449 case EIHVN__VOLATILE_BIT:
7450 fputs (_("VOLATILE "), file);
7452 case EIHVN__SHELL_BIT:
7453 fputs (_("SHELL "), file);
7455 case EIHVN__POSIX_BIT:
7456 fputs (_("POSIX "), file);
7458 case EIHVN__MULTI_PROCESSING_BIT:
7459 fputs (_("MULTI_PROCESSING "), file);
7461 case EIHVN__GALAXY_BIT:
7462 fputs (_("GALAXY "), file);
7465 fputs (_("*unknown* "), file);
7468 fprintf (file, _(": %u.%u\n"),
7469 (unsigned)bfd_getl16 (ver.major),
7470 (unsigned)bfd_getl16 (ver.minor));
7476 struct vms_eiha eiha;
7478 if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7479 || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7481 fprintf (file, _("cannot read EIHA\n"));
7484 fprintf (file, _("Image activation: (size=%u)\n"),
7485 (unsigned)bfd_getl32 (eiha.size));
7486 fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7487 (unsigned)bfd_getl32 (eiha.tfradr1_h),
7488 (unsigned)bfd_getl32 (eiha.tfradr1));
7489 fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7490 (unsigned)bfd_getl32 (eiha.tfradr2_h),
7491 (unsigned)bfd_getl32 (eiha.tfradr2));
7492 fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7493 (unsigned)bfd_getl32 (eiha.tfradr3_h),
7494 (unsigned)bfd_getl32 (eiha.tfradr3));
7495 fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7496 (unsigned)bfd_getl32 (eiha.tfradr4_h),
7497 (unsigned)bfd_getl32 (eiha.tfradr4));
7498 fprintf (file, _(" Shared image : 0x%08x 0x%08x\n"),
7499 (unsigned)bfd_getl32 (eiha.inishr_h),
7500 (unsigned)bfd_getl32 (eiha.inishr));
7504 struct vms_eihi eihi;
7506 if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7507 || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7509 fprintf (file, _("cannot read EIHI\n"));
7512 fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7513 (unsigned)bfd_getl32 (eihi.majorid),
7514 (unsigned)bfd_getl32 (eihi.minorid));
7515 fprintf (file, _(" image name : %.*s\n"),
7516 eihi.imgnam[0], eihi.imgnam + 1);
7517 fprintf (file, _(" link time : %s\n"),
7518 vms_time_to_str (eihi.linktime));
7519 fprintf (file, _(" image ident : %.*s\n"),
7520 eihi.imgid[0], eihi.imgid + 1);
7521 fprintf (file, _(" linker ident : %.*s\n"),
7522 eihi.linkid[0], eihi.linkid + 1);
7523 fprintf (file, _(" image build ident: %.*s\n"),
7524 eihi.imgbid[0], eihi.imgbid + 1);
7528 struct vms_eihs eihs;
7530 if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7531 || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7533 fprintf (file, _("cannot read EIHS\n"));
7536 fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7537 (unsigned)bfd_getl32 (eihs.majorid),
7538 (unsigned)bfd_getl32 (eihs.minorid));
7539 dst_vbn = bfd_getl32 (eihs.dstvbn);
7540 dst_size = bfd_getl32 (eihs.dstsize);
7541 fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7542 dst_vbn, dst_size, dst_size);
7543 gst_vbn = bfd_getl32 (eihs.gstvbn);
7544 gst_size = bfd_getl32 (eihs.gstsize);
7545 fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7547 dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7548 dmt_size = bfd_getl32 (eihs.dmtsize);
7549 fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7552 while (eisd_off != 0)
7554 struct vms_eisd eisd;
7559 if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7560 || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7562 fprintf (file, _("cannot read EISD\n"));
7565 len = (unsigned)bfd_getl32 (eisd.eisdsize);
7566 if (len != (unsigned)-1)
7570 eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7572 fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7573 "size: %u, offset: %u)\n"),
7574 (unsigned)bfd_getl32 (eisd.majorid),
7575 (unsigned)bfd_getl32 (eisd.minorid),
7579 fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7580 (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7581 (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7582 (unsigned)bfd_getl32 (eisd.secsize));
7583 val = (unsigned)bfd_getl32 (eisd.flags);
7584 fprintf (file, _(" flags: 0x%04x"), val);
7585 if (val & EISD__M_GBL)
7586 fprintf (file, " GBL");
7587 if (val & EISD__M_CRF)
7588 fprintf (file, " CRF");
7589 if (val & EISD__M_DZRO)
7590 fprintf (file, " DZRO");
7591 if (val & EISD__M_WRT)
7592 fprintf (file, " WRT");
7593 if (val & EISD__M_INITALCODE)
7594 fprintf (file, " INITALCODE");
7595 if (val & EISD__M_BASED)
7596 fprintf (file, " BASED");
7597 if (val & EISD__M_FIXUPVEC)
7598 fprintf (file, " FIXUPVEC");
7599 if (val & EISD__M_RESIDENT)
7600 fprintf (file, " RESIDENT");
7601 if (val & EISD__M_VECTOR)
7602 fprintf (file, " VECTOR");
7603 if (val & EISD__M_PROTECT)
7604 fprintf (file, " PROTECT");
7605 if (val & EISD__M_LASTCLU)
7606 fprintf (file, " LASTCLU");
7607 if (val & EISD__M_EXE)
7608 fprintf (file, " EXE");
7609 if (val & EISD__M_NONSHRADR)
7610 fprintf (file, " NONSHRADR");
7611 if (val & EISD__M_QUAD_LENGTH)
7612 fprintf (file, " QUAD_LENGTH");
7613 if (val & EISD__M_ALLOC_64BIT)
7614 fprintf (file, " ALLOC_64BIT");
7615 fprintf (file, "\n");
7616 if (val & EISD__M_FIXUPVEC)
7618 eiaf_vbn = bfd_getl32 (eisd.vbn);
7619 eiaf_size = bfd_getl32 (eisd.secsize);
7621 fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7622 (unsigned)bfd_getl32 (eisd.vbn),
7623 eisd.pfc, eisd.matchctl, eisd.type);
7626 case EISD__K_NORMAL:
7627 fputs (_("NORMAL"), file);
7629 case EISD__K_SHRFXD:
7630 fputs (_("SHRFXD"), file);
7632 case EISD__K_PRVFXD:
7633 fputs (_("PRVFXD"), file);
7635 case EISD__K_SHRPIC:
7636 fputs (_("SHRPIC"), file);
7638 case EISD__K_PRVPIC:
7639 fputs (_("PRVPIC"), file);
7641 case EISD__K_USRSTACK:
7642 fputs (_("USRSTACK"), file);
7645 fputs (_("*unknown*"), file);
7648 fputs (_(")\n"), file);
7649 if (val & EISD__M_GBL)
7650 fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7651 (unsigned)bfd_getl32 (eisd.ident),
7652 eisd.gblnam[0], eisd.gblnam + 1);
7658 if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7660 fprintf (file, _("cannot read DMT\n"));
7664 fprintf (file, _("Debug module table:\n"));
7666 while (dmt_size > 0)
7668 struct vms_dmt_header dmth;
7671 if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7673 fprintf (file, _("cannot read DMT header\n"));
7676 count = bfd_getl16 (dmth.psect_count);
7678 _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
7679 (unsigned)bfd_getl32 (dmth.modbeg),
7680 (unsigned)bfd_getl32 (dmth.size), count);
7681 dmt_size -= sizeof (dmth);
7684 struct vms_dmt_psect dmtp;
7686 if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7688 fprintf (file, _("cannot read DMT psect\n"));
7691 fprintf (file, _(" psect start: 0x%08x, length: %u\n"),
7692 (unsigned)bfd_getl32 (dmtp.start),
7693 (unsigned)bfd_getl32 (dmtp.length));
7695 dmt_size -= sizeof (dmtp);
7702 if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7704 fprintf (file, _("cannot read DST\n"));
7708 evax_bfd_print_dst (abfd, dst_size, file);
7712 if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7714 fprintf (file, _("cannot read GST\n"));
7718 fprintf (file, _("Global symbol table:\n"));
7719 evax_bfd_print_eobj (abfd, file);
7724 struct vms_eiaf *eiaf;
7725 unsigned int qrelfixoff;
7726 unsigned int lrelfixoff;
7727 unsigned int qdotadroff;
7728 unsigned int ldotadroff;
7729 unsigned int shrimgcnt;
7730 unsigned int shlstoff;
7731 unsigned int codeadroff;
7732 unsigned int lpfixoff;
7733 unsigned int chgprtoff;
7735 buf = bfd_malloc (eiaf_size);
7737 if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7738 || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7740 fprintf (file, _("cannot read EIHA\n"));
7744 eiaf = (struct vms_eiaf *)buf;
7746 _("Image activator fixup: (major: %u, minor: %u)\n"),
7747 (unsigned)bfd_getl32 (eiaf->majorid),
7748 (unsigned)bfd_getl32 (eiaf->minorid));
7749 fprintf (file, _(" iaflink : 0x%08x %08x\n"),
7750 (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7751 (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7752 fprintf (file, _(" fixuplnk: 0x%08x %08x\n"),
7753 (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7754 (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7755 fprintf (file, _(" size : %u\n"),
7756 (unsigned)bfd_getl32 (eiaf->size));
7757 fprintf (file, _(" flags: 0x%08x\n"),
7758 (unsigned)bfd_getl32 (eiaf->flags));
7759 qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7760 lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7761 fprintf (file, _(" qrelfixoff: %5u, lrelfixoff: %5u\n"),
7762 qrelfixoff, lrelfixoff);
7763 qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7764 ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7765 fprintf (file, _(" qdotadroff: %5u, ldotadroff: %5u\n"),
7766 qdotadroff, ldotadroff);
7767 codeadroff = bfd_getl32 (eiaf->codeadroff);
7768 lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7769 fprintf (file, _(" codeadroff: %5u, lpfixoff : %5u\n"),
7770 codeadroff, lpfixoff);
7771 chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7772 fprintf (file, _(" chgprtoff : %5u\n"), chgprtoff);
7773 shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7774 shlstoff = bfd_getl32 (eiaf->shlstoff);
7775 fprintf (file, _(" shlstoff : %5u, shrimgcnt : %5u\n"),
7776 shlstoff, shrimgcnt);
7777 fprintf (file, _(" shlextra : %5u, permctx : %5u\n"),
7778 (unsigned)bfd_getl32 (eiaf->shlextra),
7779 (unsigned)bfd_getl32 (eiaf->permctx));
7780 fprintf (file, _(" base_va : 0x%08x\n"),
7781 (unsigned)bfd_getl32 (eiaf->base_va));
7782 fprintf (file, _(" lppsbfixoff: %5u\n"),
7783 (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7787 struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7790 fprintf (file, _(" Shareable images:\n"));
7791 for (j = 0; j < shrimgcnt; j++, shl++)
7794 _(" %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7795 j, shl->size, shl->flags,
7796 shl->imgnam[0], shl->imgnam + 1);
7799 if (qrelfixoff != 0)
7801 fprintf (file, _(" quad-word relocation fixups:\n"));
7802 evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7804 if (lrelfixoff != 0)
7806 fprintf (file, _(" long-word relocation fixups:\n"));
7807 evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7809 if (qdotadroff != 0)
7811 fprintf (file, _(" quad-word .address reference fixups:\n"));
7812 evax_bfd_print_address_fixups (file, buf + qdotadroff);
7814 if (ldotadroff != 0)
7816 fprintf (file, _(" long-word .address reference fixups:\n"));
7817 evax_bfd_print_address_fixups (file, buf + ldotadroff);
7819 if (codeadroff != 0)
7821 fprintf (file, _(" Code Address Reference Fixups:\n"));
7822 evax_bfd_print_reference_fixups (file, buf + codeadroff);
7826 fprintf (file, _(" Linkage Pairs Referece Fixups:\n"));
7827 evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7831 unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7832 struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7835 fprintf (file, _(" Change Protection (%u entries):\n"), count);
7836 for (j = 0; j < count; j++, eicp++)
7838 unsigned int prot = bfd_getl32 (eicp->newprt);
7840 _(" base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7841 (unsigned)bfd_getl32 (eicp->baseva + 4),
7842 (unsigned)bfd_getl32 (eicp->baseva + 0),
7843 (unsigned)bfd_getl32 (eicp->size),
7844 (unsigned)bfd_getl32 (eicp->newprt));
7848 fprintf (file, "NA");
7850 case PRT__C_RESERVED:
7851 fprintf (file, "RES");
7854 fprintf (file, "KW");
7857 fprintf (file, "KR");
7860 fprintf (file, "UW");
7863 fprintf (file, "EW");
7866 fprintf (file, "ERKW");
7869 fprintf (file, "ER");
7872 fprintf (file, "SW");
7875 fprintf (file, "SREW");
7878 fprintf (file, "SRKW");
7881 fprintf (file, "SR");
7884 fprintf (file, "URSW");
7887 fprintf (file, "UREW");
7890 fprintf (file, "URKW");
7893 fprintf (file, "UR");
7907 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7909 FILE *file = (FILE *)ptr;
7911 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7912 evax_bfd_print_image (abfd, file);
7915 if (bfd_seek (abfd, 0, SEEK_SET))
7917 evax_bfd_print_eobj (abfd, file);
7924 /* Slurp ETIR/EDBG/ETBT VMS object records. */
7927 alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7929 asection *cur_section;
7930 file_ptr cur_offset;
7931 asection *dst_section;
7932 file_ptr dst_offset;
7934 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7940 dst_section = PRIV (dst_section);
7944 if (info->strip == strip_all || info->strip == strip_debugger)
7946 /* Discard the DST section. */
7950 else if (dst_section)
7952 dst_offset = dst_section->output_offset;
7953 dst_section = dst_section->output_section;
7962 type = _bfd_vms_get_object_record (abfd);
7965 vms_debug2 ((2, "next_record failed\n"));
7971 PRIV (image_section) = cur_section;
7972 PRIV (image_offset) = cur_offset;
7973 res = _bfd_vms_slurp_etir (abfd, info);
7974 cur_section = PRIV (image_section);
7975 cur_offset = PRIV (image_offset);
7979 if (dst_section == NULL)
7981 PRIV (image_section) = dst_section;
7982 PRIV (image_offset) = dst_offset;
7983 res = _bfd_vms_slurp_etir (abfd, info);
7984 dst_offset = PRIV (image_offset);
7993 vms_debug2 ((2, "slurp eobj type %d failed\n", type));
8000 alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
8001 struct bfd_link_info *info ATTRIBUTE_UNUSED)
8006 /* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
8009 alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
8011 struct alpha_vms_shlib_el *sl;
8012 asection *sect = PRIV2 (src, image_section);
8013 file_ptr offset = PRIV2 (src, image_offset);
8015 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8016 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8017 sl->has_fixups = TRUE;
8018 VEC_APPEND_EL (sl->lp, bfd_vma,
8019 sect->output_section->vma + sect->output_offset + offset);
8023 alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
8025 struct alpha_vms_shlib_el *sl;
8026 asection *sect = PRIV2 (src, image_section);
8027 file_ptr offset = PRIV2 (src, image_offset);
8029 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8030 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8031 sl->has_fixups = TRUE;
8032 VEC_APPEND_EL (sl->ca, bfd_vma,
8033 sect->output_section->vma + sect->output_offset + offset);
8037 alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
8038 bfd *shlib, bfd_vma vec)
8040 struct alpha_vms_shlib_el *sl;
8041 struct alpha_vms_vma_ref *r;
8042 asection *sect = PRIV2 (src, image_section);
8043 file_ptr offset = PRIV2 (src, image_offset);
8045 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8046 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8047 sl->has_fixups = TRUE;
8048 r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
8049 r->vma = sect->output_section->vma + sect->output_offset + offset;
8054 alpha_vms_add_fixup_lr (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8055 unsigned int shr ATTRIBUTE_UNUSED,
8056 bfd_vma vec ATTRIBUTE_UNUSED)
8061 /* Add relocation. FIXME: Not yet emitted. */
8064 alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8069 alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8073 static struct bfd_hash_entry *
8074 alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
8075 struct bfd_hash_table *table,
8078 struct alpha_vms_link_hash_entry *ret =
8079 (struct alpha_vms_link_hash_entry *) entry;
8081 /* Allocate the structure if it has not already been allocated by a
8084 ret = ((struct alpha_vms_link_hash_entry *)
8085 bfd_hash_allocate (table,
8086 sizeof (struct alpha_vms_link_hash_entry)));
8090 /* Call the allocation method of the superclass. */
8091 ret = ((struct alpha_vms_link_hash_entry *)
8092 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
8097 return (struct bfd_hash_entry *) ret;
8100 /* Create an Alpha/VMS link hash table. */
8102 static struct bfd_link_hash_table *
8103 alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8105 struct alpha_vms_link_hash_table *ret;
8106 bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8108 ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8111 if (!_bfd_link_hash_table_init (&ret->root, abfd,
8112 alpha_vms_link_hash_newfunc,
8113 sizeof (struct alpha_vms_link_hash_entry)))
8119 VEC_INIT (ret->shrlibs);
8126 alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8130 for (i = 0; i < PRIV (gsd_sym_count); i++)
8132 struct vms_symbol_entry *e = PRIV (syms)[i];
8133 struct alpha_vms_link_hash_entry *h;
8134 struct bfd_link_hash_entry *h_root;
8137 if (!alpha_vms_convert_symbol (abfd, e, &sym))
8140 if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8142 /* In selective_search mode, only add definition that are
8144 h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8145 (info->hash, sym.name, FALSE, FALSE, FALSE);
8146 if (h == NULL || h->root.type != bfd_link_hash_undefined)
8152 h_root = (struct bfd_link_hash_entry *) h;
8153 if (_bfd_generic_link_add_one_symbol
8154 (info, abfd, sym.name, sym.flags, sym.section, sym.value,
8155 NULL, FALSE, FALSE, &h_root) == FALSE)
8157 h = (struct alpha_vms_link_hash_entry *) h_root;
8159 if ((e->flags & EGSY__V_DEF)
8161 && abfd->xvec == info->output_bfd->xvec)
8165 if (abfd->flags & DYNAMIC)
8167 struct alpha_vms_shlib_el *shlib;
8169 /* We do not want to include any of the sections in a dynamic
8170 object in the output file. See comment in elflink.c. */
8171 bfd_section_list_clear (abfd);
8173 shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8174 struct alpha_vms_shlib_el);
8176 VEC_INIT (shlib->ca);
8177 VEC_INIT (shlib->lp);
8178 VEC_INIT (shlib->qr);
8179 PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8186 alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8189 struct bfd_link_hash_entry **pundef;
8190 struct bfd_link_hash_entry **next_pundef;
8192 /* We only accept VMS libraries. */
8193 if (info->output_bfd->xvec != abfd->xvec)
8195 bfd_set_error (bfd_error_wrong_format);
8199 /* The archive_pass field in the archive itself is used to
8200 initialize PASS, since we may search the same archive multiple
8202 pass = ++abfd->archive_pass;
8204 /* Look through the list of undefined symbols. */
8205 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8207 struct bfd_link_hash_entry *h;
8213 next_pundef = &(*pundef)->u.undef.next;
8215 /* When a symbol is defined, it is not necessarily removed from
8217 if (h->type != bfd_link_hash_undefined
8218 && h->type != bfd_link_hash_common)
8220 /* Remove this entry from the list, for general cleanliness
8221 and because we are going to look through the list again
8222 if we search any more libraries. We can't remove the
8223 entry if it is the tail, because that would lose any
8224 entries we add to the list later on. */
8225 if (*pundef != info->hash->undefs_tail)
8227 *pundef = *next_pundef;
8228 next_pundef = pundef;
8233 /* Look for this symbol in the archive hash table. */
8234 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8235 if (symidx == BFD_NO_MORE_SYMBOLS)
8237 /* Nothing in this slot. */
8241 element = bfd_get_elt_at_index (abfd, symidx);
8242 if (element == NULL)
8245 if (element->archive_pass == -1 || element->archive_pass == pass)
8248 if (! bfd_check_format (element, bfd_object))
8250 element->archive_pass = -1;
8254 orig_element = element;
8255 if (bfd_is_thin_archive (abfd))
8257 element = _bfd_vms_lib_get_imagelib_file (element);
8258 if (element == NULL || !bfd_check_format (element, bfd_object))
8260 orig_element->archive_pass = -1;
8265 /* Unlike the generic linker, we know that this element provides
8266 a definition for an undefined symbol and we know that we want
8267 to include it. We don't need to check anything. */
8268 if (! (*info->callbacks->add_archive_element) (info, element,
8271 if (! alpha_vms_link_add_object_symbols (element, info))
8274 orig_element->archive_pass = pass;
8281 alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8283 switch (bfd_get_format (abfd))
8286 vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8288 return alpha_vms_link_add_object_symbols (abfd, info);
8291 vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8293 return alpha_vms_link_add_archive_symbols (abfd, info);
8296 bfd_set_error (bfd_error_wrong_format);
8302 alpha_vms_build_fixups (struct bfd_link_info *info)
8304 struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8305 unsigned char *content;
8307 unsigned int sz = 0;
8308 unsigned int lp_sz = 0;
8309 unsigned int ca_sz = 0;
8310 unsigned int qr_sz = 0;
8311 unsigned int shrimg_cnt = 0;
8312 struct vms_eiaf *eiaf;
8316 /* Shared libraries. */
8317 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8319 struct alpha_vms_shlib_el *shlib;
8321 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8323 if (!shlib->has_fixups)
8328 if (VEC_COUNT (shlib->ca) > 0)
8330 /* Header + entries. */
8332 ca_sz += VEC_COUNT (shlib->ca) * 4;
8334 if (VEC_COUNT (shlib->lp) > 0)
8336 /* Header + entries. */
8338 lp_sz += VEC_COUNT (shlib->lp) * 4;
8340 if (VEC_COUNT (shlib->qr) > 0)
8342 /* Header + entries. */
8344 qr_sz += VEC_COUNT (shlib->qr) * 8;
8355 /* Finish now if there is no content. */
8356 if (ca_sz + lp_sz + qr_sz == 0)
8359 /* Allocate section content (round-up size) */
8360 sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8361 + ca_sz + lp_sz + qr_sz;
8362 sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8363 content = bfd_zalloc (info->output_bfd, sz);
8364 if (content == NULL)
8367 sec = alpha_vms_link_hash (info)->fixup;
8368 sec->contents = content;
8371 eiaf = (struct vms_eiaf *)content;
8372 off = sizeof (struct vms_eiaf);
8373 bfd_putl32 (0, eiaf->majorid);
8374 bfd_putl32 (0, eiaf->minorid);
8375 bfd_putl32 (0, eiaf->iaflink);
8376 bfd_putl32 (0, eiaf->fixuplnk);
8377 bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8378 bfd_putl32 (0, eiaf->flags);
8379 bfd_putl32 (0, eiaf->qrelfixoff);
8380 bfd_putl32 (0, eiaf->lrelfixoff);
8381 bfd_putl32 (0, eiaf->qdotadroff);
8382 bfd_putl32 (0, eiaf->ldotadroff);
8383 bfd_putl32 (0, eiaf->codeadroff);
8384 bfd_putl32 (0, eiaf->lpfixoff);
8385 bfd_putl32 (0, eiaf->chgprtoff);
8386 bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8387 bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8388 bfd_putl32 (0, eiaf->shlextra);
8389 bfd_putl32 (0, eiaf->permctx);
8390 bfd_putl32 (0, eiaf->base_va);
8391 bfd_putl32 (0, eiaf->lppsbfixoff);
8398 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8400 struct alpha_vms_shlib_el *shlib;
8401 struct vms_shl *shl;
8403 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8405 if (!shlib->has_fixups)
8408 /* Renumber shared images. */
8409 PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8411 shl = (struct vms_shl *)(content + off);
8412 bfd_putl32 (0, shl->baseva);
8413 bfd_putl32 (0, shl->shlptr);
8414 bfd_putl32 (0, shl->ident);
8415 bfd_putl32 (0, shl->permctx);
8416 shl->size = sizeof (struct vms_shl);
8417 bfd_putl16 (0, shl->fill_1);
8419 bfd_putl32 (0, shl->icb);
8420 shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8421 memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8424 off += sizeof (struct vms_shl);
8430 bfd_putl32 (off, eiaf->codeadroff);
8432 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8434 struct alpha_vms_shlib_el *shlib;
8437 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8439 if (VEC_COUNT (shlib->ca) == 0)
8442 bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8443 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8446 for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8448 bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8454 bfd_putl32 (0, content + off);
8455 bfd_putl32 (0, content + off + 4);
8462 bfd_putl32 (off, eiaf->lpfixoff);
8464 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8466 struct alpha_vms_shlib_el *shlib;
8469 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8471 if (VEC_COUNT (shlib->lp) == 0)
8474 bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8475 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8478 for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8480 bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8486 bfd_putl32 (0, content + off);
8487 bfd_putl32 (0, content + off + 4);
8494 bfd_putl32 (off, eiaf->qdotadroff);
8496 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8498 struct alpha_vms_shlib_el *shlib;
8501 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8503 if (VEC_COUNT (shlib->qr) == 0)
8506 bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8507 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8510 for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8512 struct alpha_vms_vma_ref *r;
8513 r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8514 bfd_putl32 (r->vma - t->base_addr, content + off);
8515 bfd_putl32 (r->ref, content + off + 4);
8520 bfd_putl32 (0, content + off);
8521 bfd_putl32 (0, content + off + 4);
8529 /* Called by bfd_link_hash_traverse to fill the symbol table.
8530 Return FALSE in case of failure. */
8533 alpha_vms_link_output_symbol (struct bfd_link_hash_entry *hc, void *infov)
8535 struct bfd_link_info *info = (struct bfd_link_info *)infov;
8536 struct alpha_vms_link_hash_entry *h = (struct alpha_vms_link_hash_entry *)hc;
8537 struct vms_symbol_entry *sym;
8539 switch (h->root.type)
8541 case bfd_link_hash_new:
8542 case bfd_link_hash_undefined:
8544 case bfd_link_hash_undefweak:
8546 case bfd_link_hash_defined:
8547 case bfd_link_hash_defweak:
8549 asection *sec = h->root.u.def.section;
8551 /* FIXME: this is certainly a symbol from a dynamic library. */
8552 if (bfd_is_abs_section (sec))
8555 if (sec->owner->flags & DYNAMIC)
8559 case bfd_link_hash_common:
8561 case bfd_link_hash_indirect:
8562 case bfd_link_hash_warning:
8566 /* Do not write not kept symbols. */
8567 if (info->strip == strip_some
8568 && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8569 FALSE, FALSE) != NULL)
8574 /* This symbol doesn't come from a VMS object. So we suppose it is
8576 int len = strlen (h->root.root.string);
8578 sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8579 sizeof (*sym) + len);
8583 memcpy (sym->name, h->root.root.string, len);
8585 sym->owner = info->output_bfd;
8587 sym->typ = EGSD__C_SYMG;
8589 sym->flags = EGSY__V_DEF | EGSY__V_REL;
8590 sym->symbol_vector = h->root.u.def.value;
8591 sym->section = h->root.u.def.section;
8592 sym->value = h->root.u.def.value;
8597 if (!add_symbol_entry (info->output_bfd, sym))
8604 alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8607 struct bfd_link_order *p;
8615 bfd_get_outsymbols (abfd) = NULL;
8616 bfd_get_symcount (abfd) = 0;
8618 /* Mark all sections which will be included in the output file. */
8619 for (o = abfd->sections; o != NULL; o = o->next)
8620 for (p = o->map_head.link_order; p != NULL; p = p->next)
8621 if (p->type == bfd_indirect_link_order)
8622 p->u.indirect.section->linker_mark = TRUE;
8625 /* Handle all the link order information for the sections. */
8626 for (o = abfd->sections; o != NULL; o = o->next)
8628 printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8629 o->name, (unsigned)o->vma, (unsigned)o->flags);
8631 for (p = o->map_head.link_order; p != NULL; p = p->next)
8633 printf (" at 0x%08x - 0x%08x: ",
8634 (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8637 case bfd_section_reloc_link_order:
8638 case bfd_symbol_reloc_link_order:
8639 printf (" section/symbol reloc\n");
8641 case bfd_indirect_link_order:
8642 printf (" section %s of %s\n",
8643 p->u.indirect.section->name,
8644 p->u.indirect.section->owner->filename);
8646 case bfd_data_link_order:
8647 printf (" explicit data\n");
8650 printf (" *unknown* type %u\n", p->type);
8657 /* Generate the symbol table. */
8658 BFD_ASSERT (PRIV (syms) == NULL);
8659 if (info->strip != strip_all)
8660 bfd_link_hash_traverse (info->hash, alpha_vms_link_output_symbol, info);
8662 /* Find the entry point. */
8663 if (bfd_get_start_address (abfd) == 0)
8665 bfd *startbfd = NULL;
8667 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8669 /* Consider only VMS object files. */
8670 if (sub->xvec != abfd->xvec)
8673 if (!PRIV2 (sub, eom_data).eom_has_transfer)
8675 if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8677 if (startbfd != NULL
8678 && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8680 (*info->callbacks->einfo)
8681 (_("%P: multiple entry points: in modules %B and %B\n"),
8690 unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8691 bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8694 sec = PRIV2 (startbfd, sections)[ps_idx];
8696 bfd_set_start_address
8697 (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8701 /* Set transfer addresses. */
8704 struct bfd_link_hash_entry *h;
8707 PRIV (transfer_address[i++]) = 0xffffffff00000340ULL; /* SYS$IMGACT */
8708 h = bfd_link_hash_lookup (info->hash, "LIB$INITIALIZE", FALSE, FALSE, TRUE);
8709 if (h != NULL && h->type == bfd_link_hash_defined)
8710 PRIV (transfer_address[i++]) =
8711 alpha_vms_get_sym_value (h->u.def.section, h->u.def.value);
8712 PRIV (transfer_address[i++]) = bfd_get_start_address (abfd);
8714 PRIV (transfer_address[i++]) = 0;
8717 /* Allocate contents. */
8718 base_addr = (bfd_vma)-1;
8720 for (o = abfd->sections; o != NULL; o = o->next)
8722 if (o->flags & SEC_HAS_CONTENTS)
8724 o->contents = bfd_alloc (abfd, o->size);
8725 if (o->contents == NULL)
8728 if (o->flags & SEC_LOAD)
8730 if (o->vma < base_addr)
8732 if (o->vma + o->size > last_addr)
8733 last_addr = o->vma + o->size;
8737 /* Create the fixup section. */
8738 fixupsec = bfd_make_section_anyway_with_flags
8739 (info->output_bfd, "$FIXUP$",
8740 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8741 if (fixupsec == NULL)
8743 last_addr = (last_addr + 0xffff) & ~0xffff;
8744 fixupsec->vma = last_addr;
8746 alpha_vms_link_hash (info)->fixup = fixupsec;
8747 alpha_vms_link_hash (info)->base_addr = base_addr;
8749 /* Create the DMT section, if necessary. */
8750 BFD_ASSERT (PRIV (dst_section) == NULL);
8751 dst = bfd_get_section_by_name (abfd, "$DST$");
8752 if (dst != NULL && dst->size == 0)
8756 PRIV (dst_section) = dst;
8757 dmt = bfd_make_section_anyway_with_flags
8758 (info->output_bfd, "$DMT$",
8759 SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8766 /* Read all sections from the inputs. */
8767 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8769 if (sub->flags & DYNAMIC)
8771 alpha_vms_create_eisd_for_shared (abfd, sub);
8775 if (!alpha_vms_read_sections_content (sub, info))
8779 /* Handle all the link order information for the sections.
8780 Note: past this point, it is not possible to create new sections. */
8781 for (o = abfd->sections; o != NULL; o = o->next)
8783 for (p = o->map_head.link_order; p != NULL; p = p->next)
8787 case bfd_section_reloc_link_order:
8788 case bfd_symbol_reloc_link_order:
8791 case bfd_indirect_link_order:
8795 if (! _bfd_default_link_order (abfd, info, o, p))
8802 /* Compute fixups. */
8803 if (!alpha_vms_build_fixups (info))
8806 /* Compute the DMT. */
8810 unsigned char *contents = NULL;
8812 /* In pass 1, compute the size. In pass 2, write the DMT contents. */
8813 for (pass = 0; pass < 2; pass++)
8815 unsigned int off = 0;
8817 /* For each object file (ie for each module). */
8818 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8821 struct vms_dmt_header *dmth = NULL;
8822 unsigned int psect_count;
8824 /* Skip this module if it has no DST. */
8825 sub_dst = PRIV2 (sub, dst_section);
8826 if (sub_dst == NULL || sub_dst->size == 0)
8831 /* Write the header. */
8832 dmth = (struct vms_dmt_header *)(contents + off);
8833 bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8834 bfd_putl32 (sub_dst->size, dmth->size);
8837 off += sizeof (struct vms_dmt_header);
8840 /* For each section (ie for each psect). */
8841 for (o = sub->sections; o != NULL; o = o->next)
8843 /* Only consider interesting sections. */
8844 if (!(o->flags & SEC_ALLOC))
8846 if (o->flags & SEC_LINKER_CREATED)
8851 /* Write an entry. */
8852 struct vms_dmt_psect *dmtp;
8854 dmtp = (struct vms_dmt_psect *)(contents + off);
8855 bfd_putl32 (o->output_offset + o->output_section->vma,
8857 bfd_putl32 (o->size, dmtp->length);
8860 off += sizeof (struct vms_dmt_psect);
8863 bfd_putl32 (psect_count, dmth->psect_count);
8868 contents = bfd_zalloc (info->output_bfd, off);
8869 if (contents == NULL)
8871 dmt->contents = contents;
8876 BFD_ASSERT (off == dmt->size);
8884 /* Read the contents of a section.
8885 buf points to a buffer of buf_size bytes to be filled with
8886 section data (starting at offset into section) */
8889 alpha_vms_get_section_contents (bfd *abfd, asection *section,
8890 void *buf, file_ptr offset,
8891 bfd_size_type count)
8895 /* Image are easy. */
8896 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8897 return _bfd_generic_get_section_contents (abfd, section,
8898 buf, offset, count);
8901 if (offset + count < count
8902 || offset + count > section->size)
8904 bfd_set_error (bfd_error_invalid_operation);
8908 /* Alloc in memory and read ETIRs. */
8909 BFD_ASSERT (section->contents == NULL);
8911 for (sec = abfd->sections; sec; sec = sec->next)
8913 BFD_ASSERT (sec->contents == NULL);
8915 if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
8917 sec->contents = bfd_alloc (abfd, sec->size);
8918 if (sec->contents == NULL)
8922 if (!alpha_vms_read_sections_content (abfd, NULL))
8924 for (sec = abfd->sections; sec; sec = sec->next)
8925 if (section->contents)
8926 section->flags |= SEC_IN_MEMORY;
8927 memcpy (buf, section->contents + offset, count);
8932 /* Set the format of a file being written. */
8935 alpha_vms_mkobject (bfd * abfd)
8937 const bfd_arch_info_type *arch;
8939 vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
8941 if (!vms_initialize (abfd))
8944 PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
8945 if (PRIV (recwr.buf) == NULL)
8948 arch = bfd_scan_arch ("alpha");
8952 bfd_set_error (bfd_error_wrong_format);
8956 abfd->arch_info = arch;
8963 /* Called when the BFD is being closed to do any necessary cleanup. */
8966 vms_close_and_cleanup (bfd * abfd)
8968 vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
8970 if (abfd == NULL || abfd->tdata.any == NULL)
8973 if (abfd->format == bfd_archive)
8975 bfd_release (abfd, abfd->tdata.any);
8976 abfd->tdata.any = NULL;
8980 if (PRIV (recrd.buf) != NULL)
8981 free (PRIV (recrd.buf));
8983 if (PRIV (sections) != NULL)
8984 free (PRIV (sections));
8986 bfd_release (abfd, abfd->tdata.any);
8987 abfd->tdata.any = NULL;
8990 if (abfd->direction == write_direction)
8992 /* Last step on VMS is to convert the file to variable record length
8994 if (bfd_cache_close (abfd) != TRUE)
8996 if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
9004 /* Called when a new section is created. */
9007 vms_new_section_hook (bfd * abfd, asection *section)
9011 vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
9012 abfd, section->index, section->name));
9014 bfd_set_section_alignment (abfd, section, 0);
9016 vms_debug2 ((7, "%d: %s\n", section->index, section->name));
9018 amt = sizeof (struct vms_section_data_struct);
9019 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
9020 if (section->used_by_bfd == NULL)
9023 /* Create the section symbol. */
9024 return _bfd_generic_new_section_hook (abfd, section);
9027 /* Part 4.5, symbols. */
9029 /* Print symbol to file according to how. how is one of
9030 bfd_print_symbol_name just print the name
9031 bfd_print_symbol_more print more (???)
9032 bfd_print_symbol_all print all we know, which is not much right now :-). */
9035 vms_print_symbol (bfd * abfd,
9038 bfd_print_symbol_type how)
9040 vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
9041 abfd, file, symbol, how));
9045 case bfd_print_symbol_name:
9046 case bfd_print_symbol_more:
9047 fprintf ((FILE *)file," %s", symbol->name);
9050 case bfd_print_symbol_all:
9052 const char *section_name = symbol->section->name;
9054 bfd_print_symbol_vandf (abfd, file, symbol);
9056 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9062 /* Return information about symbol in ret.
9064 fill type, value and name
9067 B bss segment symbol
9069 D data segment symbol
9071 t a static function symbol
9072 T text segment symbol
9077 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9083 vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9085 sec = symbol->section;
9092 else if (bfd_is_com_section (sec))
9094 else if (bfd_is_abs_section (sec))
9096 else if (bfd_is_und_section (sec))
9098 else if (bfd_is_ind_section (sec))
9100 else if ((symbol->flags & BSF_FUNCTION)
9101 || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
9103 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9105 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9110 if (ret->type != 'U')
9111 ret->value = symbol->value + symbol->section->vma;
9114 ret->name = symbol->name;
9117 /* Return TRUE if the given symbol sym in the BFD abfd is
9118 a compiler generated local label, else return FALSE. */
9121 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9124 vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
9125 return name[0] == '$';
9128 /* Part 4.7, writing an object file. */
9130 /* Sets the contents of the section section in BFD abfd to the data starting
9131 in memory at LOCATION. The data is written to the output section starting
9132 at offset offset for count bytes.
9134 Normally TRUE is returned, else FALSE. Possible error returns are:
9135 o bfd_error_no_contents - The output section does not have the
9136 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9137 o and some more too */
9140 _bfd_vms_set_section_contents (bfd * abfd,
9142 const void * location,
9144 bfd_size_type count)
9146 if (section->contents == NULL)
9148 section->contents = bfd_alloc (abfd, section->size);
9149 if (section->contents == NULL)
9152 memcpy (section->contents + offset, location, (size_t) count);
9158 /* Set the architecture and machine type in BFD abfd to arch and mach.
9159 Find the correct pointer to a structure and insert it into the arch_info
9163 alpha_vms_set_arch_mach (bfd *abfd,
9164 enum bfd_architecture arch, unsigned long mach)
9166 if (arch != bfd_arch_alpha
9167 && arch != bfd_arch_unknown)
9170 return bfd_default_set_arch_mach (abfd, arch, mach);
9173 /* Set section VMS flags. Clear NO_FLAGS and set FLAGS. */
9176 bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9177 asection *sec, flagword no_flags, flagword flags)
9179 vms_section_data (sec)->no_flags = no_flags;
9180 vms_section_data (sec)->flags = flags;
9183 struct vms_private_data_struct *
9184 bfd_vms_get_data (bfd *abfd)
9186 return (struct vms_private_data_struct *)abfd->tdata.any;
9189 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9190 #define vms_bfd_link_just_syms _bfd_generic_link_just_syms
9191 #define vms_bfd_copy_link_hash_symbol_type \
9192 _bfd_generic_copy_link_hash_symbol_type
9193 #define vms_bfd_is_group_section bfd_generic_is_group_section
9194 #define vms_bfd_discard_group bfd_generic_discard_group
9195 #define vms_section_already_linked _bfd_generic_section_already_linked
9196 #define vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9197 #define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
9199 #define vms_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
9200 #define vms_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
9201 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9202 #define vms_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
9203 #define vms_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
9204 #define vms_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
9206 /* Symbols table. */
9207 #define alpha_vms_make_empty_symbol _bfd_generic_make_empty_symbol
9208 #define alpha_vms_bfd_is_target_special_symbol \
9209 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9210 #define alpha_vms_print_symbol vms_print_symbol
9211 #define alpha_vms_get_symbol_info vms_get_symbol_info
9212 #define alpha_vms_read_minisymbols _bfd_generic_read_minisymbols
9213 #define alpha_vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
9214 #define alpha_vms_get_lineno _bfd_nosymbols_get_lineno
9215 #define alpha_vms_find_inliner_info _bfd_nosymbols_find_inliner_info
9216 #define alpha_vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
9217 #define alpha_vms_find_nearest_line _bfd_vms_find_nearest_dst_line
9218 #define alpha_vms_bfd_is_local_label_name vms_bfd_is_local_label_name
9220 /* Generic table. */
9221 #define alpha_vms_close_and_cleanup vms_close_and_cleanup
9222 #define alpha_vms_bfd_free_cached_info vms_bfd_free_cached_info
9223 #define alpha_vms_new_section_hook vms_new_section_hook
9224 #define alpha_vms_set_section_contents _bfd_vms_set_section_contents
9225 #define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9227 #define alpha_vms_bfd_get_relocated_section_contents \
9228 bfd_generic_get_relocated_section_contents
9230 #define alpha_vms_bfd_relax_section bfd_generic_relax_section
9231 #define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9232 #define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9233 #define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9234 #define alpha_vms_bfd_discard_group bfd_generic_discard_group
9235 #define alpha_vms_section_already_linked \
9236 _bfd_generic_section_already_linked
9238 #define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9239 #define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
9240 #define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9241 #define alpha_vms_bfd_copy_link_hash_symbol_type \
9242 _bfd_generic_copy_link_hash_symbol_type
9244 #define alpha_vms_bfd_link_split_section _bfd_generic_link_split_section
9246 #define alpha_vms_get_dynamic_symtab_upper_bound \
9247 _bfd_nodynamic_get_dynamic_symtab_upper_bound
9248 #define alpha_vms_canonicalize_dynamic_symtab \
9249 _bfd_nodynamic_canonicalize_dynamic_symtab
9250 #define alpha_vms_get_dynamic_reloc_upper_bound \
9251 _bfd_nodynamic_get_dynamic_reloc_upper_bound
9252 #define alpha_vms_canonicalize_dynamic_reloc \
9253 _bfd_nodynamic_canonicalize_dynamic_reloc
9255 const bfd_target vms_alpha_vec =
9257 "vms-alpha", /* Name. */
9258 bfd_target_evax_flavour,
9259 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
9260 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
9262 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9263 | WP_TEXT | D_PAGED), /* Object flags. */
9264 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9265 | SEC_READONLY | SEC_CODE | SEC_DATA
9266 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
9267 0, /* symbol_leading_char. */
9268 ' ', /* ar_pad_char. */
9269 15, /* ar_max_namelen. */
9270 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9271 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9272 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9273 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9274 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9275 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9277 {_bfd_dummy_target, alpha_vms_object_p, /* bfd_check_format. */
9278 _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9279 {bfd_false, alpha_vms_mkobject, /* bfd_set_format. */
9280 _bfd_vms_lib_alpha_mkarchive, bfd_false},
9281 {bfd_false, alpha_vms_write_object_contents, /* bfd_write_contents. */
9282 _bfd_vms_lib_write_archive_contents, bfd_false},
9284 BFD_JUMP_TABLE_GENERIC (alpha_vms),
9285 BFD_JUMP_TABLE_COPY (vms),
9286 BFD_JUMP_TABLE_CORE (_bfd_nocore),
9287 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9288 BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9289 BFD_JUMP_TABLE_RELOCS (alpha_vms),
9290 BFD_JUMP_TABLE_WRITE (alpha_vms),
9291 BFD_JUMP_TABLE_LINK (alpha_vms),
9292 BFD_JUMP_TABLE_DYNAMIC (alpha_vms),