1 /* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
2 Copyright (C) 1996-2014 Free Software Foundation, Inc.
4 Initial version written by Klaus Kaempf (kkaempf@rmi.de)
5 Major rewrite by Adacore.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
25 o Generation of shared image
26 o Relocation optimizations
32 o protected sections (for messages)
50 #include "vms/eihvn.h"
51 #include "vms/eobjrec.h"
54 #include "vms/esgps.h"
63 #include "vms/esdfm.h"
64 #include "vms/esdfv.h"
70 #include "vms/internal.h"
73 #define MIN(a,b) ((a) < (b) ? (a) : (b))
75 /* The r_type field in a reloc is one of the following values. */
76 #define ALPHA_R_IGNORE 0
77 #define ALPHA_R_REFQUAD 1
78 #define ALPHA_R_BRADDR 2
79 #define ALPHA_R_HINT 3
80 #define ALPHA_R_SREL16 4
81 #define ALPHA_R_SREL32 5
82 #define ALPHA_R_SREL64 6
83 #define ALPHA_R_OP_PUSH 7
84 #define ALPHA_R_OP_STORE 8
85 #define ALPHA_R_OP_PSUB 9
86 #define ALPHA_R_OP_PRSHIFT 10
87 #define ALPHA_R_LINKAGE 11
88 #define ALPHA_R_REFLONG 12
89 #define ALPHA_R_CODEADDR 13
90 #define ALPHA_R_NOP 14
91 #define ALPHA_R_BSR 15
92 #define ALPHA_R_LDA 16
93 #define ALPHA_R_BOH 17
95 /* These are used with DST_S_C_LINE_NUM. */
96 #define DST_S_C_LINE_NUM_HEADER_SIZE 4
98 /* These are used with DST_S_C_SOURCE */
100 #define DST_S_B_PCLINE_UNSBYTE 1
101 #define DST_S_W_PCLINE_UNSWORD 1
102 #define DST_S_L_PCLINE_UNSLONG 1
104 #define DST_S_B_MODBEG_NAME 14
105 #define DST_S_L_RTNBEG_ADDRESS 5
106 #define DST_S_B_RTNBEG_NAME 13
107 #define DST_S_L_RTNEND_SIZE 5
109 /* These are used with DST_S_C_SOURCE. */
110 #define DST_S_C_SOURCE_HEADER_SIZE 4
112 #define DST_S_B_SRC_DF_LENGTH 1
113 #define DST_S_W_SRC_DF_FILEID 3
114 #define DST_S_B_SRC_DF_FILENAME 20
115 #define DST_S_B_SRC_UNSBYTE 1
116 #define DST_S_W_SRC_UNSWORD 1
117 #define DST_S_L_SRC_UNSLONG 1
119 /* Debugger symbol definitions. */
121 #define DBG_S_L_DMT_MODBEG 0
122 #define DBG_S_L_DST_SIZE 4
123 #define DBG_S_W_DMT_PSECT_COUNT 8
124 #define DBG_S_C_DMT_HEADER_SIZE 12
126 #define DBG_S_L_DMT_PSECT_START 0
127 #define DBG_S_L_DMT_PSECT_LENGTH 4
128 #define DBG_S_C_DMT_PSECT_SIZE 8
130 /* VMS module header. */
146 #define EMH_DATE_LENGTH 17
148 /* VMS End-Of-Module records (EOM/EEOM). */
152 unsigned int eom_l_total_lps;
153 unsigned short eom_w_comcod;
154 bfd_boolean eom_has_transfer;
155 unsigned char eom_b_tfrflg;
156 unsigned int eom_l_psindx;
157 unsigned int eom_l_tfradr;
160 struct vms_symbol_entry
166 unsigned char data_type;
167 unsigned short flags;
169 /* Section and offset/value of the symbol. */
173 /* Section and offset/value for the entry point (only for subprg). */
174 asection *code_section;
175 unsigned int code_value;
177 /* Symbol vector offset. */
178 unsigned int symbol_vector;
180 /* Length of the name. */
181 unsigned char namelen;
186 /* Stack value for push/pop commands. */
194 #define STACKSIZE 128
196 /* A minimal decoding of DST compilation units. We only decode
197 what's needed to get to the line number information. */
207 struct srecinfo *next;
215 struct lineinfo *next;
222 struct funcinfo *next;
230 /* Chain the previously read compilation unit. */
233 /* The module name. */
236 /* The start offset and size of debug info in the DST section. */
240 /* The lowest and highest addresses contained in this compilation
241 unit as specified in the compilation unit header. */
245 /* The listing line table. */
246 struct lineinfo *line_table;
248 /* The source record table. */
249 struct srecinfo *srec_table;
251 /* A list of the functions found in this module. */
252 struct funcinfo *func_table;
254 /* Current allocation of file_table. */
255 unsigned int file_table_count;
257 /* An array of the files making up this module. */
258 struct fileinfo *file_table;
261 /* BFD private data for alpha-vms. */
263 struct vms_private_data_struct
265 /* If true, relocs have been read. */
266 bfd_boolean reloc_done;
268 /* Record input buffer. */
269 struct vms_rec_rd recrd;
270 struct vms_rec_wr recwr;
272 struct hdr_struct hdr_data; /* data from HDR/EMH record */
273 struct eom_struct eom_data; /* data from EOM/EEOM record */
275 /* Transfer addresses (entry points). */
276 bfd_vma transfer_address[4];
278 /* Array of GSD sections to get the correspond BFD one. */
279 unsigned int section_max; /* Size of the sections array. */
280 unsigned int section_count; /* Number of GSD sections. */
283 /* Array of raw symbols. */
284 struct vms_symbol_entry **syms;
286 /* Canonicalized symbols. */
289 /* Number of symbols. */
290 unsigned int gsd_sym_count;
291 /* Size of the syms array. */
292 unsigned int max_sym_count;
293 /* Number of procedure symbols. */
294 unsigned int norm_sym_count;
296 /* Stack used to evaluate TIR/ETIR commands. */
297 struct stack_struct *stack;
300 /* Content reading. */
301 asection *image_section; /* section for image_ptr */
302 file_ptr image_offset; /* Offset for image_ptr. */
304 struct module *modules; /* list of all compilation units */
306 /* The DST section. */
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 unsigned int vms_linkage_index;
335 #define PRIV2(abfd, name) \
336 (((struct vms_private_data_struct *)(abfd)->tdata.any)->name)
337 #define PRIV(name) PRIV2(abfd,name)
340 /* Used to keep extra VMS specific information for a given section.
342 reloc_size holds the size of the relocation stream, note this
343 is very different from the number of relocations as VMS relocations
346 reloc_stream is the actual stream of relocation entries. */
348 struct vms_section_data_struct
350 /* Maximnum number of entries in sec->relocation. */
353 /* Corresponding eisd. Used only while generating executables. */
354 struct vms_internal_eisd_map *eisd;
356 /* PSC flags to be clear. */
359 /* PSC flags to be set. */
363 #define vms_section_data(sec) \
364 ((struct vms_section_data_struct *)sec->used_by_bfd)
366 /* To be called from the debugger. */
367 struct vms_private_data_struct *bfd_vms_get_data (bfd *);
369 static int vms_get_remaining_object_record (bfd *, unsigned int);
370 static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);
371 static void alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);
372 static void alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);
373 static void alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,
375 static void alpha_vms_add_fixup_lr (struct bfd_link_info *, unsigned int,
377 static void alpha_vms_add_lw_reloc (struct bfd_link_info *);
378 static void alpha_vms_add_qw_reloc (struct bfd_link_info *);
387 /* Number of elements in VEC. */
389 #define VEC_COUNT(VEC) ((VEC).nbr_el)
391 /* Get the address of the Nth element. */
393 #define VEC_EL(VEC, TYPE, N) (((TYPE *)((VEC).els))[N])
395 #define VEC_INIT(VEC) \
402 /* Be sure there is room for a new element. */
404 static void vector_grow1 (struct vector_type *vec, size_t elsz);
406 /* Allocate room for a new element and return its address. */
408 #define VEC_APPEND(VEC, TYPE) \
409 (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))
411 /* Append an element. */
413 #define VEC_APPEND_EL(VEC, TYPE, EL) \
414 (*(VEC_APPEND (VEC, TYPE)) = EL)
416 struct alpha_vms_vma_ref
418 bfd_vma vma; /* Vma in the output. */
419 bfd_vma ref; /* Reference in the input. */
422 struct alpha_vms_shlib_el
425 bfd_boolean has_fixups;
427 struct vector_type lp; /* Vector of bfd_vma. */
428 struct vector_type ca; /* Vector of bfd_vma. */
429 struct vector_type qr; /* Vector of struct alpha_vms_vma_ref. */
432 /* Alpha VMS linker hash table. */
434 struct alpha_vms_link_hash_table
436 struct bfd_link_hash_table root;
438 /* Vector of shared libraries. */
439 struct vector_type shrlibs;
444 /* Base address. Used by fixups. */
448 #define alpha_vms_link_hash(INFO) \
449 ((struct alpha_vms_link_hash_table *)(INFO->hash))
451 /* Alpha VMS linker hash table entry. */
453 struct alpha_vms_link_hash_entry
455 struct bfd_link_hash_entry root;
457 /* Pointer to the original vms symbol. */
458 struct vms_symbol_entry *sym;
463 /* Read & process EIHD record.
464 Return TRUE on success, FALSE on error. */
467 _bfd_vms_slurp_eihd (bfd *abfd, unsigned int *eisd_offset,
468 unsigned int *eihs_offset)
470 unsigned int imgtype, size;
472 struct vms_eihd *eihd = (struct vms_eihd *)PRIV (recrd.rec);
474 vms_debug2 ((8, "_bfd_vms_slurp_eihd\n"));
476 size = bfd_getl32 (eihd->size);
477 imgtype = bfd_getl32 (eihd->imgtype);
479 if (imgtype == EIHD__K_EXE || imgtype == EIHD__K_LIM)
480 abfd->flags |= EXEC_P;
482 symvva = bfd_getl64 (eihd->symvva);
485 PRIV (symvva) = symvva;
486 abfd->flags |= DYNAMIC;
489 PRIV (ident) = bfd_getl32 (eihd->ident);
490 PRIV (matchctl) = eihd->matchctl;
492 *eisd_offset = bfd_getl32 (eihd->isdoff);
493 *eihs_offset = bfd_getl32 (eihd->symdbgoff);
495 vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",
496 size, imgtype, (unsigned long)symvva,
497 *eisd_offset, *eihs_offset));
502 /* Read & process EISD record.
503 Return TRUE on success, FALSE on error. */
506 _bfd_vms_slurp_eisd (bfd *abfd, unsigned int offset)
508 int section_count = 0;
510 vms_debug2 ((8, "_bfd_vms_slurp_eisd\n"));
514 struct vms_eisd *eisd;
515 unsigned int rec_size;
517 unsigned long long vaddr;
524 /* PR 17512: file: 3d9e9fe9. */
525 if (offset >= PRIV (recrd.rec_size))
527 eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
528 rec_size = bfd_getl32 (eisd->eisdsize);
532 /* Skip to next block if pad. */
533 if (rec_size == 0xffffffff)
535 offset = (offset + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
541 size = bfd_getl32 (eisd->secsize);
542 vaddr = bfd_getl64 (eisd->virt_addr);
543 flags = bfd_getl32 (eisd->flags);
544 vbn = bfd_getl32 (eisd->vbn);
546 vms_debug2 ((4, "EISD at 0x%x size 0x%x addr 0x%lx flags 0x%x blk %d\n",
547 offset, size, (unsigned long)vaddr, flags, vbn));
549 /* VMS combines psects from .obj files into isects in the .exe. This
550 process doesn't preserve enough information to reliably determine
551 what's in each section without examining the data. This is
552 especially true of DWARF debug sections. */
553 bfd_flags = SEC_ALLOC;
555 bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
557 if (flags & EISD__M_EXE)
558 bfd_flags |= SEC_CODE;
560 if (flags & EISD__M_NONSHRADR)
561 bfd_flags |= SEC_DATA;
563 if (!(flags & EISD__M_WRT))
564 bfd_flags |= SEC_READONLY;
566 if (flags & EISD__M_DZRO)
567 bfd_flags |= SEC_DATA;
569 if (flags & EISD__M_FIXUPVEC)
570 bfd_flags |= SEC_DATA;
572 if (flags & EISD__M_CRF)
573 bfd_flags |= SEC_DATA;
575 if (flags & EISD__M_GBL)
577 name = _bfd_vms_save_counted_string (eisd->gblnam);
578 bfd_flags |= SEC_COFF_SHARED_LIBRARY;
579 bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
581 else if (flags & EISD__M_FIXUPVEC)
583 else if (eisd->type == EISD__K_USRSTACK)
589 name = (char*) bfd_alloc (abfd, 32);
590 if (flags & EISD__M_DZRO)
592 else if (flags & EISD__M_EXE)
594 else if (!(flags & EISD__M_WRT))
598 BFD_ASSERT (section_count < 999);
599 sprintf (name, "$%s_%03d$", pfx, section_count++);
602 section = bfd_make_section (abfd, name);
607 section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : 0;
608 section->size = size;
609 section->vma = vaddr;
611 if (!bfd_set_section_flags (abfd, section, bfd_flags))
618 /* Read & process EIHS record.
619 Return TRUE on success, FALSE on error. */
622 _bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)
624 unsigned char *p = PRIV (recrd.rec) + offset;
625 unsigned int gstvbn = bfd_getl32 (p + EIHS__L_GSTVBN);
626 unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS__L_GSTSIZE);
627 unsigned int dstvbn = bfd_getl32 (p + EIHS__L_DSTVBN);
628 unsigned int dstsize = bfd_getl32 (p + EIHS__L_DSTSIZE);
629 unsigned int dmtvbn = bfd_getl32 (p + EIHS__L_DMTVBN);
630 unsigned int dmtbytes = bfd_getl32 (p + EIHS__L_DMTBYTES);
634 vms_debug (8, "_bfd_vms_slurp_ihs\n");
635 vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
636 gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
641 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
643 section = bfd_make_section (abfd, "$DST$");
647 section->size = dstsize;
648 section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
650 if (!bfd_set_section_flags (abfd, section, bfd_flags))
653 PRIV (dst_section) = section;
654 abfd->flags |= (HAS_DEBUG | HAS_LINENO);
659 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
661 section = bfd_make_section (abfd, "$DMT$");
665 section->size = dmtbytes;
666 section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
668 if (!bfd_set_section_flags (abfd, section, bfd_flags))
674 if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
676 bfd_set_error (bfd_error_file_truncated);
680 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
683 abfd->flags |= HAS_SYMS;
689 /* Object file reading. */
691 /* Object file input functions. */
693 /* Get next record from object file to vms_buf.
694 Set PRIV(buf_size) and return it
696 This is a little tricky since it should be portable.
698 The openVMS object file has 'variable length' which means that
699 read() returns data in chunks of (hopefully) correct and expected
700 size. The linker (and other tools on VMS) depend on that. Unix
701 doesn't know about 'formatted' files, so reading and writing such
702 an object file in a Unix environment is not trivial.
704 With the tool 'file' (available on all VMS FTP sites), one
705 can view and change the attributes of a file. Changing from
706 'variable length' to 'fixed length, 512 bytes' reveals the
707 record size at the first 2 bytes of every record. The same
708 may happen during the transfer of object files from VMS to Unix,
709 at least with UCX, the DEC implementation of TCP/IP.
711 The VMS format repeats the size at bytes 2 & 3 of every record.
713 On the first call (file_format == FF_UNKNOWN) we check if
714 the first and the third byte pair (!) of the record match.
715 If they do it's an object file in an Unix environment or with
716 wrong attributes (FF_FOREIGN), else we should be in a VMS
717 environment where read() returns the record size (FF_NATIVE).
719 Reading is always done in 2 steps:
720 1. first just the record header is read and the size extracted,
721 2. then the read buffer is adjusted and the remaining bytes are
724 All file I/O is done on even file positions. */
726 #define VMS_OBJECT_ADJUSTMENT 2
729 maybe_adjust_record_pointer_for_object (bfd *abfd)
731 /* Set the file format once for all on the first invocation. */
732 if (PRIV (recrd.file_format) == FF_UNKNOWN)
734 if (PRIV (recrd.rec)[0] == PRIV (recrd.rec)[4]
735 && PRIV (recrd.rec)[1] == PRIV (recrd.rec)[5])
736 PRIV (recrd.file_format) = FF_FOREIGN;
738 PRIV (recrd.file_format) = FF_NATIVE;
741 /* The adjustment is needed only in an Unix environment. */
742 if (PRIV (recrd.file_format) == FF_FOREIGN)
743 PRIV (recrd.rec) += VMS_OBJECT_ADJUSTMENT;
746 /* Implement step #1 of the object record reading procedure.
747 Return the record type or -1 on failure. */
750 _bfd_vms_get_object_record (bfd *abfd)
752 unsigned int test_len = 6;
755 vms_debug2 ((8, "_bfd_vms_get_obj_record\n"));
757 /* Skip alignment byte if the current position is odd. */
758 if (PRIV (recrd.file_format) == FF_FOREIGN && (bfd_tell (abfd) & 1))
760 if (bfd_bread (PRIV (recrd.buf), 1, abfd) != 1)
762 bfd_set_error (bfd_error_file_truncated);
767 /* Read the record header */
768 if (bfd_bread (PRIV (recrd.buf), test_len, abfd) != test_len)
770 bfd_set_error (bfd_error_file_truncated);
774 /* Reset the record pointer. */
775 PRIV (recrd.rec) = PRIV (recrd.buf);
776 maybe_adjust_record_pointer_for_object (abfd);
778 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
781 type = bfd_getl16 (PRIV (recrd.rec));
783 vms_debug2 ((8, "_bfd_vms_get_obj_record: rec %p, size %d, type %d\n",
784 PRIV (recrd.rec), PRIV (recrd.rec_size), type));
789 /* Implement step #2 of the object record reading procedure.
790 Return the size of the record or 0 on failure. */
793 vms_get_remaining_object_record (bfd *abfd, unsigned int read_so_far)
795 unsigned int to_read;
797 vms_debug2 ((8, "vms_get_remaining_obj_record\n"));
799 /* Extract record size. */
800 PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);
802 if (PRIV (recrd.rec_size) == 0)
804 bfd_set_error (bfd_error_file_truncated);
808 /* That's what the linker manual says. */
809 if (PRIV (recrd.rec_size) > EOBJ__C_MAXRECSIZ)
811 bfd_set_error (bfd_error_file_truncated);
815 /* Take into account object adjustment. */
816 to_read = PRIV (recrd.rec_size);
817 if (PRIV (recrd.file_format) == FF_FOREIGN)
818 to_read += VMS_OBJECT_ADJUSTMENT;
820 /* Adjust the buffer. */
821 if (to_read > PRIV (recrd.buf_size))
824 = (unsigned char *) bfd_realloc (PRIV (recrd.buf), to_read);
825 if (PRIV (recrd.buf) == NULL)
827 PRIV (recrd.buf_size) = to_read;
829 /* PR 17512: file: 025-1974-0.004. */
830 else if (to_read <= read_so_far)
833 /* Read the remaining record. */
834 to_read -= read_so_far;
836 vms_debug2 ((8, "vms_get_remaining_obj_record: to_read %d\n", to_read));
838 if (bfd_bread (PRIV (recrd.buf) + read_so_far, to_read, abfd) != to_read)
840 bfd_set_error (bfd_error_file_truncated);
844 /* Reset the record pointer. */
845 PRIV (recrd.rec) = PRIV (recrd.buf);
846 maybe_adjust_record_pointer_for_object (abfd);
848 vms_debug2 ((8, "vms_get_remaining_obj_record: size %d\n",
849 PRIV (recrd.rec_size)));
851 return PRIV (recrd.rec_size);
854 /* Read and process emh record.
855 Return TRUE on success, FALSE on error. */
858 _bfd_vms_slurp_ehdr (bfd *abfd)
861 unsigned char *vms_rec;
864 vms_rec = PRIV (recrd.rec);
866 vms_debug2 ((2, "HDR/EMH\n"));
868 subtype = bfd_getl16 (vms_rec + 4);
870 vms_debug2 ((3, "subtype %d\n", subtype));
876 PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
877 PRIV (hdr_data).hdr_l_arch1 = bfd_getl32 (vms_rec + 8);
878 PRIV (hdr_data).hdr_l_arch2 = bfd_getl32 (vms_rec + 12);
879 PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
880 PRIV (hdr_data).hdr_t_name = _bfd_vms_save_counted_string (vms_rec + 20);
881 ptr = vms_rec + 20 + vms_rec[20] + 1;
882 PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
884 PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
888 PRIV (hdr_data).hdr_c_lnm =
889 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
893 PRIV (hdr_data).hdr_c_src =
894 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
898 PRIV (hdr_data).hdr_c_ttl =
899 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
908 bfd_set_error (bfd_error_wrong_format);
915 /* Typical sections for evax object files. */
917 #define EVAX_ABS_NAME "$ABS$"
918 #define EVAX_CODE_NAME "$CODE$"
919 #define EVAX_LINK_NAME "$LINK$"
920 #define EVAX_DATA_NAME "$DATA$"
921 #define EVAX_BSS_NAME "$BSS$"
922 #define EVAX_READONLYADDR_NAME "$READONLY_ADDR$"
923 #define EVAX_READONLY_NAME "$READONLY$"
924 #define EVAX_LITERAL_NAME "$LITERAL$"
925 #define EVAX_LITERALS_NAME "$LITERALS"
926 #define EVAX_COMMON_NAME "$COMMON$"
927 #define EVAX_LOCAL_NAME "$LOCAL$"
929 struct sec_flags_struct
931 const char *name; /* Name of section. */
933 flagword flags_always; /* Flags we set always. */
935 flagword flags_hassize; /* Flags we set if the section has a size > 0. */
938 /* These flags are deccrtl/vaxcrtl (openVMS 6.2 Alpha) compatible. */
940 static const struct sec_flags_struct evax_section_flags[] =
948 EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE,
949 SEC_CODE | SEC_READONLY,
950 EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE,
951 SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
953 EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD,
954 SEC_DATA | SEC_READONLY,
955 EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD,
956 SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
958 EGPS__V_REL | EGPS__V_RD,
959 SEC_DATA | SEC_READONLY,
960 EGPS__V_REL | EGPS__V_RD,
961 SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
963 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
965 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
966 SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
968 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
970 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
972 { EVAX_READONLYADDR_NAME,
973 EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD,
974 SEC_DATA | SEC_READONLY,
975 EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD,
976 SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
977 { EVAX_READONLY_NAME,
978 EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD,
979 SEC_DATA | SEC_READONLY,
980 EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD,
981 SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
983 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
985 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
986 SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
987 { EVAX_LITERALS_NAME,
988 EGPS__V_PIC | EGPS__V_OVR,
989 SEC_DATA | SEC_READONLY,
990 EGPS__V_PIC | EGPS__V_OVR,
991 SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
993 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
995 EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
996 SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD }
999 /* Retrieve BFD section flags by name and size. */
1002 vms_secflag_by_name (const struct sec_flags_struct *section_flags,
1008 while (section_flags[i].name != NULL)
1010 if (strcmp (name, section_flags[i].name) == 0)
1013 return section_flags[i].flags_hassize;
1015 return section_flags[i].flags_always;
1020 return section_flags[i].flags_hassize;
1021 return section_flags[i].flags_always;
1024 /* Retrieve VMS section flags by name and size. */
1027 vms_esecflag_by_name (const struct sec_flags_struct *section_flags,
1033 while (section_flags[i].name != NULL)
1035 if (strcmp (name, section_flags[i].name) == 0)
1038 return section_flags[i].vflags_hassize;
1040 return section_flags[i].vflags_always;
1045 return section_flags[i].vflags_hassize;
1046 return section_flags[i].vflags_always;
1049 /* Add SYM to the symbol table of ABFD.
1050 Return FALSE in case of error. */
1053 add_symbol_entry (bfd *abfd, struct vms_symbol_entry *sym)
1055 if (PRIV (gsd_sym_count) >= PRIV (max_sym_count))
1057 if (PRIV (max_sym_count) == 0)
1059 PRIV (max_sym_count) = 128;
1060 PRIV (syms) = bfd_malloc
1061 (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *));
1065 PRIV (max_sym_count) *= 2;
1066 PRIV (syms) = bfd_realloc
1068 (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *)));
1070 if (PRIV (syms) == NULL)
1074 PRIV (syms)[PRIV (gsd_sym_count)++] = sym;
1078 /* Create a symbol whose name is ASCIC and add it to ABFD.
1079 Return NULL in case of error. */
1081 static struct vms_symbol_entry *
1082 add_symbol (bfd *abfd, const unsigned char *ascic)
1084 struct vms_symbol_entry *entry;
1088 entry = (struct vms_symbol_entry *)bfd_zalloc (abfd, sizeof (*entry) + len);
1091 entry->namelen = len;
1092 memcpy (entry->name, ascic, len);
1093 entry->name[len] = 0;
1094 entry->owner = abfd;
1096 if (!add_symbol_entry (abfd, entry))
1101 /* Read and process EGSD. Return FALSE on failure. */
1104 _bfd_vms_slurp_egsd (bfd *abfd)
1106 int gsd_type, gsd_size;
1107 unsigned char *vms_rec;
1108 unsigned long base_addr;
1110 vms_debug2 ((2, "EGSD\n"));
1112 PRIV (recrd.rec) += 8; /* Skip type, size, align pad. */
1113 PRIV (recrd.rec_size) -= 8;
1115 /* Calculate base address for each section. */
1118 while (PRIV (recrd.rec_size) > 0)
1120 vms_rec = PRIV (recrd.rec);
1122 gsd_type = bfd_getl16 (vms_rec);
1123 gsd_size = bfd_getl16 (vms_rec + 2);
1125 vms_debug2 ((3, "egsd_type %d\n", gsd_type));
1130 /* Program section definition. */
1132 struct vms_egps *egps = (struct vms_egps *)vms_rec;
1133 flagword new_flags, vms_flags;
1136 vms_flags = bfd_getl16 (egps->flags);
1138 if ((vms_flags & EGPS__V_REL) == 0)
1140 /* Use the global absolute section for all
1141 absolute sections. */
1142 section = bfd_abs_section_ptr;
1147 unsigned long align_addr;
1149 name = _bfd_vms_save_counted_string (&egps->namlng);
1151 section = bfd_make_section (abfd, name);
1155 section->filepos = 0;
1156 section->size = bfd_getl32 (egps->alloc);
1157 section->alignment_power = egps->align;
1159 vms_section_data (section)->flags = vms_flags;
1160 vms_section_data (section)->no_flags = 0;
1162 new_flags = vms_secflag_by_name (evax_section_flags, name,
1164 if (section->size > 0)
1165 new_flags |= SEC_LOAD;
1166 if (!(vms_flags & EGPS__V_NOMOD) && section->size > 0)
1168 /* Set RELOC and HAS_CONTENTS if the section is not
1169 demand-zero and not empty. */
1170 new_flags |= SEC_HAS_CONTENTS;
1171 if (vms_flags & EGPS__V_REL)
1172 new_flags |= SEC_RELOC;
1174 if (vms_flags & EGPS__V_EXE)
1176 /* Set CODE if section is executable. */
1177 new_flags |= SEC_CODE;
1178 new_flags &= ~SEC_DATA;
1180 if (!bfd_set_section_flags (abfd, section, new_flags))
1183 /* Give a non-overlapping vma to non absolute sections. */
1184 align_addr = (1 << section->alignment_power);
1185 if ((base_addr % align_addr) != 0)
1186 base_addr += (align_addr - (base_addr % align_addr));
1187 section->vma = (bfd_vma)base_addr;
1188 base_addr += section->size;
1191 /* Append it to the section array. */
1192 if (PRIV (section_count) >= PRIV (section_max))
1194 if (PRIV (section_max) == 0)
1195 PRIV (section_max) = 16;
1197 PRIV (section_max) *= 2;
1198 PRIV (sections) = bfd_realloc_or_free
1199 (PRIV (sections), PRIV (section_max) * sizeof (asection *));
1200 if (PRIV (sections) == NULL)
1204 PRIV (sections)[PRIV (section_count)] = section;
1205 PRIV (section_count)++;
1212 struct vms_symbol_entry *entry;
1213 struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
1216 old_flags = bfd_getl16 (egsy->flags);
1217 if (old_flags & EGSY__V_DEF)
1218 nameoff = ESDF__B_NAMLNG;
1220 nameoff = ESRF__B_NAMLNG;
1222 entry = add_symbol (abfd, vms_rec + nameoff);
1226 /* Allow only duplicate reference. */
1227 if ((entry->flags & EGSY__V_DEF) && (old_flags & EGSY__V_DEF))
1230 if (entry->typ == 0)
1232 entry->typ = gsd_type;
1233 entry->data_type = egsy->datyp;
1234 entry->flags = old_flags;
1237 if (old_flags & EGSY__V_DEF)
1239 struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
1241 entry->value = bfd_getl64 (esdf->value);
1242 entry->section = PRIV (sections)[bfd_getl32 (esdf->psindx)];
1244 if (old_flags & EGSY__V_NORM)
1246 PRIV (norm_sym_count)++;
1248 entry->code_value = bfd_getl64 (esdf->code_address);
1249 entry->code_section =
1250 PRIV (sections)[bfd_getl32 (esdf->ca_psindx)];
1258 struct vms_symbol_entry *entry;
1259 struct vms_egst *egst = (struct vms_egst *)vms_rec;
1262 old_flags = bfd_getl16 (egst->header.flags);
1264 entry = add_symbol (abfd, &egst->namlng);
1269 entry->typ = gsd_type;
1270 entry->data_type = egst->header.datyp;
1271 entry->flags = old_flags;
1273 entry->symbol_vector = bfd_getl32 (egst->value);
1275 if (old_flags & EGSY__V_REL)
1276 entry->section = PRIV (sections)[bfd_getl32 (egst->psindx)];
1278 entry->section = bfd_abs_section_ptr;
1280 entry->value = bfd_getl64 (egst->lp_2);
1282 if (old_flags & EGSY__V_NORM)
1284 PRIV (norm_sym_count)++;
1286 entry->code_value = bfd_getl64 (egst->lp_1);
1287 entry->code_section = bfd_abs_section_ptr;
1294 /* Currently ignored. */
1299 (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
1300 bfd_set_error (bfd_error_bad_value);
1304 PRIV (recrd.rec_size) -= gsd_size;
1305 PRIV (recrd.rec) += gsd_size;
1308 if (PRIV (gsd_sym_count) > 0)
1309 abfd->flags |= HAS_SYMS;
1314 /* Stack routines for vms ETIR commands. */
1316 /* Push value and section index. */
1319 _bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
1321 vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
1322 (unsigned long)val, reloc, PRIV (stackptr)));
1324 PRIV (stack[PRIV (stackptr)]).value = val;
1325 PRIV (stack[PRIV (stackptr)]).reloc = reloc;
1327 if (PRIV (stackptr) >= STACKSIZE)
1329 bfd_set_error (bfd_error_bad_value);
1330 (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
1335 /* Pop value and section index. */
1338 _bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
1340 if (PRIV (stackptr) == 0)
1342 bfd_set_error (bfd_error_bad_value);
1343 (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
1347 *val = PRIV (stack[PRIV (stackptr)]).value;
1348 *rel = PRIV (stack[PRIV (stackptr)]).reloc;
1350 vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
1353 /* Routines to fill sections contents during tir/etir read. */
1355 /* Initialize image buffer pointer to be filled. */
1358 image_set_ptr (bfd *abfd, bfd_vma vma, int sect, struct bfd_link_info *info)
1362 vms_debug2 ((4, "image_set_ptr (0x%08x, sect=%d)\n", (unsigned)vma, sect));
1364 sec = PRIV (sections)[sect];
1368 /* Reading contents to an output bfd. */
1370 if (sec->output_section == NULL)
1372 /* Section discarded. */
1373 vms_debug2 ((5, " section %s discarded\n", sec->name));
1375 /* This is not used. */
1376 PRIV (image_section) = NULL;
1377 PRIV (image_offset) = 0;
1380 PRIV (image_offset) = sec->output_offset + vma;
1381 PRIV (image_section) = sec->output_section;
1385 PRIV (image_offset) = vma;
1386 PRIV (image_section) = sec;
1390 /* Increment image buffer pointer by offset. */
1393 image_inc_ptr (bfd *abfd, bfd_vma offset)
1395 vms_debug2 ((4, "image_inc_ptr (%u)\n", (unsigned)offset));
1397 PRIV (image_offset) += offset;
1400 /* Save current DST location counter under specified index. */
1403 dst_define_location (bfd *abfd, unsigned int loc)
1405 vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
1407 /* Grow the ptr offset table if necessary. */
1408 if (loc + 1 > PRIV (dst_ptr_offsets_count))
1410 PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
1411 (loc + 1) * sizeof (unsigned int));
1412 PRIV (dst_ptr_offsets_count) = loc + 1;
1415 PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
1418 /* Restore saved DST location counter from specified index. */
1421 dst_restore_location (bfd *abfd, unsigned int loc)
1423 vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
1425 PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
1428 /* Retrieve saved DST location counter from specified index. */
1431 dst_retrieve_location (bfd *abfd, unsigned int loc)
1433 vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
1435 return PRIV (dst_ptr_offsets)[loc];
1438 /* Write multiple bytes to section image. */
1441 image_write (bfd *abfd, unsigned char *ptr, int size)
1444 _bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
1445 (long)PRIV (image_offset));
1446 _bfd_hexdump (9, ptr, size, 0);
1449 if (PRIV (image_section)->contents != NULL)
1451 asection *sec = PRIV (image_section);
1452 file_ptr off = PRIV (image_offset);
1455 if (off > (file_ptr)sec->size
1456 || size > (file_ptr)sec->size
1457 || off + size > (file_ptr)sec->size)
1459 bfd_set_error (bfd_error_bad_value);
1463 memcpy (sec->contents + off, ptr, size);
1466 PRIV (image_offset) += size;
1470 /* Write byte to section image. */
1473 image_write_b (bfd * abfd, unsigned int value)
1475 unsigned char data[1];
1477 vms_debug2 ((6, "image_write_b (%02x)\n", (int) value));
1481 return image_write (abfd, data, sizeof (data));
1484 /* Write 2-byte word to image. */
1487 image_write_w (bfd * abfd, unsigned int value)
1489 unsigned char data[2];
1491 vms_debug2 ((6, "image_write_w (%04x)\n", (int) value));
1493 bfd_putl16 (value, data);
1494 return image_write (abfd, data, sizeof (data));
1497 /* Write 4-byte long to image. */
1500 image_write_l (bfd * abfd, unsigned long value)
1502 unsigned char data[4];
1504 vms_debug2 ((6, "image_write_l (%08lx)\n", value));
1506 bfd_putl32 (value, data);
1507 return image_write (abfd, data, sizeof (data));
1510 /* Write 8-byte quad to image. */
1513 image_write_q (bfd * abfd, bfd_vma value)
1515 unsigned char data[8];
1517 vms_debug2 ((6, "image_write_q (%08lx)\n", (unsigned long)value));
1519 bfd_putl64 (value, data);
1520 return image_write (abfd, data, sizeof (data));
1524 _bfd_vms_etir_name (int cmd)
1528 case ETIR__C_STA_GBL: return "ETIR__C_STA_GBL";
1529 case ETIR__C_STA_LW: return "ETIR__C_STA_LW";
1530 case ETIR__C_STA_QW: return "ETIR__C_STA_QW";
1531 case ETIR__C_STA_PQ: return "ETIR__C_STA_PQ";
1532 case ETIR__C_STA_LI: return "ETIR__C_STA_LI";
1533 case ETIR__C_STA_MOD: return "ETIR__C_STA_MOD";
1534 case ETIR__C_STA_CKARG: return "ETIR__C_STA_CKARG";
1535 case ETIR__C_STO_B: return "ETIR__C_STO_B";
1536 case ETIR__C_STO_W: return "ETIR__C_STO_W";
1537 case ETIR__C_STO_GBL: return "ETIR__C_STO_GBL";
1538 case ETIR__C_STO_CA: return "ETIR__C_STO_CA";
1539 case ETIR__C_STO_RB: return "ETIR__C_STO_RB";
1540 case ETIR__C_STO_AB: return "ETIR__C_STO_AB";
1541 case ETIR__C_STO_OFF: return "ETIR__C_STO_OFF";
1542 case ETIR__C_STO_IMM: return "ETIR__C_STO_IMM";
1543 case ETIR__C_STO_IMMR: return "ETIR__C_STO_IMMR";
1544 case ETIR__C_STO_LW: return "ETIR__C_STO_LW";
1545 case ETIR__C_STO_QW: return "ETIR__C_STO_QW";
1546 case ETIR__C_STO_GBL_LW: return "ETIR__C_STO_GBL_LW";
1547 case ETIR__C_STO_LP_PSB: return "ETIR__C_STO_LP_PSB";
1548 case ETIR__C_STO_HINT_GBL: return "ETIR__C_STO_HINT_GBL";
1549 case ETIR__C_STO_HINT_PS: return "ETIR__C_STO_HINT_PS";
1550 case ETIR__C_OPR_ADD: return "ETIR__C_OPR_ADD";
1551 case ETIR__C_OPR_SUB: return "ETIR__C_OPR_SUB";
1552 case ETIR__C_OPR_INSV: return "ETIR__C_OPR_INSV";
1553 case ETIR__C_OPR_USH: return "ETIR__C_OPR_USH";
1554 case ETIR__C_OPR_ROT: return "ETIR__C_OPR_ROT";
1555 case ETIR__C_OPR_REDEF: return "ETIR__C_OPR_REDEF";
1556 case ETIR__C_OPR_DFLIT: return "ETIR__C_OPR_DFLIT";
1557 case ETIR__C_STC_LP: return "ETIR__C_STC_LP";
1558 case ETIR__C_STC_GBL: return "ETIR__C_STC_GBL";
1559 case ETIR__C_STC_GCA: return "ETIR__C_STC_GCA";
1560 case ETIR__C_STC_PS: return "ETIR__C_STC_PS";
1561 case ETIR__C_STC_NBH_PS: return "ETIR__C_STC_NBH_PS";
1562 case ETIR__C_STC_NOP_GBL: return "ETIR__C_STC_NOP_GBL";
1563 case ETIR__C_STC_NOP_PS: return "ETIR__C_STC_NOP_PS";
1564 case ETIR__C_STC_BSR_GBL: return "ETIR__C_STC_BSR_GBL";
1565 case ETIR__C_STC_BSR_PS: return "ETIR__C_STC_BSR_PS";
1566 case ETIR__C_STC_LDA_GBL: return "ETIR__C_STC_LDA_GBL";
1567 case ETIR__C_STC_LDA_PS: return "ETIR__C_STC_LDA_PS";
1568 case ETIR__C_STC_BOH_GBL: return "ETIR__C_STC_BOH_GBL";
1569 case ETIR__C_STC_BOH_PS: return "ETIR__C_STC_BOH_PS";
1570 case ETIR__C_STC_NBH_GBL: return "ETIR__C_STC_NBH_GBL";
1571 case ETIR__C_STC_LP_PSB: return "ETIR__C_STC_LP_PSB";
1572 case ETIR__C_CTL_SETRB: return "ETIR__C_CTL_SETRB";
1573 case ETIR__C_CTL_AUGRB: return "ETIR__C_CTL_AUGRB";
1574 case ETIR__C_CTL_DFLOC: return "ETIR__C_CTL_DFLOC";
1575 case ETIR__C_CTL_STLOC: return "ETIR__C_CTL_STLOC";
1576 case ETIR__C_CTL_STKDL: return "ETIR__C_CTL_STKDL";
1579 /* These names have not yet been added to this switch statement. */
1580 (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
1585 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
1588 _bfd_vms_get_value (bfd *abfd, const unsigned char *ascic,
1589 struct bfd_link_info *info,
1591 struct alpha_vms_link_hash_entry **hp)
1596 struct alpha_vms_link_hash_entry *h;
1598 /* Not linking. Do not try to resolve the symbol. */
1607 for (i = 0; i < len; i++)
1608 name[i] = ascic[i + 1];
1611 h = (struct alpha_vms_link_hash_entry *)
1612 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
1617 && (h->root.type == bfd_link_hash_defined
1618 || h->root.type == bfd_link_hash_defweak))
1619 *vma = h->root.u.def.value
1620 + h->root.u.def.section->output_offset
1621 + h->root.u.def.section->output_section->vma;
1622 else if (h && h->root.type == bfd_link_hash_undefweak)
1626 if (!(*info->callbacks->undefined_symbol)
1627 (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
1635 #define RELC_SHR_BASE 0x10000
1636 #define RELC_SEC_BASE 0x20000
1637 #define RELC_MASK 0x0ffff
1640 alpha_vms_sym_to_ctxt (struct alpha_vms_link_hash_entry *h)
1642 /* Handle undefined symbols. */
1643 if (h == NULL || h->sym == NULL)
1646 if (h->sym->typ == EGSD__C_SYMG)
1648 if (h->sym->flags & EGSY__V_REL)
1649 return RELC_SHR_BASE + PRIV2 (h->sym->owner, shr_index);
1652 /* Can this happen (non-relocatable symg) ? I'd like to see
1657 if (h->sym->typ == EGSD__C_SYM)
1659 if (h->sym->flags & EGSY__V_REL)
1668 alpha_vms_get_sym_value (asection *sect, bfd_vma addr)
1670 return sect->output_section->vma + sect->output_offset + addr;
1674 alpha_vms_fix_sec_rel (bfd *abfd, struct bfd_link_info *info,
1675 unsigned int rel, bfd_vma vma)
1677 asection *sec = PRIV (sections)[rel & RELC_MASK];
1681 if (sec->output_section == NULL)
1683 return vma + sec->output_section->vma + sec->output_offset;
1686 return vma + sec->vma;
1689 /* Read an ETIR record from ABFD. If INFO is not null, put the content into
1690 the output section (used during linking).
1691 Return FALSE in case of error. */
1694 _bfd_vms_slurp_etir (bfd *abfd, struct bfd_link_info *info)
1697 unsigned int length;
1698 unsigned char *maxptr;
1703 struct alpha_vms_link_hash_entry *h;
1705 PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
1706 PRIV (recrd.rec_size) -= ETIR__C_HEADER_SIZE;
1708 ptr = PRIV (recrd.rec);
1709 length = PRIV (recrd.rec_size);
1710 maxptr = ptr + length;
1712 vms_debug2 ((2, "ETIR: %d bytes\n", length));
1714 while (ptr < maxptr)
1716 int cmd = bfd_getl16 (ptr);
1717 int cmd_length = bfd_getl16 (ptr + 2);
1722 _bfd_vms_debug (4, "etir: %s(%d)\n",
1723 _bfd_vms_etir_name (cmd), cmd);
1724 _bfd_hexdump (8, ptr, cmd_length - 4, 0);
1732 stack 32 bit value of symbol (high bits set to 0). */
1733 case ETIR__C_STA_GBL:
1734 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1735 _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
1741 stack 32 bit value, sign extend to 64 bit. */
1742 case ETIR__C_STA_LW:
1743 _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
1749 stack 64 bit value of symbol. */
1750 case ETIR__C_STA_QW:
1751 _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
1754 /* Stack psect base plus quadword offset
1755 arg: lw section index
1756 qw signed quadword offset (low 32 bits)
1758 Stack qw argument and section index
1759 (see ETIR__C_STO_OFF, ETIR__C_CTL_SETRB). */
1760 case ETIR__C_STA_PQ:
1764 psect = bfd_getl32 (ptr);
1765 if ((unsigned int) psect >= PRIV (section_count))
1767 (*_bfd_error_handler) (_("bad section index in %s"),
1768 _bfd_vms_etir_name (cmd));
1769 bfd_set_error (bfd_error_bad_value);
1772 op1 = bfd_getl64 (ptr + 4);
1773 _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
1777 case ETIR__C_STA_LI:
1778 case ETIR__C_STA_MOD:
1779 case ETIR__C_STA_CKARG:
1780 (*_bfd_error_handler) (_("unsupported STA cmd %s"),
1781 _bfd_vms_etir_name (cmd));
1785 /* Store byte: pop stack, write byte
1788 _bfd_vms_pop (abfd, &op1, &rel1);
1789 if (rel1 != RELC_NONE)
1791 image_write_b (abfd, (unsigned int) op1 & 0xff);
1794 /* Store word: pop stack, write word
1797 _bfd_vms_pop (abfd, &op1, &rel1);
1798 if (rel1 != RELC_NONE)
1800 image_write_w (abfd, (unsigned int) op1 & 0xffff);
1803 /* Store longword: pop stack, write longword
1805 case ETIR__C_STO_LW:
1806 _bfd_vms_pop (abfd, &op1, &rel1);
1807 if (rel1 & RELC_SEC_BASE)
1809 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1812 else if (rel1 & RELC_SHR_BASE)
1814 alpha_vms_add_fixup_lr (info, rel1 & RELC_MASK, op1);
1817 if (rel1 != RELC_NONE)
1819 if (rel1 != RELC_REL)
1821 alpha_vms_add_lw_reloc (info);
1823 image_write_l (abfd, op1);
1826 /* Store quadword: pop stack, write quadword
1828 case ETIR__C_STO_QW:
1829 _bfd_vms_pop (abfd, &op1, &rel1);
1830 if (rel1 & RELC_SEC_BASE)
1832 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1835 else if (rel1 & RELC_SHR_BASE)
1837 if (rel1 != RELC_NONE)
1839 if (rel1 != RELC_REL)
1841 alpha_vms_add_qw_reloc (info);
1843 image_write_q (abfd, op1);
1846 /* Store immediate repeated: pop stack for repeat count
1849 case ETIR__C_STO_IMMR:
1853 size = bfd_getl32 (ptr);
1854 _bfd_vms_pop (abfd, &op1, &rel1);
1855 if (rel1 != RELC_NONE)
1858 image_write (abfd, ptr + 4, size);
1862 /* Store global: write symbol value
1863 arg: cs global symbol name. */
1864 case ETIR__C_STO_GBL:
1865 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1868 if (h->sym->typ == EGSD__C_SYMG)
1870 alpha_vms_add_fixup_qr
1871 (info, abfd, h->sym->owner, h->sym->symbol_vector);
1876 op1 = alpha_vms_get_sym_value (h->sym->section,
1878 alpha_vms_add_qw_reloc (info);
1881 image_write_q (abfd, op1);
1884 /* Store code address: write address of entry point
1885 arg: cs global symbol name (procedure). */
1886 case ETIR__C_STO_CA:
1887 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1890 if (h->sym->flags & EGSY__V_NORM)
1892 /* That's really a procedure. */
1893 if (h->sym->typ == EGSD__C_SYMG)
1895 alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
1896 op1 = h->sym->symbol_vector;
1900 op1 = alpha_vms_get_sym_value (h->sym->code_section,
1901 h->sym->code_value);
1902 alpha_vms_add_qw_reloc (info);
1907 /* Symbol is not a procedure. */
1911 image_write_q (abfd, op1);
1914 /* Store offset to psect: pop stack, add low 32 bits to base of psect
1916 case ETIR__C_STO_OFF:
1917 _bfd_vms_pop (abfd, &op1, &rel1);
1919 if (!(rel1 & RELC_SEC_BASE))
1922 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1924 image_write_q (abfd, op1);
1928 arg: lw count of bytes
1930 case ETIR__C_STO_IMM:
1934 size = bfd_getl32 (ptr);
1935 image_write (abfd, ptr + 4, size);
1939 /* This code is 'reserved to digital' according to the openVMS
1940 linker manual, however it is generated by the DEC C compiler
1941 and defined in the include file.
1942 FIXME, since the following is just a guess
1943 store global longword: store 32bit value of symbol
1944 arg: cs symbol name. */
1945 case ETIR__C_STO_GBL_LW:
1946 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1950 image_write_l (abfd, op1);
1953 case ETIR__C_STO_RB:
1954 case ETIR__C_STO_AB:
1955 case ETIR__C_STO_LP_PSB:
1956 (*_bfd_error_handler) (_("%s: not supported"),
1957 _bfd_vms_etir_name (cmd));
1960 case ETIR__C_STO_HINT_GBL:
1961 case ETIR__C_STO_HINT_PS:
1962 (*_bfd_error_handler) (_("%s: not implemented"),
1963 _bfd_vms_etir_name (cmd));
1967 /* 200 Store-conditional Linkage Pair
1969 case ETIR__C_STC_LP:
1971 /* 202 Store-conditional Address at global address
1975 case ETIR__C_STC_GBL:
1977 /* 203 Store-conditional Code Address at global address
1979 cs procedure name. */
1980 case ETIR__C_STC_GCA:
1982 /* 204 Store-conditional Address at psect + offset
1986 case ETIR__C_STC_PS:
1987 (*_bfd_error_handler) (_("%s: not supported"),
1988 _bfd_vms_etir_name (cmd));
1992 /* 201 Store-conditional Linkage Pair with Procedure Signature
1998 case ETIR__C_STC_LP_PSB:
1999 _bfd_vms_get_value (abfd, ptr + 4, info, &op1, &h);
2002 if (h->sym->typ == EGSD__C_SYMG)
2004 alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
2005 op1 = h->sym->symbol_vector;
2010 op1 = alpha_vms_get_sym_value (h->sym->code_section,
2011 h->sym->code_value);
2012 op2 = alpha_vms_get_sym_value (h->sym->section,
2018 /* Undefined symbol. */
2022 image_write_q (abfd, op1);
2023 image_write_q (abfd, op2);
2026 /* 205 Store-conditional NOP at address of global
2028 case ETIR__C_STC_NOP_GBL:
2031 /* 207 Store-conditional BSR at global address
2034 case ETIR__C_STC_BSR_GBL:
2037 /* 209 Store-conditional LDA at global address
2040 case ETIR__C_STC_LDA_GBL:
2043 /* 211 Store-conditional BSR or Hint at global address
2046 case ETIR__C_STC_BOH_GBL:
2047 /* Currentl ignored. */
2050 /* 213 Store-conditional NOP,BSR or HINT at global address
2053 case ETIR__C_STC_NBH_GBL:
2055 /* 206 Store-conditional NOP at pect + offset
2058 case ETIR__C_STC_NOP_PS:
2060 /* 208 Store-conditional BSR at pect + offset
2063 case ETIR__C_STC_BSR_PS:
2065 /* 210 Store-conditional LDA at psect + offset
2068 case ETIR__C_STC_LDA_PS:
2070 /* 212 Store-conditional BSR or Hint at pect + offset
2073 case ETIR__C_STC_BOH_PS:
2075 /* 214 Store-conditional NOP, BSR or HINT at psect + offset
2077 case ETIR__C_STC_NBH_PS:
2078 (*_bfd_error_handler) ("%s: not supported",
2079 _bfd_vms_etir_name (cmd));
2083 /* Det relocation base: pop stack, set image location counter
2085 case ETIR__C_CTL_SETRB:
2086 _bfd_vms_pop (abfd, &op1, &rel1);
2087 if (!(rel1 & RELC_SEC_BASE))
2089 image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
2092 /* Augment relocation base: increment image location counter by offset
2093 arg: lw offset value. */
2094 case ETIR__C_CTL_AUGRB:
2095 op1 = bfd_getl32 (ptr);
2096 image_inc_ptr (abfd, op1);
2099 /* Define location: pop index, save location counter under index
2101 case ETIR__C_CTL_DFLOC:
2102 _bfd_vms_pop (abfd, &op1, &rel1);
2103 if (rel1 != RELC_NONE)
2105 dst_define_location (abfd, op1);
2108 /* Set location: pop index, restore location counter from index
2110 case ETIR__C_CTL_STLOC:
2111 _bfd_vms_pop (abfd, &op1, &rel1);
2112 if (rel1 != RELC_NONE)
2114 dst_restore_location (abfd, op1);
2117 /* Stack defined location: pop index, push location counter from index
2119 case ETIR__C_CTL_STKDL:
2120 _bfd_vms_pop (abfd, &op1, &rel1);
2121 if (rel1 != RELC_NONE)
2123 _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
2126 case ETIR__C_OPR_NOP: /* No-op. */
2129 case ETIR__C_OPR_ADD: /* Add. */
2130 _bfd_vms_pop (abfd, &op1, &rel1);
2131 _bfd_vms_pop (abfd, &op2, &rel2);
2132 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2134 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2136 _bfd_vms_push (abfd, op1 + op2, rel1);
2139 case ETIR__C_OPR_SUB: /* Subtract. */
2140 _bfd_vms_pop (abfd, &op1, &rel1);
2141 _bfd_vms_pop (abfd, &op2, &rel2);
2142 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2144 else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
2146 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
2147 op2 = alpha_vms_fix_sec_rel (abfd, info, rel2, op2);
2150 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2152 _bfd_vms_push (abfd, op2 - op1, rel1);
2155 case ETIR__C_OPR_MUL: /* Multiply. */
2156 _bfd_vms_pop (abfd, &op1, &rel1);
2157 _bfd_vms_pop (abfd, &op2, &rel2);
2158 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2160 _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
2163 case ETIR__C_OPR_DIV: /* Divide. */
2164 _bfd_vms_pop (abfd, &op1, &rel1);
2165 _bfd_vms_pop (abfd, &op2, &rel2);
2166 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2169 _bfd_vms_push (abfd, 0, RELC_NONE);
2171 _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
2174 case ETIR__C_OPR_AND: /* Logical AND. */
2175 _bfd_vms_pop (abfd, &op1, &rel1);
2176 _bfd_vms_pop (abfd, &op2, &rel2);
2177 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2179 _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
2182 case ETIR__C_OPR_IOR: /* Logical inclusive OR. */
2183 _bfd_vms_pop (abfd, &op1, &rel1);
2184 _bfd_vms_pop (abfd, &op2, &rel2);
2185 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2187 _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
2190 case ETIR__C_OPR_EOR: /* Logical exclusive OR. */
2191 _bfd_vms_pop (abfd, &op1, &rel1);
2192 _bfd_vms_pop (abfd, &op2, &rel2);
2193 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2195 _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
2198 case ETIR__C_OPR_NEG: /* Negate. */
2199 _bfd_vms_pop (abfd, &op1, &rel1);
2200 if (rel1 != RELC_NONE)
2202 _bfd_vms_push (abfd, -op1, RELC_NONE);
2205 case ETIR__C_OPR_COM: /* Complement. */
2206 _bfd_vms_pop (abfd, &op1, &rel1);
2207 if (rel1 != RELC_NONE)
2209 _bfd_vms_push (abfd, ~op1, RELC_NONE);
2212 case ETIR__C_OPR_ASH: /* Arithmetic shift. */
2213 _bfd_vms_pop (abfd, &op1, &rel1);
2214 _bfd_vms_pop (abfd, &op2, &rel2);
2215 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2218 (*_bfd_error_handler) (_("invalid use of %s with contexts"),
2219 _bfd_vms_etir_name (cmd));
2222 if ((int)op2 < 0) /* Shift right. */
2224 else /* Shift left. */
2226 _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym. */
2229 case ETIR__C_OPR_INSV: /* Insert field. */
2230 case ETIR__C_OPR_USH: /* Unsigned shift. */
2231 case ETIR__C_OPR_ROT: /* Rotate. */
2232 case ETIR__C_OPR_REDEF: /* Redefine symbol to current location. */
2233 case ETIR__C_OPR_DFLIT: /* Define a literal. */
2234 (*_bfd_error_handler) (_("%s: not supported"),
2235 _bfd_vms_etir_name (cmd));
2239 case ETIR__C_OPR_SEL: /* Select. */
2240 _bfd_vms_pop (abfd, &op1, &rel1);
2242 _bfd_vms_pop (abfd, &op1, &rel1);
2245 _bfd_vms_pop (abfd, &op1, &rel1);
2246 _bfd_vms_pop (abfd, &op2, &rel2);
2247 _bfd_vms_push (abfd, op1, rel1);
2252 (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
2257 ptr += cmd_length - 4;
2263 /* Process EDBG/ETBT record.
2264 Return TRUE on success, FALSE on error */
2267 vms_slurp_debug (bfd *abfd)
2269 asection *section = PRIV (dst_section);
2271 if (section == NULL)
2273 /* We have no way to find out beforehand how much debug info there
2274 is in an object file, so pick an initial amount and grow it as
2276 flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC
2279 section = bfd_make_section (abfd, "$DST$");
2282 if (!bfd_set_section_flags (abfd, section, flags))
2284 PRIV (dst_section) = section;
2287 PRIV (image_section) = section;
2288 PRIV (image_offset) = section->size;
2290 if (!_bfd_vms_slurp_etir (abfd, NULL))
2293 section->size = PRIV (image_offset);
2297 /* Process EDBG record.
2298 Return TRUE on success, FALSE on error. */
2301 _bfd_vms_slurp_edbg (bfd *abfd)
2303 vms_debug2 ((2, "EDBG\n"));
2305 abfd->flags |= HAS_DEBUG | HAS_LINENO;
2307 return vms_slurp_debug (abfd);
2310 /* Process ETBT record.
2311 Return TRUE on success, FALSE on error. */
2314 _bfd_vms_slurp_etbt (bfd *abfd)
2316 vms_debug2 ((2, "ETBT\n"));
2318 abfd->flags |= HAS_LINENO;
2320 return vms_slurp_debug (abfd);
2323 /* Process EEOM record.
2324 Return TRUE on success, FALSE on error. */
2327 _bfd_vms_slurp_eeom (bfd *abfd)
2329 struct vms_eeom *eeom = (struct vms_eeom *) PRIV (recrd.rec);
2331 vms_debug2 ((2, "EEOM\n"));
2333 PRIV (eom_data).eom_l_total_lps = bfd_getl32 (eeom->total_lps);
2334 PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
2335 if (PRIV (eom_data).eom_w_comcod > 1)
2337 (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
2338 bfd_set_error (bfd_error_bad_value);
2342 PRIV (eom_data).eom_has_transfer = FALSE;
2343 if (PRIV (recrd.rec_size) > 10)
2345 PRIV (eom_data).eom_has_transfer = TRUE;
2346 PRIV (eom_data).eom_b_tfrflg = eeom->tfrflg;
2347 PRIV (eom_data).eom_l_psindx = bfd_getl32 (eeom->psindx);
2348 PRIV (eom_data).eom_l_tfradr = bfd_getl32 (eeom->tfradr);
2350 abfd->start_address = PRIV (eom_data).eom_l_tfradr;
2355 /* Slurp an ordered set of VMS object records. Return FALSE on error. */
2358 _bfd_vms_slurp_object_records (bfd * abfd)
2365 vms_debug2 ((7, "reading at %08lx\n", (unsigned long)bfd_tell (abfd)));
2367 type = _bfd_vms_get_object_record (abfd);
2370 vms_debug2 ((2, "next_record failed\n"));
2377 err = _bfd_vms_slurp_ehdr (abfd);
2380 err = _bfd_vms_slurp_eeom (abfd);
2383 err = _bfd_vms_slurp_egsd (abfd);
2386 err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
2389 err = _bfd_vms_slurp_edbg (abfd);
2392 err = _bfd_vms_slurp_etbt (abfd);
2399 vms_debug2 ((2, "slurp type %d failed\n", type));
2403 while (type != EOBJ__C_EEOM);
2408 /* Initialize private data */
2410 vms_initialize (bfd * abfd)
2414 amt = sizeof (struct vms_private_data_struct);
2415 abfd->tdata.any = bfd_zalloc (abfd, amt);
2416 if (abfd->tdata.any == NULL)
2419 PRIV (recrd.file_format) = FF_UNKNOWN;
2421 amt = sizeof (struct stack_struct) * STACKSIZE;
2422 PRIV (stack) = bfd_alloc (abfd, amt);
2423 if (PRIV (stack) == NULL)
2429 bfd_release (abfd, abfd->tdata.any);
2430 abfd->tdata.any = NULL;
2434 /* Check the format for a file being read.
2435 Return a (bfd_target *) if it's an object file or zero if not. */
2437 static const struct bfd_target *
2438 alpha_vms_object_p (bfd *abfd)
2440 void *tdata_save = abfd->tdata.any;
2441 unsigned int test_len;
2444 vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
2446 /* Allocate alpha-vms specific data. */
2447 if (!vms_initialize (abfd))
2450 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
2451 goto err_wrong_format;
2453 /* The first challenge with VMS is to discover the kind of the file.
2455 Image files (executable or shared images) are stored as a raw
2456 stream of bytes (like on UNIX), but there is no magic number.
2458 Object files are written with RMS (record management service), ie
2459 each records are preceeded by its length (on a word - 2 bytes), and
2460 padded for word-alignment. That would be simple but when files
2461 are transfered to a UNIX filesystem (using ftp), records are lost.
2462 Only the raw content of the records are transfered. Fortunately,
2463 the Alpha Object file format also store the length of the record
2464 in the records. Is that clear ? */
2466 /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
2467 2 bytes size repeated) and 12 bytes for images (4 bytes major id,
2468 4 bytes minor id, 4 bytes length). */
2471 /* Size the main buffer. */
2472 buf = (unsigned char *) bfd_malloc (test_len);
2475 PRIV (recrd.buf) = buf;
2476 PRIV (recrd.buf_size) = test_len;
2478 /* Initialize the record pointer. */
2479 PRIV (recrd.rec) = buf;
2481 if (bfd_bread (buf, test_len, abfd) != test_len)
2482 goto err_wrong_format;
2484 /* Is it an image? */
2485 if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
2486 && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
2488 unsigned int to_read;
2489 unsigned int read_so_far;
2490 unsigned int remaining;
2491 unsigned int eisd_offset, eihs_offset;
2493 /* Extract the header size. */
2494 PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
2496 /* The header size is 0 for DSF files. */
2497 if (PRIV (recrd.rec_size) == 0)
2498 PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
2500 if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
2502 buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
2506 PRIV (recrd.buf) = NULL;
2509 PRIV (recrd.buf) = buf;
2510 PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
2513 /* Read the remaining record. */
2514 remaining = PRIV (recrd.rec_size) - test_len;
2515 to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
2516 read_so_far = test_len;
2518 while (remaining > 0)
2520 if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
2521 goto err_wrong_format;
2523 read_so_far += to_read;
2524 remaining -= to_read;
2526 to_read = MIN (VMS_BLOCK_SIZE, remaining);
2529 /* Reset the record pointer. */
2530 PRIV (recrd.rec) = buf;
2532 /* PR 17512: file: 7d7c57c2. */
2533 if (PRIV (recrd.rec_size) < sizeof (struct vms_eihd))
2535 vms_debug2 ((2, "file type is image\n"));
2537 if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
2538 goto err_wrong_format;
2540 if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
2541 goto err_wrong_format;
2543 /* EIHS is optional. */
2544 if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
2545 goto err_wrong_format;
2551 /* Assume it's a module and adjust record pointer if necessary. */
2552 maybe_adjust_record_pointer_for_object (abfd);
2554 /* But is it really a module? */
2555 if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
2556 && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
2558 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
2559 goto err_wrong_format;
2561 vms_debug2 ((2, "file type is module\n"));
2563 type = bfd_getl16 (PRIV (recrd.rec));
2564 if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
2565 goto err_wrong_format;
2567 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
2568 goto err_wrong_format;
2571 goto err_wrong_format;
2574 /* Set arch_info to alpha. */
2576 if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
2577 goto err_wrong_format;
2582 bfd_set_error (bfd_error_wrong_format);
2585 if (PRIV (recrd.buf))
2586 free (PRIV (recrd.buf));
2587 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
2588 bfd_release (abfd, abfd->tdata.any);
2589 abfd->tdata.any = tdata_save;
2595 /* Write an EMH/MHD record. */
2598 _bfd_vms_write_emh (bfd *abfd)
2600 struct vms_rec_wr *recwr = &PRIV (recwr);
2602 _bfd_vms_output_alignment (recwr, 2);
2605 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2606 _bfd_vms_output_short (recwr, EMH__C_MHD);
2607 _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
2608 _bfd_vms_output_long (recwr, 0);
2609 _bfd_vms_output_long (recwr, 0);
2610 _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
2612 /* Create module name from filename. */
2613 if (bfd_get_filename (abfd) != 0)
2615 char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2616 _bfd_vms_output_counted (recwr, module);
2620 _bfd_vms_output_counted (recwr, "NONAME");
2622 _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
2623 _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
2624 _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
2625 _bfd_vms_output_end (abfd, recwr);
2628 /* Write an EMH/LMN record. */
2631 _bfd_vms_write_lmn (bfd *abfd, const char *name)
2634 struct vms_rec_wr *recwr = &PRIV (recwr);
2635 unsigned int ver = BFD_VERSION / 10000;
2638 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2639 _bfd_vms_output_short (recwr, EMH__C_LNM);
2640 snprintf (version, sizeof (version), "%s %d.%d.%d", name,
2641 ver / 10000, (ver / 100) % 100, ver % 100);
2642 _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
2643 _bfd_vms_output_end (abfd, recwr);
2647 /* Write eom record for bfd abfd. Return FALSE on error. */
2650 _bfd_vms_write_eeom (bfd *abfd)
2652 struct vms_rec_wr *recwr = &PRIV (recwr);
2654 vms_debug2 ((2, "vms_write_eeom\n"));
2656 _bfd_vms_output_alignment (recwr, 2);
2658 _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
2659 _bfd_vms_output_long (recwr, PRIV (vms_linkage_index + 1) >> 1);
2660 _bfd_vms_output_byte (recwr, 0); /* Completion code. */
2661 _bfd_vms_output_byte (recwr, 0); /* Fill byte. */
2663 if ((abfd->flags & EXEC_P) == 0
2664 && bfd_get_start_address (abfd) != (bfd_vma)-1)
2668 section = bfd_get_section_by_name (abfd, ".link");
2671 bfd_set_error (bfd_error_nonrepresentable_section);
2674 _bfd_vms_output_short (recwr, 0);
2675 _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
2676 _bfd_vms_output_long (recwr,
2677 (unsigned long) bfd_get_start_address (abfd));
2678 _bfd_vms_output_long (recwr, 0);
2681 _bfd_vms_output_end (abfd, recwr);
2686 vector_grow1 (struct vector_type *vec, size_t elsz)
2688 if (vec->nbr_el + 1 < vec->max_el)
2691 if (vec->max_el == 0)
2694 vec->els = bfd_malloc2 (vec->max_el, elsz);
2699 vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
2703 /* Bump ABFD file position to next block. */
2706 alpha_vms_file_position_block (bfd *abfd)
2709 PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
2710 PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
2713 /* Convert from internal structure SRC to external structure DST. */
2716 alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
2717 struct vms_eisd *dst)
2719 bfd_putl32 (src->u.eisd.majorid, dst->majorid);
2720 bfd_putl32 (src->u.eisd.minorid, dst->minorid);
2721 bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
2722 if (src->u.eisd.eisdsize <= EISD__K_LENEND)
2724 bfd_putl32 (src->u.eisd.secsize, dst->secsize);
2725 bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
2726 bfd_putl32 (src->u.eisd.flags, dst->flags);
2727 bfd_putl32 (src->u.eisd.vbn, dst->vbn);
2728 dst->pfc = src->u.eisd.pfc;
2729 dst->matchctl = src->u.eisd.matchctl;
2730 dst->type = src->u.eisd.type;
2732 if (src->u.eisd.flags & EISD__M_GBL)
2734 bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
2735 memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
2736 src->u.gbl_eisd.gblnam[0] + 1);
2740 /* Append EISD to the list of extra eisd for ABFD. */
2743 alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
2746 if (PRIV (gbl_eisd_head) == NULL)
2747 PRIV (gbl_eisd_head) = eisd;
2749 PRIV (gbl_eisd_tail)->next = eisd;
2750 PRIV (gbl_eisd_tail) = eisd;
2753 /* Create an EISD for shared image SHRIMG.
2754 Return FALSE in case of error. */
2757 alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
2759 struct vms_internal_eisd_map *eisd;
2762 namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
2763 if (namlen + 5 > EISD__K_GBLNAMLEN)
2769 eisd = bfd_alloc (abfd, sizeof (*eisd));
2773 /* Fill the fields. */
2774 eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
2775 eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
2776 eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
2777 eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE; /* Must not be 0. */
2778 eisd->u.gbl_eisd.common.virt_addr = 0;
2779 eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
2780 eisd->u.gbl_eisd.common.vbn = 0;
2781 eisd->u.gbl_eisd.common.pfc = 0;
2782 eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
2783 eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
2785 eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
2786 eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
2787 memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
2789 memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
2791 /* Append it to the list. */
2792 alpha_vms_append_extra_eisd (abfd, eisd);
2797 /* Create an EISD for section SEC.
2798 Return FALSE in case of failure. */
2801 alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
2803 struct vms_internal_eisd_map *eisd;
2805 /* Only for allocating section. */
2806 if (!(sec->flags & SEC_ALLOC))
2809 BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
2810 eisd = bfd_alloc (abfd, sizeof (*eisd));
2813 vms_section_data (sec)->eisd = eisd;
2815 /* Fill the fields. */
2816 eisd->u.eisd.majorid = EISD__K_MAJORID;
2817 eisd->u.eisd.minorid = EISD__K_MINORID;
2818 eisd->u.eisd.eisdsize = EISD__K_LEN;
2819 eisd->u.eisd.secsize =
2820 (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
2821 eisd->u.eisd.virt_addr = sec->vma;
2822 eisd->u.eisd.flags = 0;
2823 eisd->u.eisd.vbn = 0; /* To be later defined. */
2824 eisd->u.eisd.pfc = 0; /* Default. */
2825 eisd->u.eisd.matchctl = EISD__K_MATALL;
2826 eisd->u.eisd.type = EISD__K_NORMAL;
2828 if (sec->flags & SEC_CODE)
2829 eisd->u.eisd.flags |= EISD__M_EXE;
2830 if (!(sec->flags & SEC_READONLY))
2831 eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2833 /* If relocations or fixup will be applied, make this isect writeable. */
2834 if (sec->flags & SEC_RELOC)
2835 eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2837 if (!(sec->flags & SEC_HAS_CONTENTS))
2839 eisd->u.eisd.flags |= EISD__M_DZRO;
2840 eisd->u.eisd.flags &= ~EISD__M_CRF;
2842 if (sec->flags & SEC_LINKER_CREATED)
2844 if (strcmp (sec->name, "$FIXUP$") == 0)
2845 eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
2848 /* Append it to the list. */
2850 if (PRIV (eisd_head) == NULL)
2851 PRIV (eisd_head) = eisd;
2853 PRIV (eisd_tail)->next = eisd;
2854 PRIV (eisd_tail) = eisd;
2859 /* Layout executable ABFD and write it to the disk.
2860 Return FALSE in case of failure. */
2863 alpha_vms_write_exec (bfd *abfd)
2865 struct vms_eihd eihd;
2866 struct vms_eiha *eiha;
2867 struct vms_eihi *eihi;
2868 struct vms_eihs *eihs = NULL;
2870 struct vms_internal_eisd_map *first_eisd;
2871 struct vms_internal_eisd_map *eisd;
2874 file_ptr gst_filepos = 0;
2875 unsigned int lnkflags = 0;
2877 /* Build the EIHD. */
2878 PRIV (file_pos) = EIHD__C_LENGTH;
2880 memset (&eihd, 0, sizeof (eihd));
2881 memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
2883 bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
2884 bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
2886 bfd_putl32 (sizeof (eihd), eihd.size);
2887 bfd_putl32 (0, eihd.isdoff);
2888 bfd_putl32 (0, eihd.activoff);
2889 bfd_putl32 (0, eihd.symdbgoff);
2890 bfd_putl32 (0, eihd.imgidoff);
2891 bfd_putl32 (0, eihd.patchoff);
2892 bfd_putl64 (0, eihd.iafva);
2893 bfd_putl32 (0, eihd.version_array_off);
2895 bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
2896 bfd_putl32 (0, eihd.subtype);
2898 bfd_putl32 (0, eihd.imgiocnt);
2899 bfd_putl32 (-1, eihd.privreqs);
2900 bfd_putl32 (-1, eihd.privreqs + 4);
2902 bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
2904 bfd_putl32 (0, eihd.ident);
2905 bfd_putl32 (0, eihd.sysver);
2908 bfd_putl32 (0, eihd.symvect_size);
2909 bfd_putl32 (16, eihd.virt_mem_block_size);
2910 bfd_putl32 (0, eihd.ext_fixup_off);
2911 bfd_putl32 (0, eihd.noopt_psect_off);
2912 bfd_putl32 (-1, eihd.alias);
2915 eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
2916 bfd_putl32 (PRIV (file_pos), eihd.activoff);
2917 PRIV (file_pos) += sizeof (struct vms_eiha);
2919 bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
2920 bfd_putl32 (0, eiha->spare);
2921 bfd_putl64 (PRIV (transfer_address[0]), eiha->tfradr1);
2922 bfd_putl64 (PRIV (transfer_address[1]), eiha->tfradr2);
2923 bfd_putl64 (PRIV (transfer_address[2]), eiha->tfradr3);
2924 bfd_putl64 (PRIV (transfer_address[3]), eiha->tfradr4);
2925 bfd_putl64 (0, eiha->inishr);
2928 eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
2929 bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
2930 PRIV (file_pos) += sizeof (struct vms_eihi);
2932 bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
2933 bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
2938 /* Set module name. */
2939 module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2940 len = strlen (module);
2941 if (len > sizeof (eihi->imgnam) - 1)
2942 len = sizeof (eihi->imgnam) - 1;
2943 eihi->imgnam[0] = len;
2944 memcpy (eihi->imgnam + 1, module, len);
2952 vms_get_time (&hi, &lo);
2953 bfd_putl32 (lo, eihi->linktime + 0);
2954 bfd_putl32 (hi, eihi->linktime + 4);
2957 eihi->linkid[0] = 0;
2958 eihi->imgbid[0] = 0;
2961 dst = PRIV (dst_section);
2962 dmt = bfd_get_section_by_name (abfd, "$DMT$");
2963 if (dst != NULL && dst->size != 0)
2965 eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
2966 bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
2967 PRIV (file_pos) += sizeof (struct vms_eihs);
2969 bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
2970 bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
2971 bfd_putl32 (0, eihs->dstvbn);
2972 bfd_putl32 (0, eihs->dstsize);
2973 bfd_putl32 (0, eihs->gstvbn);
2974 bfd_putl32 (0, eihs->gstsize);
2975 bfd_putl32 (0, eihs->dmtvbn);
2976 bfd_putl32 (0, eihs->dmtsize);
2979 /* One EISD per section. */
2980 for (sec = abfd->sections; sec; sec = sec->next)
2982 if (!alpha_vms_create_eisd_for_section (abfd, sec))
2986 /* Merge section EIDS which extra ones. */
2987 if (PRIV (eisd_tail))
2988 PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
2990 PRIV (eisd_head) = PRIV (gbl_eisd_head);
2991 if (PRIV (gbl_eisd_tail))
2992 PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
2994 first_eisd = PRIV (eisd_head);
2996 /* Add end of eisd. */
2999 eisd = bfd_zalloc (abfd, sizeof (*eisd));
3002 eisd->u.eisd.majorid = 0;
3003 eisd->u.eisd.minorid = 0;
3004 eisd->u.eisd.eisdsize = 0;
3005 alpha_vms_append_extra_eisd (abfd, eisd);
3008 /* Place EISD in the file. */
3009 for (eisd = first_eisd; eisd; eisd = eisd->next)
3011 file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
3013 /* First block is a little bit special: there is a word at the end. */
3014 if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
3016 if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
3017 alpha_vms_file_position_block (abfd);
3019 eisd->file_pos = PRIV (file_pos);
3020 PRIV (file_pos) += eisd->u.eisd.eisdsize;
3022 if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
3023 bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
3026 if (first_eisd != NULL)
3028 bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
3029 /* Real size of end of eisd marker. */
3030 PRIV (file_pos) += EISD__K_LENEND;
3033 bfd_putl32 (PRIV (file_pos), eihd.size);
3034 bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
3037 /* Place sections. */
3038 for (sec = abfd->sections; sec; sec = sec->next)
3040 if (!(sec->flags & SEC_HAS_CONTENTS))
3043 eisd = vms_section_data (sec)->eisd;
3045 /* Align on a block. */
3046 alpha_vms_file_position_block (abfd);
3047 sec->filepos = PRIV (file_pos);
3050 eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
3052 PRIV (file_pos) += sec->size;
3056 if (eihs != NULL && dst != NULL)
3058 bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
3059 bfd_putl32 (dst->size, eihs->dstsize);
3063 lnkflags |= EIHD__M_DBGDMT;
3064 bfd_putl32 ((dmt->filepos / VMS_BLOCK_SIZE) + 1, eihs->dmtvbn);
3065 bfd_putl32 (dmt->size, eihs->dmtsize);
3067 if (PRIV (gsd_sym_count) != 0)
3069 alpha_vms_file_position_block (abfd);
3070 gst_filepos = PRIV (file_pos);
3071 bfd_putl32 ((gst_filepos / VMS_BLOCK_SIZE) + 1, eihs->gstvbn);
3072 bfd_putl32 ((PRIV (gsd_sym_count) + 4) / 5 + 4, eihs->gstsize);
3076 /* Write EISD in hdr. */
3077 for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
3079 alpha_vms_swap_eisd_out
3080 (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
3082 /* Write first block. */
3083 bfd_putl32 (lnkflags, eihd.lnkflags);
3084 if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
3087 /* Write remaining eisd. */
3090 unsigned char blk[VMS_BLOCK_SIZE];
3091 struct vms_internal_eisd_map *next_eisd;
3093 memset (blk, 0xff, sizeof (blk));
3094 while (eisd != NULL)
3096 alpha_vms_swap_eisd_out
3098 (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
3100 next_eisd = eisd->next;
3101 if (next_eisd == NULL
3102 || (next_eisd->file_pos / VMS_BLOCK_SIZE
3103 != eisd->file_pos / VMS_BLOCK_SIZE))
3105 if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
3108 memset (blk, 0xff, sizeof (blk));
3114 /* Write sections. */
3115 for (sec = abfd->sections; sec; sec = sec->next)
3117 unsigned char blk[VMS_BLOCK_SIZE];
3120 if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
3122 if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
3126 len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
3127 if (len != VMS_BLOCK_SIZE)
3129 memset (blk, 0, len);
3130 if (bfd_bwrite (blk, len, abfd) != len)
3136 if (gst_filepos != 0)
3138 struct vms_rec_wr *recwr = &PRIV (recwr);
3141 _bfd_vms_write_emh (abfd);
3142 _bfd_vms_write_lmn (abfd, "GNU LD");
3144 /* PSC for the absolute section. */
3145 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3146 _bfd_vms_output_long (recwr, 0);
3147 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3148 _bfd_vms_output_short (recwr, 0);
3149 _bfd_vms_output_short (recwr, EGPS__V_PIC | EGPS__V_LIB | EGPS__V_RD);
3150 _bfd_vms_output_long (recwr, 0);
3151 _bfd_vms_output_counted (recwr, ".$$ABS$$.");
3152 _bfd_vms_output_end_subrec (recwr);
3153 _bfd_vms_output_end (abfd, recwr);
3155 for (i = 0; i < PRIV (gsd_sym_count); i++)
3157 struct vms_symbol_entry *sym = PRIV (syms)[i];
3163 _bfd_vms_output_alignment (recwr, 8);
3164 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3165 _bfd_vms_output_long (recwr, 0);
3167 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYMG);
3168 _bfd_vms_output_short (recwr, 0); /* Data type, alignment. */
3169 _bfd_vms_output_short (recwr, sym->flags);
3171 if (sym->code_section)
3172 ep = alpha_vms_get_sym_value (sym->code_section, sym->code_value);
3175 BFD_ASSERT (sym->code_value == 0);
3178 val = alpha_vms_get_sym_value (sym->section, sym->value);
3179 _bfd_vms_output_quad
3180 (recwr, sym->typ == EGSD__C_SYMG ? sym->symbol_vector : val);
3181 _bfd_vms_output_quad (recwr, ep);
3182 _bfd_vms_output_quad (recwr, val);
3183 _bfd_vms_output_long (recwr, 0);
3184 _bfd_vms_output_counted (recwr, sym->name);
3185 _bfd_vms_output_end_subrec (recwr);
3187 _bfd_vms_output_end (abfd, recwr);
3190 _bfd_vms_output_end (abfd, recwr);
3192 if (!_bfd_vms_write_eeom (abfd))
3200 /* Write section and symbol directory of bfd abfd. Return FALSE on error. */
3203 _bfd_vms_write_egsd (bfd *abfd)
3207 unsigned int symnum;
3209 flagword new_flags, old_flags;
3210 int abs_section_index = -1;
3211 unsigned int target_index = 0;
3212 struct vms_rec_wr *recwr = &PRIV (recwr);
3214 vms_debug2 ((2, "vms_write_egsd\n"));
3216 /* Egsd is quadword aligned. */
3217 _bfd_vms_output_alignment (recwr, 8);
3219 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3220 _bfd_vms_output_long (recwr, 0);
3222 /* Number sections. */
3223 for (section = abfd->sections; section != NULL; section = section->next)
3225 if (section->flags & SEC_DEBUGGING)
3227 if (!strcmp (section->name, ".vmsdebug"))
3229 section->flags |= SEC_DEBUGGING;
3232 section->target_index = target_index++;
3235 for (section = abfd->sections; section != NULL; section = section->next)
3237 vms_debug2 ((3, "Section #%d %s, %d bytes\n",
3238 section->target_index, section->name, (int)section->size));
3240 /* Don't write out the VMS debug info section since it is in the
3241 ETBT and EDBG sections in etir. */
3242 if (section->flags & SEC_DEBUGGING)
3245 /* 13 bytes egsd, max 31 chars name -> should be 44 bytes. */
3246 if (_bfd_vms_output_check (recwr, 64) < 0)
3248 _bfd_vms_output_end (abfd, recwr);
3249 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3250 _bfd_vms_output_long (recwr, 0);
3253 /* Don't know if this is necessary for the linker but for now it keeps
3254 vms_slurp_gsd happy. */
3255 sname = section->name;
3258 /* Remove leading dot. */
3260 if ((*sname == 't') && (strcmp (sname, "text") == 0))
3261 sname = EVAX_CODE_NAME;
3262 else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
3263 sname = EVAX_DATA_NAME;
3264 else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
3265 sname = EVAX_BSS_NAME;
3266 else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
3267 sname = EVAX_LINK_NAME;
3268 else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
3269 sname = EVAX_READONLY_NAME;
3270 else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
3271 sname = EVAX_LITERAL_NAME;
3272 else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
3273 sname = EVAX_LITERALS_NAME;
3274 else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
3275 sname = EVAX_COMMON_NAME;
3276 else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
3277 sname = EVAX_LOCAL_NAME;
3280 if (bfd_is_com_section (section))
3281 new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
3282 | EGPS__V_WRT | EGPS__V_NOMOD | EGPS__V_COM);
3284 new_flags = vms_esecflag_by_name (evax_section_flags, sname,
3287 /* Modify them as directed. */
3288 if (section->flags & SEC_READONLY)
3289 new_flags &= ~EGPS__V_WRT;
3291 new_flags &= ~vms_section_data (section)->no_flags;
3292 new_flags |= vms_section_data (section)->flags;
3294 vms_debug2 ((3, "sec flags %x\n", section->flags));
3295 vms_debug2 ((3, "new_flags %x, _raw_size %lu\n",
3296 new_flags, (unsigned long)section->size));
3298 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3299 _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
3300 _bfd_vms_output_short (recwr, new_flags);
3301 _bfd_vms_output_long (recwr, (unsigned long) section->size);
3302 _bfd_vms_output_counted (recwr, sname);
3303 _bfd_vms_output_end_subrec (recwr);
3305 /* If the section is an obsolute one, remind its index as it will be
3306 used later for absolute symbols. */
3307 if ((new_flags & EGPS__V_REL) == 0 && abs_section_index < 0)
3308 abs_section_index = section->target_index;
3311 /* Output symbols. */
3312 vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
3314 bfd_set_start_address (abfd, (bfd_vma) -1);
3316 for (symnum = 0; symnum < abfd->symcount; symnum++)
3318 symbol = abfd->outsymbols[symnum];
3319 old_flags = symbol->flags;
3321 /* Work-around a missing feature: consider __main as the main entry
3323 if (symbol->name[0] == '_' && strcmp (symbol->name, "__main") == 0)
3324 bfd_set_start_address (abfd, (bfd_vma)symbol->value);
3326 /* Only put in the GSD the global and the undefined symbols. */
3327 if (old_flags & BSF_FILE)
3330 if ((old_flags & BSF_GLOBAL) == 0 && !bfd_is_und_section (symbol->section))
3332 /* If the LIB$INITIIALIZE section is present, add a reference to
3333 LIB$INITIALIZE symbol. FIXME: this should be done explicitely
3334 in the assembly file. */
3335 if (!((old_flags & BSF_SECTION_SYM) != 0
3336 && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
3340 /* 13 bytes egsd, max 64 chars name -> should be 77 bytes. Add 16 more
3341 bytes for a possible ABS section. */
3342 if (_bfd_vms_output_check (recwr, 80 + 16) < 0)
3344 _bfd_vms_output_end (abfd, recwr);
3345 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3346 _bfd_vms_output_long (recwr, 0);
3349 if ((old_flags & BSF_GLOBAL) != 0
3350 && bfd_is_abs_section (symbol->section)
3351 && abs_section_index <= 0)
3353 /* Create an absolute section if none was defined. It is highly
3354 unlikely that the name $ABS$ clashes with a user defined
3355 non-absolute section name. */
3356 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3357 _bfd_vms_output_short (recwr, 4);
3358 _bfd_vms_output_short (recwr, EGPS__V_SHR);
3359 _bfd_vms_output_long (recwr, 0);
3360 _bfd_vms_output_counted (recwr, "$ABS$");
3361 _bfd_vms_output_end_subrec (recwr);
3363 abs_section_index = target_index++;
3366 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
3368 /* Data type, alignment. */
3369 _bfd_vms_output_short (recwr, 0);
3373 if (old_flags & BSF_WEAK)
3374 new_flags |= EGSY__V_WEAK;
3375 if (bfd_is_com_section (symbol->section)) /* .comm */
3376 new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
3378 if (old_flags & BSF_FUNCTION)
3380 new_flags |= EGSY__V_NORM;
3381 new_flags |= EGSY__V_REL;
3383 if (old_flags & BSF_GLOBAL)
3385 new_flags |= EGSY__V_DEF;
3386 if (!bfd_is_abs_section (symbol->section))
3387 new_flags |= EGSY__V_REL;
3389 _bfd_vms_output_short (recwr, new_flags);
3391 if (old_flags & BSF_GLOBAL)
3393 /* Symbol definition. */
3394 bfd_vma code_address = 0;
3395 unsigned long ca_psindx = 0;
3396 unsigned long psindx;
3398 if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
3403 ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
3404 code_address = sym->value;
3405 ca_psindx = sym->section->target_index;
3407 if (bfd_is_abs_section (symbol->section))
3408 psindx = abs_section_index;
3410 psindx = symbol->section->target_index;
3412 _bfd_vms_output_quad (recwr, symbol->value);
3413 _bfd_vms_output_quad (recwr, code_address);
3414 _bfd_vms_output_long (recwr, ca_psindx);
3415 _bfd_vms_output_long (recwr, psindx);
3417 _bfd_vms_output_counted (recwr, symbol->name);
3419 _bfd_vms_output_end_subrec (recwr);
3422 _bfd_vms_output_alignment (recwr, 8);
3423 _bfd_vms_output_end (abfd, recwr);
3428 /* Write object header for bfd abfd. Return FALSE on error. */
3431 _bfd_vms_write_ehdr (bfd *abfd)
3434 unsigned int symnum;
3435 struct vms_rec_wr *recwr = &PRIV (recwr);
3437 vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
3439 _bfd_vms_output_alignment (recwr, 2);
3441 _bfd_vms_write_emh (abfd);
3442 _bfd_vms_write_lmn (abfd, "GNU AS");
3445 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3446 _bfd_vms_output_short (recwr, EMH__C_SRC);
3448 for (symnum = 0; symnum < abfd->symcount; symnum++)
3450 symbol = abfd->outsymbols[symnum];
3452 if (symbol->flags & BSF_FILE)
3454 _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
3455 (int) strlen (symbol->name));
3460 if (symnum == abfd->symcount)
3461 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
3463 _bfd_vms_output_end (abfd, recwr);
3466 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3467 _bfd_vms_output_short (recwr, EMH__C_TTL);
3468 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
3469 _bfd_vms_output_end (abfd, recwr);
3472 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3473 _bfd_vms_output_short (recwr, EMH__C_CPR);
3474 _bfd_vms_output_dump (recwr,
3475 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
3477 _bfd_vms_output_end (abfd, recwr);
3482 /* Part 4.6, relocations. */
3485 /* WRITE ETIR SECTION
3487 This is still under construction and therefore not documented. */
3489 /* Close the etir/etbt record. */
3492 end_etir_record (bfd * abfd)
3494 struct vms_rec_wr *recwr = &PRIV (recwr);
3496 _bfd_vms_output_end (abfd, recwr);
3500 start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
3502 struct vms_rec_wr *recwr = &PRIV (recwr);
3504 if (section->flags & SEC_DEBUGGING)
3506 _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
3510 /* Push start offset. */
3511 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3512 _bfd_vms_output_long (recwr, (unsigned long) 0);
3513 _bfd_vms_output_end_subrec (recwr);
3516 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
3517 _bfd_vms_output_end_subrec (recwr);
3522 _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
3526 /* Push start offset. */
3527 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3528 _bfd_vms_output_long (recwr, (unsigned long) section->target_index);
3529 _bfd_vms_output_quad (recwr, offset);
3530 _bfd_vms_output_end_subrec (recwr);
3532 /* Start = pop (). */
3533 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
3534 _bfd_vms_output_end_subrec (recwr);
3539 /* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
3540 address VADDR in section specified by SEC_INDEX and NAME. */
3543 sto_imm (bfd *abfd, asection *section,
3544 bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
3547 struct vms_rec_wr *recwr = &PRIV (recwr);
3550 _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
3551 _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
3556 /* Try all the rest. */
3559 if (_bfd_vms_output_check (recwr, size) < 0)
3561 /* Doesn't fit, split ! */
3562 end_etir_record (abfd);
3564 start_etir_or_etbt_record (abfd, section, vaddr);
3566 size = _bfd_vms_output_check (recwr, 0); /* get max size */
3567 if (size > ssize) /* more than what's left ? */
3571 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
3572 _bfd_vms_output_long (recwr, (unsigned long) (size));
3573 _bfd_vms_output_dump (recwr, cptr, size);
3574 _bfd_vms_output_end_subrec (recwr);
3577 _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
3578 _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
3588 etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
3590 if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
3592 /* Not enough room in this record. Close it and open a new one. */
3593 end_etir_record (abfd);
3594 start_etir_or_etbt_record (abfd, section, vaddr);
3598 /* Return whether RELOC must be deferred till the end. */
3601 defer_reloc_p (arelent *reloc)
3603 switch (reloc->howto->type)
3616 /* Write section contents for bfd abfd. Return FALSE on error. */
3619 _bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
3622 struct vms_rec_wr *recwr = &PRIV (recwr);
3624 vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
3626 _bfd_vms_output_alignment (recwr, 4);
3628 PRIV (vms_linkage_index) = 0;
3630 for (section = abfd->sections; section; section = section->next)
3632 vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
3633 section->target_index, section->name, (int) (section->size)));
3635 if (!(section->flags & SEC_HAS_CONTENTS)
3636 || bfd_is_com_section (section))
3639 if (!section->contents)
3641 bfd_set_error (bfd_error_no_contents);
3645 start_etir_or_etbt_record (abfd, section, 0);
3647 if (section->flags & SEC_RELOC)
3649 bfd_vma curr_addr = 0;
3650 unsigned char *curr_data = section->contents;
3652 int pass2_needed = 0;
3653 int pass2_in_progress = 0;
3656 if (section->reloc_count == 0)
3657 (*_bfd_error_handler)
3658 (_("SEC_RELOC with no relocs in section %s"), section->name);
3663 int i = section->reloc_count;
3664 arelent **rptr = section->orelocation;
3665 _bfd_vms_debug (4, "%d relocations:\n", i);
3668 _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
3669 "addr %08lx, off %08lx, len %d: %s\n",
3670 (*(*rptr)->sym_ptr_ptr)->name,
3671 (*(*rptr)->sym_ptr_ptr)->section->name,
3672 (long) (*(*rptr)->sym_ptr_ptr)->value,
3673 (unsigned long)(*rptr)->address,
3674 (unsigned long)(*rptr)->addend,
3675 bfd_get_reloc_size ((*rptr)->howto),
3676 ( *rptr)->howto->name);
3683 for (irel = 0; irel < section->reloc_count; irel++)
3685 struct evax_private_udata_struct *udata;
3686 arelent *rptr = section->orelocation [irel];
3687 bfd_vma addr = rptr->address;
3688 asymbol *sym = *rptr->sym_ptr_ptr;
3689 asection *sec = sym->section;
3690 bfd_boolean defer = defer_reloc_p (rptr);
3693 if (pass2_in_progress)
3695 /* Non-deferred relocs have already been output. */
3701 /* Deferred relocs must be output at the very end. */
3708 /* Regular relocs are intertwined with binary data. */
3709 if (curr_addr > addr)
3710 (*_bfd_error_handler) (_("Size error in section %s"),
3712 size = addr - curr_addr;
3713 sto_imm (abfd, section, size, curr_data, curr_addr);
3718 size = bfd_get_reloc_size (rptr->howto);
3720 switch (rptr->howto->type)
3722 case ALPHA_R_IGNORE:
3725 case ALPHA_R_REFLONG:
3726 if (bfd_is_und_section (sym->section))
3728 bfd_vma addend = rptr->addend;
3729 slen = strlen ((char *) sym->name);
3730 etir_output_check (abfd, section, curr_addr, slen);
3733 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3734 _bfd_vms_output_counted (recwr, sym->name);
3735 _bfd_vms_output_end_subrec (recwr);
3736 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3737 _bfd_vms_output_long (recwr, (unsigned long) addend);
3738 _bfd_vms_output_end_subrec (recwr);
3739 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3740 _bfd_vms_output_end_subrec (recwr);
3741 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3742 _bfd_vms_output_end_subrec (recwr);
3746 _bfd_vms_output_begin_subrec
3747 (recwr, ETIR__C_STO_GBL_LW);
3748 _bfd_vms_output_counted (recwr, sym->name);
3749 _bfd_vms_output_end_subrec (recwr);
3752 else if (bfd_is_abs_section (sym->section))
3754 etir_output_check (abfd, section, curr_addr, 16);
3755 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3756 _bfd_vms_output_long (recwr, (unsigned long) sym->value);
3757 _bfd_vms_output_end_subrec (recwr);
3758 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3759 _bfd_vms_output_end_subrec (recwr);
3763 etir_output_check (abfd, section, curr_addr, 32);
3764 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3765 _bfd_vms_output_long (recwr,
3766 (unsigned long) sec->target_index);
3767 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3768 _bfd_vms_output_end_subrec (recwr);
3769 /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
3770 says that we should have a ETIR__C_STO_OFF here.
3771 But the relocation would not be BFD_RELOC_32 then.
3772 This case is very likely unreachable. */
3773 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3774 _bfd_vms_output_end_subrec (recwr);
3778 case ALPHA_R_REFQUAD:
3779 if (bfd_is_und_section (sym->section))
3781 bfd_vma addend = rptr->addend;
3782 slen = strlen ((char *) sym->name);
3783 etir_output_check (abfd, section, curr_addr, slen);
3786 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3787 _bfd_vms_output_counted (recwr, sym->name);
3788 _bfd_vms_output_end_subrec (recwr);
3789 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3790 _bfd_vms_output_quad (recwr, addend);
3791 _bfd_vms_output_end_subrec (recwr);
3792 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3793 _bfd_vms_output_end_subrec (recwr);
3794 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3795 _bfd_vms_output_end_subrec (recwr);
3799 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
3800 _bfd_vms_output_counted (recwr, sym->name);
3801 _bfd_vms_output_end_subrec (recwr);
3804 else if (bfd_is_abs_section (sym->section))
3806 etir_output_check (abfd, section, curr_addr, 16);
3807 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3808 _bfd_vms_output_quad (recwr, sym->value);
3809 _bfd_vms_output_end_subrec (recwr);
3810 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3811 _bfd_vms_output_end_subrec (recwr);
3815 etir_output_check (abfd, section, curr_addr, 32);
3816 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3817 _bfd_vms_output_long (recwr,
3818 (unsigned long) sec->target_index);
3819 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3820 _bfd_vms_output_end_subrec (recwr);
3821 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
3822 _bfd_vms_output_end_subrec (recwr);
3827 sto_imm (abfd, section, size, curr_data, curr_addr);
3830 case ALPHA_R_LINKAGE:
3831 etir_output_check (abfd, section, curr_addr, 64);
3832 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
3833 _bfd_vms_output_long
3834 (recwr, (unsigned long) rptr->addend);
3835 if (rptr->addend > PRIV (vms_linkage_index))
3836 PRIV (vms_linkage_index) = rptr->addend;
3837 _bfd_vms_output_counted (recwr, sym->name);
3838 _bfd_vms_output_byte (recwr, 0);
3839 _bfd_vms_output_end_subrec (recwr);
3842 case ALPHA_R_CODEADDR:
3843 slen = strlen ((char *) sym->name);
3844 etir_output_check (abfd, section, curr_addr, slen);
3845 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
3846 _bfd_vms_output_counted (recwr, sym->name);
3847 _bfd_vms_output_end_subrec (recwr);
3852 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3853 etir_output_check (abfd, section, curr_addr,
3854 32 + 1 + strlen (udata->origname));
3855 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
3856 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3857 _bfd_vms_output_long
3858 (recwr, (unsigned long) section->target_index);
3859 _bfd_vms_output_quad (recwr, rptr->address);
3860 _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3861 _bfd_vms_output_long
3862 (recwr, (unsigned long) section->target_index);
3863 _bfd_vms_output_quad (recwr, rptr->addend);
3864 _bfd_vms_output_counted (recwr, udata->origname);
3865 _bfd_vms_output_end_subrec (recwr);
3869 (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3874 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3875 etir_output_check (abfd, section, curr_addr,
3876 32 + 1 + strlen (udata->origname));
3877 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
3878 _bfd_vms_output_long
3879 (recwr, (unsigned long) udata->lkindex + 1);
3880 _bfd_vms_output_long
3881 (recwr, (unsigned long) section->target_index);
3882 _bfd_vms_output_quad (recwr, rptr->address);
3883 _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
3884 _bfd_vms_output_long
3885 (recwr, (unsigned long) udata->bsym->section->target_index);
3886 _bfd_vms_output_quad (recwr, rptr->addend);
3887 _bfd_vms_output_counted (recwr, udata->origname);
3888 _bfd_vms_output_end_subrec (recwr);
3893 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3894 etir_output_check (abfd, section, curr_addr,
3895 32 + 1 + strlen (udata->origname));
3896 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
3897 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3898 _bfd_vms_output_long
3899 (recwr, (unsigned long) section->target_index);
3900 _bfd_vms_output_quad (recwr, rptr->address);
3901 _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
3902 _bfd_vms_output_long
3903 (recwr, (unsigned long) section->target_index);
3904 _bfd_vms_output_quad (recwr, rptr->addend);
3905 _bfd_vms_output_counted (recwr, udata->origname);
3906 _bfd_vms_output_end_subrec (recwr);
3910 (*_bfd_error_handler) (_("Unhandled relocation %s"),
3917 } /* End of relocs loop. */
3919 if (!pass2_in_progress)
3921 /* Output rest of section. */
3922 if (curr_addr > section->size)
3923 (*_bfd_error_handler) (_("Size error in section %s"),
3925 size = section->size - curr_addr;
3926 sto_imm (abfd, section, size, curr_data, curr_addr);
3932 pass2_in_progress = 1;
3938 else /* (section->flags & SEC_RELOC) */
3939 sto_imm (abfd, section, section->size, section->contents, 0);
3941 end_etir_record (abfd);
3944 _bfd_vms_output_alignment (recwr, 2);
3948 /* Write cached information into a file being written, at bfd_close. */
3951 alpha_vms_write_object_contents (bfd *abfd)
3953 vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
3955 if (abfd->flags & (EXEC_P | DYNAMIC))
3957 return alpha_vms_write_exec (abfd);
3961 if (abfd->section_count > 0) /* we have sections */
3963 if (_bfd_vms_write_ehdr (abfd) != TRUE)
3965 if (_bfd_vms_write_egsd (abfd) != TRUE)
3967 if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
3969 if (_bfd_vms_write_eeom (abfd) != TRUE)
3976 /* Debug stuff: nearest line. */
3978 #define SET_MODULE_PARSED(m) \
3979 do { if ((m)->name == NULL) (m)->name = ""; } while (0)
3980 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
3982 /* Build a new module for the specified BFD. */
3984 static struct module *
3985 new_module (bfd *abfd)
3987 struct module *module
3988 = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
3989 module->file_table_count = 16; /* Arbitrary. */
3991 = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
3995 /* Parse debug info for a module and internalize it. */
3998 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
4001 unsigned char *maxptr = ptr + length;
4002 unsigned char *src_ptr, *pcl_ptr;
4003 unsigned int prev_linum = 0, curr_linenum = 0;
4004 bfd_vma prev_pc = 0, curr_pc = 0;
4005 struct srecinfo *curr_srec, *srec;
4006 struct lineinfo *curr_line, *line;
4007 struct funcinfo *funcinfo;
4009 /* Initialize tables with zero element. */
4010 curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4011 module->srec_table = curr_srec;
4013 curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4014 module->line_table = curr_line;
4016 while (length == -1 || ptr < maxptr)
4018 /* The first byte is not counted in the recorded length. */
4019 int rec_length = bfd_getl16 (ptr) + 1;
4020 int rec_type = bfd_getl16 (ptr + 2);
4022 vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4024 if (length == -1 && rec_type == DST__K_MODEND)
4031 = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4038 vms_debug2 ((3, "module: %s\n", module->name));
4045 funcinfo = (struct funcinfo *)
4046 bfd_zalloc (abfd, sizeof (struct funcinfo));
4048 = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4049 funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4050 funcinfo->next = module->func_table;
4051 module->func_table = funcinfo;
4053 vms_debug2 ((3, "routine: %s at 0x%lx\n",
4054 funcinfo->name, (unsigned long) funcinfo->low));
4058 module->func_table->high = module->func_table->low
4059 + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4061 if (module->func_table->high > module->high)
4062 module->high = module->func_table->high;
4064 vms_debug2 ((3, "end routine\n"));
4068 vms_debug2 ((3, "prologue\n"));
4072 vms_debug2 ((3, "epilog\n"));
4076 vms_debug2 ((3, "block\n"));
4080 vms_debug2 ((3, "end block\n"));
4084 src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4086 vms_debug2 ((3, "source info\n"));
4088 while (src_ptr < ptr + rec_length)
4090 int cmd = src_ptr[0], cmd_length, data;
4094 case DST__K_SRC_DECLFILE:
4097 = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4099 = _bfd_vms_save_counted_string (src_ptr
4100 + DST_S_B_SRC_DF_FILENAME);
4102 while (fileid >= module->file_table_count)
4104 module->file_table_count *= 2;
4106 = bfd_realloc (module->file_table,
4107 module->file_table_count
4108 * sizeof (struct fileinfo));
4111 module->file_table [fileid].name = filename;
4112 module->file_table [fileid].srec = 1;
4113 cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4114 vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4115 fileid, module->file_table [fileid].name));
4119 case DST__K_SRC_DEFLINES_B:
4120 /* Perform the association and set the next higher index
4122 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4123 srec = (struct srecinfo *)
4124 bfd_zalloc (abfd, sizeof (struct srecinfo));
4125 srec->line = curr_srec->line + data;
4126 srec->srec = curr_srec->srec + data;
4127 srec->sfile = curr_srec->sfile;
4128 curr_srec->next = srec;
4131 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4134 case DST__K_SRC_DEFLINES_W:
4135 /* Perform the association and set the next higher index
4137 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4138 srec = (struct srecinfo *)
4139 bfd_zalloc (abfd, sizeof (struct srecinfo));
4140 srec->line = curr_srec->line + data;
4141 srec->srec = curr_srec->srec + data,
4142 srec->sfile = curr_srec->sfile;
4143 curr_srec->next = srec;
4146 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4149 case DST__K_SRC_INCRLNUM_B:
4150 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4151 curr_srec->line += data;
4153 vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4156 case DST__K_SRC_SETFILE:
4157 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4158 curr_srec->sfile = data;
4159 curr_srec->srec = module->file_table[data].srec;
4161 vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4164 case DST__K_SRC_SETLNUM_L:
4165 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4166 curr_srec->line = data;
4168 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4171 case DST__K_SRC_SETLNUM_W:
4172 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4173 curr_srec->line = data;
4175 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4178 case DST__K_SRC_SETREC_L:
4179 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4180 curr_srec->srec = data;
4181 module->file_table[curr_srec->sfile].srec = data;
4183 vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4186 case DST__K_SRC_SETREC_W:
4187 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4188 curr_srec->srec = data;
4189 module->file_table[curr_srec->sfile].srec = data;
4191 vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4194 case DST__K_SRC_FORMFEED:
4196 vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4200 (*_bfd_error_handler) (_("unknown source command %d"),
4206 src_ptr += cmd_length;
4210 case DST__K_LINE_NUM:
4211 pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4213 vms_debug2 ((3, "line info\n"));
4215 while (pcl_ptr < ptr + rec_length)
4217 /* The command byte is signed so we must sign-extend it. */
4218 int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4222 case DST__K_DELTA_PC_W:
4223 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4227 vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4230 case DST__K_DELTA_PC_L:
4231 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4235 vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4238 case DST__K_INCR_LINUM:
4239 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4240 curr_linenum += data;
4242 vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4245 case DST__K_INCR_LINUM_W:
4246 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4247 curr_linenum += data;
4249 vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4252 case DST__K_INCR_LINUM_L:
4253 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4254 curr_linenum += data;
4256 vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4259 case DST__K_SET_LINUM_INCR:
4260 (*_bfd_error_handler)
4261 (_("DST__K_SET_LINUM_INCR not implemented"));
4265 case DST__K_SET_LINUM_INCR_W:
4266 (*_bfd_error_handler)
4267 (_("DST__K_SET_LINUM_INCR_W not implemented"));
4271 case DST__K_RESET_LINUM_INCR:
4272 (*_bfd_error_handler)
4273 (_("DST__K_RESET_LINUM_INCR not implemented"));
4277 case DST__K_BEG_STMT_MODE:
4278 (*_bfd_error_handler)
4279 (_("DST__K_BEG_STMT_MODE not implemented"));
4283 case DST__K_END_STMT_MODE:
4284 (*_bfd_error_handler)
4285 (_("DST__K_END_STMT_MODE not implemented"));
4289 case DST__K_SET_LINUM_B:
4290 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4291 curr_linenum = data;
4293 vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4296 case DST__K_SET_LINUM:
4297 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4298 curr_linenum = data;
4300 vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4303 case DST__K_SET_LINUM_L:
4304 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4305 curr_linenum = data;
4307 vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4311 (*_bfd_error_handler)
4312 (_("DST__K_SET_PC not implemented"));
4316 case DST__K_SET_PC_W:
4317 (*_bfd_error_handler)
4318 (_("DST__K_SET_PC_W not implemented"));
4322 case DST__K_SET_PC_L:
4323 (*_bfd_error_handler)
4324 (_("DST__K_SET_PC_L not implemented"));
4328 case DST__K_SET_STMTNUM:
4329 (*_bfd_error_handler)
4330 (_("DST__K_SET_STMTNUM not implemented"));
4335 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4338 vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4342 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4345 vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4349 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4352 vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
4355 case DST__K_SET_ABS_PC:
4356 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4359 vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4368 vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4369 (unsigned long)curr_pc, curr_linenum));
4373 (*_bfd_error_handler) (_("unknown line command %d"),
4380 if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4382 || cmd == DST__K_DELTA_PC_L
4383 || cmd == DST__K_DELTA_PC_W)
4385 line = (struct lineinfo *)
4386 bfd_zalloc (abfd, sizeof (struct lineinfo));
4387 line->address = curr_pc;
4388 line->line = curr_linenum;
4390 curr_line->next = line;
4393 prev_linum = curr_linenum;
4395 vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4396 (unsigned long)curr_pc, curr_linenum));
4399 pcl_ptr += cmd_length;
4403 case 0x17: /* Undocumented type used by DEC C to declare equates. */
4404 vms_debug2 ((3, "undocumented type 0x17\n"));
4408 vms_debug2 ((3, "ignoring record\n"));
4416 /* Finalize tables with EOL marker. */
4417 srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4418 srec->line = (unsigned int) -1;
4419 srec->srec = (unsigned int) -1;
4420 curr_srec->next = srec;
4422 line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4423 line->line = (unsigned int) -1;
4424 line->address = (bfd_vma) -1;
4425 curr_line->next = line;
4427 /* Advertise that this module has been parsed. This is needed
4428 because parsing can be either performed at module creation
4429 or deferred until debug info is consumed. */
4430 SET_MODULE_PARSED (module);
4433 /* Build the list of modules for the specified BFD. */
4435 static struct module *
4436 build_module_list (bfd *abfd)
4438 struct module *module, *list = NULL;
4441 if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4443 /* We have a DMT section so this must be an image. Parse the
4444 section and build the list of modules. This is sufficient
4445 since we can compute the start address and the end address
4446 of every module from the section contents. */
4447 bfd_size_type size = bfd_get_section_size (dmt);
4448 unsigned char *ptr, *end;
4450 ptr = (unsigned char *) bfd_alloc (abfd, size);
4454 if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4457 vms_debug2 ((2, "DMT\n"));
4463 /* Each header declares a module with its start offset and size
4464 of debug info in the DST section, as well as the count of
4465 program sections (i.e. address spans) it contains. */
4466 int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4467 int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4468 int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4469 ptr += DBG_S_C_DMT_HEADER_SIZE;
4471 vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4472 modbeg, msize, count));
4474 /* We create a 'module' structure for each program section since
4475 we only support contiguous addresses in a 'module' structure.
4476 As a consequence, the actual debug info in the DST section is
4477 shared and can be parsed multiple times; that doesn't seem to
4478 cause problems in practice. */
4481 int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4482 int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4483 module = new_module (abfd);
4484 module->modbeg = modbeg;
4485 module->size = msize;
4486 module->low = start;
4487 module->high = start + length;
4488 module->next = list;
4490 ptr += DBG_S_C_DMT_PSECT_SIZE;
4492 vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4499 /* We don't have a DMT section so this must be an object. Parse
4500 the module right now in order to compute its start address and
4502 void *dst = PRIV (dst_section)->contents;
4507 module = new_module (abfd);
4508 parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4515 /* Calculate and return the name of the source file and the line nearest
4516 to the wanted location in the specified module. */
4519 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4520 const char **file, const char **func,
4523 struct funcinfo *funcinfo;
4524 struct lineinfo *lineinfo;
4525 struct srecinfo *srecinfo;
4526 bfd_boolean ret = FALSE;
4528 /* Parse this module if that was not done at module creation. */
4529 if (! IS_MODULE_PARSED (module))
4531 unsigned int size = module->size;
4532 unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4533 unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4535 if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4536 || bfd_bread (buffer, size, abfd) != size)
4538 bfd_set_error (bfd_error_no_debug_section);
4542 parse_module (abfd, module, buffer, size);
4546 /* Find out the function (if any) that contains the address. */
4547 for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4548 if (addr >= funcinfo->low && addr <= funcinfo->high)
4550 *func = funcinfo->name;
4555 /* Find out the source file and the line nearest to the address. */
4556 for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4557 if (lineinfo->next && addr < lineinfo->next->address)
4559 for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4560 if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4562 if (srecinfo->sfile > 0)
4564 *file = module->file_table[srecinfo->sfile].name;
4565 *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4569 *file = module->name;
4570 *line = lineinfo->line;
4581 /* Provided a BFD, a section and an offset into the section, calculate and
4582 return the name of the source file and the line nearest to the wanted
4586 _bfd_vms_find_nearest_line (bfd *abfd,
4587 asymbol **symbols ATTRIBUTE_UNUSED,
4593 unsigned int *discriminator)
4595 struct module *module;
4597 /* What address are we looking for? */
4598 bfd_vma addr = section->vma + offset;
4606 /* We can't do anything if there is no DST (debug symbol table). */
4607 if (PRIV (dst_section) == NULL)
4610 /* Create the module list - if not already done. */
4611 if (PRIV (modules) == NULL)
4613 PRIV (modules) = build_module_list (abfd);
4614 if (PRIV (modules) == NULL)
4618 for (module = PRIV (modules); module; module = module->next)
4619 if (addr >= module->low && addr <= module->high)
4620 return module_find_nearest_line (abfd, module, addr, file, func, line);
4625 /* Canonicalizations. */
4626 /* Set name, value, section and flags of SYM from E. */
4629 alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4638 flags = BSF_NO_FLAGS;
4644 if (e->flags & EGSY__V_WEAK)
4647 if (e->flags & EGSY__V_DEF)
4649 /* Symbol definition. */
4650 flags |= BSF_GLOBAL;
4651 if (e->flags & EGSY__V_NORM)
4652 flags |= BSF_FUNCTION;
4658 /* Symbol reference. */
4659 sec = bfd_und_section_ptr;
4664 /* A universal symbol is by definition global... */
4665 flags |= BSF_GLOBAL;
4667 /* ...and dynamic in shared libraries. */
4668 if (abfd->flags & DYNAMIC)
4669 flags |= BSF_DYNAMIC;
4671 if (e->flags & EGSY__V_WEAK)
4674 if (!(e->flags & EGSY__V_DEF))
4677 if (e->flags & EGSY__V_NORM)
4678 flags |= BSF_FUNCTION;
4681 /* sec = e->section; */
4682 sec = bfd_abs_section_ptr;
4697 /* Return the number of bytes required to store a vector of pointers
4698 to asymbols for all the symbols in the BFD abfd, including a
4699 terminal NULL pointer. If there are no symbols in the BFD,
4700 then return 0. If an error occurs, return -1. */
4703 alpha_vms_get_symtab_upper_bound (bfd *abfd)
4705 vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4706 abfd, PRIV (gsd_sym_count)));
4708 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4711 /* Read the symbols from the BFD abfd, and fills in the vector
4712 location with pointers to the symbols and a trailing NULL.
4714 Return number of symbols read. */
4717 alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4721 vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4723 if (PRIV (csymbols) == NULL)
4725 PRIV (csymbols) = (asymbol **) bfd_alloc
4726 (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4728 /* Traverse table and fill symbols vector. */
4729 for (i = 0; i < PRIV (gsd_sym_count); i++)
4731 struct vms_symbol_entry *e = PRIV (syms)[i];
4734 sym = bfd_make_empty_symbol (abfd);
4735 if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4737 bfd_release (abfd, PRIV (csymbols));
4738 PRIV (csymbols) = NULL;
4742 PRIV (csymbols)[i] = sym;
4746 if (symbols != NULL)
4748 for (i = 0; i < PRIV (gsd_sym_count); i++)
4749 symbols[i] = PRIV (csymbols)[i];
4753 return PRIV (gsd_sym_count);
4756 /* Read and convert relocations from ETIR. We do it once for all sections. */
4759 alpha_vms_slurp_relocs (bfd *abfd)
4763 vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4765 /* We slurp relocs only once, for all sections. */
4766 if (PRIV (reloc_done))
4768 PRIV (reloc_done) = TRUE;
4770 if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4773 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4778 unsigned char *begin;
4781 bfd_reloc_code_real_type reloc_code;
4787 bfd_vma cur_address;
4789 unsigned char *cur_sym = NULL;
4791 bfd_vma cur_addend = 0;
4793 /* Skip non-ETIR records. */
4794 type = _bfd_vms_get_object_record (abfd);
4795 if (type == EOBJ__C_EEOM)
4797 if (type != EOBJ__C_ETIR)
4800 begin = PRIV (recrd.rec) + 4;
4801 end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4803 for (ptr = begin; ptr < end; ptr += length)
4807 cmd = bfd_getl16 (ptr);
4808 length = bfd_getl16 (ptr + 2);
4810 cur_address = vaddr;
4812 vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4813 _bfd_vms_etir_name (cmd)));
4817 case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4818 /* ALPHA_R_REFQUAD und_section, step 1 */
4823 case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4824 cur_psidx = bfd_getl32 (ptr + 4);
4825 cur_addend = bfd_getl64 (ptr + 8);
4829 case ETIR__C_CTL_SETRB:
4830 if (prev_cmd != ETIR__C_STA_PQ)
4832 (*_bfd_error_handler)
4833 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4834 _bfd_vms_etir_name (cmd));
4837 cur_psect = cur_psidx;
4843 case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4844 /* ALPHA_R_REFLONG und_section, step 2 */
4847 if (prev_cmd != ETIR__C_STA_GBL)
4849 (*_bfd_error_handler)
4850 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4851 _bfd_vms_etir_name (ETIR__C_STA_LW));
4855 cur_addend = bfd_getl32 (ptr + 4);
4859 case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4860 /* ALPHA_R_REFQUAD und_section, step 2 */
4861 if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4863 (*_bfd_error_handler)
4864 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4865 _bfd_vms_etir_name (ETIR__C_STA_QW));
4868 cur_addend = bfd_getl64 (ptr + 4);
4872 case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4873 /* ALPHA_R_REFLONG abs_section, step 2 */
4874 /* ALPHA_R_REFLONG others, step 2 */
4875 if (prev_cmd != ETIR__C_OPR_ADD
4876 && prev_cmd != ETIR__C_STA_LW
4877 && prev_cmd != ETIR__C_STA_PQ)
4879 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4880 _bfd_vms_etir_name (prev_cmd),
4881 _bfd_vms_etir_name (ETIR__C_STO_LW));
4884 reloc_code = BFD_RELOC_32;
4887 case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
4888 /* ALPHA_R_REFQUAD abs_section, step 2 */
4889 if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
4891 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4892 _bfd_vms_etir_name (prev_cmd),
4893 _bfd_vms_etir_name (ETIR__C_STO_QW));
4896 reloc_code = BFD_RELOC_64;
4899 case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
4900 if (prev_cmd != ETIR__C_STA_PQ)
4902 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4903 _bfd_vms_etir_name (prev_cmd),
4904 _bfd_vms_etir_name (ETIR__C_STO_OFF));
4907 reloc_code = BFD_RELOC_64;
4910 case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
4911 /* ALPHA_R_REFQUAD und_section, step 3 */
4912 if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
4914 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4915 _bfd_vms_etir_name (prev_cmd),
4916 _bfd_vms_etir_name (ETIR__C_OPR_ADD));
4919 prev_cmd = ETIR__C_OPR_ADD;
4922 case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
4923 reloc_code = BFD_RELOC_ALPHA_CODEADDR;
4927 case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
4928 reloc_code = BFD_RELOC_64;
4932 case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
4933 reloc_code = BFD_RELOC_32;
4937 case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
4938 reloc_code = BFD_RELOC_ALPHA_LINKAGE;
4942 case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
4943 reloc_code = BFD_RELOC_ALPHA_NOP;
4946 case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
4947 reloc_code = BFD_RELOC_ALPHA_BSR;
4950 case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
4951 reloc_code = BFD_RELOC_ALPHA_LDA;
4954 case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
4955 reloc_code = BFD_RELOC_ALPHA_BOH;
4959 cur_sym = ptr + 4 + 32;
4960 cur_address = bfd_getl64 (ptr + 4 + 8);
4961 cur_addend = bfd_getl64 (ptr + 4 + 24);
4964 case ETIR__C_STO_IMM:
4965 vaddr += bfd_getl32 (ptr + 4);
4969 (*_bfd_error_handler) (_("Unknown reloc %s"),
4970 _bfd_vms_etir_name (cmd));
4976 struct vms_section_data_struct *vms_sec;
4979 /* Get section to which the relocation applies. */
4980 if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
4982 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
4986 sec = PRIV (sections)[cur_psect];
4987 if (sec == bfd_abs_section_ptr)
4989 (*_bfd_error_handler) (_("Relocation for non-REL psect"));
4993 vms_sec = vms_section_data (sec);
4995 /* Allocate a reloc entry. */
4996 if (sec->reloc_count >= vms_sec->reloc_max)
4998 if (vms_sec->reloc_max == 0)
5000 vms_sec->reloc_max = 64;
5001 sec->relocation = bfd_zmalloc
5002 (vms_sec->reloc_max * sizeof (arelent));
5006 vms_sec->reloc_max *= 2;
5007 sec->relocation = bfd_realloc
5008 (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5011 reloc = &sec->relocation[sec->reloc_count];
5014 reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5016 if (cur_sym != NULL)
5019 unsigned int symlen = *cur_sym;
5022 /* Linear search. */
5027 for (j = 0; j < PRIV (gsd_sym_count); j++)
5028 if (PRIV (syms)[j]->namelen == symlen
5029 && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5031 sym = &PRIV (csymbols)[j];
5036 (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5037 _bfd_vms_etir_name (cmd));
5038 reloc->sym_ptr_ptr = NULL;
5041 reloc->sym_ptr_ptr = sym;
5043 else if (cur_psidx >= 0)
5044 reloc->sym_ptr_ptr =
5045 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5047 reloc->sym_ptr_ptr = NULL;
5049 reloc->address = cur_address;
5050 reloc->addend = cur_addend;
5052 vaddr += bfd_get_reloc_size (reloc->howto);
5061 vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5066 /* Return the number of bytes required to store the relocation
5067 information associated with the given section. */
5070 alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5072 alpha_vms_slurp_relocs (abfd);
5074 return (section->reloc_count + 1) * sizeof (arelent *);
5077 /* Convert relocations from VMS (external) form into BFD internal
5078 form. Return the number of relocations. */
5081 alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5082 asymbol **symbols ATTRIBUTE_UNUSED)
5087 if (!alpha_vms_slurp_relocs (abfd))
5090 count = section->reloc_count;
5091 tblptr = section->relocation;
5094 *relptr++ = tblptr++;
5096 *relptr = (arelent *) NULL;
5097 return section->reloc_count;
5100 /* This is just copied from ecoff-alpha, needs to be fixed probably. */
5102 /* How to process the various reloc types. */
5104 static bfd_reloc_status_type
5105 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5106 arelent *reloc ATTRIBUTE_UNUSED,
5107 asymbol *sym ATTRIBUTE_UNUSED,
5108 void * data ATTRIBUTE_UNUSED,
5109 asection *sec ATTRIBUTE_UNUSED,
5110 bfd *output_bfd ATTRIBUTE_UNUSED,
5111 char **error_message ATTRIBUTE_UNUSED)
5114 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5115 vms_debug (2, "In section %s, symbol %s\n",
5116 sec->name, sym->name);
5117 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5118 reloc->sym_ptr_ptr[0]->name,
5119 (unsigned long)reloc->address,
5120 (unsigned long)reloc->addend, reloc->howto->name);
5121 vms_debug (2, "data at %p\n", data);
5122 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5125 return bfd_reloc_ok;
5128 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5129 from smaller values. Start with zero, widen, *then* decrement. */
5130 #define MINUS_ONE (((bfd_vma)0) - 1)
5132 static reloc_howto_type alpha_howto_table[] =
5134 HOWTO (ALPHA_R_IGNORE, /* Type. */
5135 0, /* Rightshift. */
5136 0, /* Size (0 = byte, 1 = short, 2 = long). */
5138 TRUE, /* PC relative. */
5140 complain_overflow_dont,/* Complain_on_overflow. */
5141 reloc_nil, /* Special_function. */
5142 "IGNORE", /* Name. */
5143 TRUE, /* Partial_inplace. */
5144 0, /* Source mask */
5146 TRUE), /* PC rel offset. */
5148 /* A 64 bit reference to a symbol. */
5149 HOWTO (ALPHA_R_REFQUAD, /* Type. */
5150 0, /* Rightshift. */
5151 4, /* Size (0 = byte, 1 = short, 2 = long). */
5153 FALSE, /* PC relative. */
5155 complain_overflow_bitfield, /* Complain_on_overflow. */
5156 reloc_nil, /* Special_function. */
5157 "REFQUAD", /* Name. */
5158 TRUE, /* Partial_inplace. */
5159 MINUS_ONE, /* Source mask. */
5160 MINUS_ONE, /* Dest mask. */
5161 FALSE), /* PC rel offset. */
5163 /* A 21 bit branch. The native assembler generates these for
5164 branches within the text segment, and also fills in the PC
5165 relative offset in the instruction. */
5166 HOWTO (ALPHA_R_BRADDR, /* Type. */
5167 2, /* Rightshift. */
5168 2, /* Size (0 = byte, 1 = short, 2 = long). */
5170 TRUE, /* PC relative. */
5172 complain_overflow_signed, /* Complain_on_overflow. */
5173 reloc_nil, /* Special_function. */
5174 "BRADDR", /* Name. */
5175 TRUE, /* Partial_inplace. */
5176 0x1fffff, /* Source mask. */
5177 0x1fffff, /* Dest mask. */
5178 FALSE), /* PC rel offset. */
5180 /* A hint for a jump to a register. */
5181 HOWTO (ALPHA_R_HINT, /* Type. */
5182 2, /* Rightshift. */
5183 1, /* Size (0 = byte, 1 = short, 2 = long). */
5185 TRUE, /* PC relative. */
5187 complain_overflow_dont,/* Complain_on_overflow. */
5188 reloc_nil, /* Special_function. */
5190 TRUE, /* Partial_inplace. */
5191 0x3fff, /* Source mask. */
5192 0x3fff, /* Dest mask. */
5193 FALSE), /* PC rel offset. */
5195 /* 16 bit PC relative offset. */
5196 HOWTO (ALPHA_R_SREL16, /* Type. */
5197 0, /* Rightshift. */
5198 1, /* Size (0 = byte, 1 = short, 2 = long). */
5200 TRUE, /* PC relative. */
5202 complain_overflow_signed, /* Complain_on_overflow. */
5203 reloc_nil, /* Special_function. */
5204 "SREL16", /* Name. */
5205 TRUE, /* Partial_inplace. */
5206 0xffff, /* Source mask. */
5207 0xffff, /* Dest mask. */
5208 FALSE), /* PC rel offset. */
5210 /* 32 bit PC relative offset. */
5211 HOWTO (ALPHA_R_SREL32, /* Type. */
5212 0, /* Rightshift. */
5213 2, /* Size (0 = byte, 1 = short, 2 = long). */
5215 TRUE, /* PC relative. */
5217 complain_overflow_signed, /* Complain_on_overflow. */
5218 reloc_nil, /* Special_function. */
5219 "SREL32", /* Name. */
5220 TRUE, /* Partial_inplace. */
5221 0xffffffff, /* Source mask. */
5222 0xffffffff, /* Dest mask. */
5223 FALSE), /* PC rel offset. */
5225 /* A 64 bit PC relative offset. */
5226 HOWTO (ALPHA_R_SREL64, /* Type. */
5227 0, /* Rightshift. */
5228 4, /* Size (0 = byte, 1 = short, 2 = long). */
5230 TRUE, /* PC relative. */
5232 complain_overflow_signed, /* Complain_on_overflow. */
5233 reloc_nil, /* Special_function. */
5234 "SREL64", /* Name. */
5235 TRUE, /* Partial_inplace. */
5236 MINUS_ONE, /* Source mask. */
5237 MINUS_ONE, /* Dest mask. */
5238 FALSE), /* PC rel offset. */
5240 /* Push a value on the reloc evaluation stack. */
5241 HOWTO (ALPHA_R_OP_PUSH, /* Type. */
5242 0, /* Rightshift. */
5243 0, /* Size (0 = byte, 1 = short, 2 = long). */
5245 FALSE, /* PC relative. */
5247 complain_overflow_dont,/* Complain_on_overflow. */
5248 reloc_nil, /* Special_function. */
5249 "OP_PUSH", /* Name. */
5250 FALSE, /* Partial_inplace. */
5251 0, /* Source mask. */
5253 FALSE), /* PC rel offset. */
5255 /* Store the value from the stack at the given address. Store it in
5256 a bitfield of size r_size starting at bit position r_offset. */
5257 HOWTO (ALPHA_R_OP_STORE, /* Type. */
5258 0, /* Rightshift. */
5259 4, /* Size (0 = byte, 1 = short, 2 = long). */
5261 FALSE, /* PC relative. */
5263 complain_overflow_dont,/* Complain_on_overflow. */
5264 reloc_nil, /* Special_function. */
5265 "OP_STORE", /* Name. */
5266 FALSE, /* Partial_inplace. */
5267 0, /* Source mask. */
5268 MINUS_ONE, /* Dest mask. */
5269 FALSE), /* PC rel offset. */
5271 /* Subtract the reloc address from the value on the top of the
5272 relocation stack. */
5273 HOWTO (ALPHA_R_OP_PSUB, /* Type. */
5274 0, /* Rightshift. */
5275 0, /* Size (0 = byte, 1 = short, 2 = long). */
5277 FALSE, /* PC relative. */
5279 complain_overflow_dont,/* Complain_on_overflow. */
5280 reloc_nil, /* Special_function. */
5281 "OP_PSUB", /* Name. */
5282 FALSE, /* Partial_inplace. */
5283 0, /* Source mask. */
5285 FALSE), /* PC rel offset. */
5287 /* Shift the value on the top of the relocation stack right by the
5289 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */
5290 0, /* Rightshift. */
5291 0, /* Size (0 = byte, 1 = short, 2 = long). */
5293 FALSE, /* PC relative. */
5295 complain_overflow_dont,/* Complain_on_overflow. */
5296 reloc_nil, /* Special_function. */
5297 "OP_PRSHIFT", /* Name. */
5298 FALSE, /* Partial_inplace. */
5299 0, /* Source mask. */
5301 FALSE), /* PC rel offset. */
5303 /* Hack. Linkage is done by linker. */
5304 HOWTO (ALPHA_R_LINKAGE, /* Type. */
5305 0, /* Rightshift. */
5306 8, /* Size (0 = byte, 1 = short, 2 = long). */
5308 FALSE, /* PC relative. */
5310 complain_overflow_dont,/* Complain_on_overflow. */
5311 reloc_nil, /* Special_function. */
5312 "LINKAGE", /* Name. */
5313 FALSE, /* Partial_inplace. */
5314 0, /* Source mask. */
5316 FALSE), /* PC rel offset. */
5318 /* A 32 bit reference to a symbol. */
5319 HOWTO (ALPHA_R_REFLONG, /* Type. */
5320 0, /* Rightshift. */
5321 2, /* Size (0 = byte, 1 = short, 2 = long). */
5323 FALSE, /* PC relative. */
5325 complain_overflow_bitfield, /* Complain_on_overflow. */
5326 reloc_nil, /* Special_function. */
5327 "REFLONG", /* Name. */
5328 TRUE, /* Partial_inplace. */
5329 0xffffffff, /* Source mask. */
5330 0xffffffff, /* Dest mask. */
5331 FALSE), /* PC rel offset. */
5333 /* A 64 bit reference to a procedure, written as 32 bit value. */
5334 HOWTO (ALPHA_R_CODEADDR, /* Type. */
5335 0, /* Rightshift. */
5336 4, /* Size (0 = byte, 1 = short, 2 = long). */
5338 FALSE, /* PC relative. */
5340 complain_overflow_signed,/* Complain_on_overflow. */
5341 reloc_nil, /* Special_function. */
5342 "CODEADDR", /* Name. */
5343 FALSE, /* Partial_inplace. */
5344 0xffffffff, /* Source mask. */
5345 0xffffffff, /* Dest mask. */
5346 FALSE), /* PC rel offset. */
5348 HOWTO (ALPHA_R_NOP, /* Type. */
5349 0, /* Rightshift. */
5350 3, /* Size (0 = byte, 1 = short, 2 = long). */
5352 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5353 because the calculations for the 3 relocations are the same.
5354 See B.4.5.2 of the OpenVMS Linker Utility Manual. */
5355 TRUE, /* PC relative. */
5357 complain_overflow_dont,/* Complain_on_overflow. */
5358 reloc_nil, /* Special_function. */
5360 FALSE, /* Partial_inplace. */
5361 0xffffffff, /* Source mask. */
5362 0xffffffff, /* Dest mask. */
5363 FALSE), /* PC rel offset. */
5365 HOWTO (ALPHA_R_BSR, /* Type. */
5366 0, /* Rightshift. */
5367 3, /* Size (0 = byte, 1 = short, 2 = long). */
5369 TRUE, /* PC relative. */
5371 complain_overflow_dont,/* Complain_on_overflow. */
5372 reloc_nil, /* Special_function. */
5374 FALSE, /* Partial_inplace. */
5375 0xffffffff, /* Source mask. */
5376 0xffffffff, /* Dest mask. */
5377 FALSE), /* PC rel offset. */
5379 HOWTO (ALPHA_R_LDA, /* Type. */
5380 0, /* Rightshift. */
5381 3, /* Size (0 = byte, 1 = short, 2 = long). */
5383 FALSE, /* PC relative. */
5385 complain_overflow_dont,/* Complain_on_overflow. */
5386 reloc_nil, /* Special_function. */
5388 FALSE, /* Partial_inplace. */
5389 0xffffffff, /* Source mask. */
5390 0xffffffff, /* Dest mask. */
5391 FALSE), /* PC rel offset. */
5393 HOWTO (ALPHA_R_BOH, /* Type. */
5394 0, /* Rightshift. */
5395 3, /* Size (0 = byte, 1 = short, 2 = long, 3 = nil). */
5397 TRUE, /* PC relative. */
5399 complain_overflow_dont,/* Complain_on_overflow. */
5400 reloc_nil, /* Special_function. */
5402 FALSE, /* Partial_inplace. */
5403 0xffffffff, /* Source mask. */
5404 0xffffffff, /* Dest mask. */
5405 FALSE), /* PC rel offset. */
5408 /* Return a pointer to a howto structure which, when invoked, will perform
5409 the relocation code on data from the architecture noted. */
5411 static const struct reloc_howto_struct *
5412 alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5413 bfd_reloc_code_real_type code)
5417 vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5421 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break;
5422 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break;
5423 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break;
5424 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break;
5425 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break;
5426 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break;
5427 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break;
5428 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break;
5429 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break;
5430 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break;
5431 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break;
5432 case BFD_RELOC_ALPHA_NOP: alpha_type = ALPHA_R_NOP; break;
5433 case BFD_RELOC_ALPHA_BSR: alpha_type = ALPHA_R_BSR; break;
5434 case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
5435 case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
5437 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5440 vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5441 return & alpha_howto_table[alpha_type];
5444 static reloc_howto_type *
5445 alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5451 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5453 if (alpha_howto_table[i].name != NULL
5454 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5455 return &alpha_howto_table[i];
5461 alpha_vms_get_synthetic_symtab (bfd *abfd,
5462 long symcount ATTRIBUTE_UNUSED,
5463 asymbol **usyms ATTRIBUTE_UNUSED,
5464 long dynsymcount ATTRIBUTE_UNUSED,
5465 asymbol **dynsyms ATTRIBUTE_UNUSED,
5472 syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5477 for (i = 0; i < PRIV (gsd_sym_count); i++)
5479 struct vms_symbol_entry *e = PRIV (syms)[i];
5490 flags = BSF_LOCAL | BSF_SYNTHETIC;
5497 if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5499 value = e->code_value;
5500 sec = e->code_section;
5511 sname = bfd_alloc (abfd, l + 5);
5514 memcpy (sname, name, l);
5515 memcpy (sname + l, "..en", 5);
5522 sym->udata.p = NULL;
5531 vms_time_to_str (unsigned char *buf)
5533 time_t t = vms_rawtime_to_time_t (buf);
5534 char *res = ctime (&t);
5537 res = "*invalid time*";
5544 evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5546 struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5547 unsigned int subtype;
5549 subtype = (unsigned)bfd_getl16 (emh->subtyp);
5551 fprintf (file, _(" EMH %u (len=%u): "), subtype, rec_len);
5557 struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5560 fprintf (file, _("Module header\n"));
5561 fprintf (file, _(" structure level: %u\n"), mhd->strlvl);
5562 fprintf (file, _(" max record size: %u\n"),
5563 (unsigned)bfd_getl32 (mhd->recsiz));
5564 name = (char *)(mhd + 1);
5565 fprintf (file, _(" module name : %.*s\n"), name[0], name + 1);
5566 name += name[0] + 1;
5567 fprintf (file, _(" module version : %.*s\n"), name[0], name + 1);
5568 name += name[0] + 1;
5569 fprintf (file, _(" compile date : %.17s\n"), name);
5574 fprintf (file, _("Language Processor Name\n"));
5575 fprintf (file, _(" language name: %.*s\n"),
5576 (int)(rec_len - sizeof (struct vms_emh_common)),
5577 (char *)rec + sizeof (struct vms_emh_common));
5582 fprintf (file, _("Source Files Header\n"));
5583 fprintf (file, _(" file: %.*s\n"),
5584 (int)(rec_len - sizeof (struct vms_emh_common)),
5585 (char *)rec + sizeof (struct vms_emh_common));
5590 fprintf (file, _("Title Text Header\n"));
5591 fprintf (file, _(" title: %.*s\n"),
5592 (int)(rec_len - sizeof (struct vms_emh_common)),
5593 (char *)rec + sizeof (struct vms_emh_common));
5598 fprintf (file, _("Copyright Header\n"));
5599 fprintf (file, _(" copyright: %.*s\n"),
5600 (int)(rec_len - sizeof (struct vms_emh_common)),
5601 (char *)rec + sizeof (struct vms_emh_common));
5605 fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5611 evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5613 struct vms_eeom *eeom = (struct vms_eeom *)rec;
5615 fprintf (file, _(" EEOM (len=%u):\n"), rec_len);
5616 fprintf (file, _(" number of cond linkage pairs: %u\n"),
5617 (unsigned)bfd_getl32 (eeom->total_lps));
5618 fprintf (file, _(" completion code: %u\n"),
5619 (unsigned)bfd_getl16 (eeom->comcod));
5622 fprintf (file, _(" transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5623 fprintf (file, _(" transfer addr psect: %u\n"),
5624 (unsigned)bfd_getl32 (eeom->psindx));
5625 fprintf (file, _(" transfer address : 0x%08x\n"),
5626 (unsigned)bfd_getl32 (eeom->tfradr));
5631 exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5633 if (flags & EGSY__V_WEAK)
5634 fputs (_(" WEAK"), file);
5635 if (flags & EGSY__V_DEF)
5636 fputs (_(" DEF"), file);
5637 if (flags & EGSY__V_UNI)
5638 fputs (_(" UNI"), file);
5639 if (flags & EGSY__V_REL)
5640 fputs (_(" REL"), file);
5641 if (flags & EGSY__V_COMM)
5642 fputs (_(" COMM"), file);
5643 if (flags & EGSY__V_VECEP)
5644 fputs (_(" VECEP"), file);
5645 if (flags & EGSY__V_NORM)
5646 fputs (_(" NORM"), file);
5647 if (flags & EGSY__V_QUAD_VAL)
5648 fputs (_(" QVAL"), file);
5652 evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5654 if (flags & EGPS__V_PIC)
5655 fputs (_(" PIC"), file);
5656 if (flags & EGPS__V_LIB)
5657 fputs (_(" LIB"), file);
5658 if (flags & EGPS__V_OVR)
5659 fputs (_(" OVR"), file);
5660 if (flags & EGPS__V_REL)
5661 fputs (_(" REL"), file);
5662 if (flags & EGPS__V_GBL)
5663 fputs (_(" GBL"), file);
5664 if (flags & EGPS__V_SHR)
5665 fputs (_(" SHR"), file);
5666 if (flags & EGPS__V_EXE)
5667 fputs (_(" EXE"), file);
5668 if (flags & EGPS__V_RD)
5669 fputs (_(" RD"), file);
5670 if (flags & EGPS__V_WRT)
5671 fputs (_(" WRT"), file);
5672 if (flags & EGPS__V_VEC)
5673 fputs (_(" VEC"), file);
5674 if (flags & EGPS__V_NOMOD)
5675 fputs (_(" NOMOD"), file);
5676 if (flags & EGPS__V_COM)
5677 fputs (_(" COM"), file);
5678 if (flags & EGPS__V_ALLOC_64BIT)
5679 fputs (_(" 64B"), file);
5683 evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5685 unsigned int off = sizeof (struct vms_egsd);
5688 fprintf (file, _(" EGSD (len=%u):\n"), rec_len);
5691 for (off = sizeof (struct vms_egsd); off < rec_len; )
5693 struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5697 type = (unsigned)bfd_getl16 (e->gsdtyp);
5698 len = (unsigned)bfd_getl16 (e->gsdsiz);
5700 fprintf (file, _(" EGSD entry %2u (type: %u, len: %u): "),
5708 struct vms_egps *egps = (struct vms_egps *)e;
5709 unsigned int flags = bfd_getl16 (egps->flags);
5712 fprintf (file, _("PSC - Program section definition\n"));
5713 fprintf (file, _(" alignment : 2**%u\n"), egps->align);
5714 fprintf (file, _(" flags : 0x%04x"), flags);
5715 evax_bfd_print_egsd_flags (file, flags);
5717 l = bfd_getl32 (egps->alloc);
5718 fprintf (file, _(" alloc (len): %u (0x%08x)\n"), l, l);
5719 fprintf (file, _(" name : %.*s\n"),
5720 egps->namlng, egps->name);
5725 struct vms_esgps *esgps = (struct vms_esgps *)e;
5726 unsigned int flags = bfd_getl16 (esgps->flags);
5729 fprintf (file, _("SPSC - Shared Image Program section def\n"));
5730 fprintf (file, _(" alignment : 2**%u\n"), esgps->align);
5731 fprintf (file, _(" flags : 0x%04x"), flags);
5732 evax_bfd_print_egsd_flags (file, flags);
5734 l = bfd_getl32 (esgps->alloc);
5735 fprintf (file, _(" alloc (len) : %u (0x%08x)\n"), l, l);
5736 fprintf (file, _(" image offset : 0x%08x\n"),
5737 (unsigned int)bfd_getl32 (esgps->base));
5738 fprintf (file, _(" symvec offset : 0x%08x\n"),
5739 (unsigned int)bfd_getl32 (esgps->value));
5740 fprintf (file, _(" name : %.*s\n"),
5741 esgps->namlng, esgps->name);
5746 struct vms_egsy *egsy = (struct vms_egsy *)e;
5747 unsigned int flags = bfd_getl16 (egsy->flags);
5749 if (flags & EGSY__V_DEF)
5751 struct vms_esdf *esdf = (struct vms_esdf *)e;
5753 fprintf (file, _("SYM - Global symbol definition\n"));
5754 fprintf (file, _(" flags: 0x%04x"), flags);
5755 exav_bfd_print_egsy_flags (flags, file);
5757 fprintf (file, _(" psect offset: 0x%08x\n"),
5758 (unsigned)bfd_getl32 (esdf->value));
5759 if (flags & EGSY__V_NORM)
5761 fprintf (file, _(" code address: 0x%08x\n"),
5762 (unsigned)bfd_getl32 (esdf->code_address));
5763 fprintf (file, _(" psect index for entry point : %u\n"),
5764 (unsigned)bfd_getl32 (esdf->ca_psindx));
5766 fprintf (file, _(" psect index : %u\n"),
5767 (unsigned)bfd_getl32 (esdf->psindx));
5768 fprintf (file, _(" name : %.*s\n"),
5769 esdf->namlng, esdf->name);
5773 struct vms_esrf *esrf = (struct vms_esrf *)e;
5775 fprintf (file, _("SYM - Global symbol reference\n"));
5776 fprintf (file, _(" name : %.*s\n"),
5777 esrf->namlng, esrf->name);
5783 struct vms_eidc *eidc = (struct vms_eidc *)e;
5784 unsigned int flags = bfd_getl32 (eidc->flags);
5787 fprintf (file, _("IDC - Ident Consistency check\n"));
5788 fprintf (file, _(" flags : 0x%08x"), flags);
5789 if (flags & EIDC__V_BINIDENT)
5790 fputs (" BINDENT", file);
5792 fprintf (file, _(" id match : %x\n"),
5793 (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5794 fprintf (file, _(" error severity: %x\n"),
5795 (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5797 fprintf (file, _(" entity name : %.*s\n"), p[0], p + 1);
5799 fprintf (file, _(" object name : %.*s\n"), p[0], p + 1);
5801 if (flags & EIDC__V_BINIDENT)
5802 fprintf (file, _(" binary ident : 0x%08x\n"),
5803 (unsigned)bfd_getl32 (p + 1));
5805 fprintf (file, _(" ascii ident : %.*s\n"), p[0], p + 1);
5810 struct vms_egst *egst = (struct vms_egst *)e;
5811 unsigned int flags = bfd_getl16 (egst->header.flags);
5813 fprintf (file, _("SYMG - Universal symbol definition\n"));
5814 fprintf (file, _(" flags: 0x%04x"), flags);
5815 exav_bfd_print_egsy_flags (flags, file);
5817 fprintf (file, _(" symbol vector offset: 0x%08x\n"),
5818 (unsigned)bfd_getl32 (egst->value));
5819 fprintf (file, _(" entry point: 0x%08x\n"),
5820 (unsigned)bfd_getl32 (egst->lp_1));
5821 fprintf (file, _(" proc descr : 0x%08x\n"),
5822 (unsigned)bfd_getl32 (egst->lp_2));
5823 fprintf (file, _(" psect index: %u\n"),
5824 (unsigned)bfd_getl32 (egst->psindx));
5825 fprintf (file, _(" name : %.*s\n"),
5826 egst->namlng, egst->name);
5831 struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5832 unsigned int flags = bfd_getl16 (esdfv->flags);
5834 fprintf (file, _("SYMV - Vectored symbol definition\n"));
5835 fprintf (file, _(" flags: 0x%04x"), flags);
5836 exav_bfd_print_egsy_flags (flags, file);
5838 fprintf (file, _(" vector : 0x%08x\n"),
5839 (unsigned)bfd_getl32 (esdfv->vector));
5840 fprintf (file, _(" psect offset: %u\n"),
5841 (unsigned)bfd_getl32 (esdfv->value));
5842 fprintf (file, _(" psect index : %u\n"),
5843 (unsigned)bfd_getl32 (esdfv->psindx));
5844 fprintf (file, _(" name : %.*s\n"),
5845 esdfv->namlng, esdfv->name);
5850 struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5851 unsigned int flags = bfd_getl16 (esdfm->flags);
5853 fprintf (file, _("SYMM - Global symbol definition with version\n"));
5854 fprintf (file, _(" flags: 0x%04x"), flags);
5855 exav_bfd_print_egsy_flags (flags, file);
5857 fprintf (file, _(" version mask: 0x%08x\n"),
5858 (unsigned)bfd_getl32 (esdfm->version_mask));
5859 fprintf (file, _(" psect offset: %u\n"),
5860 (unsigned)bfd_getl32 (esdfm->value));
5861 fprintf (file, _(" psect index : %u\n"),
5862 (unsigned)bfd_getl32 (esdfm->psindx));
5863 fprintf (file, _(" name : %.*s\n"),
5864 esdfm->namlng, esdfm->name);
5868 fprintf (file, _("unhandled egsd entry type %u\n"), type);
5876 evax_bfd_print_hex (FILE *file, const char *pfx,
5877 const unsigned char *buf, unsigned int len)
5883 for (i = 0; i < len; i++)
5887 fprintf (file, " %02x", buf[i]);
5900 evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
5902 fprintf (file, _(" linkage index: %u, replacement insn: 0x%08x\n"),
5903 (unsigned)bfd_getl32 (buf),
5904 (unsigned)bfd_getl32 (buf + 16));
5905 fprintf (file, _(" psect idx 1: %u, offset 1: 0x%08x %08x\n"),
5906 (unsigned)bfd_getl32 (buf + 4),
5907 (unsigned)bfd_getl32 (buf + 12),
5908 (unsigned)bfd_getl32 (buf + 8));
5909 fprintf (file, _(" psect idx 2: %u, offset 2: 0x%08x %08x\n"),
5910 (unsigned)bfd_getl32 (buf + 20),
5911 (unsigned)bfd_getl32 (buf + 28),
5912 (unsigned)bfd_getl32 (buf + 24));
5914 fprintf (file, _(" psect idx 3: %u, offset 3: 0x%08x %08x\n"),
5915 (unsigned)bfd_getl32 (buf + 32),
5916 (unsigned)bfd_getl32 (buf + 40),
5917 (unsigned)bfd_getl32 (buf + 36));
5919 fprintf (file, _(" global name: %.*s\n"), buf[32], buf + 33);
5923 evax_bfd_print_etir (FILE *file, const char *name,
5924 unsigned char *rec, unsigned int rec_len)
5926 unsigned int off = sizeof (struct vms_egsd);
5927 unsigned int sec_len = 0;
5929 fprintf (file, _(" %s (len=%u+%u):\n"), name,
5930 (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
5931 (unsigned)sizeof (struct vms_eobjrec));
5933 for (off = sizeof (struct vms_eobjrec); off < rec_len; )
5935 struct vms_etir *etir = (struct vms_etir *)(rec + off);
5940 type = bfd_getl16 (etir->rectyp);
5941 size = bfd_getl16 (etir->size);
5942 buf = rec + off + sizeof (struct vms_etir);
5944 fprintf (file, _(" (type: %3u, size: 4+%3u): "), type, size - 4);
5947 case ETIR__C_STA_GBL:
5948 fprintf (file, _("STA_GBL (stack global) %.*s\n"),
5951 case ETIR__C_STA_LW:
5952 fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
5953 (unsigned)bfd_getl32 (buf));
5955 case ETIR__C_STA_QW:
5956 fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
5957 (unsigned)bfd_getl32 (buf + 4),
5958 (unsigned)bfd_getl32 (buf + 0));
5960 case ETIR__C_STA_PQ:
5961 fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
5962 fprintf (file, _(" psect: %u, offset: 0x%08x %08x\n"),
5963 (unsigned)bfd_getl32 (buf + 0),
5964 (unsigned)bfd_getl32 (buf + 8),
5965 (unsigned)bfd_getl32 (buf + 4));
5967 case ETIR__C_STA_LI:
5968 fprintf (file, _("STA_LI (stack literal)\n"));
5970 case ETIR__C_STA_MOD:
5971 fprintf (file, _("STA_MOD (stack module)\n"));
5973 case ETIR__C_STA_CKARG:
5974 fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
5978 fprintf (file, _("STO_B (store byte)\n"));
5981 fprintf (file, _("STO_W (store word)\n"));
5983 case ETIR__C_STO_LW:
5984 fprintf (file, _("STO_LW (store longword)\n"));
5986 case ETIR__C_STO_QW:
5987 fprintf (file, _("STO_QW (store quadword)\n"));
5989 case ETIR__C_STO_IMMR:
5991 unsigned int len = bfd_getl32 (buf);
5993 _("STO_IMMR (store immediate repeat) %u bytes\n"),
5995 evax_bfd_print_hex (file, " ", buf + 4, len);
5999 case ETIR__C_STO_GBL:
6000 fprintf (file, _("STO_GBL (store global) %.*s\n"),
6003 case ETIR__C_STO_CA:
6004 fprintf (file, _("STO_CA (store code address) %.*s\n"),
6007 case ETIR__C_STO_RB:
6008 fprintf (file, _("STO_RB (store relative branch)\n"));
6010 case ETIR__C_STO_AB:
6011 fprintf (file, _("STO_AB (store absolute branch)\n"));
6013 case ETIR__C_STO_OFF:
6014 fprintf (file, _("STO_OFF (store offset to psect)\n"));
6016 case ETIR__C_STO_IMM:
6018 unsigned int len = bfd_getl32 (buf);
6020 _("STO_IMM (store immediate) %u bytes\n"),
6022 evax_bfd_print_hex (file, " ", buf + 4, len);
6026 case ETIR__C_STO_GBL_LW:
6027 fprintf (file, _("STO_GBL_LW (store global longword) %.*s\n"),
6030 case ETIR__C_STO_LP_PSB:
6031 fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6033 case ETIR__C_STO_HINT_GBL:
6034 fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6036 case ETIR__C_STO_HINT_PS:
6037 fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6040 case ETIR__C_OPR_NOP:
6041 fprintf (file, _("OPR_NOP (no-operation)\n"));
6043 case ETIR__C_OPR_ADD:
6044 fprintf (file, _("OPR_ADD (add)\n"));
6046 case ETIR__C_OPR_SUB:
6047 fprintf (file, _("OPR_SUB (substract)\n"));
6049 case ETIR__C_OPR_MUL:
6050 fprintf (file, _("OPR_MUL (multiply)\n"));
6052 case ETIR__C_OPR_DIV:
6053 fprintf (file, _("OPR_DIV (divide)\n"));
6055 case ETIR__C_OPR_AND:
6056 fprintf (file, _("OPR_AND (logical and)\n"));
6058 case ETIR__C_OPR_IOR:
6059 fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6061 case ETIR__C_OPR_EOR:
6062 fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6064 case ETIR__C_OPR_NEG:
6065 fprintf (file, _("OPR_NEG (negate)\n"));
6067 case ETIR__C_OPR_COM:
6068 fprintf (file, _("OPR_COM (complement)\n"));
6070 case ETIR__C_OPR_INSV:
6071 fprintf (file, _("OPR_INSV (insert field)\n"));
6073 case ETIR__C_OPR_ASH:
6074 fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6076 case ETIR__C_OPR_USH:
6077 fprintf (file, _("OPR_USH (unsigned shift)\n"));
6079 case ETIR__C_OPR_ROT:
6080 fprintf (file, _("OPR_ROT (rotate)\n"));
6082 case ETIR__C_OPR_SEL:
6083 fprintf (file, _("OPR_SEL (select)\n"));
6085 case ETIR__C_OPR_REDEF:
6086 fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6088 case ETIR__C_OPR_DFLIT:
6089 fprintf (file, _("OPR_REDEF (define a literal)\n"));
6092 case ETIR__C_STC_LP:
6093 fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6095 case ETIR__C_STC_LP_PSB:
6097 _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6098 fprintf (file, _(" linkage index: %u, procedure: %.*s\n"),
6099 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6100 buf += 4 + 1 + buf[4];
6101 fprintf (file, _(" signature: %.*s\n"), buf[0], buf + 1);
6103 case ETIR__C_STC_GBL:
6104 fprintf (file, _("STC_GBL (store cond global)\n"));
6105 fprintf (file, _(" linkage index: %u, global: %.*s\n"),
6106 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6108 case ETIR__C_STC_GCA:
6109 fprintf (file, _("STC_GCA (store cond code address)\n"));
6110 fprintf (file, _(" linkage index: %u, procedure name: %.*s\n"),
6111 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6113 case ETIR__C_STC_PS:
6114 fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6116 _(" linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6117 (unsigned)bfd_getl32 (buf),
6118 (unsigned)bfd_getl32 (buf + 4),
6119 (unsigned)bfd_getl32 (buf + 12),
6120 (unsigned)bfd_getl32 (buf + 8));
6122 case ETIR__C_STC_NOP_GBL:
6123 fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6124 evax_bfd_print_etir_stc_ir (file, buf, 0);
6126 case ETIR__C_STC_NOP_PS:
6127 fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6128 evax_bfd_print_etir_stc_ir (file, buf, 1);
6130 case ETIR__C_STC_BSR_GBL:
6131 fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6132 evax_bfd_print_etir_stc_ir (file, buf, 0);
6134 case ETIR__C_STC_BSR_PS:
6135 fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6136 evax_bfd_print_etir_stc_ir (file, buf, 1);
6138 case ETIR__C_STC_LDA_GBL:
6139 fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6140 evax_bfd_print_etir_stc_ir (file, buf, 0);
6142 case ETIR__C_STC_LDA_PS:
6143 fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6144 evax_bfd_print_etir_stc_ir (file, buf, 1);
6146 case ETIR__C_STC_BOH_GBL:
6147 fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6148 evax_bfd_print_etir_stc_ir (file, buf, 0);
6150 case ETIR__C_STC_BOH_PS:
6151 fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6152 evax_bfd_print_etir_stc_ir (file, buf, 1);
6154 case ETIR__C_STC_NBH_GBL:
6156 _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6158 case ETIR__C_STC_NBH_PS:
6160 _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6163 case ETIR__C_CTL_SETRB:
6164 fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6167 case ETIR__C_CTL_AUGRB:
6169 unsigned int val = bfd_getl32 (buf);
6170 fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6173 case ETIR__C_CTL_DFLOC:
6174 fprintf (file, _("CTL_DFLOC (define location)\n"));
6176 case ETIR__C_CTL_STLOC:
6177 fprintf (file, _("CTL_STLOC (set location)\n"));
6179 case ETIR__C_CTL_STKDL:
6180 fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6183 fprintf (file, _("*unhandled*\n"));
6191 evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6193 bfd_boolean is_first = TRUE;
6194 bfd_boolean has_records = FALSE;
6198 unsigned int rec_len;
6199 unsigned int pad_len;
6201 unsigned int hdr_size;
6206 unsigned char buf[6];
6211 if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6213 fprintf (file, _("cannot read GST record length\n"));
6216 rec_len = bfd_getl16 (buf + 0);
6217 if (rec_len == bfd_getl16 (buf + 4)
6218 && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6220 /* The format is raw: record-size, type, record-size. */
6222 pad_len = (rec_len + 1) & ~1U;
6225 else if (rec_len == EOBJ__C_EMH)
6227 has_records = FALSE;
6228 pad_len = bfd_getl16 (buf + 2);
6234 fprintf (file, _("cannot find EMH in first GST record\n"));
6237 rec = bfd_malloc (pad_len);
6238 memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6242 unsigned int rec_len2 = 0;
6243 unsigned char hdr[4];
6247 unsigned char buf_len[2];
6249 if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6250 != sizeof (buf_len))
6252 fprintf (file, _("cannot read GST record length\n"));
6255 rec_len2 = (unsigned)bfd_getl16 (buf_len);
6258 if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6260 fprintf (file, _("cannot read GST record header\n"));
6263 rec_len = (unsigned)bfd_getl16 (hdr + 2);
6265 pad_len = (rec_len + 1) & ~1U;
6268 rec = bfd_malloc (pad_len);
6269 memcpy (rec, hdr, sizeof (hdr));
6270 hdr_size = sizeof (hdr);
6271 if (has_records && rec_len2 != rec_len)
6273 fprintf (file, _(" corrupted GST\n"));
6278 if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6279 != pad_len - hdr_size)
6281 fprintf (file, _("cannot read GST record\n"));
6285 type = (unsigned)bfd_getl16 (rec);
6290 evax_bfd_print_emh (file, rec, rec_len);
6293 evax_bfd_print_egsd (file, rec, rec_len);
6296 evax_bfd_print_eeom (file, rec, rec_len);
6301 evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6304 evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6307 evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6310 fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6318 evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6319 unsigned int stride)
6327 count = bfd_getl32 (rel + 0);
6331 base = bfd_getl32 (rel + 4);
6333 fprintf (file, _(" bitcount: %u, base addr: 0x%08x\n"),
6337 for (j = 0; count > 0; j += 4, count -= 32)
6343 val = bfd_getl32 (rel);
6346 fprintf (file, _(" bitmap: 0x%08x (count: %u):\n"), val, count);
6348 for (k = 0; k < 32; k++)
6353 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6368 evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6375 count = bfd_getl32 (rel + 0);
6378 fprintf (file, _(" image %u (%u entries)\n"),
6379 (unsigned)bfd_getl32 (rel + 4), count);
6381 for (j = 0; j < count; j++)
6383 fprintf (file, _(" offset: 0x%08x, val: 0x%08x\n"),
6384 (unsigned)bfd_getl32 (rel + 0),
6385 (unsigned)bfd_getl32 (rel + 4));
6392 evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6401 count = bfd_getl32 (rel + 0);
6404 fprintf (file, _(" image %u (%u entries), offsets:\n"),
6405 (unsigned)bfd_getl32 (rel + 4), count);
6407 for (j = 0; j < count; j++)
6411 fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6426 evax_bfd_print_indent (int indent, FILE *file)
6428 for (; indent; indent--)
6433 evax_bfd_get_dsc_name (unsigned int v)
6437 case DSC__K_DTYPE_Z:
6438 return "Z (Unspecified)";
6439 case DSC__K_DTYPE_V:
6441 case DSC__K_DTYPE_BU:
6442 return "BU (Byte logical)";
6443 case DSC__K_DTYPE_WU:
6444 return "WU (Word logical)";
6445 case DSC__K_DTYPE_LU:
6446 return "LU (Longword logical)";
6447 case DSC__K_DTYPE_QU:
6448 return "QU (Quadword logical)";
6449 case DSC__K_DTYPE_B:
6450 return "B (Byte integer)";
6451 case DSC__K_DTYPE_W:
6452 return "W (Word integer)";
6453 case DSC__K_DTYPE_L:
6454 return "L (Longword integer)";
6455 case DSC__K_DTYPE_Q:
6456 return "Q (Quadword integer)";
6457 case DSC__K_DTYPE_F:
6458 return "F (Single-precision floating)";
6459 case DSC__K_DTYPE_D:
6460 return "D (Double-precision floating)";
6461 case DSC__K_DTYPE_FC:
6462 return "FC (Complex)";
6463 case DSC__K_DTYPE_DC:
6464 return "DC (Double-precision Complex)";
6465 case DSC__K_DTYPE_T:
6466 return "T (ASCII text string)";
6467 case DSC__K_DTYPE_NU:
6468 return "NU (Numeric string, unsigned)";
6469 case DSC__K_DTYPE_NL:
6470 return "NL (Numeric string, left separate sign)";
6471 case DSC__K_DTYPE_NLO:
6472 return "NLO (Numeric string, left overpunched sign)";
6473 case DSC__K_DTYPE_NR:
6474 return "NR (Numeric string, right separate sign)";
6475 case DSC__K_DTYPE_NRO:
6476 return "NRO (Numeric string, right overpunched sig)";
6477 case DSC__K_DTYPE_NZ:
6478 return "NZ (Numeric string, zoned sign)";
6479 case DSC__K_DTYPE_P:
6480 return "P (Packed decimal string)";
6481 case DSC__K_DTYPE_ZI:
6482 return "ZI (Sequence of instructions)";
6483 case DSC__K_DTYPE_ZEM:
6484 return "ZEM (Procedure entry mask)";
6485 case DSC__K_DTYPE_DSC:
6486 return "DSC (Descriptor, used for arrays of dyn strings)";
6487 case DSC__K_DTYPE_OU:
6488 return "OU (Octaword logical)";
6489 case DSC__K_DTYPE_O:
6490 return "O (Octaword integer)";
6491 case DSC__K_DTYPE_G:
6492 return "G (Double precision G floating, 64 bit)";
6493 case DSC__K_DTYPE_H:
6494 return "H (Quadruple precision floating, 128 bit)";
6495 case DSC__K_DTYPE_GC:
6496 return "GC (Double precision complex, G floating)";
6497 case DSC__K_DTYPE_HC:
6498 return "HC (Quadruple precision complex, H floating)";
6499 case DSC__K_DTYPE_CIT:
6500 return "CIT (COBOL intermediate temporary)";
6501 case DSC__K_DTYPE_BPV:
6502 return "BPV (Bound Procedure Value)";
6503 case DSC__K_DTYPE_BLV:
6504 return "BLV (Bound Label Value)";
6505 case DSC__K_DTYPE_VU:
6506 return "VU (Bit Unaligned)";
6507 case DSC__K_DTYPE_ADT:
6508 return "ADT (Absolute Date-Time)";
6509 case DSC__K_DTYPE_VT:
6510 return "VT (Varying Text)";
6511 case DSC__K_DTYPE_T2:
6512 return "T2 (16-bit char)";
6513 case DSC__K_DTYPE_VT2:
6514 return "VT2 (16-bit varying char)";
6516 return "?? (unknown)";
6521 evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6523 unsigned char bclass = buf[3];
6524 unsigned char dtype = buf[2];
6525 unsigned int len = (unsigned)bfd_getl16 (buf);
6526 unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6528 evax_bfd_print_indent (indent, file);
6530 if (len == 1 && pointer == 0xffffffffUL)
6533 fprintf (file, _("64 bits *unhandled*\n"));
6537 fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6538 bclass, dtype, len, pointer);
6541 case DSC__K_CLASS_NCA:
6543 const struct vms_dsc_nca *dsc = (const void *)buf;
6545 const unsigned char *b;
6547 evax_bfd_print_indent (indent, file);
6548 fprintf (file, _("non-contiguous array of %s\n"),
6549 evax_bfd_get_dsc_name (dsc->dtype));
6550 evax_bfd_print_indent (indent + 1, file);
6552 _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6553 dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6554 evax_bfd_print_indent (indent + 1, file);
6556 _("arsize: %u, a0: 0x%08x\n"),
6557 (unsigned)bfd_getl32 (dsc->arsize),
6558 (unsigned)bfd_getl32 (dsc->a0));
6559 evax_bfd_print_indent (indent + 1, file);
6560 fprintf (file, _("Strides:\n"));
6561 b = buf + sizeof (*dsc);
6562 for (i = 0; i < dsc->dimct; i++)
6564 evax_bfd_print_indent (indent + 2, file);
6565 fprintf (file, _("[%u]: %u\n"), i + 1,
6566 (unsigned)bfd_getl32 (b));
6569 evax_bfd_print_indent (indent + 1, file);
6570 fprintf (file, _("Bounds:\n"));
6571 b = buf + sizeof (*dsc);
6572 for (i = 0; i < dsc->dimct; i++)
6574 evax_bfd_print_indent (indent + 2, file);
6575 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6576 (unsigned)bfd_getl32 (b + 0),
6577 (unsigned)bfd_getl32 (b + 4));
6582 case DSC__K_CLASS_UBS:
6584 const struct vms_dsc_ubs *ubs = (const void *)buf;
6586 evax_bfd_print_indent (indent, file);
6587 fprintf (file, _("unaligned bit-string of %s\n"),
6588 evax_bfd_get_dsc_name (ubs->dtype));
6589 evax_bfd_print_indent (indent + 1, file);
6591 _("base: %u, pos: %u\n"),
6592 (unsigned)bfd_getl32 (ubs->base),
6593 (unsigned)bfd_getl32 (ubs->pos));
6597 fprintf (file, _("*unhandled*\n"));
6604 evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6606 unsigned int vflags = buf[0];
6607 unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6608 unsigned int len = 5;
6610 evax_bfd_print_indent (indent, file);
6611 fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6616 case DST__K_VFLAGS_NOVAL:
6617 fprintf (file, _("(no value)\n"));
6619 case DST__K_VFLAGS_NOTACTIVE:
6620 fprintf (file, _("(not active)\n"));
6622 case DST__K_VFLAGS_UNALLOC:
6623 fprintf (file, _("(not allocated)\n"));
6625 case DST__K_VFLAGS_DSC:
6626 fprintf (file, _("(descriptor)\n"));
6627 evax_bfd_print_desc (buf + value, indent + 1, file);
6629 case DST__K_VFLAGS_TVS:
6630 fprintf (file, _("(trailing value)\n"));
6632 case DST__K_VS_FOLLOWS:
6633 fprintf (file, _("(value spec follows)\n"));
6635 case DST__K_VFLAGS_BITOFFS:
6636 fprintf (file, _("(at bit offset %u)\n"), value);
6639 fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6640 (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6641 vflags & DST__K_DISP ? 1 : 0,
6642 vflags & DST__K_INDIR ? 1 : 0);
6643 switch (vflags & DST__K_VALKIND_MASK)
6645 case DST__K_VALKIND_LITERAL:
6646 fputs (_("literal"), file);
6648 case DST__K_VALKIND_ADDR:
6649 fputs (_("address"), file);
6651 case DST__K_VALKIND_DESC:
6652 fputs (_("desc"), file);
6654 case DST__K_VALKIND_REG:
6655 fputs (_("reg"), file);
6658 fputs (")\n", file);
6665 evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6667 unsigned char kind = buf[2];
6668 unsigned int len = (unsigned)bfd_getl16 (buf);
6670 evax_bfd_print_indent (indent, file);
6671 fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6675 case DST__K_TS_ATOM:
6676 fprintf (file, ("atomic, type=0x%02x %s\n"),
6677 buf[0], evax_bfd_get_dsc_name (buf[0]));
6680 fprintf (file, ("indirect, defined at 0x%08x\n"),
6681 (unsigned)bfd_getl32 (buf));
6683 case DST__K_TS_TPTR:
6684 fprintf (file, ("typed pointer\n"));
6685 evax_bfd_print_typspec (buf, indent + 1, file);
6688 fprintf (file, ("pointer\n"));
6690 case DST__K_TS_ARRAY:
6692 const unsigned char *vs;
6693 unsigned int vec_len;
6696 fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6697 vec_len = (buf[0] + 1 + 7) / 8;
6698 for (i = 0; i < vec_len; i++)
6699 fprintf (file, " %02x", buf[i + 1]);
6701 vs = buf + 1 + vec_len;
6702 evax_bfd_print_indent (indent, file);
6703 fprintf (file, ("array descriptor:\n"));
6704 vs += evax_bfd_print_valspec (vs, indent + 1, file);
6705 for (i = 0; i < buf[0] + 1U; i++)
6706 if (buf[1 + i / 8] & (1 << (i % 8)))
6708 evax_bfd_print_indent (indent, file);
6710 fprintf (file, ("type spec for element:\n"));
6712 fprintf (file, ("type spec for subscript %u:\n"), i);
6713 evax_bfd_print_typspec (vs, indent + 1, file);
6714 vs += bfd_getl16 (vs);
6719 fprintf (file, ("*unhandled*\n"));
6724 evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6726 unsigned int off = 0;
6727 unsigned int pc = 0;
6728 unsigned int line = 0;
6730 fprintf (file, _("Debug symbol table:\n"));
6732 while (dst_size > 0)
6734 struct vms_dst_header dsth;
6739 if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6741 fprintf (file, _("cannot read DST header\n"));
6744 len = bfd_getl16 (dsth.length);
6745 type = bfd_getl16 (dsth.type);
6746 fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6756 len -= sizeof (dsth);
6757 buf = bfd_malloc (len);
6758 if (bfd_bread (buf, len, abfd) != len)
6760 fprintf (file, _("cannot read DST symbol\n"));
6765 case DSC__K_DTYPE_V:
6766 case DSC__K_DTYPE_BU:
6767 case DSC__K_DTYPE_WU:
6768 case DSC__K_DTYPE_LU:
6769 case DSC__K_DTYPE_QU:
6770 case DSC__K_DTYPE_B:
6771 case DSC__K_DTYPE_W:
6772 case DSC__K_DTYPE_L:
6773 case DSC__K_DTYPE_Q:
6774 case DSC__K_DTYPE_F:
6775 case DSC__K_DTYPE_D:
6776 case DSC__K_DTYPE_FC:
6777 case DSC__K_DTYPE_DC:
6778 case DSC__K_DTYPE_T:
6779 case DSC__K_DTYPE_NU:
6780 case DSC__K_DTYPE_NL:
6781 case DSC__K_DTYPE_NLO:
6782 case DSC__K_DTYPE_NR:
6783 case DSC__K_DTYPE_NRO:
6784 case DSC__K_DTYPE_NZ:
6785 case DSC__K_DTYPE_P:
6786 case DSC__K_DTYPE_ZI:
6787 case DSC__K_DTYPE_ZEM:
6788 case DSC__K_DTYPE_DSC:
6789 case DSC__K_DTYPE_OU:
6790 case DSC__K_DTYPE_O:
6791 case DSC__K_DTYPE_G:
6792 case DSC__K_DTYPE_H:
6793 case DSC__K_DTYPE_GC:
6794 case DSC__K_DTYPE_HC:
6795 case DSC__K_DTYPE_CIT:
6796 case DSC__K_DTYPE_BPV:
6797 case DSC__K_DTYPE_BLV:
6798 case DSC__K_DTYPE_VU:
6799 case DSC__K_DTYPE_ADT:
6800 case DSC__K_DTYPE_VT:
6801 case DSC__K_DTYPE_T2:
6802 case DSC__K_DTYPE_VT2:
6803 fprintf (file, _("standard data: %s\n"),
6804 evax_bfd_get_dsc_name (type));
6805 evax_bfd_print_valspec (buf, 4, file);
6806 fprintf (file, _(" name: %.*s\n"), buf[5], buf + 6);
6810 struct vms_dst_modbeg *dst = (void *)buf;
6811 const char *name = (const char *)buf + sizeof (*dst);
6813 fprintf (file, _("modbeg\n"));
6814 fprintf (file, _(" flags: %d, language: %u, "
6815 "major: %u, minor: %u\n"),
6817 (unsigned)bfd_getl32 (dst->language),
6818 (unsigned)bfd_getl16 (dst->major),
6819 (unsigned)bfd_getl16 (dst->minor));
6820 fprintf (file, _(" module name: %.*s\n"),
6822 name += name[0] + 1;
6823 fprintf (file, _(" compiler : %.*s\n"),
6828 fprintf (file, _("modend\n"));
6832 struct vms_dst_rtnbeg *dst = (void *)buf;
6833 const char *name = (const char *)buf + sizeof (*dst);
6835 fputs (_("rtnbeg\n"), file);
6836 fprintf (file, _(" flags: %u, address: 0x%08x, "
6837 "pd-address: 0x%08x\n"),
6839 (unsigned)bfd_getl32 (dst->address),
6840 (unsigned)bfd_getl32 (dst->pd_address));
6841 fprintf (file, _(" routine name: %.*s\n"),
6847 struct vms_dst_rtnend *dst = (void *)buf;
6849 fprintf (file, _("rtnend: size 0x%08x\n"),
6850 (unsigned)bfd_getl32 (dst->size));
6855 struct vms_dst_prolog *dst = (void *)buf;
6857 fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6858 (unsigned)bfd_getl32 (dst->bkpt_addr));
6863 struct vms_dst_epilog *dst = (void *)buf;
6865 fprintf (file, _("epilog: flags: %u, count: %u\n"),
6866 dst->flags, (unsigned)bfd_getl32 (dst->count));
6871 struct vms_dst_blkbeg *dst = (void *)buf;
6872 const char *name = (const char *)buf + sizeof (*dst);
6874 fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6875 (unsigned)bfd_getl32 (dst->address),
6881 struct vms_dst_blkend *dst = (void *)buf;
6883 fprintf (file, _("blkend: size: 0x%08x\n"),
6884 (unsigned)bfd_getl32 (dst->size));
6887 case DST__K_TYPSPEC:
6889 fprintf (file, _("typspec (len: %u)\n"), len);
6890 fprintf (file, _(" name: %.*s\n"), buf[0], buf + 1);
6891 evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
6896 fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
6897 evax_bfd_print_valspec (buf, 4, file);
6902 struct vms_dst_recbeg *recbeg = (void *)buf;
6903 const char *name = (const char *)buf + sizeof (*recbeg);
6905 fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
6906 evax_bfd_print_valspec (buf, 4, file);
6907 fprintf (file, (" len: %u bits\n"),
6908 (unsigned)bfd_getl32 (name + 1 + name[0]));
6912 fprintf (file, _("recend\n"));
6914 case DST__K_ENUMBEG:
6915 fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
6916 buf[0], buf[1], buf + 2);
6918 case DST__K_ENUMELT:
6919 fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
6920 evax_bfd_print_valspec (buf, 4, file);
6922 case DST__K_ENUMEND:
6923 fprintf (file, _("enumend\n"));
6927 struct vms_dst_label *lab = (void *)buf;
6928 fprintf (file, ("label, name: %.*s\n"),
6929 lab->name[0], lab->name + 1);
6930 fprintf (file, (" address: 0x%08x\n"),
6931 (unsigned)bfd_getl32 (lab->value));
6934 case DST__K_DIS_RANGE:
6936 unsigned int cnt = bfd_getl32 (buf);
6937 unsigned char *rng = buf + 4;
6940 fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
6941 for (i = 0; i < cnt; i++, rng += 8)
6942 fprintf (file, _(" address: 0x%08x, size: %u\n"),
6943 (unsigned)bfd_getl32 (rng),
6944 (unsigned)bfd_getl32 (rng + 4));
6948 case DST__K_LINE_NUM:
6950 unsigned char *buf_orig = buf;
6952 fprintf (file, _("line num (len: %u)\n"), len);
6957 unsigned char cmdlen;
6967 case DST__K_DELTA_PC_W:
6968 val = bfd_getl16 (buf + 1);
6969 fprintf (file, _("delta_pc_w %u\n"), val);
6974 case DST__K_INCR_LINUM:
6976 fprintf (file, _("incr_linum(b): +%u\n"), val);
6980 case DST__K_INCR_LINUM_W:
6981 val = bfd_getl16 (buf + 1);
6982 fprintf (file, _("incr_linum_w: +%u\n"), val);
6986 case DST__K_INCR_LINUM_L:
6987 val = bfd_getl32 (buf + 1);
6988 fprintf (file, _("incr_linum_l: +%u\n"), val);
6992 case DST__K_SET_LINUM:
6993 line = bfd_getl16 (buf + 1);
6994 fprintf (file, _("set_line_num(w) %u\n"), line);
6997 case DST__K_SET_LINUM_B:
6999 fprintf (file, _("set_line_num_b %u\n"), line);
7002 case DST__K_SET_LINUM_L:
7003 line = bfd_getl32 (buf + 1);
7004 fprintf (file, _("set_line_num_l %u\n"), line);
7007 case DST__K_SET_ABS_PC:
7008 pc = bfd_getl32 (buf + 1);
7009 fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7012 case DST__K_DELTA_PC_L:
7013 fprintf (file, _("delta_pc_l: +0x%08x\n"),
7014 (unsigned)bfd_getl32 (buf + 1));
7018 fprintf (file, _("term(b): 0x%02x"), buf[1]);
7020 fprintf (file, _(" pc: 0x%08x\n"), pc);
7024 val = bfd_getl16 (buf + 1);
7025 fprintf (file, _("term_w: 0x%04x"), val);
7027 fprintf (file, _(" pc: 0x%08x\n"), pc);
7033 fprintf (file, _("delta pc +%-4d"), -cmd);
7034 line++; /* FIXME: curr increment. */
7036 fprintf (file, _(" pc: 0x%08x line: %5u\n"),
7041 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7054 unsigned char *buf_orig = buf;
7056 fprintf (file, _("source (len: %u)\n"), len);
7060 signed char cmd = buf[0];
7061 unsigned char cmdlen = 0;
7065 case DST__K_SRC_DECLFILE:
7067 struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7070 fprintf (file, _(" declfile: len: %u, flags: %u, "
7072 src->length, src->flags,
7073 (unsigned)bfd_getl16 (src->fileid));
7074 fprintf (file, _(" rms: cdt: 0x%08x %08x, "
7075 "ebk: 0x%08x, ffb: 0x%04x, "
7077 (unsigned)bfd_getl32 (src->rms_cdt + 4),
7078 (unsigned)bfd_getl32 (src->rms_cdt + 0),
7079 (unsigned)bfd_getl32 (src->rms_ebk),
7080 (unsigned)bfd_getl16 (src->rms_ffb),
7082 name = (const char *)buf + 1 + sizeof (*src);
7083 fprintf (file, _(" filename : %.*s\n"),
7085 name += name[0] + 1;
7086 fprintf (file, _(" module name: %.*s\n"),
7088 cmdlen = 2 + src->length;
7091 case DST__K_SRC_SETFILE:
7092 fprintf (file, _(" setfile %u\n"),
7093 (unsigned)bfd_getl16 (buf + 1));
7096 case DST__K_SRC_SETREC_W:
7097 fprintf (file, _(" setrec %u\n"),
7098 (unsigned)bfd_getl16 (buf + 1));
7101 case DST__K_SRC_SETREC_L:
7102 fprintf (file, _(" setrec %u\n"),
7103 (unsigned)bfd_getl32 (buf + 1));
7106 case DST__K_SRC_SETLNUM_W:
7107 fprintf (file, _(" setlnum %u\n"),
7108 (unsigned)bfd_getl16 (buf + 1));
7111 case DST__K_SRC_SETLNUM_L:
7112 fprintf (file, _(" setlnum %u\n"),
7113 (unsigned)bfd_getl32 (buf + 1));
7116 case DST__K_SRC_DEFLINES_W:
7117 fprintf (file, _(" deflines %u\n"),
7118 (unsigned)bfd_getl16 (buf + 1));
7121 case DST__K_SRC_DEFLINES_B:
7122 fprintf (file, _(" deflines %u\n"), buf[1]);
7125 case DST__K_SRC_FORMFEED:
7126 fprintf (file, _(" formfeed\n"));
7130 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7142 fprintf (file, _("*unhandled* dst type %u\n"), type);
7150 evax_bfd_print_image (bfd *abfd, FILE *file)
7152 struct vms_eihd eihd;
7155 unsigned int eiha_off;
7156 unsigned int eihi_off;
7157 unsigned int eihs_off;
7158 unsigned int eisd_off;
7159 unsigned int eihef_off = 0;
7160 unsigned int eihnp_off = 0;
7161 unsigned int dmt_vbn = 0;
7162 unsigned int dmt_size = 0;
7163 unsigned int dst_vbn = 0;
7164 unsigned int dst_size = 0;
7165 unsigned int gst_vbn = 0;
7166 unsigned int gst_size = 0;
7167 unsigned int eiaf_vbn = 0;
7168 unsigned int eiaf_size = 0;
7169 unsigned int eihvn_off;
7171 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7172 || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7174 fprintf (file, _("cannot read EIHD\n"));
7177 fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7178 (unsigned)bfd_getl32 (eihd.size),
7179 (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7180 fprintf (file, _(" majorid: %u, minorid: %u\n"),
7181 (unsigned)bfd_getl32 (eihd.majorid),
7182 (unsigned)bfd_getl32 (eihd.minorid));
7184 val = (unsigned)bfd_getl32 (eihd.imgtype);
7188 name = _("executable");
7191 name = _("linkable image");
7194 name = _("unknown");
7197 fprintf (file, _(" image type: %u (%s)"), val, name);
7199 val = (unsigned)bfd_getl32 (eihd.subtype);
7202 case EIHD__C_NATIVE:
7209 name = _("unknown");
7212 fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7214 eisd_off = bfd_getl32 (eihd.isdoff);
7215 eiha_off = bfd_getl32 (eihd.activoff);
7216 eihi_off = bfd_getl32 (eihd.imgidoff);
7217 eihs_off = bfd_getl32 (eihd.symdbgoff);
7218 fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7219 "imgid: %u, patch: %u\n"),
7220 eisd_off, eiha_off, eihs_off, eihi_off,
7221 (unsigned)bfd_getl32 (eihd.patchoff));
7222 fprintf (file, _(" fixup info rva: "));
7223 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7224 fprintf (file, _(", symbol vector rva: "));
7225 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7226 eihvn_off = bfd_getl32 (eihd.version_array_off);
7227 fprintf (file, _("\n"
7228 " version array off: %u\n"),
7231 _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7232 (unsigned)bfd_getl32 (eihd.imgiocnt),
7233 (unsigned)bfd_getl32 (eihd.iochancnt),
7234 (unsigned)bfd_getl32 (eihd.privreqs + 4),
7235 (unsigned)bfd_getl32 (eihd.privreqs + 0));
7236 val = (unsigned)bfd_getl32 (eihd.lnkflags);
7237 fprintf (file, _(" linker flags: %08x:"), val);
7238 if (val & EIHD__M_LNKDEBUG)
7239 fprintf (file, " LNKDEBUG");
7240 if (val & EIHD__M_LNKNOTFR)
7241 fprintf (file, " LNKNOTFR");
7242 if (val & EIHD__M_NOP0BUFS)
7243 fprintf (file, " NOP0BUFS");
7244 if (val & EIHD__M_PICIMG)
7245 fprintf (file, " PICIMG");
7246 if (val & EIHD__M_P0IMAGE)
7247 fprintf (file, " P0IMAGE");
7248 if (val & EIHD__M_DBGDMT)
7249 fprintf (file, " DBGDMT");
7250 if (val & EIHD__M_INISHR)
7251 fprintf (file, " INISHR");
7252 if (val & EIHD__M_XLATED)
7253 fprintf (file, " XLATED");
7254 if (val & EIHD__M_BIND_CODE_SEC)
7255 fprintf (file, " BIND_CODE_SEC");
7256 if (val & EIHD__M_BIND_DATA_SEC)
7257 fprintf (file, " BIND_DATA_SEC");
7258 if (val & EIHD__M_MKTHREADS)
7259 fprintf (file, " MKTHREADS");
7260 if (val & EIHD__M_UPCALLS)
7261 fprintf (file, " UPCALLS");
7262 if (val & EIHD__M_OMV_READY)
7263 fprintf (file, " OMV_READY");
7264 if (val & EIHD__M_EXT_BIND_SECT)
7265 fprintf (file, " EXT_BIND_SECT");
7266 fprintf (file, "\n");
7267 fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7268 "match ctrl: %u, symvect_size: %u\n"),
7269 (unsigned)bfd_getl32 (eihd.ident),
7270 (unsigned)bfd_getl32 (eihd.sysver),
7272 (unsigned)bfd_getl32 (eihd.symvect_size));
7273 fprintf (file, _(" BPAGE: %u"),
7274 (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7275 if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7277 eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7278 eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7279 fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7280 eihef_off, eihnp_off);
7282 fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7286 struct vms_eihvn eihvn;
7290 fprintf (file, _("system version array information:\n"));
7291 if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7292 || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7294 fprintf (file, _("cannot read EIHVN header\n"));
7297 mask = bfd_getl32 (eihvn.subsystem_mask);
7298 for (j = 0; j < 32; j++)
7299 if (mask & (1 << j))
7301 struct vms_eihvn_subversion ver;
7302 if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7304 fprintf (file, _("cannot read EIHVN version\n"));
7307 fprintf (file, _(" %02u "), j);
7310 case EIHVN__BASE_IMAGE_BIT:
7311 fputs (_("BASE_IMAGE "), file);
7313 case EIHVN__MEMORY_MANAGEMENT_BIT:
7314 fputs (_("MEMORY_MANAGEMENT"), file);
7317 fputs (_("IO "), file);
7319 case EIHVN__FILES_VOLUMES_BIT:
7320 fputs (_("FILES_VOLUMES "), file);
7322 case EIHVN__PROCESS_SCHED_BIT:
7323 fputs (_("PROCESS_SCHED "), file);
7325 case EIHVN__SYSGEN_BIT:
7326 fputs (_("SYSGEN "), file);
7328 case EIHVN__CLUSTERS_LOCKMGR_BIT:
7329 fputs (_("CLUSTERS_LOCKMGR "), file);
7331 case EIHVN__LOGICAL_NAMES_BIT:
7332 fputs (_("LOGICAL_NAMES "), file);
7334 case EIHVN__SECURITY_BIT:
7335 fputs (_("SECURITY "), file);
7337 case EIHVN__IMAGE_ACTIVATOR_BIT:
7338 fputs (_("IMAGE_ACTIVATOR "), file);
7340 case EIHVN__NETWORKS_BIT:
7341 fputs (_("NETWORKS "), file);
7343 case EIHVN__COUNTERS_BIT:
7344 fputs (_("COUNTERS "), file);
7346 case EIHVN__STABLE_BIT:
7347 fputs (_("STABLE "), file);
7349 case EIHVN__MISC_BIT:
7350 fputs (_("MISC "), file);
7352 case EIHVN__CPU_BIT:
7353 fputs (_("CPU "), file);
7355 case EIHVN__VOLATILE_BIT:
7356 fputs (_("VOLATILE "), file);
7358 case EIHVN__SHELL_BIT:
7359 fputs (_("SHELL "), file);
7361 case EIHVN__POSIX_BIT:
7362 fputs (_("POSIX "), file);
7364 case EIHVN__MULTI_PROCESSING_BIT:
7365 fputs (_("MULTI_PROCESSING "), file);
7367 case EIHVN__GALAXY_BIT:
7368 fputs (_("GALAXY "), file);
7371 fputs (_("*unknown* "), file);
7374 fprintf (file, _(": %u.%u\n"),
7375 (unsigned)bfd_getl16 (ver.major),
7376 (unsigned)bfd_getl16 (ver.minor));
7382 struct vms_eiha eiha;
7384 if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7385 || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7387 fprintf (file, _("cannot read EIHA\n"));
7390 fprintf (file, _("Image activation: (size=%u)\n"),
7391 (unsigned)bfd_getl32 (eiha.size));
7392 fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7393 (unsigned)bfd_getl32 (eiha.tfradr1_h),
7394 (unsigned)bfd_getl32 (eiha.tfradr1));
7395 fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7396 (unsigned)bfd_getl32 (eiha.tfradr2_h),
7397 (unsigned)bfd_getl32 (eiha.tfradr2));
7398 fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7399 (unsigned)bfd_getl32 (eiha.tfradr3_h),
7400 (unsigned)bfd_getl32 (eiha.tfradr3));
7401 fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7402 (unsigned)bfd_getl32 (eiha.tfradr4_h),
7403 (unsigned)bfd_getl32 (eiha.tfradr4));
7404 fprintf (file, _(" Shared image : 0x%08x 0x%08x\n"),
7405 (unsigned)bfd_getl32 (eiha.inishr_h),
7406 (unsigned)bfd_getl32 (eiha.inishr));
7410 struct vms_eihi eihi;
7412 if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7413 || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7415 fprintf (file, _("cannot read EIHI\n"));
7418 fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7419 (unsigned)bfd_getl32 (eihi.majorid),
7420 (unsigned)bfd_getl32 (eihi.minorid));
7421 fprintf (file, _(" image name : %.*s\n"),
7422 eihi.imgnam[0], eihi.imgnam + 1);
7423 fprintf (file, _(" link time : %s\n"),
7424 vms_time_to_str (eihi.linktime));
7425 fprintf (file, _(" image ident : %.*s\n"),
7426 eihi.imgid[0], eihi.imgid + 1);
7427 fprintf (file, _(" linker ident : %.*s\n"),
7428 eihi.linkid[0], eihi.linkid + 1);
7429 fprintf (file, _(" image build ident: %.*s\n"),
7430 eihi.imgbid[0], eihi.imgbid + 1);
7434 struct vms_eihs eihs;
7436 if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7437 || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7439 fprintf (file, _("cannot read EIHS\n"));
7442 fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7443 (unsigned)bfd_getl32 (eihs.majorid),
7444 (unsigned)bfd_getl32 (eihs.minorid));
7445 dst_vbn = bfd_getl32 (eihs.dstvbn);
7446 dst_size = bfd_getl32 (eihs.dstsize);
7447 fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7448 dst_vbn, dst_size, dst_size);
7449 gst_vbn = bfd_getl32 (eihs.gstvbn);
7450 gst_size = bfd_getl32 (eihs.gstsize);
7451 fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7453 dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7454 dmt_size = bfd_getl32 (eihs.dmtsize);
7455 fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7458 while (eisd_off != 0)
7460 struct vms_eisd eisd;
7465 if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7466 || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7468 fprintf (file, _("cannot read EISD\n"));
7471 len = (unsigned)bfd_getl32 (eisd.eisdsize);
7472 if (len != (unsigned)-1)
7476 eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7478 fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7479 "size: %u, offset: %u)\n"),
7480 (unsigned)bfd_getl32 (eisd.majorid),
7481 (unsigned)bfd_getl32 (eisd.minorid),
7485 fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7486 (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7487 (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7488 (unsigned)bfd_getl32 (eisd.secsize));
7489 val = (unsigned)bfd_getl32 (eisd.flags);
7490 fprintf (file, _(" flags: 0x%04x"), val);
7491 if (val & EISD__M_GBL)
7492 fprintf (file, " GBL");
7493 if (val & EISD__M_CRF)
7494 fprintf (file, " CRF");
7495 if (val & EISD__M_DZRO)
7496 fprintf (file, " DZRO");
7497 if (val & EISD__M_WRT)
7498 fprintf (file, " WRT");
7499 if (val & EISD__M_INITALCODE)
7500 fprintf (file, " INITALCODE");
7501 if (val & EISD__M_BASED)
7502 fprintf (file, " BASED");
7503 if (val & EISD__M_FIXUPVEC)
7504 fprintf (file, " FIXUPVEC");
7505 if (val & EISD__M_RESIDENT)
7506 fprintf (file, " RESIDENT");
7507 if (val & EISD__M_VECTOR)
7508 fprintf (file, " VECTOR");
7509 if (val & EISD__M_PROTECT)
7510 fprintf (file, " PROTECT");
7511 if (val & EISD__M_LASTCLU)
7512 fprintf (file, " LASTCLU");
7513 if (val & EISD__M_EXE)
7514 fprintf (file, " EXE");
7515 if (val & EISD__M_NONSHRADR)
7516 fprintf (file, " NONSHRADR");
7517 if (val & EISD__M_QUAD_LENGTH)
7518 fprintf (file, " QUAD_LENGTH");
7519 if (val & EISD__M_ALLOC_64BIT)
7520 fprintf (file, " ALLOC_64BIT");
7521 fprintf (file, "\n");
7522 if (val & EISD__M_FIXUPVEC)
7524 eiaf_vbn = bfd_getl32 (eisd.vbn);
7525 eiaf_size = bfd_getl32 (eisd.secsize);
7527 fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7528 (unsigned)bfd_getl32 (eisd.vbn),
7529 eisd.pfc, eisd.matchctl, eisd.type);
7532 case EISD__K_NORMAL:
7533 fputs (_("NORMAL"), file);
7535 case EISD__K_SHRFXD:
7536 fputs (_("SHRFXD"), file);
7538 case EISD__K_PRVFXD:
7539 fputs (_("PRVFXD"), file);
7541 case EISD__K_SHRPIC:
7542 fputs (_("SHRPIC"), file);
7544 case EISD__K_PRVPIC:
7545 fputs (_("PRVPIC"), file);
7547 case EISD__K_USRSTACK:
7548 fputs (_("USRSTACK"), file);
7551 fputs (_("*unknown*"), file);
7554 fputs (_(")\n"), file);
7555 if (val & EISD__M_GBL)
7556 fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7557 (unsigned)bfd_getl32 (eisd.ident),
7558 eisd.gblnam[0], eisd.gblnam + 1);
7564 if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7566 fprintf (file, _("cannot read DMT\n"));
7570 fprintf (file, _("Debug module table:\n"));
7572 while (dmt_size > 0)
7574 struct vms_dmt_header dmth;
7577 if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7579 fprintf (file, _("cannot read DMT header\n"));
7582 count = bfd_getl16 (dmth.psect_count);
7584 _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
7585 (unsigned)bfd_getl32 (dmth.modbeg),
7586 (unsigned)bfd_getl32 (dmth.size), count);
7587 dmt_size -= sizeof (dmth);
7590 struct vms_dmt_psect dmtp;
7592 if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7594 fprintf (file, _("cannot read DMT psect\n"));
7597 fprintf (file, _(" psect start: 0x%08x, length: %u\n"),
7598 (unsigned)bfd_getl32 (dmtp.start),
7599 (unsigned)bfd_getl32 (dmtp.length));
7601 dmt_size -= sizeof (dmtp);
7608 if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7610 fprintf (file, _("cannot read DST\n"));
7614 evax_bfd_print_dst (abfd, dst_size, file);
7618 if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7620 fprintf (file, _("cannot read GST\n"));
7624 fprintf (file, _("Global symbol table:\n"));
7625 evax_bfd_print_eobj (abfd, file);
7630 struct vms_eiaf *eiaf;
7631 unsigned int qrelfixoff;
7632 unsigned int lrelfixoff;
7633 unsigned int qdotadroff;
7634 unsigned int ldotadroff;
7635 unsigned int shrimgcnt;
7636 unsigned int shlstoff;
7637 unsigned int codeadroff;
7638 unsigned int lpfixoff;
7639 unsigned int chgprtoff;
7641 buf = bfd_malloc (eiaf_size);
7643 if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7644 || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7646 fprintf (file, _("cannot read EIHA\n"));
7650 eiaf = (struct vms_eiaf *)buf;
7652 _("Image activator fixup: (major: %u, minor: %u)\n"),
7653 (unsigned)bfd_getl32 (eiaf->majorid),
7654 (unsigned)bfd_getl32 (eiaf->minorid));
7655 fprintf (file, _(" iaflink : 0x%08x %08x\n"),
7656 (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7657 (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7658 fprintf (file, _(" fixuplnk: 0x%08x %08x\n"),
7659 (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7660 (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7661 fprintf (file, _(" size : %u\n"),
7662 (unsigned)bfd_getl32 (eiaf->size));
7663 fprintf (file, _(" flags: 0x%08x\n"),
7664 (unsigned)bfd_getl32 (eiaf->flags));
7665 qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7666 lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7667 fprintf (file, _(" qrelfixoff: %5u, lrelfixoff: %5u\n"),
7668 qrelfixoff, lrelfixoff);
7669 qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7670 ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7671 fprintf (file, _(" qdotadroff: %5u, ldotadroff: %5u\n"),
7672 qdotadroff, ldotadroff);
7673 codeadroff = bfd_getl32 (eiaf->codeadroff);
7674 lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7675 fprintf (file, _(" codeadroff: %5u, lpfixoff : %5u\n"),
7676 codeadroff, lpfixoff);
7677 chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7678 fprintf (file, _(" chgprtoff : %5u\n"), chgprtoff);
7679 shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7680 shlstoff = bfd_getl32 (eiaf->shlstoff);
7681 fprintf (file, _(" shlstoff : %5u, shrimgcnt : %5u\n"),
7682 shlstoff, shrimgcnt);
7683 fprintf (file, _(" shlextra : %5u, permctx : %5u\n"),
7684 (unsigned)bfd_getl32 (eiaf->shlextra),
7685 (unsigned)bfd_getl32 (eiaf->permctx));
7686 fprintf (file, _(" base_va : 0x%08x\n"),
7687 (unsigned)bfd_getl32 (eiaf->base_va));
7688 fprintf (file, _(" lppsbfixoff: %5u\n"),
7689 (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7693 struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7696 fprintf (file, _(" Shareable images:\n"));
7697 for (j = 0; j < shrimgcnt; j++, shl++)
7700 _(" %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7701 j, shl->size, shl->flags,
7702 shl->imgnam[0], shl->imgnam + 1);
7705 if (qrelfixoff != 0)
7707 fprintf (file, _(" quad-word relocation fixups:\n"));
7708 evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7710 if (lrelfixoff != 0)
7712 fprintf (file, _(" long-word relocation fixups:\n"));
7713 evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7715 if (qdotadroff != 0)
7717 fprintf (file, _(" quad-word .address reference fixups:\n"));
7718 evax_bfd_print_address_fixups (file, buf + qdotadroff);
7720 if (ldotadroff != 0)
7722 fprintf (file, _(" long-word .address reference fixups:\n"));
7723 evax_bfd_print_address_fixups (file, buf + ldotadroff);
7725 if (codeadroff != 0)
7727 fprintf (file, _(" Code Address Reference Fixups:\n"));
7728 evax_bfd_print_reference_fixups (file, buf + codeadroff);
7732 fprintf (file, _(" Linkage Pairs Reference Fixups:\n"));
7733 evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7737 unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7738 struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7741 fprintf (file, _(" Change Protection (%u entries):\n"), count);
7742 for (j = 0; j < count; j++, eicp++)
7744 unsigned int prot = bfd_getl32 (eicp->newprt);
7746 _(" base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7747 (unsigned)bfd_getl32 (eicp->baseva + 4),
7748 (unsigned)bfd_getl32 (eicp->baseva + 0),
7749 (unsigned)bfd_getl32 (eicp->size),
7750 (unsigned)bfd_getl32 (eicp->newprt));
7754 fprintf (file, "NA");
7756 case PRT__C_RESERVED:
7757 fprintf (file, "RES");
7760 fprintf (file, "KW");
7763 fprintf (file, "KR");
7766 fprintf (file, "UW");
7769 fprintf (file, "EW");
7772 fprintf (file, "ERKW");
7775 fprintf (file, "ER");
7778 fprintf (file, "SW");
7781 fprintf (file, "SREW");
7784 fprintf (file, "SRKW");
7787 fprintf (file, "SR");
7790 fprintf (file, "URSW");
7793 fprintf (file, "UREW");
7796 fprintf (file, "URKW");
7799 fprintf (file, "UR");
7813 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7815 FILE *file = (FILE *)ptr;
7817 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7818 evax_bfd_print_image (abfd, file);
7821 if (bfd_seek (abfd, 0, SEEK_SET))
7823 evax_bfd_print_eobj (abfd, file);
7830 /* Slurp ETIR/EDBG/ETBT VMS object records. */
7833 alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7835 asection *cur_section;
7836 file_ptr cur_offset;
7837 asection *dst_section;
7838 file_ptr dst_offset;
7840 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7846 dst_section = PRIV (dst_section);
7850 if (info->strip == strip_all || info->strip == strip_debugger)
7852 /* Discard the DST section. */
7856 else if (dst_section)
7858 dst_offset = dst_section->output_offset;
7859 dst_section = dst_section->output_section;
7868 type = _bfd_vms_get_object_record (abfd);
7871 vms_debug2 ((2, "next_record failed\n"));
7877 PRIV (image_section) = cur_section;
7878 PRIV (image_offset) = cur_offset;
7879 res = _bfd_vms_slurp_etir (abfd, info);
7880 cur_section = PRIV (image_section);
7881 cur_offset = PRIV (image_offset);
7885 if (dst_section == NULL)
7887 PRIV (image_section) = dst_section;
7888 PRIV (image_offset) = dst_offset;
7889 res = _bfd_vms_slurp_etir (abfd, info);
7890 dst_offset = PRIV (image_offset);
7899 vms_debug2 ((2, "slurp eobj type %d failed\n", type));
7906 alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
7907 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7912 /* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
7915 alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
7917 struct alpha_vms_shlib_el *sl;
7918 asection *sect = PRIV2 (src, image_section);
7919 file_ptr offset = PRIV2 (src, image_offset);
7921 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7922 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7923 sl->has_fixups = TRUE;
7924 VEC_APPEND_EL (sl->lp, bfd_vma,
7925 sect->output_section->vma + sect->output_offset + offset);
7926 sect->output_section->flags |= SEC_RELOC;
7929 /* Add a code address fixup at address SECT + OFFSET to SHLIB. */
7932 alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
7934 struct alpha_vms_shlib_el *sl;
7935 asection *sect = PRIV2 (src, image_section);
7936 file_ptr offset = PRIV2 (src, image_offset);
7938 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7939 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7940 sl->has_fixups = TRUE;
7941 VEC_APPEND_EL (sl->ca, bfd_vma,
7942 sect->output_section->vma + sect->output_offset + offset);
7943 sect->output_section->flags |= SEC_RELOC;
7946 /* Add a quad word relocation fixup at address SECT + OFFSET to SHLIB. */
7949 alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
7950 bfd *shlib, bfd_vma vec)
7952 struct alpha_vms_shlib_el *sl;
7953 struct alpha_vms_vma_ref *r;
7954 asection *sect = PRIV2 (src, image_section);
7955 file_ptr offset = PRIV2 (src, image_offset);
7957 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7958 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7959 sl->has_fixups = TRUE;
7960 r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
7961 r->vma = sect->output_section->vma + sect->output_offset + offset;
7963 sect->output_section->flags |= SEC_RELOC;
7967 alpha_vms_add_fixup_lr (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7968 unsigned int shr ATTRIBUTE_UNUSED,
7969 bfd_vma vec ATTRIBUTE_UNUSED)
7971 /* Not yet supported. */
7975 /* Add relocation. FIXME: Not yet emitted. */
7978 alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
7983 alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
7987 static struct bfd_hash_entry *
7988 alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
7989 struct bfd_hash_table *table,
7992 struct alpha_vms_link_hash_entry *ret =
7993 (struct alpha_vms_link_hash_entry *) entry;
7995 /* Allocate the structure if it has not already been allocated by a
7998 ret = ((struct alpha_vms_link_hash_entry *)
7999 bfd_hash_allocate (table,
8000 sizeof (struct alpha_vms_link_hash_entry)));
8004 /* Call the allocation method of the superclass. */
8005 ret = ((struct alpha_vms_link_hash_entry *)
8006 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
8011 return (struct bfd_hash_entry *) ret;
8014 /* Create an Alpha/VMS link hash table. */
8016 static struct bfd_link_hash_table *
8017 alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8019 struct alpha_vms_link_hash_table *ret;
8020 bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8022 ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8025 if (!_bfd_link_hash_table_init (&ret->root, abfd,
8026 alpha_vms_link_hash_newfunc,
8027 sizeof (struct alpha_vms_link_hash_entry)))
8033 VEC_INIT (ret->shrlibs);
8040 alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8044 for (i = 0; i < PRIV (gsd_sym_count); i++)
8046 struct vms_symbol_entry *e = PRIV (syms)[i];
8047 struct alpha_vms_link_hash_entry *h;
8048 struct bfd_link_hash_entry *h_root;
8051 if (!alpha_vms_convert_symbol (abfd, e, &sym))
8054 if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8056 /* In selective_search mode, only add definition that are
8058 h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8059 (info->hash, sym.name, FALSE, FALSE, FALSE);
8060 if (h == NULL || h->root.type != bfd_link_hash_undefined)
8066 h_root = (struct bfd_link_hash_entry *) h;
8067 if (_bfd_generic_link_add_one_symbol
8068 (info, abfd, sym.name, sym.flags, sym.section, sym.value,
8069 NULL, FALSE, FALSE, &h_root) == FALSE)
8071 h = (struct alpha_vms_link_hash_entry *) h_root;
8073 if ((e->flags & EGSY__V_DEF)
8075 && abfd->xvec == info->output_bfd->xvec)
8079 if (abfd->flags & DYNAMIC)
8081 struct alpha_vms_shlib_el *shlib;
8083 /* We do not want to include any of the sections in a dynamic
8084 object in the output file. See comment in elflink.c. */
8085 bfd_section_list_clear (abfd);
8087 shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8088 struct alpha_vms_shlib_el);
8090 VEC_INIT (shlib->ca);
8091 VEC_INIT (shlib->lp);
8092 VEC_INIT (shlib->qr);
8093 PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8100 alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8103 struct bfd_link_hash_entry **pundef;
8104 struct bfd_link_hash_entry **next_pundef;
8106 /* We only accept VMS libraries. */
8107 if (info->output_bfd->xvec != abfd->xvec)
8109 bfd_set_error (bfd_error_wrong_format);
8113 /* The archive_pass field in the archive itself is used to
8114 initialize PASS, since we may search the same archive multiple
8116 pass = ++abfd->archive_pass;
8118 /* Look through the list of undefined symbols. */
8119 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8121 struct bfd_link_hash_entry *h;
8127 next_pundef = &(*pundef)->u.undef.next;
8129 /* When a symbol is defined, it is not necessarily removed from
8131 if (h->type != bfd_link_hash_undefined
8132 && h->type != bfd_link_hash_common)
8134 /* Remove this entry from the list, for general cleanliness
8135 and because we are going to look through the list again
8136 if we search any more libraries. We can't remove the
8137 entry if it is the tail, because that would lose any
8138 entries we add to the list later on. */
8139 if (*pundef != info->hash->undefs_tail)
8141 *pundef = *next_pundef;
8142 next_pundef = pundef;
8147 /* Look for this symbol in the archive hash table. */
8148 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8149 if (symidx == BFD_NO_MORE_SYMBOLS)
8151 /* Nothing in this slot. */
8155 element = bfd_get_elt_at_index (abfd, symidx);
8156 if (element == NULL)
8159 if (element->archive_pass == -1 || element->archive_pass == pass)
8161 /* Next symbol if this archive is wrong or already handled. */
8165 if (! bfd_check_format (element, bfd_object))
8167 element->archive_pass = -1;
8171 orig_element = element;
8172 if (bfd_is_thin_archive (abfd))
8174 element = _bfd_vms_lib_get_imagelib_file (element);
8175 if (element == NULL || !bfd_check_format (element, bfd_object))
8177 orig_element->archive_pass = -1;
8182 /* Unlike the generic linker, we know that this element provides
8183 a definition for an undefined symbol and we know that we want
8184 to include it. We don't need to check anything. */
8185 if (!(*info->callbacks
8186 ->add_archive_element) (info, element, h->root.string, &element))
8188 if (!alpha_vms_link_add_object_symbols (element, info))
8191 orig_element->archive_pass = pass;
8198 alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8200 switch (bfd_get_format (abfd))
8203 vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8205 return alpha_vms_link_add_object_symbols (abfd, info);
8208 vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8210 return alpha_vms_link_add_archive_symbols (abfd, info);
8213 bfd_set_error (bfd_error_wrong_format);
8219 alpha_vms_build_fixups (struct bfd_link_info *info)
8221 struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8222 unsigned char *content;
8224 unsigned int sz = 0;
8225 unsigned int lp_sz = 0;
8226 unsigned int ca_sz = 0;
8227 unsigned int qr_sz = 0;
8228 unsigned int shrimg_cnt = 0;
8229 unsigned int chgprt_num = 0;
8230 unsigned int chgprt_sz = 0;
8231 struct vms_eiaf *eiaf;
8235 /* Shared libraries. */
8236 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8238 struct alpha_vms_shlib_el *shlib;
8240 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8242 if (!shlib->has_fixups)
8247 if (VEC_COUNT (shlib->ca) > 0)
8249 /* Header + entries. */
8251 ca_sz += VEC_COUNT (shlib->ca) * 4;
8253 if (VEC_COUNT (shlib->lp) > 0)
8255 /* Header + entries. */
8257 lp_sz += VEC_COUNT (shlib->lp) * 4;
8259 if (VEC_COUNT (shlib->qr) > 0)
8261 /* Header + entries. */
8263 qr_sz += VEC_COUNT (shlib->qr) * 8;
8274 /* Finish now if there is no content. */
8275 if (ca_sz + lp_sz + qr_sz == 0)
8278 /* Add an eicp entry for the fixup itself. */
8280 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8282 /* This isect could be made RO or EXE after relocations are applied. */
8283 if ((sec->flags & SEC_RELOC) != 0
8284 && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8287 chgprt_sz = 4 + chgprt_num * sizeof (struct vms_eicp);
8289 /* Allocate section content (round-up size) */
8290 sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8291 + ca_sz + lp_sz + qr_sz + chgprt_sz;
8292 sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8293 content = bfd_zalloc (info->output_bfd, sz);
8294 if (content == NULL)
8297 sec = alpha_vms_link_hash (info)->fixup;
8298 sec->contents = content;
8301 eiaf = (struct vms_eiaf *)content;
8302 off = sizeof (struct vms_eiaf);
8303 bfd_putl32 (0, eiaf->majorid);
8304 bfd_putl32 (0, eiaf->minorid);
8305 bfd_putl32 (0, eiaf->iaflink);
8306 bfd_putl32 (0, eiaf->fixuplnk);
8307 bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8308 bfd_putl32 (0, eiaf->flags);
8309 bfd_putl32 (0, eiaf->qrelfixoff);
8310 bfd_putl32 (0, eiaf->lrelfixoff);
8311 bfd_putl32 (0, eiaf->qdotadroff);
8312 bfd_putl32 (0, eiaf->ldotadroff);
8313 bfd_putl32 (0, eiaf->codeadroff);
8314 bfd_putl32 (0, eiaf->lpfixoff);
8315 bfd_putl32 (0, eiaf->chgprtoff);
8316 bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8317 bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8318 bfd_putl32 (0, eiaf->shlextra);
8319 bfd_putl32 (0, eiaf->permctx);
8320 bfd_putl32 (0, eiaf->base_va);
8321 bfd_putl32 (0, eiaf->lppsbfixoff);
8328 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8330 struct alpha_vms_shlib_el *shlib;
8331 struct vms_shl *shl;
8333 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8335 if (!shlib->has_fixups)
8338 /* Renumber shared images. */
8339 PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8341 shl = (struct vms_shl *)(content + off);
8342 bfd_putl32 (0, shl->baseva);
8343 bfd_putl32 (0, shl->shlptr);
8344 bfd_putl32 (0, shl->ident);
8345 bfd_putl32 (0, shl->permctx);
8346 shl->size = sizeof (struct vms_shl);
8347 bfd_putl16 (0, shl->fill_1);
8349 bfd_putl32 (0, shl->icb);
8350 shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8351 memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8354 off += sizeof (struct vms_shl);
8360 bfd_putl32 (off, eiaf->codeadroff);
8362 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8364 struct alpha_vms_shlib_el *shlib;
8367 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8369 if (VEC_COUNT (shlib->ca) == 0)
8372 bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8373 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8376 for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8378 bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8384 bfd_putl32 (0, content + off);
8385 bfd_putl32 (0, content + off + 4);
8392 bfd_putl32 (off, eiaf->lpfixoff);
8394 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8396 struct alpha_vms_shlib_el *shlib;
8399 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8401 if (VEC_COUNT (shlib->lp) == 0)
8404 bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8405 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8408 for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8410 bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8416 bfd_putl32 (0, content + off);
8417 bfd_putl32 (0, content + off + 4);
8424 bfd_putl32 (off, eiaf->qdotadroff);
8426 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8428 struct alpha_vms_shlib_el *shlib;
8431 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8433 if (VEC_COUNT (shlib->qr) == 0)
8436 bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8437 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8440 for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8442 struct alpha_vms_vma_ref *r;
8443 r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8444 bfd_putl32 (r->vma - t->base_addr, content + off);
8445 bfd_putl32 (r->ref, content + off + 4);
8450 bfd_putl32 (0, content + off);
8451 bfd_putl32 (0, content + off + 4);
8456 /* Write the change protection table. */
8457 bfd_putl32 (off, eiaf->chgprtoff);
8458 bfd_putl32 (chgprt_num, content + off);
8461 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8463 struct vms_eicp *eicp;
8466 if ((sec->flags & SEC_LINKER_CREATED) != 0 &&
8467 strcmp (sec->name, "$FIXUP$") == 0)
8469 else if ((sec->flags & SEC_RELOC) != 0
8470 && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8475 eicp = (struct vms_eicp *)(content + off);
8476 bfd_putl64 (sec->vma - t->base_addr, eicp->baseva);
8477 bfd_putl32 ((sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1),
8479 bfd_putl32 (prot, eicp->newprt);
8480 off += sizeof (struct vms_eicp);
8486 /* Called by bfd_hash_traverse to fill the symbol table.
8487 Return FALSE in case of failure. */
8490 alpha_vms_link_output_symbol (struct bfd_hash_entry *bh, void *infov)
8492 struct bfd_link_hash_entry *hc = (struct bfd_link_hash_entry *) bh;
8493 struct bfd_link_info *info = (struct bfd_link_info *)infov;
8494 struct alpha_vms_link_hash_entry *h;
8495 struct vms_symbol_entry *sym;
8497 if (hc->type == bfd_link_hash_warning)
8500 if (hc->type == bfd_link_hash_new)
8503 h = (struct alpha_vms_link_hash_entry *) hc;
8505 switch (h->root.type)
8507 case bfd_link_hash_undefined:
8509 case bfd_link_hash_new:
8510 case bfd_link_hash_warning:
8512 case bfd_link_hash_undefweak:
8514 case bfd_link_hash_defined:
8515 case bfd_link_hash_defweak:
8517 asection *sec = h->root.u.def.section;
8519 /* FIXME: this is certainly a symbol from a dynamic library. */
8520 if (bfd_is_abs_section (sec))
8523 if (sec->owner->flags & DYNAMIC)
8527 case bfd_link_hash_common:
8529 case bfd_link_hash_indirect:
8533 /* Do not write not kept symbols. */
8534 if (info->strip == strip_some
8535 && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8536 FALSE, FALSE) != NULL)
8541 /* This symbol doesn't come from a VMS object. So we suppose it is
8543 int len = strlen (h->root.root.string);
8545 sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8546 sizeof (*sym) + len);
8550 memcpy (sym->name, h->root.root.string, len);
8552 sym->owner = info->output_bfd;
8554 sym->typ = EGSD__C_SYMG;
8556 sym->flags = EGSY__V_DEF | EGSY__V_REL;
8557 sym->symbol_vector = h->root.u.def.value;
8558 sym->section = h->root.u.def.section;
8559 sym->value = h->root.u.def.value;
8564 if (!add_symbol_entry (info->output_bfd, sym))
8571 alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8574 struct bfd_link_order *p;
8582 if (info->relocatable)
8584 /* FIXME: we do not yet support relocatable link. It is not obvious
8585 how to do it for debug infos. */
8586 (*info->callbacks->einfo)(_("%P: relocatable link is not supported\n"));
8590 bfd_get_outsymbols (abfd) = NULL;
8591 bfd_get_symcount (abfd) = 0;
8593 /* Mark all sections which will be included in the output file. */
8594 for (o = abfd->sections; o != NULL; o = o->next)
8595 for (p = o->map_head.link_order; p != NULL; p = p->next)
8596 if (p->type == bfd_indirect_link_order)
8597 p->u.indirect.section->linker_mark = TRUE;
8600 /* Handle all the link order information for the sections. */
8601 for (o = abfd->sections; o != NULL; o = o->next)
8603 printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8604 o->name, (unsigned)o->vma, (unsigned)o->flags);
8606 for (p = o->map_head.link_order; p != NULL; p = p->next)
8608 printf (" at 0x%08x - 0x%08x: ",
8609 (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8612 case bfd_section_reloc_link_order:
8613 case bfd_symbol_reloc_link_order:
8614 printf (" section/symbol reloc\n");
8616 case bfd_indirect_link_order:
8617 printf (" section %s of %s\n",
8618 p->u.indirect.section->name,
8619 p->u.indirect.section->owner->filename);
8621 case bfd_data_link_order:
8622 printf (" explicit data\n");
8625 printf (" *unknown* type %u\n", p->type);
8632 /* Generate the symbol table. */
8633 BFD_ASSERT (PRIV (syms) == NULL);
8634 if (info->strip != strip_all)
8635 bfd_hash_traverse (&info->hash->table, alpha_vms_link_output_symbol, info);
8637 /* Find the entry point. */
8638 if (bfd_get_start_address (abfd) == 0)
8640 bfd *startbfd = NULL;
8642 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
8644 /* Consider only VMS object files. */
8645 if (sub->xvec != abfd->xvec)
8648 if (!PRIV2 (sub, eom_data).eom_has_transfer)
8650 if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8652 if (startbfd != NULL
8653 && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8655 (*info->callbacks->einfo)
8656 (_("%P: multiple entry points: in modules %B and %B\n"),
8665 unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8666 bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8669 sec = PRIV2 (startbfd, sections)[ps_idx];
8671 bfd_set_start_address
8672 (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8676 /* Set transfer addresses. */
8679 struct bfd_link_hash_entry *h;
8682 PRIV (transfer_address[i++]) = 0xffffffff00000340ULL; /* SYS$IMGACT */
8683 h = bfd_link_hash_lookup (info->hash, "LIB$INITIALIZE", FALSE, FALSE, TRUE);
8684 if (h != NULL && h->type == bfd_link_hash_defined)
8685 PRIV (transfer_address[i++]) =
8686 alpha_vms_get_sym_value (h->u.def.section, h->u.def.value);
8687 PRIV (transfer_address[i++]) = bfd_get_start_address (abfd);
8689 PRIV (transfer_address[i++]) = 0;
8692 /* Allocate contents.
8693 Also compute the virtual base address. */
8694 base_addr = (bfd_vma)-1;
8696 for (o = abfd->sections; o != NULL; o = o->next)
8698 if (o->flags & SEC_HAS_CONTENTS)
8700 o->contents = bfd_alloc (abfd, o->size);
8701 if (o->contents == NULL)
8704 if (o->flags & SEC_LOAD)
8706 if (o->vma < base_addr)
8708 if (o->vma + o->size > last_addr)
8709 last_addr = o->vma + o->size;
8711 /* Clear the RELOC flags. Currently we don't support incremental
8712 linking. We use the RELOC flag for computing the eicp entries. */
8713 o->flags &= ~SEC_RELOC;
8716 /* Create the fixup section. */
8717 fixupsec = bfd_make_section_anyway_with_flags
8718 (info->output_bfd, "$FIXUP$",
8719 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8720 if (fixupsec == NULL)
8722 last_addr = (last_addr + 0xffff) & ~0xffff;
8723 fixupsec->vma = last_addr;
8725 alpha_vms_link_hash (info)->fixup = fixupsec;
8726 alpha_vms_link_hash (info)->base_addr = base_addr;
8728 /* Create the DMT section, if necessary. */
8729 BFD_ASSERT (PRIV (dst_section) == NULL);
8730 dst = bfd_get_section_by_name (abfd, "$DST$");
8731 if (dst != NULL && dst->size == 0)
8735 PRIV (dst_section) = dst;
8736 dmt = bfd_make_section_anyway_with_flags
8737 (info->output_bfd, "$DMT$",
8738 SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8745 /* Read all sections from the inputs. */
8746 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
8748 if (sub->flags & DYNAMIC)
8750 alpha_vms_create_eisd_for_shared (abfd, sub);
8754 if (!alpha_vms_read_sections_content (sub, info))
8758 /* Handle all the link order information for the sections.
8759 Note: past this point, it is not possible to create new sections. */
8760 for (o = abfd->sections; o != NULL; o = o->next)
8762 for (p = o->map_head.link_order; p != NULL; p = p->next)
8766 case bfd_section_reloc_link_order:
8767 case bfd_symbol_reloc_link_order:
8770 case bfd_indirect_link_order:
8774 if (! _bfd_default_link_order (abfd, info, o, p))
8781 /* Compute fixups. */
8782 if (!alpha_vms_build_fixups (info))
8785 /* Compute the DMT. */
8789 unsigned char *contents = NULL;
8791 /* In pass 1, compute the size. In pass 2, write the DMT contents. */
8792 for (pass = 0; pass < 2; pass++)
8794 unsigned int off = 0;
8796 /* For each object file (ie for each module). */
8797 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
8800 struct vms_dmt_header *dmth = NULL;
8801 unsigned int psect_count;
8803 /* Skip this module if it has no DST. */
8804 sub_dst = PRIV2 (sub, dst_section);
8805 if (sub_dst == NULL || sub_dst->size == 0)
8810 /* Write the header. */
8811 dmth = (struct vms_dmt_header *)(contents + off);
8812 bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8813 bfd_putl32 (sub_dst->size, dmth->size);
8816 off += sizeof (struct vms_dmt_header);
8819 /* For each section (ie for each psect). */
8820 for (o = sub->sections; o != NULL; o = o->next)
8822 /* Only consider interesting sections. */
8823 if (!(o->flags & SEC_ALLOC))
8825 if (o->flags & SEC_LINKER_CREATED)
8830 /* Write an entry. */
8831 struct vms_dmt_psect *dmtp;
8833 dmtp = (struct vms_dmt_psect *)(contents + off);
8834 bfd_putl32 (o->output_offset + o->output_section->vma,
8836 bfd_putl32 (o->size, dmtp->length);
8839 off += sizeof (struct vms_dmt_psect);
8842 bfd_putl32 (psect_count, dmth->psect_count);
8847 contents = bfd_zalloc (info->output_bfd, off);
8848 if (contents == NULL)
8850 dmt->contents = contents;
8855 BFD_ASSERT (off == dmt->size);
8863 /* Read the contents of a section.
8864 buf points to a buffer of buf_size bytes to be filled with
8865 section data (starting at offset into section) */
8868 alpha_vms_get_section_contents (bfd *abfd, asection *section,
8869 void *buf, file_ptr offset,
8870 bfd_size_type count)
8874 /* Image are easy. */
8875 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8876 return _bfd_generic_get_section_contents (abfd, section,
8877 buf, offset, count);
8880 if (offset + count < count
8881 || offset + count > section->size)
8883 bfd_set_error (bfd_error_invalid_operation);
8887 /* If the section is already in memory, just copy it. */
8888 if (section->flags & SEC_IN_MEMORY)
8890 BFD_ASSERT (section->contents != NULL);
8891 memcpy (buf, section->contents + offset, count);
8894 if (section->size == 0)
8897 /* Alloc in memory and read ETIRs. */
8898 for (sec = abfd->sections; sec; sec = sec->next)
8900 BFD_ASSERT (sec->contents == NULL);
8902 if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
8904 sec->contents = bfd_alloc (abfd, sec->size);
8905 if (sec->contents == NULL)
8909 if (!alpha_vms_read_sections_content (abfd, NULL))
8911 for (sec = abfd->sections; sec; sec = sec->next)
8913 sec->flags |= SEC_IN_MEMORY;
8914 memcpy (buf, section->contents + offset, count);
8919 /* Set the format of a file being written. */
8922 alpha_vms_mkobject (bfd * abfd)
8924 const bfd_arch_info_type *arch;
8926 vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
8928 if (!vms_initialize (abfd))
8931 PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
8932 if (PRIV (recwr.buf) == NULL)
8935 arch = bfd_scan_arch ("alpha");
8939 bfd_set_error (bfd_error_wrong_format);
8943 abfd->arch_info = arch;
8950 /* Called when the BFD is being closed to do any necessary cleanup. */
8953 vms_close_and_cleanup (bfd * abfd)
8955 vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
8957 if (abfd == NULL || abfd->tdata.any == NULL)
8960 if (abfd->format == bfd_archive)
8962 bfd_release (abfd, abfd->tdata.any);
8963 abfd->tdata.any = NULL;
8967 if (PRIV (recrd.buf) != NULL)
8968 free (PRIV (recrd.buf));
8970 if (PRIV (sections) != NULL)
8971 free (PRIV (sections));
8973 bfd_release (abfd, abfd->tdata.any);
8974 abfd->tdata.any = NULL;
8977 if (abfd->direction == write_direction)
8979 /* Last step on VMS is to convert the file to variable record length
8981 if (bfd_cache_close (abfd) != TRUE)
8983 if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
8991 /* Called when a new section is created. */
8994 vms_new_section_hook (bfd * abfd, asection *section)
8998 vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
8999 abfd, section->index, section->name));
9001 if (! bfd_set_section_alignment (abfd, section, 0))
9004 vms_debug2 ((7, "%d: %s\n", section->index, section->name));
9006 amt = sizeof (struct vms_section_data_struct);
9007 section->used_by_bfd = bfd_zalloc (abfd, amt);
9008 if (section->used_by_bfd == NULL)
9011 /* Create the section symbol. */
9012 return _bfd_generic_new_section_hook (abfd, section);
9015 /* Part 4.5, symbols. */
9017 /* Print symbol to file according to how. how is one of
9018 bfd_print_symbol_name just print the name
9019 bfd_print_symbol_more print more (???)
9020 bfd_print_symbol_all print all we know, which is not much right now :-). */
9023 vms_print_symbol (bfd * abfd,
9026 bfd_print_symbol_type how)
9028 vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
9029 abfd, file, symbol, how));
9033 case bfd_print_symbol_name:
9034 case bfd_print_symbol_more:
9035 fprintf ((FILE *)file," %s", symbol->name);
9038 case bfd_print_symbol_all:
9040 const char *section_name = symbol->section->name;
9042 bfd_print_symbol_vandf (abfd, file, symbol);
9044 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9050 /* Return information about symbol in ret.
9052 fill type, value and name
9055 B bss segment symbol
9057 D data segment symbol
9059 t a static function symbol
9060 T text segment symbol
9065 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9071 vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9073 sec = symbol->section;
9080 else if (bfd_is_com_section (sec))
9082 else if (bfd_is_abs_section (sec))
9084 else if (bfd_is_und_section (sec))
9086 else if (bfd_is_ind_section (sec))
9088 else if ((symbol->flags & BSF_FUNCTION)
9089 || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
9091 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9093 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9098 if (ret->type != 'U')
9099 ret->value = symbol->value + symbol->section->vma;
9102 ret->name = symbol->name;
9105 /* Return TRUE if the given symbol sym in the BFD abfd is
9106 a compiler generated local label, else return FALSE. */
9109 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9112 return name[0] == '$';
9115 /* Part 4.7, writing an object file. */
9117 /* Sets the contents of the section section in BFD abfd to the data starting
9118 in memory at LOCATION. The data is written to the output section starting
9119 at offset offset for count bytes.
9121 Normally TRUE is returned, else FALSE. Possible error returns are:
9122 o bfd_error_no_contents - The output section does not have the
9123 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9124 o and some more too */
9127 _bfd_vms_set_section_contents (bfd * abfd,
9129 const void * location,
9131 bfd_size_type count)
9133 if (section->contents == NULL)
9135 section->contents = bfd_alloc (abfd, section->size);
9136 if (section->contents == NULL)
9139 memcpy (section->contents + offset, location, (size_t) count);
9145 /* Set the architecture and machine type in BFD abfd to arch and mach.
9146 Find the correct pointer to a structure and insert it into the arch_info
9150 alpha_vms_set_arch_mach (bfd *abfd,
9151 enum bfd_architecture arch, unsigned long mach)
9153 if (arch != bfd_arch_alpha
9154 && arch != bfd_arch_unknown)
9157 return bfd_default_set_arch_mach (abfd, arch, mach);
9160 /* Set section VMS flags. Clear NO_FLAGS and set FLAGS. */
9163 bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9164 asection *sec, flagword no_flags, flagword flags)
9166 vms_section_data (sec)->no_flags = no_flags;
9167 vms_section_data (sec)->flags = flags;
9170 struct vms_private_data_struct *
9171 bfd_vms_get_data (bfd *abfd)
9173 return (struct vms_private_data_struct *)abfd->tdata.any;
9176 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9177 #define vms_bfd_link_just_syms _bfd_generic_link_just_syms
9178 #define vms_bfd_copy_link_hash_symbol_type \
9179 _bfd_generic_copy_link_hash_symbol_type
9180 #define vms_bfd_is_group_section bfd_generic_is_group_section
9181 #define vms_bfd_discard_group bfd_generic_discard_group
9182 #define vms_section_already_linked _bfd_generic_section_already_linked
9183 #define vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9184 #define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
9186 #define vms_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
9187 #define vms_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
9188 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9189 #define vms_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
9190 #define vms_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
9191 #define vms_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
9193 /* Symbols table. */
9194 #define alpha_vms_make_empty_symbol _bfd_generic_make_empty_symbol
9195 #define alpha_vms_bfd_is_target_special_symbol \
9196 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9197 #define alpha_vms_print_symbol vms_print_symbol
9198 #define alpha_vms_get_symbol_info vms_get_symbol_info
9199 #define alpha_vms_get_symbol_version_string \
9200 _bfd_nosymbols_get_symbol_version_string
9202 #define alpha_vms_read_minisymbols _bfd_generic_read_minisymbols
9203 #define alpha_vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
9204 #define alpha_vms_get_lineno _bfd_nosymbols_get_lineno
9205 #define alpha_vms_find_inliner_info _bfd_nosymbols_find_inliner_info
9206 #define alpha_vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
9207 #define alpha_vms_find_nearest_line _bfd_vms_find_nearest_line
9208 #define alpha_vms_find_line _bfd_nosymbols_find_line
9209 #define alpha_vms_bfd_is_local_label_name vms_bfd_is_local_label_name
9211 /* Generic table. */
9212 #define alpha_vms_close_and_cleanup vms_close_and_cleanup
9213 #define alpha_vms_bfd_free_cached_info vms_bfd_free_cached_info
9214 #define alpha_vms_new_section_hook vms_new_section_hook
9215 #define alpha_vms_set_section_contents _bfd_vms_set_section_contents
9216 #define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9218 #define alpha_vms_bfd_get_relocated_section_contents \
9219 bfd_generic_get_relocated_section_contents
9221 #define alpha_vms_bfd_relax_section bfd_generic_relax_section
9222 #define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9223 #define alpha_vms_bfd_lookup_section_flags bfd_generic_lookup_section_flags
9224 #define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9225 #define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9226 #define alpha_vms_bfd_discard_group bfd_generic_discard_group
9227 #define alpha_vms_section_already_linked \
9228 _bfd_generic_section_already_linked
9230 #define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9231 #define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9232 #define alpha_vms_bfd_copy_link_hash_symbol_type \
9233 _bfd_generic_copy_link_hash_symbol_type
9235 #define alpha_vms_bfd_link_split_section _bfd_generic_link_split_section
9237 #define alpha_vms_get_dynamic_symtab_upper_bound \
9238 _bfd_nodynamic_get_dynamic_symtab_upper_bound
9239 #define alpha_vms_canonicalize_dynamic_symtab \
9240 _bfd_nodynamic_canonicalize_dynamic_symtab
9241 #define alpha_vms_get_dynamic_reloc_upper_bound \
9242 _bfd_nodynamic_get_dynamic_reloc_upper_bound
9243 #define alpha_vms_canonicalize_dynamic_reloc \
9244 _bfd_nodynamic_canonicalize_dynamic_reloc
9246 const bfd_target alpha_vms_vec =
9248 "vms-alpha", /* Name. */
9249 bfd_target_evax_flavour,
9250 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
9251 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
9253 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9254 | WP_TEXT | D_PAGED), /* Object flags. */
9255 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9256 | SEC_READONLY | SEC_CODE | SEC_DATA
9257 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
9258 0, /* symbol_leading_char. */
9259 ' ', /* ar_pad_char. */
9260 15, /* ar_max_namelen. */
9261 0, /* match priority. */
9262 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9263 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9264 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9265 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9266 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9267 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9269 {_bfd_dummy_target, alpha_vms_object_p, /* bfd_check_format. */
9270 _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9271 {bfd_false, alpha_vms_mkobject, /* bfd_set_format. */
9272 _bfd_vms_lib_alpha_mkarchive, bfd_false},
9273 {bfd_false, alpha_vms_write_object_contents, /* bfd_write_contents. */
9274 _bfd_vms_lib_write_archive_contents, bfd_false},
9276 BFD_JUMP_TABLE_GENERIC (alpha_vms),
9277 BFD_JUMP_TABLE_COPY (vms),
9278 BFD_JUMP_TABLE_CORE (_bfd_nocore),
9279 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9280 BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9281 BFD_JUMP_TABLE_RELOCS (alpha_vms),
9282 BFD_JUMP_TABLE_WRITE (alpha_vms),
9283 BFD_JUMP_TABLE_LINK (alpha_vms),
9284 BFD_JUMP_TABLE_DYNAMIC (alpha_vms),