projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
daily update
[deliverable/binutils-gdb.git] / bfd / vms-alpha.c
CommitLineData
95e34ef7
TG		 1/* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4
5 Initial version written by Klaus Kaempf (kkaempf@rmi.de)
6 Major rewrite by Adacore.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23/* TODO:
f9eeb9c9 24 o overlayed sections
95e34ef7
TG		 25 o PIC
26 o Generation of shared image
95e34ef7
TG		 27 o Relocation optimizations
28 o EISD for the stack
29 o Vectors isect
30 o 64 bits sections
31 o Entry point
f9eeb9c9
TG		 32 o LIB$INITIALIZE
33 o protected sections (for messages)
95e34ef7
TG		 34 ...
35*/
36
37#include "sysdep.h"
38#include "bfd.h"
39#include "bfdlink.h"
40#include "libbfd.h"
41#include "bfdver.h"
42
43#include "vms.h"
44#include "vms/eihd.h"
45#include "vms/eiha.h"
46#include "vms/eihi.h"
47#include "vms/eihs.h"
48#include "vms/eisd.h"
49#include "vms/dmt.h"
50#include "vms/dst.h"
51#include "vms/eihvn.h"
52#include "vms/eobjrec.h"
53#include "vms/egsd.h"
54#include "vms/egps.h"
9a1b4480 55#include "vms/esgps.h"
95e34ef7
TG		 56#include "vms/eeom.h"
57#include "vms/emh.h"
58#include "vms/eiaf.h"
59#include "vms/shl.h"
60#include "vms/eicp.h"
61#include "vms/etir.h"
62#include "vms/egsy.h"
63#include "vms/esdf.h"
64#include "vms/esdfm.h"
65#include "vms/esdfv.h"
66#include "vms/esrf.h"
67#include "vms/egst.h"
9a1b4480 68#include "vms/eidc.h"
95e34ef7
TG		 69#include "vms/dsc.h"
70#include "vms/prt.h"
71#include "vms/internal.h"
72\f
73
74#define MIN(a,b) ((a) < (b) ? (a) : (b))
75
76/* The r_type field in a reloc is one of the following values. */
77#define ALPHA_R_IGNORE 0
78#define ALPHA_R_REFQUAD 1
79#define ALPHA_R_BRADDR 2
80#define ALPHA_R_HINT 3
81#define ALPHA_R_SREL16 4
82#define ALPHA_R_SREL32 5
83#define ALPHA_R_SREL64 6
84#define ALPHA_R_OP_PUSH 7
85#define ALPHA_R_OP_STORE 8
86#define ALPHA_R_OP_PSUB 9
87#define ALPHA_R_OP_PRSHIFT 10
88#define ALPHA_R_LINKAGE 11
89#define ALPHA_R_REFLONG 12
90#define ALPHA_R_CODEADDR 13
91#define ALPHA_R_NOP 14
92#define ALPHA_R_BSR 15
93#define ALPHA_R_LDA 16
94#define ALPHA_R_BOH 17
44273c5b 95
95e34ef7
TG		 96/* These are used with DST_S_C_LINE_NUM. */
97#define DST_S_C_LINE_NUM_HEADER_SIZE 4
98
99/* These are used with DST_S_C_SOURCE */
100
101#define DST_S_B_PCLINE_UNSBYTE 1
102#define DST_S_W_PCLINE_UNSWORD 1
103#define DST_S_L_PCLINE_UNSLONG 1
104
105#define DST_S_B_MODBEG_NAME 14
106#define DST_S_L_RTNBEG_ADDRESS 5
107#define DST_S_B_RTNBEG_NAME 13
108#define DST_S_L_RTNEND_SIZE 5
109
110/* These are used with DST_S_C_SOURCE. */
111#define DST_S_C_SOURCE_HEADER_SIZE 4
112
113#define DST_S_B_SRC_DF_LENGTH 1
114#define DST_S_W_SRC_DF_FILEID 3
115#define DST_S_B_SRC_DF_FILENAME 20
116#define DST_S_B_SRC_UNSBYTE 1
117#define DST_S_W_SRC_UNSWORD 1
118#define DST_S_L_SRC_UNSLONG 1
119
120/* Debugger symbol definitions. */
121
122#define DBG_S_L_DMT_MODBEG 0
123#define DBG_S_L_DST_SIZE 4
124#define DBG_S_W_DMT_PSECT_COUNT 8
125#define DBG_S_C_DMT_HEADER_SIZE 12
126
127#define DBG_S_L_DMT_PSECT_START 0
128#define DBG_S_L_DMT_PSECT_LENGTH 4
129#define DBG_S_C_DMT_PSECT_SIZE 8
130
131/* VMS module header. */
132
133struct hdr_struct
134{
135 char hdr_b_strlvl;
136 int hdr_l_arch1;
137 int hdr_l_arch2;
138 int hdr_l_recsiz;
139 char *hdr_t_name;
140 char *hdr_t_version;
141 char *hdr_t_date;
142 char *hdr_c_lnm;
143 char *hdr_c_src;
144 char *hdr_c_ttl;
145};
146
147#define EMH_DATE_LENGTH 17
148
149/* VMS End-Of-Module records (EOM/EEOM). */
150
151struct eom_struct
152{
153 unsigned int eom_l_total_lps;
154 unsigned short eom_w_comcod;
155 bfd_boolean eom_has_transfer;
156 unsigned char eom_b_tfrflg;
157 unsigned int eom_l_psindx;
158 unsigned int eom_l_tfradr;
159};
160
161struct vms_symbol_entry
162{
163 bfd *owner;
164
165 /* Common fields. */
166 unsigned char typ;
167 unsigned char data_type;
168 unsigned short flags;
169
170 /* Section and offset/value of the symbol. */
95e34ef7 171 unsigned int value;
a928f1d7 172 asection *section;
95e34ef7
TG		 173
174 /* Section and offset/value for the entry point (only for subprg). */
a928f1d7 175 asection *code_section;
95e34ef7
TG		 176 unsigned int code_value;
177
178 /* Symbol vector offset. */
179 unsigned int symbol_vector;
180
181 /* Length of the name. */
182 unsigned char namelen;
183
184 char name[1];
185};
186
187/* Stack value for push/pop commands. */
188
189struct stack_struct
190{
191 bfd_vma value;
192 unsigned int reloc;
193};
194
195#define STACKSIZE 128
196
197/* A minimal decoding of DST compilation units. We only decode
198 what's needed to get to the line number information. */
199
200struct fileinfo
201{
202 char *name;
203 unsigned int srec;
204};
205
206struct srecinfo
207{
208 struct srecinfo *next;
209 unsigned int line;
210 unsigned int sfile;
211 unsigned int srec;
212};
213
214struct lineinfo
215{
216 struct lineinfo *next;
217 bfd_vma address;
218 unsigned int line;
219};
220
221struct funcinfo
222{
223 struct funcinfo *next;
224 char *name;
225 bfd_vma low;
226 bfd_vma high;
227};
228
229struct module
230{
231 /* Chain the previously read compilation unit. */
232 struct module *next;
233
234 /* The module name. */
235 char *name;
236
237 /* The start offset and size of debug info in the DST section. */
238 unsigned int modbeg;
239 unsigned int size;
240
241 /* The lowest and highest addresses contained in this compilation
242 unit as specified in the compilation unit header. */
243 bfd_vma low;
244 bfd_vma high;
245
246 /* The listing line table. */
247 struct lineinfo *line_table;
248
249 /* The source record table. */
250 struct srecinfo *srec_table;
251
252 /* A list of the functions found in this module. */
253 struct funcinfo *func_table;
254
255 /* Current allocation of file_table. */
256 unsigned int file_table_count;
257
258 /* An array of the files making up this module. */
259 struct fileinfo *file_table;
260};
261
262/* BFD private data for alpha-vms. */
263
264struct vms_private_data_struct
265{
266 /* If true, relocs have been read. */
267 bfd_boolean reloc_done;
268
269 /* Record input buffer. */
270 struct vms_rec_rd recrd;
271 struct vms_rec_wr recwr;
272
273 struct hdr_struct hdr_data; /* data from HDR/EMH record */
274 struct eom_struct eom_data; /* data from EOM/EEOM record */
c734eb83
TG		 275
276 /* Array of GSD sections to get the correspond BFD one. */
277 unsigned int section_max; /* Size of the sections array. */
278 unsigned int section_count; /* Number of GSD sections. */
279 asection **sections;
95e34ef7
TG		 280
281 /* Array of raw symbols. */
282 struct vms_symbol_entry **syms;
283
284 /* Canonicalized symbols. */
285 asymbol **csymbols;
286
287 /* Number of symbols. */
288 unsigned int gsd_sym_count;
289 /* Size of the syms array. */
290 unsigned int max_sym_count;
291 /* Number of procedure symbols. */
292 unsigned int norm_sym_count;
293
294 /* Stack used to evaluate TIR/ETIR commands. */
295 struct stack_struct *stack;
296 int stackptr;
297
298 /* Content reading. */
299 asection *image_section; /* section for image_ptr */
300 file_ptr image_offset; /* Offset for image_ptr. */
95e34ef7
TG		 301
302 struct module *modules; /* list of all compilation units */
303
304 struct dst_info *dst_info;
305 asection *dst_section;
306
307 unsigned int dst_ptr_offsets_count; /* # of offsets in following array */
308 unsigned int *dst_ptr_offsets; /* array of saved image_ptr offsets */
309
310 /* Shared library support */
311 bfd_vma symvva; /* relative virtual address of symbol vector */
312 unsigned int ident;
313 unsigned char matchctl;
314
315 /* Shared library index. This is used for input bfd while linking. */
316 unsigned int shr_index;
317
318 /* Used to place structures in the file. */
319 file_ptr file_pos;
320
321 /* Simply linked list of eisd. */
322 struct vms_internal_eisd_map *eisd_head;
323 struct vms_internal_eisd_map *eisd_tail;
324
325 /* Simply linked list of eisd for shared libraries. */
326 struct vms_internal_eisd_map *gbl_eisd_head;
327 struct vms_internal_eisd_map *gbl_eisd_tail;
328
329 /* linkage index counter used by conditional store commands */
330 int vms_linkage_index;
331
332 /* see tc-alpha.c of gas for a description. */
333 int flag_hash_long_names; /* -+, hash instead of truncate */
334 int flag_show_after_trunc; /* -H, show hashing/truncation */
335};
336
337#define PRIV2(abfd, name) \
338 (((struct vms_private_data_struct *)(abfd)->tdata.any)->name)
339#define PRIV(name) PRIV2(abfd,name)
340
341
342/* Used to keep extra VMS specific information for a given section.
343
344 reloc_size holds the size of the relocation stream, note this
345 is very different from the number of relocations as VMS relocations
346 are variable length.
347
348 reloc_stream is the actual stream of relocation entries. */
349
350struct vms_section_data_struct
351{
352 /* Maximnum number of entries in sec->relocation. */
353 unsigned reloc_max;
354
355 /* Corresponding eisd. Used only while generating executables. */
356 struct vms_internal_eisd_map *eisd;
357
358 /* PSC flags to be clear. */
359 flagword no_flags;
360
361 /* PSC flags to be set. */
362 flagword flags;
363};
364
365#define vms_section_data(sec) \
366 ((struct vms_section_data_struct *)sec->used_by_bfd)
367
368/* To be called from the debugger. */
369struct vms_private_data_struct *bfd_vms_get_data (bfd *abfd);
370
371static int vms_get_remaining_object_record (bfd *abfd, int read_so_far);
372static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);
373static void alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);
374static void alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);
375static void alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,
376 bfd_vma);
377static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);
378static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);
379static void alpha_vms_add_lw_fixup (struct bfd_link_info *, unsigned int,
380 bfd_vma);
381
382struct vector_type
383{
384 unsigned int max_el;
385 unsigned int nbr_el;
386 void *els;
387};
388
389/* Number of elements in VEC. */
390
391#define VEC_COUNT(VEC) ((VEC).nbr_el)
392
393/* Get the address of the Nth element. */
394
395#define VEC_EL(VEC, TYPE, N) (((TYPE *)((VEC).els))[N])
396
397#define VEC_INIT(VEC) \
398 do { \
399 (VEC).max_el = 0; \
400 (VEC).nbr_el = 0; \
401 (VEC).els = NULL; \
402 } while (0)
403
404/* Be sure there is room for a new element. */
405
406static void vector_grow1 (struct vector_type *vec, size_t elsz);
407
408/* Allocate room for a new element and return its address. */
409
410#define VEC_APPEND(VEC, TYPE) \
411 (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))
412
413/* Append an element. */
414
415#define VEC_APPEND_EL(VEC, TYPE, EL) \
416 (*(VEC_APPEND (VEC, TYPE)) = EL)
417
418struct alpha_vms_vma_ref
419{
420 bfd_vma vma; /* Vma in the output. */
421 bfd_vma ref; /* Reference in the input. */
422};
423
424struct alpha_vms_shlib_el
425{
426 bfd *abfd;
427 bfd_boolean has_fixups;
428
429 struct vector_type lp; /* Vector of bfd_vma. */
430 struct vector_type ca; /* Vector of bfd_vma. */
431 struct vector_type qr; /* Vector of struct alpha_vms_vma_ref. */
432};
433
434/* Alpha VMS linker hash table. */
435
436struct alpha_vms_link_hash_table
437{
438 struct bfd_link_hash_table root;
439
440 /* Vector of shared libaries. */
441 struct vector_type shrlibs;
442
443 /* Fixup section. */
444 asection *fixup;
445
446 /* Base address. Used by fixups. */
447 bfd_vma base_addr;
448};
449
450#define alpha_vms_link_hash(INFO) \
451 ((struct alpha_vms_link_hash_table *)(INFO->hash))
452
453/* Alpha VMS linker hash table entry. */
454
455struct alpha_vms_link_hash_entry
456{
457 struct bfd_link_hash_entry root;
458
459 /* Pointer to the original vms symbol. */
460 struct vms_symbol_entry *sym;
461};
462\f
463/* Image reading. */
464
465/* Read & process EIHD record.
466 Return TRUE on success, FALSE on error. */
467
468static bfd_boolean
469_bfd_vms_slurp_eihd (bfd *abfd, unsigned int *eisd_offset,
470 unsigned int *eihs_offset)
471{
472 unsigned int imgtype, size;
473 bfd_vma symvva;
474 struct vms_eihd *eihd = (struct vms_eihd *)PRIV (recrd.rec);
475
476 vms_debug2 ((8, "_bfd_vms_slurp_eihd\n"));
477
478 size = bfd_getl32 (eihd->size);
479 imgtype = bfd_getl32 (eihd->imgtype);
480
481 if (imgtype == EIHD__K_EXE || imgtype == EIHD__K_LIM)
482 abfd->flags |= EXEC_P;
483
484 symvva = bfd_getl64 (eihd->symvva);
485 if (symvva != 0)
486 {
487 PRIV (symvva) = symvva;
488 abfd->flags |= DYNAMIC;
489 }
490
491 PRIV (ident) = bfd_getl32 (eihd->ident);
492 PRIV (matchctl) = eihd->matchctl;
493
494 *eisd_offset = bfd_getl32 (eihd->isdoff);
495 *eihs_offset = bfd_getl32 (eihd->symdbgoff);
496
497 vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",
498 size, imgtype, (unsigned long)symvva,
499 *eisd_offset, *eihs_offset));
500
ddfb684a 501 return TRUE;
95e34ef7
TG		 502}
503
504/* Read & process EISD record.
505 Return TRUE on success, FALSE on error. */
506
507static bfd_boolean
508_bfd_vms_slurp_eisd (bfd *abfd, unsigned int offset)
509{
510 int section_count = 0;
511
512 vms_debug2 ((8, "_bfd_vms_slurp_eisd\n"));
513
514 while (1)
515 {
516 struct vms_eisd *eisd;
517 unsigned int rec_size;
518 unsigned int size;
519 unsigned long long vaddr;
520 unsigned int flags;
521 unsigned int vbn;
522 char *name = NULL;
523 asection *section;
524 flagword bfd_flags;
525
526 eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
527 rec_size = bfd_getl32 (eisd->eisdsize);
528
529 if (rec_size == 0)
530 break;
531
532 /* Skip to next block if pad. */
533 if (rec_size == 0xffffffff)
534 {
535 offset = (offset + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
536 continue;
537 }
538 else
539 offset += rec_size;
540
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);
545
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));
548
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;
c068d5be
TG		 554 if (vbn != 0)
555 bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
95e34ef7
TG		 556
557 if (flags & EISD__M_EXE)
c068d5be 558 bfd_flags |= SEC_CODE;
95e34ef7
TG		 559
560 if (flags & EISD__M_NONSHRADR)
c068d5be 561 bfd_flags |= SEC_DATA;
95e34ef7
TG		 562
563 if (!(flags & EISD__M_WRT))
564 bfd_flags |= SEC_READONLY;
565
566 if (flags & EISD__M_DZRO)
567 bfd_flags |= SEC_DATA;
568
569 if (flags & EISD__M_FIXUPVEC)
c068d5be 570 bfd_flags |= SEC_DATA;
95e34ef7
TG		 571
572 if (flags & EISD__M_CRF)
c068d5be 573 bfd_flags |= SEC_DATA;
95e34ef7
TG		 574
575 if (flags & EISD__M_GBL)
576 {
577 name = _bfd_vms_save_counted_string (eisd->gblnam);
578 bfd_flags |= SEC_COFF_SHARED_LIBRARY;
579 bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
580 }
581 else if (flags & EISD__M_FIXUPVEC)
582 name = "$FIXUPVEC$";
583 else if (eisd->type == EISD__K_USRSTACK)
584 name = "$STACK$";
585 else
586 {
587 const char *pfx;
588
589 name = (char*) bfd_alloc (abfd, 32);
590 if (flags & EISD__M_DZRO)
591 pfx = "BSS";
592 else if (flags & EISD__M_EXE)
593 pfx = "CODE";
594 else if (!(flags & EISD__M_WRT))
595 pfx = "RO";
596 else
597 pfx = "LOCAL";
598 BFD_ASSERT (section_count < 999);
599 sprintf (name, "$%s_%03d$", pfx, section_count++);
600 }
601
602 section = bfd_make_section (abfd, name);
603
604 if (!section)
605 return FALSE;
606
607 section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : 0;
608 section->size = size;
609 section->vma = vaddr;
610
611 if (!bfd_set_section_flags (abfd, section, bfd_flags))
612 return FALSE;
613 }
614
615 return TRUE;
616}
617
618/* Read & process EIHS record.
619 Return TRUE on success, FALSE on error. */
620
621static bfd_boolean
622_bfd_vms_slurp_eihs (bfd *abfd, unsigned int offset)
623{
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);
631 asection *section;
632
633#if VMS_DEBUG
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);
637#endif
638
639 if (dstvbn)
640 {
641 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
642
643 section = bfd_make_section (abfd, "$DST$");
644 if (!section)
645 return FALSE;
646
647 section->size = dstsize;
648 section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
649
650 if (!bfd_set_section_flags (abfd, section, bfd_flags))
651 return FALSE;
652
653 PRIV (dst_section) = section;
654 abfd->flags |= (HAS_DEBUG | HAS_LINENO);
655 }
656
657 if (dmtvbn)
658 {
659 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
660
661 section = bfd_make_section (abfd, "$DMT$");
662 if (!section)
663 return FALSE;
664
665 section->size = dmtbytes;
666 section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
667
668 if (!bfd_set_section_flags (abfd, section, bfd_flags))
669 return FALSE;
670 }
671
672 if (gstvbn)
673 {
95e34ef7
TG		 674 if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
675 {
676 bfd_set_error (bfd_error_file_truncated);
677 return FALSE;
678 }
679
680 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
681 return FALSE;
682
95e34ef7
TG		 683 abfd->flags |= HAS_SYMS;
684 }
685
686 return TRUE;
687}
688\f
689/* Object file reading. */
690
691/* Object file input functions. */
692
693/* Get next record from object file to vms_buf.
694 Set PRIV(buf_size) and return it
695
696 This is a little tricky since it should be portable.
697
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.
703
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.
710
711 The VMS format repeats the size at bytes 2 & 3 of every record.
712
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).
718
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
722 read in.
723
724 All file I/O is done on even file positions. */
725
726#define VMS_OBJECT_ADJUSTMENT 2
727
728static void
729maybe_adjust_record_pointer_for_object (bfd *abfd)
730{
731 /* Set the file format once for all on the first invocation. */
732 if (PRIV (recrd.file_format) == FF_UNKNOWN)
733 {
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;
737 else
738 PRIV (recrd.file_format) = FF_NATIVE;
739 }
740
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;
744}
745
746/* Implement step #1 of the object record reading procedure.
747 Return the record type or -1 on failure. */
748
749static int
750_bfd_vms_get_object_record (bfd *abfd)
751{
ddfb684a 752 unsigned int test_len = 6;
95e34ef7 753 int type;
95e34ef7
TG		 754
755 vms_debug2 ((8, "_bfd_vms_get_obj_record\n"));
756
ddfb684a 757 /* Skip alignment byte if the current position is odd. */
af47dcbf 758 if (PRIV (recrd.file_format) == FF_FOREIGN && (bfd_tell (abfd) & 1))
95e34ef7
TG		 759 {
760 if (bfd_bread (PRIV (recrd.buf), 1, abfd) != 1)
761 {
762 bfd_set_error (bfd_error_file_truncated);
763 return -1;
764 }
95e34ef7
TG		 765 }
766
767 /* Read the record header */
ddfb684a 768 if (bfd_bread (PRIV (recrd.buf), test_len, abfd) != test_len)
95e34ef7
TG		 769 {
770 bfd_set_error (bfd_error_file_truncated);
771 return -1;
772 }
773
774 /* Reset the record pointer. */
775 PRIV (recrd.rec) = PRIV (recrd.buf);
776 maybe_adjust_record_pointer_for_object (abfd);
777
778 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
779 return -1;
780
781 type = bfd_getl16 (PRIV (recrd.rec));
782
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));
785
786 return type;
787}
788
789/* Implement step #2 of the object record reading procedure.
790 Return the size of the record or 0 on failure. */
791
792static int
793vms_get_remaining_object_record (bfd *abfd, int read_so_far)
794{
795 unsigned int to_read;
796
797 vms_debug2 ((8, "vms_get_remaining_obj_record\n"));
798
799 /* Extract record size. */
800 PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);
801
802 if (PRIV (recrd.rec_size) <= 0)
803 {
804 bfd_set_error (bfd_error_file_truncated);
805 return 0;
806 }
807
808 /* That's what the linker manual says. */
809 if (PRIV (recrd.rec_size) > EOBJ__C_MAXRECSIZ)
810 {
811 bfd_set_error (bfd_error_file_truncated);
812 return 0;
813 }
814
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;
819
820 /* Adjust the buffer. */
821 if (to_read > PRIV (recrd.buf_size))
822 {
823 PRIV (recrd.buf)
824 = (unsigned char *) bfd_realloc (PRIV (recrd.buf), to_read);
825 if (PRIV (recrd.buf) == NULL)
826 return 0;
827 PRIV (recrd.buf_size) = to_read;
828 }
829
830 /* Read the remaining record. */
831 to_read -= read_so_far;
832
833 vms_debug2 ((8, "vms_get_remaining_obj_record: to_read %d\n", to_read));
834
835 if (bfd_bread (PRIV (recrd.buf) + read_so_far, to_read, abfd) != to_read)
836 {
837 bfd_set_error (bfd_error_file_truncated);
838 return 0;
839 }
840
841 /* Reset the record pointer. */
842 PRIV (recrd.rec) = PRIV (recrd.buf);
843 maybe_adjust_record_pointer_for_object (abfd);
844
845 vms_debug2 ((8, "vms_get_remaining_obj_record: size %d\n",
846 PRIV (recrd.rec_size)));
847
848 return PRIV (recrd.rec_size);
849}
850
851/* Read and process emh record.
852 Return TRUE on success, FALSE on error. */
853
854static bfd_boolean
855_bfd_vms_slurp_ehdr (bfd *abfd)
856{
857 unsigned char *ptr;
858 unsigned char *vms_rec;
859 int subtype;
860
861 vms_rec = PRIV (recrd.rec);
862
863 vms_debug2 ((2, "HDR/EMH\n"));
864
865 subtype = bfd_getl16 (vms_rec + 4);
866
867 vms_debug2 ((3, "subtype %d\n", subtype));
868
869 switch (subtype)
870 {
871 case EMH__C_MHD:
872 /* Module header. */
873 PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
874 PRIV (hdr_data).hdr_l_arch1 = bfd_getl32 (vms_rec + 8);
875 PRIV (hdr_data).hdr_l_arch2 = bfd_getl32 (vms_rec + 12);
876 PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
877 PRIV (hdr_data).hdr_t_name = _bfd_vms_save_counted_string (vms_rec + 20);
878 ptr = vms_rec + 20 + vms_rec[20] + 1;
879 PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
880 ptr += *ptr + 1;
881 PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
882 break;
883
884 case EMH__C_LNM:
885 PRIV (hdr_data).hdr_c_lnm =
886 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
887 break;
888
889 case EMH__C_SRC:
890 PRIV (hdr_data).hdr_c_src =
891 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
892 break;
893
894 case EMH__C_TTL:
895 PRIV (hdr_data).hdr_c_ttl =
896 _bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
897 break;
898
899 case EMH__C_CPR:
900 case EMH__C_MTC:
901 case EMH__C_GTX:
902 break;
903
904 default:
905 bfd_set_error (bfd_error_wrong_format);
906 return FALSE;
907 }
908
909 return TRUE;
910}
911
912/* Typical sections for evax object files. */
913
914#define EVAX_ABS_NAME "$ABS$"
915#define EVAX_CODE_NAME "$CODE$"
916#define EVAX_LINK_NAME "$LINK$"
917#define EVAX_DATA_NAME "$DATA$"
918#define EVAX_BSS_NAME "$BSS$"
919#define EVAX_READONLYADDR_NAME "$READONLY_ADDR$"
920#define EVAX_READONLY_NAME "$READONLY$"
921#define EVAX_LITERAL_NAME "$LITERAL$"
922#define EVAX_LITERALS_NAME "$LITERALS"
923#define EVAX_COMMON_NAME "$COMMON$"
924#define EVAX_LOCAL_NAME "$LOCAL$"
925
926struct sec_flags_struct
927{
928 const char *name; /* Name of section. */
929 int vflags_always;
930 flagword flags_always; /* Flags we set always. */
931 int vflags_hassize;
932 flagword flags_hassize; /* Flags we set if the section has a size > 0. */
933};
934
935/* These flags are deccrtl/vaxcrtl (openVMS 6.2 Alpha) compatible. */
936
937static struct sec_flags_struct evax_section_flags[] =
938 {
939 { EVAX_ABS_NAME,
940 (EGPS__V_SHR),
941 (SEC_DATA),
942 (EGPS__V_SHR),
943 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
944 { EVAX_CODE_NAME,
945 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE),
946 (SEC_CODE),
947 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE),
948 (SEC_CODE | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
949 { EVAX_LITERAL_NAME,
950 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD),
951 (SEC_DATA | SEC_READONLY),
952 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD),
953 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
954 { EVAX_LINK_NAME,
955 (EGPS__V_REL | EGPS__V_RD),
956 (SEC_DATA | SEC_READONLY),
957 (EGPS__V_REL | EGPS__V_RD),
958 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
959 { EVAX_DATA_NAME,
960 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
961 (SEC_DATA),
962 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
963 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
964 { EVAX_BSS_NAME,
965 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
966 (SEC_NO_FLAGS),
967 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD),
968 (SEC_ALLOC) },
969 { EVAX_READONLYADDR_NAME,
970 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD),
971 (SEC_DATA | SEC_READONLY),
972 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD),
973 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
974 { EVAX_READONLY_NAME,
975 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD),
976 (SEC_DATA | SEC_READONLY),
977 (EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD),
978 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
979 { EVAX_LOCAL_NAME,
980 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
981 (SEC_DATA),
982 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
983 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) },
984 { EVAX_LITERALS_NAME,
985 (EGPS__V_PIC | EGPS__V_OVR),
986 (SEC_DATA | SEC_READONLY),
987 (EGPS__V_PIC | EGPS__V_OVR),
988 (SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD) },
989 { NULL,
990 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
991 (SEC_DATA),
992 (EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT),
993 (SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD) }
994 };
995
996/* Retrieve bfd section flags by name and size. */
997
998static flagword
999vms_secflag_by_name (bfd *abfd ATTRIBUTE_UNUSED,
1000 struct sec_flags_struct *section_flags,
1001 char *name,
1002 int hassize)
1003{
1004 int i = 0;
1005
1006 while (section_flags[i].name != NULL)
1007 {
1008 if (strcmp (name, section_flags[i].name) == 0)
1009 {
1010 if (hassize)
1011 return section_flags[i].flags_hassize;
1012 else
1013 return section_flags[i].flags_always;
1014 }
1015 i++;
1016 }
1017 if (hassize)
1018 return section_flags[i].flags_hassize;
1019 return section_flags[i].flags_always;
1020}
1021
1022/* Retrieve vms section flags by name and size. */
1023
1024static flagword
1025vms_esecflag_by_name (struct sec_flags_struct *section_flags,
1026 char *name,
1027 int hassize)
1028{
1029 int i = 0;
1030
1031 while (section_flags[i].name != NULL)
1032 {
1033 if (strcmp (name, section_flags[i].name) == 0)
1034 {
1035 if (hassize)
1036 return section_flags[i].vflags_hassize;
1037 else
1038 return section_flags[i].vflags_always;
1039 }
1040 i++;
1041 }
1042 if (hassize)
1043 return section_flags[i].vflags_hassize;
1044 return section_flags[i].vflags_always;
1045}
1046
ce76e55c
TG		 1047/* Add SYM to the symbol table of ABFD.
1048 Return FALSE in case of error. */
95e34ef7 1049
ce76e55c
TG		 1050static bfd_boolean
1051add_symbol_entry (bfd *abfd, struct vms_symbol_entry *sym)
95e34ef7 1052{
95e34ef7
TG		 1053 if (PRIV (gsd_sym_count) >= PRIV (max_sym_count))
1054 {
1055 if (PRIV (max_sym_count) == 0)
1056 {
1057 PRIV (max_sym_count) = 128;
1058 PRIV (syms) = bfd_malloc
1059 (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *));
1060 }
1061 else
1062 {
1063 PRIV (max_sym_count) *= 2;
1064 PRIV (syms) = bfd_realloc
1065 (PRIV (syms),
1066 (PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *)));
1067 }
1068 if (PRIV (syms) == NULL)
ce76e55c 1069 return FALSE;
95e34ef7
TG		 1070 }
1071
ce76e55c
TG		 1072 PRIV (syms)[PRIV (gsd_sym_count)++] = sym;
1073 return TRUE;
1074}
1075
1076/* Create a symbol whose name is ASCIC and add it to ABFD.
1077 Return NULL in case of error. */
1078
1079static struct vms_symbol_entry *
1080add_symbol (bfd *abfd, const unsigned char *ascic)
1081{
1082 struct vms_symbol_entry *entry;
1083 int len;
1084
1085 len = *ascic++;
1086 entry = (struct vms_symbol_entry *)bfd_zalloc (abfd, sizeof (*entry) + len);
1087 if (entry == NULL)
1088 return NULL;
1089 entry->namelen = len;
1090 memcpy (entry->name, ascic, len);
1091 entry->name[len] = 0;
1092 entry->owner = abfd;
1093
1094 if (!add_symbol_entry (abfd, entry))
1095 return NULL;
95e34ef7
TG		 1096 return entry;
1097}
1098
1099/* Read and process EGSD. Return FALSE on failure. */
1100
1101static bfd_boolean
5fe88cfb 1102_bfd_vms_slurp_egsd (bfd *abfd)
95e34ef7
TG		 1103{
1104 int gsd_type, gsd_size;
1105 asection *section;
1106 unsigned char *vms_rec;
1107 flagword new_flags, old_flags;
1108 char *name;
1109 unsigned long base_addr;
1110 unsigned long align_addr;
1111
1112 vms_debug2 ((2, "EGSD\n"));
1113
1114 PRIV (recrd.rec) += 8; /* Skip type, size, align pad. */
1115 PRIV (recrd.rec_size) -= 8;
1116
1117 /* Calculate base address for each section. */
1118 base_addr = 0L;
1119
1120 while (PRIV (recrd.rec_size) > 0)
1121 {
1122 vms_rec = PRIV (recrd.rec);
1123
1124 gsd_type = bfd_getl16 (vms_rec);
1125 gsd_size = bfd_getl16 (vms_rec + 2);
1126
1127 vms_debug2 ((3, "egsd_type %d\n", gsd_type));
1128
1129 switch (gsd_type)
1130 {
1131 case EGSD__C_PSC:
1132 {
1133 /* Program section definition. */
1134 struct vms_egps *egps = (struct vms_egps *)vms_rec;
5fe88cfb 1135
95e34ef7
TG		 1136 name = _bfd_vms_save_counted_string (&egps->namlng);
1137 section = bfd_make_section (abfd, name);
1138 if (!section)
1139 return FALSE;
5fe88cfb 1140
95e34ef7
TG		 1141 old_flags = bfd_getl16 (egps->flags);
1142 vms_section_data (section)->flags = old_flags;
1143 vms_section_data (section)->no_flags = 0;
1144 section->size = bfd_getl32 (egps->alloc);
1145 new_flags = vms_secflag_by_name (abfd, evax_section_flags, name,
1146 section->size > 0);
1147 if (!(old_flags & EGPS__V_NOMOD))
1148 {
1149 new_flags |= SEC_HAS_CONTENTS;
1150 if (old_flags & EGPS__V_REL)
1151 new_flags |= SEC_RELOC;
1152 }
1153 if (!bfd_set_section_flags (abfd, section, new_flags))
1154 return FALSE;
1155 section->alignment_power = egps->align;
1156 align_addr = (1 << section->alignment_power);
1157 if ((base_addr % align_addr) != 0)
1158 base_addr += (align_addr - (base_addr % align_addr));
1159 section->vma = (bfd_vma)base_addr;
1160 base_addr += section->size;
1161 section->filepos = (unsigned int)-1;
c734eb83
TG		 1162
1163 /* Append it to the section array. */
1164 if (PRIV (section_count) >= PRIV (section_max))
1165 {
1166 if (PRIV (section_max) == 0)
1167 PRIV (section_max) = 16;
1168 else
1169 PRIV (section_max) *= 2;
1170 PRIV (sections) = bfd_realloc_or_free
1171 (PRIV (sections), PRIV (section_max) * sizeof (asection *));
1172 if (PRIV (sections) == NULL)
1173 return FALSE;
1174 }
1175
1176 PRIV (sections)[PRIV (section_count)] = section;
1177 PRIV (section_count)++;
1178
95e34ef7
TG		 1179#if VMS_DEBUG
1180 vms_debug (4, "EGSD P-section %d (%s, flags %04x) ",
1181 section->index, name, old_flags);
1182 vms_debug (4, "%lu bytes at 0x%08lx (mem %p)\n",
1183 (unsigned long)section->size,
1184 (unsigned long)section->vma, section->contents);
1185#endif
1186 }
1187 break;
1188
1189 case EGSD__C_SYM:
1190 {
1191 int nameoff;
1192 struct vms_symbol_entry *entry;
1193 struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
1194
1195 old_flags = bfd_getl16 (egsy->flags);
1196 if (old_flags & EGSY__V_DEF)
1197 nameoff = ESDF__B_NAMLNG;
1198 else
1199 nameoff = ESRF__B_NAMLNG;
1200
1201 entry = add_symbol (abfd, vms_rec + nameoff);
1202 if (entry == NULL)
1203 return FALSE;
1204
1205 /* Allow only duplicate reference. */
1206 if ((entry->flags & EGSY__V_DEF) && (old_flags & EGSY__V_DEF))
1207 abort ();
1208
1209 if (entry->typ == 0)
1210 {
1211 entry->typ = gsd_type;
1212 entry->data_type = egsy->datyp;
1213 entry->flags = old_flags;
1214 }
1215
1216 if (old_flags & EGSY__V_DEF)
1217 {
1218 struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
1219
1220 entry->value = bfd_getl64 (esdf->value);
a928f1d7 1221 entry->section = PRIV (sections)[bfd_getl32 (esdf->psindx)];
95e34ef7
TG		 1222
1223 if (old_flags & EGSY__V_NORM)
1224 {
1225 PRIV (norm_sym_count)++;
1226
1227 entry->code_value = bfd_getl64 (esdf->code_address);
a928f1d7
TG		 1228 entry->code_section =
1229 PRIV (sections)[bfd_getl32 (esdf->ca_psindx)];
95e34ef7
TG		 1230 }
1231 }
1232 }
1233 break;
1234
1235 case EGSD__C_SYMG:
1236 {
1237 int nameoff;
1238 struct vms_symbol_entry *entry;
1239 struct vms_egst *egst = (struct vms_egst *)vms_rec;
1240
1241 old_flags = bfd_getl16 (egst->header.flags);
1242 if (old_flags & EGSY__V_DEF)
1243 nameoff = ESDF__B_NAMLNG;
1244 else
1245 nameoff = ESRF__B_NAMLNG;
1246
1247 entry = add_symbol (abfd, &egst->namlng);
1248
1249 if (entry == NULL)
1250 return FALSE;
1251
1252 entry->typ = gsd_type;
1253 entry->data_type = egst->header.datyp;
1254 entry->flags = old_flags;
1255
1256 entry->symbol_vector = bfd_getl32 (egst->value);
1257
a928f1d7
TG		 1258 if (old_flags & EGSY__V_REL)
1259 entry->section = PRIV (sections)[bfd_getl32 (egst->psindx)];
1260 else
1261 entry->section = bfd_abs_section_ptr;
1262
95e34ef7
TG		 1263 entry->value = bfd_getl64 (egst->lp_2);
1264
1265 if (old_flags & EGSY__V_NORM)
1266 {
1267 PRIV (norm_sym_count)++;
1268
1269 entry->code_value = bfd_getl64 (egst->lp_1);
a928f1d7 1270 entry->code_section = bfd_abs_section_ptr;
95e34ef7
TG		 1271 }
1272 }
1273 break;
1274
9a1b4480
TG		 1275 case EGSD__C_SPSC:
1276 case EGSD__C_IDC:
1277 /* Currently ignored. */
1278 break;
95e34ef7
TG		 1279 case EGSD__C_SYMM:
1280 case EGSD__C_SYMV:
1281 default:
1282 (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
1283 bfd_set_error (bfd_error_bad_value);
1284 return FALSE;
1285 }
1286
1287 PRIV (recrd.rec_size) -= gsd_size;
1288 PRIV (recrd.rec) += gsd_size;
1289 }
1290
1291 if (PRIV (gsd_sym_count) > 0)
1292 abfd->flags |= HAS_SYMS;
1293
1294 return TRUE;
1295}
1296
1297/* Stack routines for vms ETIR commands. */
1298
1299/* Push value and section index. */
1300
1301static void
1302_bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
1303{
1304 vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
1305 (unsigned long)val, reloc, PRIV (stackptr)));
1306
1307 PRIV (stack[PRIV (stackptr)]).value = val;
1308 PRIV (stack[PRIV (stackptr)]).reloc = reloc;
1309 PRIV (stackptr)++;
1310 if (PRIV (stackptr) >= STACKSIZE)
1311 {
1312 bfd_set_error (bfd_error_bad_value);
1313 (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
1314 exit (1);
1315 }
1316}
1317
1318/* Pop value and section index. */
1319
1320static void
1321_bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
1322{
1323 if (PRIV (stackptr) == 0)
1324 {
1325 bfd_set_error (bfd_error_bad_value);
1326 (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
1327 exit (1);
1328 }
1329 PRIV (stackptr)--;
1330 *val = PRIV (stack[PRIV (stackptr)]).value;
1331 *rel = PRIV (stack[PRIV (stackptr)]).reloc;
1332
1333 vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
1334}
1335
1336/* Routines to fill sections contents during tir/etir read. */
1337
1338/* Initialize image buffer pointer to be filled. */
1339
1340static void
1341image_set_ptr (bfd *abfd, bfd_vma vma, int sect, struct bfd_link_info *info)
1342{
1343 asection *sec;
1344
1345 vms_debug2 ((4, "image_set_ptr (0x%08x, sect=%d)\n", (unsigned)vma, sect));
1346
1347 sec = PRIV (sections)[sect];
1348
1349 if (info)
1350 {
1351 /* Reading contents to an output bfd. */
1352
1353 if (sec->output_section == NULL)
1354 {
1355 /* Section discarded. */
1356 vms_debug2 ((5, " section %s discarded\n", sec->name));
1357
1358 /* This is not used. */
1359 PRIV (image_section) = NULL;
1360 PRIV (image_offset) = 0;
1361 return;
1362 }
1363 PRIV (image_offset) = sec->output_offset + vma;
1364 PRIV (image_section) = sec->output_section;
1365 }
1366 else
1367 {
1368 PRIV (image_offset) = vma;
1369 PRIV (image_section) = sec;
1370 }
1371}
1372
1373/* Increment image buffer pointer by offset. */
1374
1375static void
1376image_inc_ptr (bfd *abfd, bfd_vma offset)
1377{
1378 vms_debug2 ((4, "image_inc_ptr (%u)\n", (unsigned)offset));
1379
1380 PRIV (image_offset) += offset;
1381}
1382
1383/* Save current DST location counter under specified index. */
1384
1385static void
1386dst_define_location (bfd *abfd, unsigned int loc)
1387{
1388 vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
1389
1390 /* Grow the ptr offset table if necessary. */
1391 if (loc + 1 > PRIV (dst_ptr_offsets_count))
1392 {
1393 PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
1394 (loc + 1) * sizeof (unsigned int));
1395 PRIV (dst_ptr_offsets_count) = loc + 1;
1396 }
1397
1398 PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
1399}
1400
1401/* Restore saved DST location counter from specified index. */
1402
1403static void
1404dst_restore_location (bfd *abfd, unsigned int loc)
1405{
1406 vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
1407
1408 PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
1409}
1410
1411/* Retrieve saved DST location counter from specified index. */
1412
1413static unsigned int
1414dst_retrieve_location (bfd *abfd, unsigned int loc)
1415{
1416 vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
1417
1418 return PRIV (dst_ptr_offsets)[loc];
1419}
1420
95e34ef7
TG		 1421/* Write multiple bytes to section image. */
1422
1423static bfd_boolean
1424image_write (bfd *abfd, unsigned char *ptr, int size)
1425{
1426#if VMS_DEBUG
1427 _bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
1428 (long)PRIV (image_offset));
1429 _bfd_hexdump (9, ptr, size, 0);
1430#endif
1431
95e34ef7
TG		 1432 if (PRIV (image_section)->contents != NULL)
1433 {
1434 asection *sec = PRIV (image_section);
1435 file_ptr off = PRIV (image_offset);
1436
1437 /* Check bounds. */
1438 if (off > (file_ptr)sec->size
1439 || size > (file_ptr)sec->size
1440 || off + size > (file_ptr)sec->size)
1441 {
1442 bfd_set_error (bfd_error_bad_value);
1443 return FALSE;
1444 }
1445
1446 memcpy (sec->contents + off, ptr, size);
1447 }
1448
1449 PRIV (image_offset) += size;
1450 return TRUE;
1451}
1452
1453/* Write byte to section image. */
1454
1455static bfd_boolean
1456image_write_b (bfd * abfd, unsigned int value)
1457{
1458 unsigned char data[1];
1459
1460 vms_debug2 ((6, "image_write_b (%02x)\n", (int) value));
1461
1462 *data = value;
1463
1464 return image_write (abfd, data, sizeof (data));
1465}
1466
1467/* Write 2-byte word to image. */
1468
1469static bfd_boolean
1470image_write_w (bfd * abfd, unsigned int value)
1471{
1472 unsigned char data[2];
1473
1474 vms_debug2 ((6, "image_write_w (%04x)\n", (int) value));
1475
1476 bfd_putl16 (value, data);
1477 return image_write (abfd, data, sizeof (data));
1478}
1479
1480/* Write 4-byte long to image. */
1481
1482static bfd_boolean
1483image_write_l (bfd * abfd, unsigned long value)
1484{
1485 unsigned char data[4];
1486
1487 vms_debug2 ((6, "image_write_l (%08lx)\n", value));
1488
1489 bfd_putl32 (value, data);
1490 return image_write (abfd, data, sizeof (data));
1491}
1492
1493/* Write 8-byte quad to image. */
1494
1495static bfd_boolean
1496image_write_q (bfd * abfd, bfd_vma value)
1497{
1498 unsigned char data[8];
1499
1500 vms_debug2 ((6, "image_write_q (%08lx)\n", (unsigned long)value));
1501
1502 bfd_putl64 (value, data);
1503 return image_write (abfd, data, sizeof (data));
1504}
1505\f
1506static const char *
1507_bfd_vms_etir_name (int cmd)
1508{
1509 switch (cmd)
1510 {
1511 case ETIR__C_STA_GBL: return "ETIR__C_STA_GBL";
1512 case ETIR__C_STA_LW: return "ETIR__C_STA_LW";
1513 case ETIR__C_STA_QW: return "ETIR__C_STA_QW";
1514 case ETIR__C_STA_PQ: return "ETIR__C_STA_PQ";
1515 case ETIR__C_STA_LI: return "ETIR__C_STA_LI";
1516 case ETIR__C_STA_MOD: return "ETIR__C_STA_MOD";
1517 case ETIR__C_STA_CKARG: return "ETIR__C_STA_CKARG";
1518 case ETIR__C_STO_B: return "ETIR__C_STO_B";
1519 case ETIR__C_STO_W: return "ETIR__C_STO_W";
1520 case ETIR__C_STO_GBL: return "ETIR__C_STO_GBL";
1521 case ETIR__C_STO_CA: return "ETIR__C_STO_CA";
1522 case ETIR__C_STO_RB: return "ETIR__C_STO_RB";
1523 case ETIR__C_STO_AB: return "ETIR__C_STO_AB";
1524 case ETIR__C_STO_OFF: return "ETIR__C_STO_OFF";
1525 case ETIR__C_STO_IMM: return "ETIR__C_STO_IMM";
1526 case ETIR__C_STO_IMMR: return "ETIR__C_STO_IMMR";
1527 case ETIR__C_STO_LW: return "ETIR__C_STO_LW";
1528 case ETIR__C_STO_QW: return "ETIR__C_STO_QW";
1529 case ETIR__C_STO_GBL_LW: return "ETIR__C_STO_GBL_LW";
1530 case ETIR__C_STO_LP_PSB: return "ETIR__C_STO_LP_PSB";
1531 case ETIR__C_STO_HINT_GBL: return "ETIR__C_STO_HINT_GBL";
1532 case ETIR__C_STO_HINT_PS: return "ETIR__C_STO_HINT_PS";
1533 case ETIR__C_OPR_ADD: return "ETIR__C_OPR_ADD";
1534 case ETIR__C_OPR_SUB: return "ETIR__C_OPR_SUB";
1535 case ETIR__C_OPR_INSV: return "ETIR__C_OPR_INSV";
1536 case ETIR__C_OPR_USH: return "ETIR__C_OPR_USH";
1537 case ETIR__C_OPR_ROT: return "ETIR__C_OPR_ROT";
1538 case ETIR__C_OPR_REDEF: return "ETIR__C_OPR_REDEF";
1539 case ETIR__C_OPR_DFLIT: return "ETIR__C_OPR_DFLIT";
1540 case ETIR__C_STC_LP: return "ETIR__C_STC_LP";
1541 case ETIR__C_STC_GBL: return "ETIR__C_STC_GBL";
1542 case ETIR__C_STC_GCA: return "ETIR__C_STC_GCA";
1543 case ETIR__C_STC_PS: return "ETIR__C_STC_PS";
1544 case ETIR__C_STC_NBH_PS: return "ETIR__C_STC_NBH_PS";
1545 case ETIR__C_STC_NOP_GBL: return "ETIR__C_STC_NOP_GBL";
1546 case ETIR__C_STC_NOP_PS: return "ETIR__C_STC_NOP_PS";
1547 case ETIR__C_STC_BSR_GBL: return "ETIR__C_STC_BSR_GBL";
1548 case ETIR__C_STC_BSR_PS: return "ETIR__C_STC_BSR_PS";
1549 case ETIR__C_STC_LDA_GBL: return "ETIR__C_STC_LDA_GBL";
1550 case ETIR__C_STC_LDA_PS: return "ETIR__C_STC_LDA_PS";
1551 case ETIR__C_STC_BOH_GBL: return "ETIR__C_STC_BOH_GBL";
1552 case ETIR__C_STC_BOH_PS: return "ETIR__C_STC_BOH_PS";
1553 case ETIR__C_STC_NBH_GBL: return "ETIR__C_STC_NBH_GBL";
1554 case ETIR__C_STC_LP_PSB: return "ETIR__C_STC_LP_PSB";
1555 case ETIR__C_CTL_SETRB: return "ETIR__C_CTL_SETRB";
1556 case ETIR__C_CTL_AUGRB: return "ETIR__C_CTL_AUGRB";
1557 case ETIR__C_CTL_DFLOC: return "ETIR__C_CTL_DFLOC";
1558 case ETIR__C_CTL_STLOC: return "ETIR__C_CTL_STLOC";
1559 case ETIR__C_CTL_STKDL: return "ETIR__C_CTL_STKDL";
1560
1561 default:
1562 /* These names have not yet been added to this switch statement. */
1563 (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
1564 }
1565
1566 return NULL;
1567}
1568#define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
1569
1570static void
1571_bfd_vms_get_value (bfd *abfd, const unsigned char *ascic,
1572 struct bfd_link_info *info,
1573 bfd_vma *vma,
1574 struct alpha_vms_link_hash_entry **hp)
1575{
1576 char name[257];
1577 int len;
1578 int i;
1579 struct alpha_vms_link_hash_entry *h;
1580
1581 /* Not linking. Do not try to resolve the symbol. */
1582 if (info == NULL)
1583 {
1584 *vma = 0;
1585 *hp = NULL;
1586 return;
1587 }
1588
1589 len = *ascic;
1590 for (i = 0; i < len; i++)
1591 name[i] = ascic[i + 1];
1592 name[i] = 0;
1593
1594 h = (struct alpha_vms_link_hash_entry *)
1595 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
1596
1597 *hp = h;
1598
1599 if (h != NULL
1600 && (h->root.type == bfd_link_hash_defined
1601 || h->root.type == bfd_link_hash_defweak))
1602 *vma = h->root.u.def.value
1603 + h->root.u.def.section->output_offset
1604 + h->root.u.def.section->output_section->vma;
1605 else if (h && h->root.type == bfd_link_hash_undefweak)
1606 *vma = 0;
1607 else
1608 {
1609 if (!(*info->callbacks->undefined_symbol)
1610 (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
1611 abort ();
1612 *vma = 0;
1613 }
1614}
1615
1616#define RELC_NONE 0
1617#define RELC_REL 1
1618#define RELC_SHR_BASE 0x10000
1619#define RELC_SEC_BASE 0x20000
1620#define RELC_MASK 0x0ffff
1621
1622static unsigned int
1623alpha_vms_sym_to_ctxt (struct alpha_vms_link_hash_entry *h)
1624{
1625 /* Handle undefined symbols. */
1626 if (h == NULL || h->sym == NULL)
1627 return RELC_NONE;
1628
1629 if (h->sym->typ == EGSD__C_SYMG)
1630 {
1631 if (h->sym->flags & EGSY__V_REL)
1632 return RELC_SHR_BASE + PRIV2 (h->sym->owner, shr_index);
1633 else
1634 {
f9eeb9c9
TG		 1635 /* Can this happen (non-relocatable symg) ? I'd like to see
1636 an example. */
95e34ef7
TG		 1637 abort ();
1638 }
1639 }
1640 if (h->sym->typ == EGSD__C_SYM)
1641 {
1642 if (h->sym->flags & EGSY__V_REL)
1643 return RELC_REL;
1644 else
1645 return RELC_NONE;
1646 }
1647 abort ();
1648}
1649
1650static bfd_vma
a928f1d7 1651alpha_vms_get_sym_value (asection *sect, bfd_vma addr)
95e34ef7 1652{
a928f1d7 1653 return sect->output_section->vma + sect->output_offset + addr;
95e34ef7
TG		 1654}
1655
1656static bfd_vma
1657alpha_vms_fix_sec_rel (bfd *abfd, struct bfd_link_info *info,
1658 unsigned int rel, bfd_vma vma)
1659{
1660 asection *sec = PRIV (sections)[rel & RELC_MASK];
1661
1662 if (info)
1663 {
1664 if (sec->output_section == NULL)
1665 abort ();
1666 return vma + sec->output_section->vma + sec->output_offset;
1667 }
1668 else
1669 return vma + sec->vma;
1670}
1671
44273c5b
TG		 1672/* Read an ETIR record from ABFD. If INFO is not null, put the content into
1673 the output section (used during linking).
1674 Return FALSE in case of error. */
1675
95e34ef7
TG		 1676static bfd_boolean
1677_bfd_vms_slurp_etir (bfd *abfd, struct bfd_link_info *info)
1678{
1679 unsigned char *ptr;
1680 unsigned int length;
1681 unsigned char *maxptr;
1682 bfd_vma op1;
1683 bfd_vma op2;
1684 unsigned int rel1;
1685 unsigned int rel2;
1686 struct alpha_vms_link_hash_entry *h;
1687
1688 PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
1689 PRIV (recrd.rec_size) -= ETIR__C_HEADER_SIZE;
1690
1691 ptr = PRIV (recrd.rec);
1692 length = PRIV (recrd.rec_size);
1693 maxptr = ptr + length;
1694
1695 vms_debug2 ((2, "ETIR: %d bytes\n", length));
1696
1697 while (ptr < maxptr)
1698 {
1699 int cmd = bfd_getl16 (ptr);
1700 int cmd_length = bfd_getl16 (ptr + 2);
1701
1702 ptr += 4;
1703
1704#if VMS_DEBUG
1705 _bfd_vms_debug (4, "etir: %s(%d)\n",
1706 _bfd_vms_etir_name (cmd), cmd);
1707 _bfd_hexdump (8, ptr, cmd_length - 4, (long) ptr);
1708#endif
1709
1710 switch (cmd)
1711 {
1712 /* Stack global
1713 arg: cs symbol name
1714
1715 stack 32 bit value of symbol (high bits set to 0). */
1716 case ETIR__C_STA_GBL:
1717 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1718 _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
1719 break;
1720
1721 /* Stack longword
1722 arg: lw value
1723
1724 stack 32 bit value, sign extend to 64 bit. */
1725 case ETIR__C_STA_LW:
1726 _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
1727 break;
1728
1729 /* Stack quadword
1730 arg: qw value
1731
1732 stack 64 bit value of symbol. */
1733 case ETIR__C_STA_QW:
1734 _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
1735 break;
1736
1737 /* Stack psect base plus quadword offset
1738 arg: lw section index
1739 qw signed quadword offset (low 32 bits)
1740
1741 Stack qw argument and section index
1742 (see ETIR__C_STO_OFF, ETIR__C_CTL_SETRB). */
1743 case ETIR__C_STA_PQ:
1744 {
1745 int psect;
1746
1747 psect = bfd_getl32 (ptr);
1748 if ((unsigned int) psect >= PRIV (section_count))
1749 {
1750 (*_bfd_error_handler) (_("bad section index in %s"),
1751 _bfd_vms_etir_name (cmd));
1752 bfd_set_error (bfd_error_bad_value);
1753 return FALSE;
1754 }
1755 op1 = bfd_getl64 (ptr + 4);
1756 _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
1757 }
1758 break;
1759
1760 case ETIR__C_STA_LI:
1761 case ETIR__C_STA_MOD:
1762 case ETIR__C_STA_CKARG:
1763 (*_bfd_error_handler) (_("unsupported STA cmd %s"),
1764 _bfd_vms_etir_name (cmd));
1765 return FALSE;
1766 break;
1767
1768 /* Store byte: pop stack, write byte
1769 arg: -. */
1770 case ETIR__C_STO_B:
1771 _bfd_vms_pop (abfd, &op1, &rel1);
1772 if (rel1 != RELC_NONE)
1773 goto bad_context;
1774 image_write_b (abfd, (unsigned int) op1 & 0xff);
1775 break;
1776
1777 /* Store word: pop stack, write word
1778 arg: -. */
1779 case ETIR__C_STO_W:
1780 _bfd_vms_pop (abfd, &op1, &rel1);
1781 if (rel1 != RELC_NONE)
1782 goto bad_context;
1783 image_write_w (abfd, (unsigned int) op1 & 0xffff);
1784 break;
1785
1786 /* Store longword: pop stack, write longword
1787 arg: -. */
1788 case ETIR__C_STO_LW:
1789 _bfd_vms_pop (abfd, &op1, &rel1);
1790 if (rel1 & RELC_SEC_BASE)
1791 {
1792 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1793 rel1 = RELC_REL;
1794 }
1795 else if (rel1 & RELC_SHR_BASE)
1796 {
1797 alpha_vms_add_lw_fixup (info, rel1 & RELC_MASK, op1);
1798 rel1 = RELC_NONE;
1799 }
1800 if (rel1 != RELC_NONE)
1801 {
1802 if (rel1 != RELC_REL)
1803 abort ();
1804 alpha_vms_add_lw_reloc (info);
1805 }
1806 image_write_l (abfd, op1);
1807 break;
1808
1809 /* Store quadword: pop stack, write quadword
1810 arg: -. */
1811 case ETIR__C_STO_QW:
1812 _bfd_vms_pop (abfd, &op1, &rel1);
1813 if (rel1 & RELC_SEC_BASE)
1814 {
1815 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1816 rel1 = RELC_REL;
1817 }
1818 else if (rel1 & RELC_SHR_BASE)
1819 abort ();
1820 if (rel1 != RELC_NONE)
1821 {
1822 if (rel1 != RELC_REL)
1823 abort ();
1824 alpha_vms_add_qw_reloc (info);
1825 }
1826 image_write_q (abfd, op1);
1827 break;
1828
1829 /* Store immediate repeated: pop stack for repeat count
1830 arg: lw byte count
1831 da data. */
1832 case ETIR__C_STO_IMMR:
1833 {
1834 int size;
1835
1836 size = bfd_getl32 (ptr);
1837 _bfd_vms_pop (abfd, &op1, &rel1);
1838 if (rel1 != RELC_NONE)
1839 goto bad_context;
1840 while (op1-- > 0)
1841 image_write (abfd, ptr + 4, size);
1842 }
1843 break;
1844
1845 /* Store global: write symbol value
1846 arg: cs global symbol name. */
1847 case ETIR__C_STO_GBL:
1848 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1849 if (h && h->sym)
1850 {
1851 if (h->sym->typ == EGSD__C_SYMG)
1852 {
1853 alpha_vms_add_fixup_qr
1854 (info, abfd, h->sym->owner, h->sym->symbol_vector);
1855 op1 = 0;
1856 }
1857 else
1858 {
1859 op1 = alpha_vms_get_sym_value (h->sym->section,
a928f1d7 1860 h->sym->value);
95e34ef7
TG		 1861 alpha_vms_add_qw_reloc (info);
1862 }
1863 }
1864 image_write_q (abfd, op1);
1865 break;
1866
1867 /* Store code address: write address of entry point
1868 arg: cs global symbol name (procedure). */
1869 case ETIR__C_STO_CA:
1870 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1871 if (h && h->sym)
1872 {
1873 if (h->sym->flags & EGSY__V_NORM)
1874 {
1875 /* That's really a procedure. */
1876 if (h->sym->typ == EGSD__C_SYMG)
1877 {
1878 alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
1879 op1 = h->sym->symbol_vector;
1880 }
1881 else
1882 {
1883 op1 = alpha_vms_get_sym_value (h->sym->code_section,
a928f1d7 1884 h->sym->code_value);
95e34ef7
TG		 1885 alpha_vms_add_qw_reloc (info);
1886 }
1887 }
1888 else
1889 {
1890 /* Symbol is not a procedure. */
1891 abort ();
1892 }
1893 }
1894 image_write_q (abfd, op1);
1895 break;
1896
1897 /* Store offset to psect: pop stack, add low 32 bits to base of psect
1898 arg: none. */
1899 case ETIR__C_STO_OFF:
1900 _bfd_vms_pop (abfd, &op1, &rel1);
1901
1902 if (!(rel1 & RELC_SEC_BASE))
1903 abort ();
1904
1905 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
1906 rel1 = RELC_REL;
1907 image_write_q (abfd, op1);
1908 break;
1909
1910 /* Store immediate
1911 arg: lw count of bytes
1912 da data. */
1913 case ETIR__C_STO_IMM:
1914 {
1915 int size;
1916
1917 size = bfd_getl32 (ptr);
1918 image_write (abfd, ptr + 4, size);
1919 }
1920 break;
1921
1922 /* This code is 'reserved to digital' according to the openVMS
1923 linker manual, however it is generated by the DEC C compiler
1924 and defined in the include file.
1925 FIXME, since the following is just a guess
1926 store global longword: store 32bit value of symbol
1927 arg: cs symbol name. */
1928 case ETIR__C_STO_GBL_LW:
1929 _bfd_vms_get_value (abfd, ptr, info, &op1, &h);
1930#if 0
1931 abort ();
1932#endif
1933 image_write_l (abfd, op1);
1934 break;
1935
1936 case ETIR__C_STO_RB:
1937 case ETIR__C_STO_AB:
1938 case ETIR__C_STO_LP_PSB:
1939 (*_bfd_error_handler) (_("%s: not supported"),
1940 _bfd_vms_etir_name (cmd));
1941 return FALSE;
1942 break;
1943 case ETIR__C_STO_HINT_GBL:
1944 case ETIR__C_STO_HINT_PS:
1945 (*_bfd_error_handler) (_("%s: not implemented"),
1946 _bfd_vms_etir_name (cmd));
1947 return FALSE;
1948 break;
1949
1950 /* 200 Store-conditional Linkage Pair
1951 arg: none. */
1952 case ETIR__C_STC_LP:
1953
1954 /* 202 Store-conditional Address at global address
1955 lw linkage index
1956 cs global name. */
1957
1958 case ETIR__C_STC_GBL:
1959
1960 /* 203 Store-conditional Code Address at global address
1961 lw linkage index
1962 cs procedure name. */
1963 case ETIR__C_STC_GCA:
1964
1965 /* 204 Store-conditional Address at psect + offset
1966 lw linkage index
1967 lw psect index
1968 qw offset. */
1969 case ETIR__C_STC_PS:
1970 (*_bfd_error_handler) (_("%s: not supported"),
1971 _bfd_vms_etir_name (cmd));
1972 return FALSE;
1973 break;
1974
1975 /* 201 Store-conditional Linkage Pair with Procedure Signature
1976 lw linkage index
1977 cs procedure name
1978 by signature length
1979 da signature. */
1980
1981 case ETIR__C_STC_LP_PSB:
1982 _bfd_vms_get_value (abfd, ptr + 4, info, &op1, &h);
1983 if (h && h->sym)
1984 {
1985 if (h->sym->typ == EGSD__C_SYMG)
1986 {
1987 alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
1988 op1 = h->sym->symbol_vector;
1989 op2 = 0;
1990 }
1991 else
1992 {
1993 op1 = alpha_vms_get_sym_value (h->sym->code_section,
a928f1d7 1994 h->sym->code_value);
95e34ef7 1995 op2 = alpha_vms_get_sym_value (h->sym->section,
a928f1d7 1996 h->sym->value);
95e34ef7
TG		 1997 }
1998 }
1999 else
2000 {
2001 /* Undefined symbol. */
2002 op1 = 0;
2003 op2 = 0;
2004 }
2005 image_write_q (abfd, op1);
2006 image_write_q (abfd, op2);
2007 break;
2008
2009 /* 205 Store-conditional NOP at address of global
2010 arg: none. */
2011 case ETIR__C_STC_NOP_GBL:
2012 /* ALPHA_R_NOP */
2013
2014 /* 207 Store-conditional BSR at global address
2015 arg: none. */
2016
2017 case ETIR__C_STC_BSR_GBL:
2018 /* ALPHA_R_BSR */
2019
2020 /* 209 Store-conditional LDA at global address
2021 arg: none. */
2022
2023 case ETIR__C_STC_LDA_GBL:
2024 /* ALPHA_R_LDA */
2025
2026 /* 211 Store-conditional BSR or Hint at global address
2027 arg: none. */
2028
2029 case ETIR__C_STC_BOH_GBL:
2030 /* Currentl ignored. */
2031 break;
2032
2033 /* 213 Store-conditional NOP,BSR or HINT at global address
2034 arg: none. */
2035
2036 case ETIR__C_STC_NBH_GBL:
2037
2038 /* 206 Store-conditional NOP at pect + offset
2039 arg: none. */
2040
2041 case ETIR__C_STC_NOP_PS:
2042
2043 /* 208 Store-conditional BSR at pect + offset
2044 arg: none. */
2045
2046 case ETIR__C_STC_BSR_PS:
2047
2048 /* 210 Store-conditional LDA at psect + offset
2049 arg: none. */
2050
2051 case ETIR__C_STC_LDA_PS:
2052
2053 /* 212 Store-conditional BSR or Hint at pect + offset
2054 arg: none. */
2055
2056 case ETIR__C_STC_BOH_PS:
2057
2058 /* 214 Store-conditional NOP, BSR or HINT at psect + offset
2059 arg: none. */
2060 case ETIR__C_STC_NBH_PS:
2061 (*_bfd_error_handler) ("%s: not supported",
2062 _bfd_vms_etir_name (cmd));
2063 return FALSE;
2064 break;
2065
2066 /* Det relocation base: pop stack, set image location counter
2067 arg: none. */
2068 case ETIR__C_CTL_SETRB:
2069 _bfd_vms_pop (abfd, &op1, &rel1);
2070 if (!(rel1 & RELC_SEC_BASE))
2071 abort ();
2072 image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
2073 break;
2074
2075 /* Augment relocation base: increment image location counter by offset
2076 arg: lw offset value. */
2077 case ETIR__C_CTL_AUGRB:
2078 op1 = bfd_getl32 (ptr);
2079 image_inc_ptr (abfd, op1);
2080 break;
2081
2082 /* Define location: pop index, save location counter under index
2083 arg: none. */
2084 case ETIR__C_CTL_DFLOC:
2085 _bfd_vms_pop (abfd, &op1, &rel1);
2086 if (rel1 != RELC_NONE)
2087 goto bad_context;
2088 dst_define_location (abfd, op1);
2089 break;
2090
2091 /* Set location: pop index, restore location counter from index
2092 arg: none. */
2093 case ETIR__C_CTL_STLOC:
2094 _bfd_vms_pop (abfd, &op1, &rel1);
2095 if (rel1 != RELC_NONE)
2096 goto bad_context;
2097 dst_restore_location (abfd, op1);
2098 break;
2099
2100 /* Stack defined location: pop index, push location counter from index
2101 arg: none. */
2102 case ETIR__C_CTL_STKDL:
2103 _bfd_vms_pop (abfd, &op1, &rel1);
2104 if (rel1 != RELC_NONE)
2105 goto bad_context;
2106 _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
2107 break;
2108
2109 case ETIR__C_OPR_NOP: /* No-op. */
2110 break;
2111
2112 case ETIR__C_OPR_ADD: /* Add. */
2113 _bfd_vms_pop (abfd, &op1, &rel1);
2114 _bfd_vms_pop (abfd, &op2, &rel2);
2115 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2116 rel1 = rel2;
2117 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2118 goto bad_context;
2119 _bfd_vms_push (abfd, op1 + op2, rel1);
2120 break;
2121
2122 case ETIR__C_OPR_SUB: /* Subtract. */
2123 _bfd_vms_pop (abfd, &op1, &rel1);
2124 _bfd_vms_pop (abfd, &op2, &rel2);
2125 if (rel1 == RELC_NONE && rel2 != RELC_NONE)
2126 rel1 = rel2;
2127 else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
2128 {
2129 op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
2130 op2 = alpha_vms_fix_sec_rel (abfd, info, rel2, op2);
2131 rel1 = RELC_NONE;
2132 }
2133 else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
2134 goto bad_context;
2135 _bfd_vms_push (abfd, op2 - op1, rel1);
2136 break;
2137
2138 case ETIR__C_OPR_MUL: /* Multiply. */
2139 _bfd_vms_pop (abfd, &op1, &rel1);
2140 _bfd_vms_pop (abfd, &op2, &rel2);
2141 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2142 goto bad_context;
2143 _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
2144 break;
2145
2146 case ETIR__C_OPR_DIV: /* Divide. */
2147 _bfd_vms_pop (abfd, &op1, &rel1);
2148 _bfd_vms_pop (abfd, &op2, &rel2);
2149 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2150 goto bad_context;
2151 if (op2 == 0)
2152 _bfd_vms_push (abfd, 0, RELC_NONE);
2153 else
2154 _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
2155 break;
2156
2157 case ETIR__C_OPR_AND: /* Logical AND. */
2158 _bfd_vms_pop (abfd, &op1, &rel1);
2159 _bfd_vms_pop (abfd, &op2, &rel2);
2160 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2161 goto bad_context;
2162 _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
2163 break;
2164
2165 case ETIR__C_OPR_IOR: /* Logical inclusive OR. */
2166 _bfd_vms_pop (abfd, &op1, &rel1);
2167 _bfd_vms_pop (abfd, &op2, &rel2);
2168 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2169 goto bad_context;
2170 _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
2171 break;
2172
2173 case ETIR__C_OPR_EOR: /* Logical exclusive OR. */
2174 _bfd_vms_pop (abfd, &op1, &rel1);
2175 _bfd_vms_pop (abfd, &op2, &rel2);
2176 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2177 goto bad_context;
2178 _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
2179 break;
2180
2181 case ETIR__C_OPR_NEG: /* Negate. */
2182 _bfd_vms_pop (abfd, &op1, &rel1);
2183 if (rel1 != RELC_NONE)
2184 goto bad_context;
2185 _bfd_vms_push (abfd, -op1, RELC_NONE);
2186 break;
2187
2188 case ETIR__C_OPR_COM: /* Complement. */
2189 _bfd_vms_pop (abfd, &op1, &rel1);
2190 if (rel1 != RELC_NONE)
2191 goto bad_context;
2192 _bfd_vms_push (abfd, ~op1, RELC_NONE);
2193 break;
2194
2195 case ETIR__C_OPR_ASH: /* Arithmetic shift. */
2196 _bfd_vms_pop (abfd, &op1, &rel1);
2197 _bfd_vms_pop (abfd, &op2, &rel2);
2198 if (rel1 != RELC_NONE || rel2 != RELC_NONE)
2199 {
2200 bad_context:
2201 (*_bfd_error_handler) (_("invalid use of %s with contexts"),
2202 _bfd_vms_etir_name (cmd));
2203 return FALSE;
2204 }
2205 if ((int)op2 < 0) /* Shift right. */
2206 op1 >>= -(int)op2;
2207 else /* Shift left. */
2208 op1 <<= (int)op2;
2209 _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym. */
2210 break;
2211
2212 case ETIR__C_OPR_INSV: /* Insert field. */
2213 case ETIR__C_OPR_USH: /* Unsigned shift. */
2214 case ETIR__C_OPR_ROT: /* Rotate. */
2215 case ETIR__C_OPR_REDEF: /* Redefine symbol to current location. */
2216 case ETIR__C_OPR_DFLIT: /* Define a literal. */
2217 (*_bfd_error_handler) (_("%s: not supported"),
2218 _bfd_vms_etir_name (cmd));
2219 return FALSE;
2220 break;
2221
2222 case ETIR__C_OPR_SEL: /* Select. */
2223 _bfd_vms_pop (abfd, &op1, &rel1);
2224 if (op1 & 0x01L)
2225 _bfd_vms_pop (abfd, &op1, &rel1);
2226 else
2227 {
2228 _bfd_vms_pop (abfd, &op1, &rel1);
2229 _bfd_vms_pop (abfd, &op2, &rel2);
2230 _bfd_vms_push (abfd, op1, rel1);
2231 }
2232 break;
2233
2234 default:
2235 (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
2236 return FALSE;
2237 break;
2238 }
2239
2240 ptr += cmd_length - 4;
2241 }
2242
2243 return TRUE;
2244}
2245
2246/* Process EDBG/ETBT record.
2247 Return TRUE on success, FALSE on error */
2248
2249static bfd_boolean
2250vms_slurp_debug (bfd *abfd)
2251{
2252 asection *section = PRIV (dst_section);
2253
2254 if (section == NULL)
2255 {
2256 /* We have no way to find out beforehand how much debug info there
2257 is in an object file, so pick an initial amount and grow it as
2258 needed later. */
2259 flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC
2260 | SEC_IN_MEMORY;
2261
2262 section = bfd_make_section (abfd, "$DST$");
2263 if (!section)
2264 return FALSE;
2265 if (!bfd_set_section_flags (abfd, section, flags))
2266 return FALSE;
2267 PRIV (dst_section) = section;
2268 }
2269
2270 PRIV (image_section) = section;
2271 PRIV (image_offset) = section->size;
95e34ef7
TG		 2272
2273 if (!_bfd_vms_slurp_etir (abfd, NULL))
2274 return FALSE;
2275
44273c5b 2276 section->size = PRIV (image_offset);
95e34ef7
TG		 2277 return TRUE;
2278}
2279
2280/* Process EDBG record.
2281 Return TRUE on success, FALSE on error. */
2282
2283static bfd_boolean
2284_bfd_vms_slurp_edbg (bfd *abfd)
2285{
2286 vms_debug2 ((2, "EDBG\n"));
2287
44273c5b 2288 abfd->flags |= HAS_DEBUG | HAS_LINENO;
95e34ef7
TG		 2289
2290 return vms_slurp_debug (abfd);
2291}
2292
2293/* Process ETBT record.
2294 Return TRUE on success, FALSE on error. */
2295
2296static bfd_boolean
2297_bfd_vms_slurp_etbt (bfd *abfd)
2298{
2299 vms_debug2 ((2, "ETBT\n"));
2300
2301 abfd->flags |= HAS_LINENO;
2302
2303 return vms_slurp_debug (abfd);
2304}
2305
2306/* Process EEOM record.
2307 Return TRUE on success, FALSE on error. */
2308
2309static bfd_boolean
2310_bfd_vms_slurp_eeom (bfd *abfd)
2311{
2312 struct vms_eeom *eeom = (struct vms_eeom *) PRIV (recrd.rec);
2313
2314 vms_debug2 ((2, "EEOM\n"));
2315
2316 PRIV (eom_data).eom_l_total_lps = bfd_getl32 (eeom->total_lps);
2317 PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
2318 if (PRIV (eom_data).eom_w_comcod > 1)
2319 {
2320 (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
2321 bfd_set_error (bfd_error_bad_value);
2322 return FALSE;
2323 }
2324
2325 PRIV (eom_data).eom_has_transfer = FALSE;
2326 if (PRIV (recrd.rec_size) > 10)
2327 {
2328 PRIV (eom_data).eom_has_transfer = TRUE;
2329 PRIV (eom_data).eom_b_tfrflg = eeom->tfrflg;
2330 PRIV (eom_data).eom_l_psindx = bfd_getl32 (eeom->psindx);
2331 PRIV (eom_data).eom_l_tfradr = bfd_getl32 (eeom->tfradr);
2332
2333 abfd->start_address = PRIV (eom_data).eom_l_tfradr;
2334 }
2335 return TRUE;
2336}
2337
2338/* Slurp an ordered set of VMS object records. Return FALSE on error. */
2339
2340static bfd_boolean
2341_bfd_vms_slurp_object_records (bfd * abfd)
2342{
44273c5b
TG		 2343 bfd_boolean err;
2344 int type;
95e34ef7
TG		 2345
2346 do
2347 {
2348 vms_debug2 ((7, "reading at %08lx\n", (unsigned long)bfd_tell (abfd)));
2349
44273c5b
TG		 2350 type = _bfd_vms_get_object_record (abfd);
2351 if (type < 0)
95e34ef7
TG		 2352 {
2353 vms_debug2 ((2, "next_record failed\n"));
2354 return FALSE;
2355 }
2356
95e34ef7
TG		 2357 switch (type)
2358 {
2359 case EOBJ__C_EMH:
2360 err = _bfd_vms_slurp_ehdr (abfd);
2361 break;
2362 case EOBJ__C_EEOM:
2363 err = _bfd_vms_slurp_eeom (abfd);
2364 break;
2365 case EOBJ__C_EGSD:
2366 err = _bfd_vms_slurp_egsd (abfd);
2367 break;
2368 case EOBJ__C_ETIR:
2369 err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
2370 break;
2371 case EOBJ__C_EDBG:
2372 err = _bfd_vms_slurp_edbg (abfd);
2373 break;
2374 case EOBJ__C_ETBT:
2375 err = _bfd_vms_slurp_etbt (abfd);
2376 break;
2377 default:
2378 err = FALSE;
2379 }
2380 if (err != TRUE)
2381 {
2382 vms_debug2 ((2, "slurp type %d failed\n", type));
2383 return FALSE;
2384 }
2385 }
2386 while (type != EOBJ__C_EEOM);
2387
2388 return TRUE;
2389}
2390
2391/* Initialize private data */
2392static bfd_boolean
2393vms_initialize (bfd * abfd)
2394{
2395 bfd_size_type amt;
2396
2397 amt = sizeof (struct vms_private_data_struct);
2398 abfd->tdata.any = bfd_zalloc (abfd, amt);
2399 if (abfd->tdata.any == NULL)
2400 return FALSE;
2401
2402 PRIV (recrd.file_format) = FF_UNKNOWN;
2403
2404 amt = sizeof (struct stack_struct) * STACKSIZE;
2405 PRIV (stack) = bfd_alloc (abfd, amt);
2406 if (PRIV (stack) == NULL)
2407 goto error_ret1;
2408
2409 return TRUE;
2410
2411 error_ret1:
2412 bfd_release (abfd, abfd->tdata.any);
2413 abfd->tdata.any = NULL;
2414 return FALSE;
2415}
2416
2417/* Check the format for a file being read.
2418 Return a (bfd_target *) if it's an object file or zero if not. */
2419
2420static const struct bfd_target *
2421alpha_vms_object_p (bfd *abfd)
2422{
2423 PTR tdata_save = abfd->tdata.any;
2424 unsigned int test_len;
2425 unsigned char *buf;
2426
2427 vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
2428
2429 /* Allocate alpha-vms specific data. */
2430 if (!vms_initialize (abfd))
2431 goto error_ret;
2432
2433 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
2434 goto err_wrong_format;
2435
2436 /* The first challenge with VMS is to discover the kind of the file.
2437
2438 Image files (executable or shared images) are stored as a raw
2439 stream of bytes (like on UNIX), but there is no magic number.
2440
2441 Object files are written with RMS (record management service), ie
2442 each records are preceeded by its length (on a word - 2 bytes), and
2443 padded for word-alignment. That would be simple but when files
2444 are transfered to a UNIX filesystem (using ftp), records are lost.
2445 Only the raw content of the records are transfered. Fortunately,
2446 the Alpha Object file format also store the length of the record
2447 in the records. Is that clear ? */
2448
2449 /* Minimum is 6 bytes for objects (2 bytes size, 2 bytes record id,
2450 2 bytes size repeated) and 12 bytes for images (4 bytes major id,
2451 4 bytes minor id, 4 bytes length). */
2452 test_len = 12;
2453
2454 /* Size the main buffer. */
2455 buf = (unsigned char *) bfd_malloc (test_len);
2456 if (buf == NULL)
2457 goto error_ret;
2458 PRIV (recrd.buf) = buf;
2459 PRIV (recrd.buf_size) = test_len;
2460
2461 /* Initialize the record pointer. */
2462 PRIV (recrd.rec) = buf;
2463
2464 if (bfd_bread (buf, test_len, abfd) != test_len)
2465 {
2466 bfd_set_error (bfd_error_file_truncated);
2467 goto error_ret;
2468 }
2469
2470 /* Is it an image? */
2471 if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
2472 && (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
2473 {
2474 unsigned int to_read;
2475 unsigned int read_so_far;
2476 unsigned int remaining;
2477 unsigned int eisd_offset, eihs_offset;
2478
2479 /* Extract the header size. */
2480 PRIV (recrd.rec_size) = bfd_getl32 (buf + EIHD__L_SIZE);
2481
af47dcbf
TG		 2482 /* The header size is 0 for DSF files. */
2483 if (PRIV (recrd.rec_size) == 0)
2484 PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
2485
95e34ef7
TG		 2486 if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
2487 {
2488 buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
2489
2490 if (buf == NULL)
2491 {
2492 PRIV (recrd.buf) = NULL;
2493 bfd_set_error (bfd_error_no_memory);
2494 goto error_ret;
2495 }
2496 PRIV (recrd.buf) = buf;
2497 PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
2498 }
2499
2500 /* Read the remaining record. */
2501 remaining = PRIV (recrd.rec_size) - test_len;
2502 to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
2503 read_so_far = test_len;
2504
2505 while (remaining > 0)
2506 {
2507 if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
2508 {
2509 bfd_set_error (bfd_error_file_truncated);
2510 goto err_wrong_format;
2511 }
2512
2513 read_so_far += to_read;
2514 remaining -= to_read;
2515
2516 to_read = MIN (VMS_BLOCK_SIZE, remaining);
2517 }
2518
2519 /* Reset the record pointer. */
2520 PRIV (recrd.rec) = buf;
2521
2522 vms_debug2 ((2, "file type is image\n"));
2523
2524 if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
2525 goto err_wrong_format;
2526
2527 if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
2528 goto err_wrong_format;
2529
2530 /* EIHS is optional. */
2531 if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
2532 goto err_wrong_format;
2533 }
2534 else
2535 {
2536 int type;
2537
2538 /* Assume it's a module and adjust record pointer if necessary. */
2539 maybe_adjust_record_pointer_for_object (abfd);
2540
2541 /* But is it really a module? */
2542 if (bfd_getl16 (PRIV (recrd.rec)) <= EOBJ__C_MAXRECTYP
2543 && bfd_getl16 (PRIV (recrd.rec) + 2) <= EOBJ__C_MAXRECSIZ)
2544 {
2545 if (vms_get_remaining_object_record (abfd, test_len) <= 0)
2546 goto err_wrong_format;
2547
2548 vms_debug2 ((2, "file type is module\n"));
2549
2550 type = bfd_getl16 (PRIV (recrd.rec));
2551 if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
2552 goto err_wrong_format;
2553
2554 if (_bfd_vms_slurp_object_records (abfd) != TRUE)
2555 goto err_wrong_format;
2556 }
2557 else
2558 goto err_wrong_format;
2559 }
2560
2561 /* Set arch_info to alpha. */
2562
2563 if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
2564 goto err_wrong_format;
2565
2566 return abfd->xvec;
2567
2568 err_wrong_format:
2569 bfd_set_error (bfd_error_wrong_format);
2570
2571 error_ret:
2572 if (PRIV (recrd.buf))
2573 free (PRIV (recrd.buf));
2574 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
2575 bfd_release (abfd, abfd->tdata.any);
2576 abfd->tdata.any = tdata_save;
2577 return NULL;
2578}
2579\f
2580/* Image write. */
2581
bd7b51b4
TG		 2582/* Write an EMH/MHD record. */
2583
2584static void
2585_bfd_vms_write_emh (bfd *abfd)
2586{
2587 struct vms_rec_wr *recwr = &PRIV (recwr);
2588
2589 _bfd_vms_output_alignment (recwr, 2);
2590
2591 /* EMH. */
2592 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2593 _bfd_vms_output_short (recwr, EMH__C_MHD);
2594 _bfd_vms_output_short (recwr, EOBJ__C_STRLVL);
2595 _bfd_vms_output_long (recwr, 0);
2596 _bfd_vms_output_long (recwr, 0);
2597 _bfd_vms_output_long (recwr, MAX_OUTREC_SIZE);
2598
2599 /* Create module name from filename. */
2600 if (bfd_get_filename (abfd) != 0)
2601 {
2602 char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
2603 _bfd_vms_output_counted (recwr, module);
2604 free (module);
2605 }
2606 else
2607 _bfd_vms_output_counted (recwr, "NONAME");
2608
2609 _bfd_vms_output_counted (recwr, BFD_VERSION_STRING);
2610 _bfd_vms_output_dump (recwr, get_vms_time_string (), EMH_DATE_LENGTH);
2611 _bfd_vms_output_fill (recwr, 0, EMH_DATE_LENGTH);
2612 _bfd_vms_output_end (abfd, recwr);
2613}
2614
2615/* Write an EMH/LMN record. */
2616
2617static void
2618_bfd_vms_write_lmn (bfd *abfd, const char *name)
2619{
2620 char version [64];
2621 struct vms_rec_wr *recwr = &PRIV (recwr);
2622 unsigned int ver = BFD_VERSION / 10000;
2623
2624 /* LMN. */
2625 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
2626 _bfd_vms_output_short (recwr, EMH__C_LNM);
2627 snprintf (version, sizeof (version), "%s %d.%d.%d", name,
2628 ver / 10000, (ver / 100) % 100, ver % 100);
2629 _bfd_vms_output_dump (recwr, (unsigned char *)version, strlen (version));
2630 _bfd_vms_output_end (abfd, recwr);
2631}
2632
2633
2634/* Write eom record for bfd abfd. Return FALSE on error. */
2635
2636static bfd_boolean
2637_bfd_vms_write_eeom (bfd *abfd)
2638{
2639 struct vms_rec_wr *recwr = &PRIV (recwr);
2640
2641 vms_debug2 ((2, "vms_write_eeom\n"));
2642
2643 _bfd_vms_output_alignment (recwr, 2);
2644
2645 _bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
2646 _bfd_vms_output_long (recwr, (unsigned long) (PRIV (vms_linkage_index) >> 1));
2647 _bfd_vms_output_byte (recwr, 0); /* Completion code. */
2648 _bfd_vms_output_byte (recwr, 0); /* Fill byte. */
2649
2650 if ((abfd->flags & EXEC_P) == 0
2651 && bfd_get_start_address (abfd) != (bfd_vma)-1)
2652 {
2653 asection *section;
2654
2655 section = bfd_get_section_by_name (abfd, ".link");
2656 if (section == 0)
2657 {
2658 bfd_set_error (bfd_error_nonrepresentable_section);
2659 return FALSE;
2660 }
2661 _bfd_vms_output_short (recwr, 0);
2662 _bfd_vms_output_long (recwr, (unsigned long) (section->index));
2663 _bfd_vms_output_long (recwr,
2664 (unsigned long) bfd_get_start_address (abfd));
2665 _bfd_vms_output_long (recwr, 0);
2666 }
2667
2668 _bfd_vms_output_end (abfd, recwr);
2669 return TRUE;
2670}
2671
2672/* This hash routine borrowed from GNU-EMACS, and strengthened
2673 slightly. ERY. */
2674
2675static int
2676hash_string (const char *ptr)
2677{
2678 const unsigned char *p = (unsigned char *) ptr;
2679 const unsigned char *end = p + strlen (ptr);
2680 unsigned char c;
2681 int hash = 0;
2682
2683 while (p != end)
2684 {
2685 c = *p++;
2686 hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
2687 }
2688 return hash;
2689}
2690
2691/* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
2692
2693static char *
2694_bfd_vms_length_hash_symbol (bfd *abfd, const char *in, int maxlen)
2695{
2696 unsigned long result;
2697 int in_len;
2698 char *new_name;
2699 const char *old_name;
2700 int i;
2701 static char outbuf[EOBJ__C_SYMSIZ + 1];
2702 char *out = outbuf;
2703
2704#if VMS_DEBUG
2705 vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
2706#endif
2707
2708 if (maxlen > EOBJ__C_SYMSIZ)
2709 maxlen = EOBJ__C_SYMSIZ;
2710
2711 /* Save this for later. */
2712 new_name = out;
2713
2714 /* We may need to truncate the symbol, save the hash for later. */
2715 in_len = strlen (in);
2716
2717 result = (in_len > maxlen) ? hash_string (in) : 0;
2718
2719 old_name = in;
2720
2721 /* Do the length checking. */
2722 if (in_len <= maxlen)
2723 i = in_len;
2724 else
2725 {
2726 if (PRIV (flag_hash_long_names))
2727 i = maxlen - 9;
2728 else
2729 i = maxlen;
2730 }
2731
2732 strncpy (out, in, (size_t) i);
2733 in += i;
2734 out += i;
2735
2736 if ((in_len > maxlen)
2737 && PRIV (flag_hash_long_names))
2738 sprintf (out, "_%08lx", result);
2739 else
2740 *out = 0;
2741
2742#if VMS_DEBUG
2743 vms_debug (4, "--> [%d]\"%s\"\n", (int)strlen (outbuf), outbuf);
2744#endif
2745
2746 if (in_len > maxlen
2747 && PRIV (flag_hash_long_names)
2748 && PRIV (flag_show_after_trunc))
2749 printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
2750
2751 return outbuf;
2752}
2753
95e34ef7
TG		 2754static void
2755vector_grow1 (struct vector_type *vec, size_t elsz)
2756{
2757 if (vec->nbr_el + 1 < vec->max_el)
2758 return;
2759
2760 if (vec->max_el == 0)
2761 {
2762 vec->max_el = 16;
2763 vec->els = bfd_malloc2 (vec->max_el, elsz);
2764 }
2765 else
2766 {
2767 vec->max_el *= 2;
2768 vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
2769 }
2770}
2771
2772/* Bump ABFD file position to next block. */
2773
2774static void
2775alpha_vms_file_position_block (bfd *abfd)
2776{
2777 /* Next block. */
2778 PRIV (file_pos) += VMS_BLOCK_SIZE - 1;
2779 PRIV (file_pos) -= (PRIV (file_pos) % VMS_BLOCK_SIZE);
2780}
2781
44273c5b
TG		 2782/* Convert from internal structure SRC to external structure DST. */
2783
95e34ef7
TG		 2784static void
2785alpha_vms_swap_eisd_out (struct vms_internal_eisd_map *src,
2786 struct vms_eisd *dst)
2787{
2788 bfd_putl32 (src->u.eisd.majorid, dst->majorid);
2789 bfd_putl32 (src->u.eisd.minorid, dst->minorid);
2790 bfd_putl32 (src->u.eisd.eisdsize, dst->eisdsize);
2791 if (src->u.eisd.eisdsize <= EISD__K_LENEND)
2792 return;
2793 bfd_putl32 (src->u.eisd.secsize, dst->secsize);
2794 bfd_putl64 (src->u.eisd.virt_addr, dst->virt_addr);
2795 bfd_putl32 (src->u.eisd.flags, dst->flags);
2796 bfd_putl32 (src->u.eisd.vbn, dst->vbn);
2797 dst->pfc = src->u.eisd.pfc;
2798 dst->matchctl = src->u.eisd.matchctl;
2799 dst->type = src->u.eisd.type;
2800 dst->fill_1 = 0;
2801 if (src->u.eisd.flags & EISD__M_GBL)
2802 {
2803 bfd_putl32 (src->u.gbl_eisd.ident, dst->ident);
2804 memcpy (dst->gblnam, src->u.gbl_eisd.gblnam,
2805 src->u.gbl_eisd.gblnam[0] + 1);
2806 }
2807}
2808
2809/* Append EISD to the list of extra eisd for ABFD. */
2810
2811static void
2812alpha_vms_append_extra_eisd (bfd *abfd, struct vms_internal_eisd_map *eisd)
2813{
2814 eisd->next = NULL;
2815 if (PRIV (gbl_eisd_head) == NULL)
2816 PRIV (gbl_eisd_head) = eisd;
2817 else
2818 PRIV (gbl_eisd_tail)->next = eisd;
2819 PRIV (gbl_eisd_tail) = eisd;
2820}
2821
44273c5b
TG		 2822/* Create an EISD for shared image SHRIMG.
2823 Return FALSE in case of error. */
2824
95e34ef7
TG		 2825static bfd_boolean
2826alpha_vms_create_eisd_for_shared (bfd *abfd, bfd *shrimg)
2827{
2828 struct vms_internal_eisd_map *eisd;
2829 int namlen;
2830
2831 namlen = strlen (PRIV2 (shrimg, hdr_data.hdr_t_name));
2832 if (namlen + 5 > EISD__K_GBLNAMLEN)
2833 {
2834 /* Won't fit. */
2835 return FALSE;
2836 }
2837
2838 eisd = bfd_alloc (abfd, sizeof (*eisd));
2839 if (eisd == NULL)
2840 return FALSE;
2841
2842 /* Fill the fields. */
2843 eisd->u.gbl_eisd.common.majorid = EISD__K_MAJORID;
2844 eisd->u.gbl_eisd.common.minorid = EISD__K_MINORID;
2845 eisd->u.gbl_eisd.common.eisdsize = (EISD__K_LEN + 4 + namlen + 5 + 3) & ~3;
2846 eisd->u.gbl_eisd.common.secsize = VMS_BLOCK_SIZE; /* Must not be 0. */
2847 eisd->u.gbl_eisd.common.virt_addr = 0;
2848 eisd->u.gbl_eisd.common.flags = EISD__M_GBL;
2849 eisd->u.gbl_eisd.common.vbn = 0;
2850 eisd->u.gbl_eisd.common.pfc = 0;
2851 eisd->u.gbl_eisd.common.matchctl = PRIV2 (shrimg, matchctl);
2852 eisd->u.gbl_eisd.common.type = EISD__K_SHRPIC;
2853
2854 eisd->u.gbl_eisd.ident = PRIV2 (shrimg, ident);
2855 eisd->u.gbl_eisd.gblnam[0] = namlen + 4;
2856 memcpy (eisd->u.gbl_eisd.gblnam + 1, PRIV2 (shrimg, hdr_data.hdr_t_name),
2857 namlen);
2858 memcpy (eisd->u.gbl_eisd.gblnam + 1 + namlen, "_001", 4);
2859
2860 /* Append it to the list. */
2861 alpha_vms_append_extra_eisd (abfd, eisd);
2862
2863 return TRUE;
2864}
2865
44273c5b
TG		 2866/* Create an EISD for section SEC.
2867 Return FALSE in case of failure. */
2868
95e34ef7
TG		 2869static bfd_boolean
2870alpha_vms_create_eisd_for_section (bfd *abfd, asection *sec)
2871{
2872 struct vms_internal_eisd_map *eisd;
2873
2874 /* Only for allocating section. */
2875 if (!(sec->flags & SEC_ALLOC))
2876 return TRUE;
2877
2878 BFD_ASSERT (vms_section_data (sec)->eisd == NULL);
2879 eisd = bfd_alloc (abfd, sizeof (*eisd));
2880 if (eisd == NULL)
2881 return FALSE;
2882 vms_section_data (sec)->eisd = eisd;
2883
2884 /* Fill the fields. */
2885 eisd->u.eisd.majorid = EISD__K_MAJORID;
2886 eisd->u.eisd.minorid = EISD__K_MINORID;
2887 eisd->u.eisd.eisdsize = EISD__K_LEN;
2888 eisd->u.eisd.secsize =
2889 (sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
2890 eisd->u.eisd.virt_addr = sec->vma;
2891 eisd->u.eisd.flags = 0;
2892 eisd->u.eisd.vbn = 0; /* To be later defined. */
2893 eisd->u.eisd.pfc = 0; /* Default. */
2894 eisd->u.eisd.matchctl = EISD__K_MATALL;
2895 eisd->u.eisd.type = EISD__K_NORMAL;
2896
2897 if (sec->flags & SEC_CODE)
2898 eisd->u.eisd.flags |= EISD__M_EXE;
2899 if (!(sec->flags & SEC_READONLY))
2900 eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
2901
2902 if (!(sec->flags & SEC_LOAD))
2903 {
2904 eisd->u.eisd.flags |= EISD__M_DZRO;
2905 eisd->u.eisd.flags &= ~EISD__M_CRF;
2906 }
2907 if (sec->flags & SEC_LINKER_CREATED)
2908 {
2909 if (strcmp (sec->name, "$FIXUP$") == 0)
2910 eisd->u.eisd.flags |= EISD__M_FIXUPVEC;
2911 }
2912
2913 /* Append it to the list. */
2914 eisd->next = NULL;
2915 if (PRIV (eisd_head) == NULL)
2916 PRIV (eisd_head) = eisd;
2917 else
2918 PRIV (eisd_tail)->next = eisd;
2919 PRIV (eisd_tail) = eisd;
2920
2921 return TRUE;
2922}
2923
44273c5b
TG		 2924/* Layout executable ABFD and write it to the disk.
2925 Return FALSE in case of failure. */
2926
95e34ef7
TG		 2927static bfd_boolean
2928alpha_vms_write_exec (bfd *abfd)
2929{
2930 struct vms_eihd eihd;
2931 struct vms_eiha *eiha;
2932 struct vms_eihi *eihi;
2933 struct vms_eihs *eihs = NULL;
2934 asection *sec;
2935 struct vms_internal_eisd_map *first_eisd;
2936 struct vms_internal_eisd_map *eisd;
2937 asection *dst;
44273c5b 2938 asection *dmt;
f9eeb9c9
TG		 2939 file_ptr gst_filepos = 0;
2940 unsigned int lnkflags = 0;
95e34ef7 2941
44273c5b 2942 /* Build the EIHD. */
95e34ef7
TG		 2943 PRIV (file_pos) = EIHD__C_LENGTH;
2944
2945 memset (&eihd, 0, sizeof (eihd));
2946 memset (eihd.fill_2, 0xff, sizeof (eihd.fill_2));
2947
2948 bfd_putl32 (EIHD__K_MAJORID, eihd.majorid);
2949 bfd_putl32 (EIHD__K_MINORID, eihd.minorid);
2950
2951 bfd_putl32 (sizeof (eihd), eihd.size);
2952 bfd_putl32 (0, eihd.isdoff);
2953 bfd_putl32 (0, eihd.activoff);
2954 bfd_putl32 (0, eihd.symdbgoff);
2955 bfd_putl32 (0, eihd.imgidoff);
2956 bfd_putl32 (0, eihd.patchoff);
2957 bfd_putl64 (0, eihd.iafva);
2958 bfd_putl32 (0, eihd.version_array_off);
2959
2960 bfd_putl32 (EIHD__K_EXE, eihd.imgtype);
2961 bfd_putl32 (0, eihd.subtype);
2962
2963 bfd_putl32 (0, eihd.imgiocnt);
2964 bfd_putl32 (-1, eihd.privreqs);
2965 bfd_putl32 (-1, eihd.privreqs + 4);
2966
2967 bfd_putl32 ((sizeof (eihd) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
2968 eihd.hdrblkcnt);
95e34ef7
TG		 2969 bfd_putl32 (0, eihd.ident);
2970 bfd_putl32 (0, eihd.sysver);
2971
2972 eihd.matchctl = 0;
2973 bfd_putl32 (0, eihd.symvect_size);
2974 bfd_putl32 (16, eihd.virt_mem_block_size);
2975 bfd_putl32 (0, eihd.ext_fixup_off);
2976 bfd_putl32 (0, eihd.noopt_psect_off);
2977 bfd_putl32 (-1, eihd.alias);
2978
2979 /* Alloc EIHA. */
2980 eiha = (struct vms_eiha *)((char *) &eihd + PRIV (file_pos));
2981 bfd_putl32 (PRIV (file_pos), eihd.activoff);
2982 PRIV (file_pos) += sizeof (struct vms_eiha);
2983
2984 bfd_putl32 (sizeof (struct vms_eiha), eiha->size);
2985 bfd_putl32 (0, eiha->spare);
2986 bfd_putl32 (0x00000340, eiha->tfradr1); /* SYS$IMGACT */
2987 bfd_putl32 (0xffffffff, eiha->tfradr1_h);
2988 bfd_putl64 (bfd_get_start_address (abfd), eiha->tfradr2);
2989 bfd_putl64 (0, eiha->tfradr3);
2990 bfd_putl64 (0, eiha->tfradr4);
2991 bfd_putl64 (0, eiha->inishr);
2992
2993 /* Alloc EIHI. */
2994 eihi = (struct vms_eihi *)((char *) &eihd + PRIV (file_pos));
2995 bfd_putl32 (PRIV (file_pos), eihd.imgidoff);
2996 PRIV (file_pos) += sizeof (struct vms_eihi);
2997
2998 bfd_putl32 (EIHI__K_MAJORID, eihi->majorid);
2999 bfd_putl32 (EIHI__K_MINORID, eihi->minorid);
3000 {
3001 char *module;
3002 unsigned int len;
3003
3004 module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
3005 len = strlen (module);
3006 if (len > sizeof (eihi->imgnam) - 1)
3007 len = sizeof (eihi->imgnam) - 1;
3008 eihi->imgnam[0] = len;
3009 memcpy (eihi->imgnam + 1, module, len);
3010 free (module);
3011 }
3012 bfd_putl32 (0, eihi->linktime + 0);
3013 bfd_putl32 (0, eihi->linktime + 4);
3014 eihi->imgid[0] = 0;
3015 eihi->linkid[0] = 0;
3016 eihi->imgbid[0] = 0;
3017
3018 /* Alloc EIHS. */
44273c5b
TG		 3019 dst = PRIV (dst_section);
3020 dmt = bfd_get_section_by_name (abfd, "$DMT$");
95e34ef7
TG		 3021 if (dst != NULL && dst->size != 0)
3022 {
3023 eihs = (struct vms_eihs *)((char *) &eihd + PRIV (file_pos));
3024 bfd_putl32 (PRIV (file_pos), eihd.symdbgoff);
3025 PRIV (file_pos) += sizeof (struct vms_eihs);
3026
3027 bfd_putl32 (EIHS__K_MAJORID, eihs->majorid);
3028 bfd_putl32 (EIHS__K_MINORID, eihs->minorid);
3029 bfd_putl32 (0, eihs->dstvbn);
3030 bfd_putl32 (0, eihs->dstsize);
3031 bfd_putl32 (0, eihs->gstvbn);
3032 bfd_putl32 (0, eihs->gstsize);
3033 bfd_putl32 (0, eihs->dmtvbn);
3034 bfd_putl32 (0, eihs->dmtsize);
3035 }
3036
44273c5b 3037 /* One EISD per section. */
95e34ef7
TG		 3038 for (sec = abfd->sections; sec; sec = sec->next)
3039 {
3040 if (!alpha_vms_create_eisd_for_section (abfd, sec))
3041 return FALSE;
3042 }
3043
3044 /* Merge section EIDS which extra ones. */
3045 if (PRIV (eisd_tail))
3046 PRIV (eisd_tail)->next = PRIV (gbl_eisd_head);
3047 else
3048 PRIV (eisd_head) = PRIV (gbl_eisd_head);
3049 if (PRIV (gbl_eisd_tail))
3050 PRIV (eisd_tail) = PRIV (gbl_eisd_tail);
3051
3052 first_eisd = PRIV (eisd_head);
3053
3054 /* Add end of eisd. */
3055 if (first_eisd)
3056 {
3057 eisd = bfd_zalloc (abfd, sizeof (*eisd));
3058 if (eisd == NULL)
3059 return FALSE;
3060 eisd->u.eisd.majorid = 0;
3061 eisd->u.eisd.minorid = 0;
3062 eisd->u.eisd.eisdsize = 0;
3063 alpha_vms_append_extra_eisd (abfd, eisd);
3064 }
3065
3066 /* Place EISD in the file. */
3067 for (eisd = first_eisd; eisd; eisd = eisd->next)
3068 {
3069 file_ptr room = VMS_BLOCK_SIZE - (PRIV (file_pos) % VMS_BLOCK_SIZE);
3070
3071 /* First block is a little bit special: there is a word at the end. */
3072 if (PRIV (file_pos) < VMS_BLOCK_SIZE && room > 2)
3073 room -= 2;
3074 if (room < eisd->u.eisd.eisdsize + EISD__K_LENEND)
3075 alpha_vms_file_position_block (abfd);
3076
3077 eisd->file_pos = PRIV (file_pos);
3078 PRIV (file_pos) += eisd->u.eisd.eisdsize;
3079
3080 if (eisd->u.eisd.flags & EISD__M_FIXUPVEC)
3081 bfd_putl64 (eisd->u.eisd.virt_addr, eihd.iafva);
3082 }
3083
3084 if (first_eisd != NULL)
3085 {
3086 bfd_putl32 (first_eisd->file_pos, eihd.isdoff);
3087 /* Real size of end of eisd marker. */
3088 PRIV (file_pos) += EISD__K_LENEND;
3089 }
3090
3091 bfd_putl32 (PRIV (file_pos), eihd.size);
3092 bfd_putl32 ((PRIV (file_pos) + VMS_BLOCK_SIZE - 1) / VMS_BLOCK_SIZE,
3093 eihd.hdrblkcnt);
3094
3095 /* Place sections. */
3096 for (sec = abfd->sections; sec; sec = sec->next)
3097 {
3098 if (!(sec->flags & SEC_HAS_CONTENTS))
3099 continue;
3100
3101 eisd = vms_section_data (sec)->eisd;
3102
3103 /* Align on a block. */
3104 alpha_vms_file_position_block (abfd);
3105 sec->filepos = PRIV (file_pos);
3106
3107 if (eisd != NULL)
3108 eisd->u.eisd.vbn = (sec->filepos / VMS_BLOCK_SIZE) + 1;
3109
3110 PRIV (file_pos) += sec->size;
3111 }
3112
5fe88cfb 3113 /* Update EIHS. */
95e34ef7
TG		 3114 if (eihs != NULL && dst != NULL)
3115 {
3116 bfd_putl32 ((dst->filepos / VMS_BLOCK_SIZE) + 1, eihs->dstvbn);
3117 bfd_putl32 (dst->size, eihs->dstsize);
44273c5b
TG		 3118
3119 if (dmt != NULL)
3120 {
f9eeb9c9 3121 lnkflags |= EIHD__M_DBGDMT;
44273c5b
TG		 3122 bfd_putl32 ((dmt->filepos / VMS_BLOCK_SIZE) + 1, eihs->dmtvbn);
3123 bfd_putl32 (dmt->size, eihs->dmtsize);
3124 }
f9eeb9c9
TG		 3125 if (PRIV (gsd_sym_count) != 0)
3126 {
3127 alpha_vms_file_position_block (abfd);
3128 gst_filepos = PRIV (file_pos);
3129 bfd_putl32 ((gst_filepos / VMS_BLOCK_SIZE) + 1, eihs->gstvbn);
3130 bfd_putl32 ((PRIV (gsd_sym_count) + 4) / 5 + 4, eihs->gstsize);
3131 }
95e34ef7
TG		 3132 }
3133
3134 /* Write EISD in hdr. */
3135 for (eisd = first_eisd; eisd && eisd->file_pos < VMS_BLOCK_SIZE;
3136 eisd = eisd->next)
3137 alpha_vms_swap_eisd_out
3138 (eisd, (struct vms_eisd *)((char *)&eihd + eisd->file_pos));
3139
3140 /* Write first block. */
f9eeb9c9 3141 bfd_putl32 (lnkflags, eihd.lnkflags);
95e34ef7
TG		 3142 if (bfd_bwrite (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
3143 return FALSE;
3144
3145 /* Write remaining eisd. */
3146 if (eisd != NULL)
3147 {
3148 unsigned char blk[VMS_BLOCK_SIZE];
3149 struct vms_internal_eisd_map *next_eisd;
3150
3151 memset (blk, 0xff, sizeof (blk));
3152 while (eisd != NULL)
3153 {
3154 alpha_vms_swap_eisd_out
3155 (eisd,
3156 (struct vms_eisd *)(blk + (eisd->file_pos % VMS_BLOCK_SIZE)));
3157
3158 next_eisd = eisd->next;
3159 if (next_eisd == NULL
3160 || (next_eisd->file_pos / VMS_BLOCK_SIZE
3161 != eisd->file_pos / VMS_BLOCK_SIZE))
3162 {
3163 if (bfd_bwrite (blk, sizeof (blk), abfd) != sizeof (blk))
3164 return FALSE;
3165
3166 memset (blk, 0xff, sizeof (blk));
3167 }
3168 eisd = next_eisd;
3169 }
3170 }
3171
3172 /* Write sections. */
3173 for (sec = abfd->sections; sec; sec = sec->next)
3174 {
3175 unsigned char blk[VMS_BLOCK_SIZE];
3176 bfd_size_type len;
3177
3178 if (sec->size == 0 || !(sec->flags & SEC_HAS_CONTENTS))
3179 continue;
3180 if (bfd_bwrite (sec->contents, sec->size, abfd) != sec->size)
3181 return FALSE;
3182
3183 /* Pad. */
3184 len = VMS_BLOCK_SIZE - sec->size % VMS_BLOCK_SIZE;
3185 if (len != VMS_BLOCK_SIZE)
3186 {
3187 memset (blk, 0, len);
3188 if (bfd_bwrite (blk, len, abfd) != len)
3189 return FALSE;
3190 }
3191 }
3192
f9eeb9c9
TG		 3193 /* Write GST. */
3194 if (gst_filepos != 0)
3195 {
3196 struct vms_rec_wr *recwr = &PRIV (recwr);
3197 unsigned int i;
3198
3199 _bfd_vms_write_emh (abfd);
3200 _bfd_vms_write_lmn (abfd, "GNU LD");
3201
3202 /* PSC for the absolute section. */
3203 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3204 _bfd_vms_output_long (recwr, 0);
3205 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3206 _bfd_vms_output_short (recwr, 0);
3207 _bfd_vms_output_short (recwr, EGPS__V_PIC | EGPS__V_LIB | EGPS__V_RD);
3208 _bfd_vms_output_long (recwr, 0);
3209 _bfd_vms_output_counted (recwr, ".$$ABS$$.");
3210 _bfd_vms_output_end_subrec (recwr);
3211 _bfd_vms_output_end (abfd, recwr);
3212
3213 for (i = 0; i < PRIV (gsd_sym_count); i++)
3214 {
3215 struct vms_symbol_entry *sym = PRIV (syms)[i];
3216 char *hash;
3217 bfd_vma val;
3218 bfd_vma ep;
3219
3220 if ((i % 5) == 0)
3221 {
3222 _bfd_vms_output_alignment (recwr, 8);
3223 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3224 _bfd_vms_output_long (recwr, 0);
3225 }
3226 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYMG);
3227 _bfd_vms_output_short (recwr, 0); /* Data type, alignment. */
3228 _bfd_vms_output_short (recwr, sym->flags);
3229
3230 if (sym->code_section)
3231 ep = alpha_vms_get_sym_value (sym->code_section, sym->code_value);
3232 else
3233 {
3234 BFD_ASSERT (sym->code_value == 0);
3235 ep = 0;
3236 }
3237 val = alpha_vms_get_sym_value (sym->section, sym->value);
3238 _bfd_vms_output_quad
3239 (recwr, sym->typ == EGSD__C_SYMG ? sym->symbol_vector : val);
3240 _bfd_vms_output_quad (recwr, ep);
3241 _bfd_vms_output_quad (recwr, val);
3242 _bfd_vms_output_long (recwr, 0);
3243 hash = _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ__C_SYMSIZ);
3244 _bfd_vms_output_counted (recwr, hash);
3245 _bfd_vms_output_end_subrec (recwr);
3246 if ((i % 5) == 4)
3247 _bfd_vms_output_end (abfd, recwr);
3248 }
3249 if ((i % 5) != 0)
3250 _bfd_vms_output_end (abfd, recwr);
3251
3252 if (!_bfd_vms_write_eeom (abfd))
3253 return FALSE;
3254 }
95e34ef7
TG		 3255 return TRUE;
3256}
3257\f
3258/* Object write. */
3259
95e34ef7
TG		 3260/* Write section and symbol directory of bfd abfd. Return FALSE on error. */
3261
3262static bfd_boolean
3263_bfd_vms_write_egsd (bfd *abfd)
3264{
3265 asection *section;
3266 asymbol *symbol;
3267 unsigned int symnum;
3268 int last_index = -1;
3269 char dummy_name[10];
3270 char *sname;
3271 flagword new_flags, old_flags;
3272 int abs_section_index = 0;
3273 struct vms_rec_wr *recwr = &PRIV (recwr);
3274
3275 vms_debug2 ((2, "vms_write_gsd\n"));
3276
3277 /* Output sections. */
3278 section = abfd->sections;
3279 vms_debug2 ((3, "%d sections found\n", abfd->section_count));
3280
3281 /* Egsd is quadword aligned. */
3282 _bfd_vms_output_alignment (recwr, 8);
3283
3284 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3285 _bfd_vms_output_long (recwr, 0);
3286
3287 while (section != 0)
3288 {
3289 vms_debug2 ((3, "Section #%d %s, %d bytes\n",
3290 section->index, section->name, (int)section->size));
3291
3292 /* Don't write out the VMS debug info section since it is in the
3293 ETBT and EDBG sections in etir. */
3294 if (!strcmp (section->name, ".vmsdebug"))
3295 goto done;
3296
3297 /* 13 bytes egsd, max 31 chars name -> should be 44 bytes. */
3298 if (_bfd_vms_output_check (recwr, 64) < 0)
3299 {
3300 _bfd_vms_output_end (abfd, recwr);
3301 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3302 _bfd_vms_output_long (recwr, 0);
3303 }
3304
3305 /* Create dummy sections to keep consecutive indices. */
3306 while (section->index - last_index > 1)
3307 {
3308 vms_debug2 ((3, "index %d, last %d\n", section->index, last_index));
3309 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3310 _bfd_vms_output_short (recwr, 0);
3311 _bfd_vms_output_short (recwr, 0);
3312 _bfd_vms_output_long (recwr, 0);
3313 sprintf (dummy_name, ".DUMMY%02d", last_index);
3314 _bfd_vms_output_counted (recwr, dummy_name);
3315 _bfd_vms_output_end_subrec (recwr);
3316 last_index++;
3317 }
3318
3319 /* Don't know if this is necessary for the linker but for now it keeps
5fe88cfb 3320 vms_slurp_gsd happy. */
95e34ef7
TG		 3321 sname = (char *)section->name;
3322 if (*sname == '.')
3323 {
5fe88cfb 3324 /* Remove leading dot. */
95e34ef7
TG		 3325 sname++;
3326 if ((*sname == 't') && (strcmp (sname, "text") == 0))
3327 sname = EVAX_CODE_NAME;
3328 else if ((*sname == 'd') && (strcmp (sname, "data") == 0))
3329 sname = EVAX_DATA_NAME;
3330 else if ((*sname == 'b') && (strcmp (sname, "bss") == 0))
3331 sname = EVAX_BSS_NAME;
3332 else if ((*sname == 'l') && (strcmp (sname, "link") == 0))
3333 sname = EVAX_LINK_NAME;
3334 else if ((*sname == 'r') && (strcmp (sname, "rdata") == 0))
3335 sname = EVAX_READONLY_NAME;
3336 else if ((*sname == 'l') && (strcmp (sname, "literal") == 0))
3337 sname = EVAX_LITERAL_NAME;
3338 else if ((*sname == 'l') && (strcmp (sname, "literals") == 0))
3339 {
3340 sname = EVAX_LITERALS_NAME;
3341 abs_section_index = section->index;
3342 }
3343 else if ((*sname == 'c') && (strcmp (sname, "comm") == 0))
3344 sname = EVAX_COMMON_NAME;
3345 else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
3346 sname = EVAX_LOCAL_NAME;
3347 }
3348 else
3349 sname = _bfd_vms_length_hash_symbol (abfd, sname, EOBJ__C_SECSIZ);
3350
3351 _bfd_vms_output_begin_subrec (recwr, EGSD__C_PSC);
3352 _bfd_vms_output_short (recwr, section->alignment_power & 0xff);
3353
3354 if (bfd_is_com_section (section))
3355 new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
3356 | EGPS__V_WRT | EGPS__V_NOMOD | EGPS__V_COM);
3357 else
3358 new_flags = vms_esecflag_by_name (evax_section_flags, sname,
3359 section->size > 0);
3360
3361 /* Modify them as directed. */
3362 if (section->flags & SEC_READONLY)
3363 new_flags &= ~EGPS__V_WRT;
3364
3365 new_flags &= ~vms_section_data (section)->no_flags;
3366 new_flags |= vms_section_data (section)->flags;
3367
3368 vms_debug2 ((3, "sec flags %x\n", section->flags));
3369 vms_debug2 ((3, "new_flags %x, _raw_size %lu\n",
3370 new_flags, (unsigned long)section->size));
3371
3372 _bfd_vms_output_short (recwr, new_flags);
3373 _bfd_vms_output_long (recwr, (unsigned long) section->size);
3374 _bfd_vms_output_counted (recwr, sname);
3375 _bfd_vms_output_end_subrec (recwr);
3376
3377 last_index = section->index;
3378done:
3379 section = section->next;
3380 }
3381
3382 /* Output symbols. */
3383 vms_debug2 ((3, "%d symbols found\n", abfd->symcount));
3384
3385 bfd_set_start_address (abfd, (bfd_vma) -1);
3386
3387 for (symnum = 0; symnum < abfd->symcount; symnum++)
3388 {
3389 char *hash;
3390
3391 symbol = abfd->outsymbols[symnum];
3392 if (*(symbol->name) == '_')
3393 {
3394 if (strcmp (symbol->name, "__main") == 0)
3395 bfd_set_start_address (abfd, (bfd_vma)symbol->value);
3396 }
3397 old_flags = symbol->flags;
3398
3399 if (old_flags & BSF_FILE)
3400 continue;
3401
3402 if ((old_flags & BSF_GLOBAL) == 0 /* Not xdef... */
3403 && !bfd_is_und_section (symbol->section) /* and not xref... */
3404 && !((old_flags & BSF_SECTION_SYM) != 0 /* and not LIB$INITIALIZE. */
3405 && strcmp (symbol->section->name, "LIB$INITIALIZE") == 0))
3406 continue;
3407
3408 /* 13 bytes egsd, max 64 chars name -> should be 77 bytes. */
3409 if (_bfd_vms_output_check (recwr, 80) < 0)
3410 {
3411 _bfd_vms_output_end (abfd, recwr);
3412 _bfd_vms_output_begin (recwr, EOBJ__C_EGSD);
3413 _bfd_vms_output_long (recwr, 0);
3414 }
3415
3416 _bfd_vms_output_begin_subrec (recwr, EGSD__C_SYM);
3417
3418 /* Data type, alignment. */
3419 _bfd_vms_output_short (recwr, 0);
3420
3421 new_flags = 0;
3422
3423 if (old_flags & BSF_WEAK)
3424 new_flags |= EGSY__V_WEAK;
3425 if (bfd_is_com_section (symbol->section)) /* .comm */
3426 new_flags |= (EGSY__V_WEAK | EGSY__V_COMM);
3427
3428 if (old_flags & BSF_FUNCTION)
3429 {
3430 new_flags |= EGSY__V_NORM;
3431 new_flags |= EGSY__V_REL;
3432 }
3433 if (old_flags & BSF_GLOBAL)
3434 {
3435 new_flags |= EGSY__V_DEF;
3436 if (!bfd_is_abs_section (symbol->section))
3437 new_flags |= EGSY__V_REL;
3438 }
3439 _bfd_vms_output_short (recwr, new_flags);
3440
3441 if (old_flags & BSF_GLOBAL)
3442 {
3443 /* Symbol definition. */
3444 bfd_vma code_address = 0;
3445 unsigned long ca_psindx = 0;
3446 unsigned long psindx;
3447
3448 if ((old_flags & BSF_FUNCTION) && symbol->udata.p != NULL)
3449 {
3450 asymbol *sym;
3451
3452 sym = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym;
3453 code_address = sym->value;
3454 ca_psindx = sym->section->index;
3455 }
3456 if (bfd_is_abs_section (symbol->section))
3457 psindx = abs_section_index;
3458 else
3459 psindx = symbol->section->index;
3460
3461 _bfd_vms_output_quad (recwr, symbol->value);
3462 _bfd_vms_output_quad (recwr, code_address);
3463 _bfd_vms_output_long (recwr, ca_psindx);
3464 _bfd_vms_output_long (recwr, psindx);
3465 }
3466 hash = _bfd_vms_length_hash_symbol (abfd, symbol->name, EOBJ__C_SYMSIZ);
3467 _bfd_vms_output_counted (recwr, hash);
3468
3469 _bfd_vms_output_end_subrec (recwr);
95e34ef7
TG		 3470 }
3471
3472 _bfd_vms_output_alignment (recwr, 8);
3473 _bfd_vms_output_end (abfd, recwr);
3474
3475 return TRUE;
3476}
3477
3478/* Write object header for bfd abfd. Return FALSE on error. */
3479
3480static bfd_boolean
3481_bfd_vms_write_ehdr (bfd *abfd)
3482{
3483 asymbol *symbol;
3484 unsigned int symnum;
3485 int had_case = 0;
3486 int had_file = 0;
95e34ef7
TG		 3487 struct vms_rec_wr *recwr = &PRIV (recwr);
3488
3489 vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
3490
3491 _bfd_vms_output_alignment (recwr, 2);
3492
bd7b51b4
TG		 3493 _bfd_vms_write_emh (abfd);
3494 _bfd_vms_write_lmn (abfd, "GNU AS");
95e34ef7
TG		 3495
3496 /* SRC. */
3497 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3498 _bfd_vms_output_short (recwr, EMH__C_SRC);
3499
3500 for (symnum = 0; symnum < abfd->symcount; symnum++)
3501 {
3502 symbol = abfd->outsymbols[symnum];
3503
3504 if (symbol->flags & BSF_FILE)
3505 {
3506 if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
3507 {
3508 PRIV (flag_hash_long_names) = symbol->name[6] - '0';
3509 PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
3510
3511 if (had_file)
3512 break;
3513 had_case = 1;
3514 continue;
3515 }
3516
3517 _bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
3518 (int) strlen (symbol->name));
3519 if (had_case)
3520 break;
3521 had_file = 1;
3522 }
3523 }
3524
3525 if (symnum == abfd->symcount)
3526 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("noname"));
3527
3528 _bfd_vms_output_end (abfd, recwr);
3529
3530 /* TTL. */
3531 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3532 _bfd_vms_output_short (recwr, EMH__C_TTL);
3533 _bfd_vms_output_dump (recwr, (unsigned char *) STRING_COMMA_LEN ("TTL"));
3534 _bfd_vms_output_end (abfd, recwr);
3535
3536 /* CPR. */
3537 _bfd_vms_output_begin (recwr, EOBJ__C_EMH);
3538 _bfd_vms_output_short (recwr, EMH__C_CPR);
3539 _bfd_vms_output_dump (recwr,
3540 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
3541 39);
3542 _bfd_vms_output_end (abfd, recwr);
3543
3544 return TRUE;
3545}
3546
3547/* Part 4.6, relocations. */
3548
3549\f
3550/* WRITE ETIR SECTION
3551
3552 This is still under construction and therefore not documented. */
3553
3554/* Close the etir/etbt record. */
3555
3556static void
3557end_etir_record (bfd * abfd)
3558{
3559 struct vms_rec_wr *recwr = &PRIV (recwr);
3560
3561 _bfd_vms_output_end (abfd, recwr);
3562}
3563
3564static void
3565start_etir_or_etbt_record (bfd *abfd, asection *section, bfd_vma offset)
3566{
3567 struct vms_rec_wr *recwr = &PRIV (recwr);
3568
3569 if (section->name[0] == '.' && section->name[1] == 'v'
3570 && !strcmp (section->name, ".vmsdebug"))
3571 {
3572 _bfd_vms_output_begin (recwr, EOBJ__C_ETBT);
3573
3574 if (offset == 0)
3575 {
3576 /* Push start offset. */
3577 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3578 _bfd_vms_output_long (recwr, (unsigned long) 0);
3579 _bfd_vms_output_end_subrec (recwr);
3580
3581 /* Set location. */
3582 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_DFLOC);
3583 _bfd_vms_output_end_subrec (recwr);
3584 }
3585 }
3586 else
3587 {
3588 _bfd_vms_output_begin (recwr, EOBJ__C_ETIR);
3589
3590 if (offset == 0)
3591 {
3592 /* Push start offset. */
3593 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3594 _bfd_vms_output_long (recwr, (unsigned long) section->index);
3595 _bfd_vms_output_quad (recwr, offset);
3596 _bfd_vms_output_end_subrec (recwr);
3597
3598 /* Start = pop (). */
3599 _bfd_vms_output_begin_subrec (recwr, ETIR__C_CTL_SETRB);
3600 _bfd_vms_output_end_subrec (recwr);
3601 }
3602 }
3603}
3604
3605/* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
3606 address VADDR in section specified by SEC_INDEX and NAME. */
3607
3608static void
3609sto_imm (bfd *abfd, asection *section,
3610 bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr)
3611{
3612 bfd_size_type size;
3613 struct vms_rec_wr *recwr = &PRIV (recwr);
3614
3615#if VMS_DEBUG
3616 _bfd_vms_debug (8, "sto_imm %d bytes\n", (int) ssize);
3617 _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
3618#endif
3619
3620 while (ssize > 0)
3621 {
3622 /* Try all the rest. */
3623 size = ssize;
3624
3625 if (_bfd_vms_output_check (recwr, size) < 0)
3626 {
3627 /* Doesn't fit, split ! */
3628 end_etir_record (abfd);
3629
3630 start_etir_or_etbt_record (abfd, section, vaddr);
3631
3632 size = _bfd_vms_output_check (recwr, 0); /* get max size */
3633 if (size > ssize) /* more than what's left ? */
3634 size = ssize;
3635 }
3636
3637 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_IMM);
3638 _bfd_vms_output_long (recwr, (unsigned long) (size));
3639 _bfd_vms_output_dump (recwr, cptr, size);
3640 _bfd_vms_output_end_subrec (recwr);
3641
3642#if VMS_DEBUG
3643 _bfd_vms_debug (10, "dumped %d bytes\n", (int) size);
3644 _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
3645#endif
3646
3647 vaddr += size;
3648 cptr += size;
3649 ssize -= size;
3650 }
3651}
3652
3653static void
3654etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
3655{
3656 if (_bfd_vms_output_check (&PRIV (recwr), checklen) < 0)
3657 {
3658 /* Not enough room in this record. Close it and open a new one. */
3659 end_etir_record (abfd);
3660 start_etir_or_etbt_record (abfd, section, vaddr);
3661 }
3662}
3663
3664/* Return whether RELOC must be deferred till the end. */
3665
3666static bfd_boolean
3667defer_reloc_p (arelent *reloc)
3668{
3669 switch (reloc->howto->type)
3670 {
3671 case ALPHA_R_NOP:
3672 case ALPHA_R_LDA:
3673 case ALPHA_R_BSR:
3674 case ALPHA_R_BOH:
3675 return TRUE;
3676
3677 default:
3678 return FALSE;
3679 }
3680}
3681
3682/* Write section contents for bfd abfd. Return FALSE on error. */
3683
3684static bfd_boolean
3685_bfd_vms_write_etir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
3686{
3687 asection *section;
3688 struct vms_rec_wr *recwr = &PRIV (recwr);
3689
3690 vms_debug2 ((2, "vms_write_tir (%p, %d)\n", abfd, objtype));
3691
3692 _bfd_vms_output_alignment (recwr, 4);
3693
3694 PRIV (vms_linkage_index) = 1;
3695
3696 for (section = abfd->sections; section; section = section->next)
3697 {
3698 vms_debug2 ((4, "writing %d. section '%s' (%d bytes)\n",
3699 section->index, section->name, (int) (section->size)));
3700
3701 if (!(section->flags & SEC_HAS_CONTENTS)
3702 || bfd_is_com_section (section))
3703 continue;
3704
3705 if (!section->contents)
3706 {
3707 bfd_set_error (bfd_error_no_contents);
3708 return FALSE;
3709 }
3710
3711 start_etir_or_etbt_record (abfd, section, 0);
3712
3713 if (section->flags & SEC_RELOC)
3714 {
3715 bfd_vma curr_addr = 0;
3716 unsigned char *curr_data = section->contents;
3717 bfd_size_type size;
3718 int pass2_needed = 0;
3719 int pass2_in_progress = 0;
3720 unsigned int irel;
3721
3722 if (section->reloc_count <= 0)
3723 (*_bfd_error_handler)
3724 (_("SEC_RELOC with no relocs in section %s"), section->name);
3725
3726#if VMS_DEBUG
3727 else
3728 {
3729 int i = section->reloc_count;
3730 arelent **rptr = section->orelocation;
3731 _bfd_vms_debug (4, "%d relocations:\n", i);
3732 while (i-- > 0)
3733 {
3734 _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
3735 "addr %08lx, off %08lx, len %d: %s\n",
3736 (*(*rptr)->sym_ptr_ptr)->name,
3737 (*(*rptr)->sym_ptr_ptr)->section->name,
3738 (long) (*(*rptr)->sym_ptr_ptr)->value,
3739 (unsigned long)(*rptr)->address,
3740 (unsigned long)(*rptr)->addend,
3741 bfd_get_reloc_size ((*rptr)->howto),
3742 ( *rptr)->howto->name);
3743 rptr++;
3744 }
3745 }
3746#endif
3747
3748 new_pass:
3749 for (irel = 0; irel < section->reloc_count; irel++)
3750 {
3751 struct evax_private_udata_struct *udata;
3752 arelent *rptr = section->orelocation [irel];
3753 bfd_vma addr = rptr->address;
3754 asymbol *sym = *rptr->sym_ptr_ptr;
3755 asection *sec = sym->section;
3756 bfd_boolean defer = defer_reloc_p (rptr);
3757 unsigned int slen;
3758 char *hash;
3759
3760 if (pass2_in_progress)
3761 {
3762 /* Non-deferred relocs have already been output. */
3763 if (!defer)
3764 continue;
3765 }
3766 else
3767 {
3768 /* Deferred relocs must be output at the very end. */
3769 if (defer)
3770 {
3771 pass2_needed = 1;
3772 continue;
3773 }
3774
3775 /* Regular relocs are intertwined with binary data. */
3776 if (curr_addr > addr)
3777 (*_bfd_error_handler) (_("Size error in section %s"),
3778 section->name);
3779 size = addr - curr_addr;
3780 sto_imm (abfd, section, size, curr_data, curr_addr);
3781 curr_data += size;
3782 curr_addr += size;
3783 }
3784
3785 size = bfd_get_reloc_size (rptr->howto);
3786
3787 switch (rptr->howto->type)
3788 {
3789 case ALPHA_R_IGNORE:
3790 break;
3791
3792 case ALPHA_R_REFLONG:
3793 if (bfd_is_und_section (sym->section))
3794 {
3795 bfd_vma addend = rptr->addend;
3796 slen = strlen ((char *) sym->name);
3797 hash = _bfd_vms_length_hash_symbol
3798 (abfd, sym->name, EOBJ__C_SYMSIZ);
3799 etir_output_check (abfd, section, curr_addr, slen);
3800 if (addend)
3801 {
3802 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3803 _bfd_vms_output_counted (recwr, hash);
3804 _bfd_vms_output_end_subrec (recwr);
3805 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3806 _bfd_vms_output_long (recwr, (unsigned long) addend);
3807 _bfd_vms_output_end_subrec (recwr);
3808 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3809 _bfd_vms_output_end_subrec (recwr);
3810 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3811 _bfd_vms_output_end_subrec (recwr);
3812 }
3813 else
3814 {
3815 _bfd_vms_output_begin_subrec
3816 (recwr, ETIR__C_STO_GBL_LW);
3817 _bfd_vms_output_counted (recwr, hash);
3818 _bfd_vms_output_end_subrec (recwr);
3819 }
3820 }
3821 else if (bfd_is_abs_section (sym->section))
3822 {
3823 etir_output_check (abfd, section, curr_addr, 16);
3824 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
3825 _bfd_vms_output_long (recwr, (unsigned long) sym->value);
3826 _bfd_vms_output_end_subrec (recwr);
3827 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3828 _bfd_vms_output_end_subrec (recwr);
3829 }
3830 else
3831 {
3832 etir_output_check (abfd, section, curr_addr, 32);
3833 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3834 _bfd_vms_output_long (recwr, (unsigned long) sec->index);
3835 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3836 _bfd_vms_output_end_subrec (recwr);
3837 /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
3838 says that we should have a ETIR__C_STO_OFF here.
3839 But the relocation would not be BFD_RELOC_32 then.
3840 This case is very likely unreachable. */
3841 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_LW);
3842 _bfd_vms_output_end_subrec (recwr);
3843 }
3844 break;
3845
3846 case ALPHA_R_REFQUAD:
3847 if (bfd_is_und_section (sym->section))
3848 {
3849 bfd_vma addend = rptr->addend;
3850 slen = strlen ((char *) sym->name);
3851 hash = _bfd_vms_length_hash_symbol
3852 (abfd, sym->name, EOBJ__C_SYMSIZ);
3853 etir_output_check (abfd, section, curr_addr, slen);
3854 if (addend)
3855 {
3856 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
3857 _bfd_vms_output_counted (recwr, hash);
3858 _bfd_vms_output_end_subrec (recwr);
3859 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3860 _bfd_vms_output_quad (recwr, addend);
3861 _bfd_vms_output_end_subrec (recwr);
3862 _bfd_vms_output_begin_subrec (recwr, ETIR__C_OPR_ADD);
3863 _bfd_vms_output_end_subrec (recwr);
3864 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3865 _bfd_vms_output_end_subrec (recwr);
3866 }
3867 else
3868 {
3869 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
3870 _bfd_vms_output_counted (recwr, hash);
3871 _bfd_vms_output_end_subrec (recwr);
3872 }
3873 }
3874 else if (bfd_is_abs_section (sym->section))
3875 {
3876 etir_output_check (abfd, section, curr_addr, 16);
3877 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
3878 _bfd_vms_output_quad (recwr, sym->value);
3879 _bfd_vms_output_end_subrec (recwr);
3880 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_QW);
3881 _bfd_vms_output_end_subrec (recwr);
3882 }
3883 else
3884 {
3885 etir_output_check (abfd, section, curr_addr, 32);
3886 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_PQ);
3887 _bfd_vms_output_long (recwr, (unsigned long) sec->index);
3888 _bfd_vms_output_quad (recwr, rptr->addend + sym->value);
3889 _bfd_vms_output_end_subrec (recwr);
3890 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_OFF);
3891 _bfd_vms_output_end_subrec (recwr);
3892 }
3893 break;
3894
3895 case ALPHA_R_HINT:
3896 sto_imm (abfd, section, size, curr_data, curr_addr);
3897 break;
3898
3899 case ALPHA_R_LINKAGE:
3900 etir_output_check (abfd, section, curr_addr, 64);
3901 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
3902 _bfd_vms_output_long
3903 (recwr, (unsigned long) PRIV (vms_linkage_index));
3904 PRIV (vms_linkage_index) += 2;
3905 hash = _bfd_vms_length_hash_symbol
3906 (abfd, sym->name, EOBJ__C_SYMSIZ);
3907 _bfd_vms_output_counted (recwr, hash);
3908 _bfd_vms_output_byte (recwr, 0);
3909 _bfd_vms_output_end_subrec (recwr);
3910 break;
3911
3912 case ALPHA_R_CODEADDR:
3913 slen = strlen ((char *) sym->name);
3914 hash = _bfd_vms_length_hash_symbol
3915 (abfd, sym->name, EOBJ__C_SYMSIZ);
3916 etir_output_check (abfd, section, curr_addr, slen);
3917 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
3918 _bfd_vms_output_counted (recwr, hash);
3919 _bfd_vms_output_end_subrec (recwr);
3920 break;
3921
3922 case ALPHA_R_NOP:
3923 udata
3924 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3925 etir_output_check (abfd, section, curr_addr,
3926 32 + 1 + strlen (udata->origname));
3927 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
3928 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3929 _bfd_vms_output_long
3930 (recwr, (unsigned long) udata->enbsym->section->index);
3931 _bfd_vms_output_quad (recwr, rptr->address);
3932 _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3933 _bfd_vms_output_long
3934 (recwr, (unsigned long) udata->enbsym->section->index);
3935 _bfd_vms_output_quad (recwr, rptr->addend);
3936 _bfd_vms_output_counted
3937 (recwr, _bfd_vms_length_hash_symbol
3938 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3939 _bfd_vms_output_end_subrec (recwr);
3940 break;
3941
3942 case ALPHA_R_BSR:
3943 (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3944 break;
3945
3946 case ALPHA_R_LDA:
3947 udata
3948 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3949 etir_output_check (abfd, section, curr_addr,
3950 32 + 1 + strlen (udata->origname));
3951 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
3952 _bfd_vms_output_long
3953 (recwr, (unsigned long) udata->lkindex + 1);
3954 _bfd_vms_output_long
3955 (recwr, (unsigned long) udata->enbsym->section->index);
3956 _bfd_vms_output_quad (recwr, rptr->address);
3957 _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
3958 _bfd_vms_output_long
3959 (recwr, (unsigned long) udata->bsym->section->index);
3960 _bfd_vms_output_quad (recwr, rptr->addend);
3961 _bfd_vms_output_counted
3962 (recwr, _bfd_vms_length_hash_symbol
3963 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3964 _bfd_vms_output_end_subrec (recwr);
3965 break;
3966
3967 case ALPHA_R_BOH:
3968 udata
3969 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3970 etir_output_check (abfd, section, curr_addr,
3971 32 + 1 + strlen (udata->origname));
3972 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
3973 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
3974 _bfd_vms_output_long
3975 (recwr, (unsigned long) udata->enbsym->section->index);
3976 _bfd_vms_output_quad (recwr, rptr->address);
3977 _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
3978 _bfd_vms_output_long
3979 (recwr, (unsigned long) udata->enbsym->section->index);
3980 _bfd_vms_output_quad (recwr, rptr->addend);
3981 _bfd_vms_output_counted
3982 (recwr, _bfd_vms_length_hash_symbol
3983 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3984 _bfd_vms_output_end_subrec (recwr);
3985 break;
3986
3987 default:
3988 (*_bfd_error_handler) (_("Unhandled relocation %s"),
3989 rptr->howto->name);
3990 break;
3991 }
3992
3993 curr_data += size;
3994 curr_addr += size;
3995 } /* End of relocs loop. */
3996
3997 if (!pass2_in_progress)
3998 {
3999 /* Output rest of section. */
4000 if (curr_addr > section->size)
4001 (*_bfd_error_handler) (_("Size error in section %s"),
4002 section->name);
4003 size = section->size - curr_addr;
4004 sto_imm (abfd, section, size, curr_data, curr_addr);
4005 curr_data += size;
4006 curr_addr += size;
4007
4008 if (pass2_needed)
4009 {
4010 pass2_in_progress = 1;
4011 goto new_pass;
4012 }
4013 }
4014 }
4015
4016 else /* (section->flags & SEC_RELOC) */
4017 sto_imm (abfd, section, section->size, section->contents, 0);
4018
4019 end_etir_record (abfd);
4020 }
4021
4022 _bfd_vms_output_alignment (recwr, 2);
4023 return TRUE;
4024}
4025
95e34ef7
TG		 4026/* Write cached information into a file being written, at bfd_close. */
4027
4028static bfd_boolean
4029alpha_vms_write_object_contents (bfd *abfd)
4030{
4031 vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
4032
4033 if (abfd->flags & (EXEC_P | DYNAMIC))
4034 {
4035 return alpha_vms_write_exec (abfd);
4036 }
4037 else
4038 {
4039 if (abfd->section_count > 0) /* we have sections */
4040 {
4041 if (_bfd_vms_write_ehdr (abfd) != TRUE)
4042 return FALSE;
4043 if (_bfd_vms_write_egsd (abfd) != TRUE)
4044 return FALSE;
4045 if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
4046 return FALSE;
4047 if (_bfd_vms_write_eeom (abfd) != TRUE)
4048 return FALSE;
4049 }
4050 }
4051 return TRUE;
4052}
4053\f
4054/* Debug stuff: nearest line. */
4055
4056#define SET_MODULE_PARSED(m) \
4057 do { if ((m)->name == NULL) (m)->name = ""; } while (0)
4058#define IS_MODULE_PARSED(m) ((m)->name != NULL)
4059
4060/* Build a new module for the specified BFD. */
4061
4062static struct module *
4063new_module (bfd *abfd)
4064{
4065 struct module *module
4066 = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
4067 module->file_table_count = 16; /* Arbitrary. */
4068 module->file_table
4069 = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
4070 return module;
4071}
4072
4073/* Parse debug info for a module and internalize it. */
4074
4075static void
4076parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
4077 int length)
4078{
4079 unsigned char *maxptr = ptr + length;
4080 unsigned char *src_ptr, *pcl_ptr;
4081 unsigned int prev_linum = 0, curr_linenum = 0;
4082 bfd_vma prev_pc = 0, curr_pc = 0;
4083 struct srecinfo *curr_srec, *srec;
4084 struct lineinfo *curr_line, *line;
4085 struct funcinfo *funcinfo;
4086
4087 /* Initialize tables with zero element. */
4088 curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4089 module->srec_table = curr_srec;
4090
4091 curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4092 module->line_table = curr_line;
4093
4094 while (length == -1 || ptr < maxptr)
4095 {
4096 /* The first byte is not counted in the recorded length. */
4097 int rec_length = bfd_getl16 (ptr) + 1;
4098 int rec_type = bfd_getl16 (ptr + 2);
4099
4100 vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4101
4102 if (length == -1 && rec_type == DST__K_MODEND)
4103 break;
4104
4105 switch (rec_type)
4106 {
4107 case DST__K_MODBEG:
4108 module->name
4109 = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4110
4111 curr_pc = 0;
4112 prev_pc = 0;
4113 curr_linenum = 0;
4114 prev_linum = 0;
4115
4116 vms_debug2 ((3, "module: %s\n", module->name));
4117 break;
4118
4119 case DST__K_MODEND:
4120 break;
4121
4122 case DST__K_RTNBEG:
4123 funcinfo = (struct funcinfo *)
4124 bfd_zalloc (abfd, sizeof (struct funcinfo));
4125 funcinfo->name
4126 = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4127 funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4128 funcinfo->next = module->func_table;
4129 module->func_table = funcinfo;
4130
4131 vms_debug2 ((3, "routine: %s at 0x%lx\n",
4132 funcinfo->name, (unsigned long) funcinfo->low));
4133 break;
4134
4135 case DST__K_RTNEND:
4136 module->func_table->high = module->func_table->low
4137 + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4138
4139 if (module->func_table->high > module->high)
4140 module->high = module->func_table->high;
4141
4142 vms_debug2 ((3, "end routine\n"));
4143 break;
4144
4145 case DST__K_PROLOG:
4146 vms_debug2 ((3, "prologue\n"));
4147 break;
4148
4149 case DST__K_EPILOG:
4150 vms_debug2 ((3, "epilog\n"));
4151 break;
4152
4153 case DST__K_BLKBEG:
4154 vms_debug2 ((3, "block\n"));
4155 break;
4156
4157 case DST__K_BLKEND:
4158 vms_debug2 ((3, "end block\n"));
4159 break;
4160
4161 case DST__K_SOURCE:
4162 src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4163
4164 vms_debug2 ((3, "source info\n"));
4165
4166 while (src_ptr < ptr + rec_length)
4167 {
4168 int cmd = src_ptr[0], cmd_length, data;
4169
4170 switch (cmd)
4171 {
4172 case DST__K_SRC_DECLFILE:
4173 {
4174 unsigned int fileid
4175 = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4176 char *filename
4177 = _bfd_vms_save_counted_string (src_ptr
4178 + DST_S_B_SRC_DF_FILENAME);
4179
4180 while (fileid >= module->file_table_count)
4181 {
4182 module->file_table_count *= 2;
4183 module->file_table
4184 = bfd_realloc (module->file_table,
4185 module->file_table_count
4186 * sizeof (struct fileinfo));
4187 }
4188
4189 module->file_table [fileid].name = filename;
4190 module->file_table [fileid].srec = 1;
4191 cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4192 vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4193 fileid, module->file_table [fileid].name));
4194 }
4195 break;
4196
4197 case DST__K_SRC_DEFLINES_B:
4198 /* Perform the association and set the next higher index
4199 to the limit. */
4200 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4201 srec = (struct srecinfo *)
4202 bfd_zalloc (abfd, sizeof (struct srecinfo));
4203 srec->line = curr_srec->line + data;
4204 srec->srec = curr_srec->srec + data;
4205 srec->sfile = curr_srec->sfile;
4206 curr_srec->next = srec;
4207 curr_srec = srec;
4208 cmd_length = 2;
4209 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4210 break;
4211
4212 case DST__K_SRC_DEFLINES_W:
4213 /* Perform the association and set the next higher index
4214 to the limit. */
4215 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4216 srec = (struct srecinfo *)
4217 bfd_zalloc (abfd, sizeof (struct srecinfo));
4218 srec->line = curr_srec->line + data;
4219 srec->srec = curr_srec->srec + data,
4220 srec->sfile = curr_srec->sfile;
4221 curr_srec->next = srec;
4222 curr_srec = srec;
4223 cmd_length = 3;
4224 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4225 break;
4226
4227 case DST__K_SRC_INCRLNUM_B:
4228 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4229 curr_srec->line += data;
4230 cmd_length = 2;
4231 vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4232 break;
4233
4234 case DST__K_SRC_SETFILE:
4235 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4236 curr_srec->sfile = data;
4237 curr_srec->srec = module->file_table[data].srec;
4238 cmd_length = 3;
4239 vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4240 break;
4241
4242 case DST__K_SRC_SETLNUM_L:
4243 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4244 curr_srec->line = data;
4245 cmd_length = 5;
4246 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4247 break;
4248
4249 case DST__K_SRC_SETLNUM_W:
4250 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4251 curr_srec->line = data;
4252 cmd_length = 3;
4253 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4254 break;
4255
4256 case DST__K_SRC_SETREC_L:
4257 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4258 curr_srec->srec = data;
4259 module->file_table[curr_srec->sfile].srec = data;
4260 cmd_length = 5;
4261 vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4262 break;
4263
4264 case DST__K_SRC_SETREC_W:
4265 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4266 curr_srec->srec = data;
4267 module->file_table[curr_srec->sfile].srec = data;
4268 cmd_length = 3;
4269 vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4270 break;
4271
4272 case DST__K_SRC_FORMFEED:
4273 cmd_length = 1;
4274 vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4275 break;
4276
4277 default:
4278 (*_bfd_error_handler) (_("unknown source command %d"),
4279 cmd);
4280 cmd_length = 2;
4281 break;
4282 }
4283
4284 src_ptr += cmd_length;
4285 }
4286 break;
4287
4288 case DST__K_LINE_NUM:
4289 pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4290
4291 vms_debug2 ((3, "line info\n"));
4292
4293 while (pcl_ptr < ptr + rec_length)
4294 {
4295 /* The command byte is signed so we must sign-extend it. */
4296 int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4297
4298 switch (cmd)
4299 {
4300 case DST__K_DELTA_PC_W:
4301 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4302 curr_pc += data;
4303 curr_linenum += 1;
4304 cmd_length = 3;
4305 vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4306 break;
4307
4308 case DST__K_DELTA_PC_L:
4309 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4310 curr_pc += data;
4311 curr_linenum += 1;
4312 cmd_length = 5;
4313 vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4314 break;
4315
4316 case DST__K_INCR_LINUM:
4317 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4318 curr_linenum += data;
4319 cmd_length = 2;
4320 vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4321 break;
4322
4323 case DST__K_INCR_LINUM_W:
4324 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4325 curr_linenum += data;
4326 cmd_length = 3;
4327 vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4328 break;
4329
4330 case DST__K_INCR_LINUM_L:
4331 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4332 curr_linenum += data;
4333 cmd_length = 5;
4334 vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4335 break;
4336
4337 case DST__K_SET_LINUM_INCR:
4338 (*_bfd_error_handler)
4339 (_("DST__K_SET_LINUM_INCR not implemented"));
4340 cmd_length = 2;
4341 break;
4342
4343 case DST__K_SET_LINUM_INCR_W:
4344 (*_bfd_error_handler)
4345 (_("DST__K_SET_LINUM_INCR_W not implemented"));
4346 cmd_length = 3;
4347 break;
4348
4349 case DST__K_RESET_LINUM_INCR:
4350 (*_bfd_error_handler)
4351 (_("DST__K_RESET_LINUM_INCR not implemented"));
4352 cmd_length = 1;
4353 break;
4354
4355 case DST__K_BEG_STMT_MODE:
4356 (*_bfd_error_handler)
4357 (_("DST__K_BEG_STMT_MODE not implemented"));
4358 cmd_length = 1;
4359 break;
4360
4361 case DST__K_END_STMT_MODE:
4362 (*_bfd_error_handler)
4363 (_("DST__K_END_STMT_MODE not implemented"));
4364 cmd_length = 1;
4365 break;
4366
4367 case DST__K_SET_LINUM_B:
4368 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4369 curr_linenum = data;
4370 cmd_length = 2;
4371 vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4372 break;
4373
4374 case DST__K_SET_LINUM:
4375 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4376 curr_linenum = data;
4377 cmd_length = 3;
4378 vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4379 break;
4380
4381 case DST__K_SET_LINUM_L:
4382 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4383 curr_linenum = data;
4384 cmd_length = 5;
4385 vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4386 break;
4387
4388 case DST__K_SET_PC:
4389 (*_bfd_error_handler)
4390 (_("DST__K_SET_PC not implemented"));
4391 cmd_length = 2;
4392 break;
4393
4394 case DST__K_SET_PC_W:
4395 (*_bfd_error_handler)
4396 (_("DST__K_SET_PC_W not implemented"));
4397 cmd_length = 3;
4398 break;
4399
4400 case DST__K_SET_PC_L:
4401 (*_bfd_error_handler)
4402 (_("DST__K_SET_PC_L not implemented"));
4403 cmd_length = 5;
4404 break;
4405
4406 case DST__K_SET_STMTNUM:
4407 (*_bfd_error_handler)
4408 (_("DST__K_SET_STMTNUM not implemented"));
4409 cmd_length = 2;
4410 break;
4411
4412 case DST__K_TERM:
4413 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4414 curr_pc += data;
4415 cmd_length = 2;
4416 vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4417 break;
4418
4419 case DST__K_TERM_W:
4420 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4421 curr_pc += data;
4422 cmd_length = 3;
4423 vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4424 break;
4425
4426 case DST__K_TERM_L:
4427 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4428 curr_pc += data;
4429 cmd_length = 5;
4430 vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
4431 break;
4432
4433 case DST__K_SET_ABS_PC:
4434 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4435 curr_pc = data;
4436 cmd_length = 5;
4437 vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4438 break;
4439
4440 default:
4441 if (cmd <= 0)
4442 {
4443 curr_pc -= cmd;
4444 curr_linenum += 1;
4445 cmd_length = 1;
4446 vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4447 (unsigned long)curr_pc, curr_linenum));
4448 }
4449 else
4450 {
4451 (*_bfd_error_handler) (_("unknown line command %d"),
4452 cmd);
4453 cmd_length = 2;
4454 }
4455 break;
4456 }
4457
4458 if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4459 || cmd <= 0
4460 || cmd == DST__K_DELTA_PC_L
4461 || cmd == DST__K_DELTA_PC_W)
4462 {
4463 line = (struct lineinfo *)
4464 bfd_zalloc (abfd, sizeof (struct lineinfo));
4465 line->address = curr_pc;
4466 line->line = curr_linenum;
4467
4468 curr_line->next = line;
4469 curr_line = line;
4470
4471 prev_linum = curr_linenum;
4472 prev_pc = curr_pc;
4473 vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4474 (unsigned long)curr_pc, curr_linenum));
4475 }
4476
4477 pcl_ptr += cmd_length;
4478 }
4479 break;
4480
4481 case 0x17: /* Undocumented type used by DEC C to declare equates. */
4482 vms_debug2 ((3, "undocumented type 0x17\n"));
4483 break;
4484
4485 default:
4486 vms_debug2 ((3, "ignoring record\n"));
4487 break;
4488
4489 }
4490
4491 ptr += rec_length;
4492 }
4493
4494 /* Finalize tables with EOL marker. */
4495 srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4496 srec->line = (unsigned int) -1;
4497 srec->srec = (unsigned int) -1;
4498 curr_srec->next = srec;
4499
4500 line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4501 line->line = (unsigned int) -1;
4502 line->address = (bfd_vma) -1;
4503 curr_line->next = line;
4504
4505 /* Advertise that this module has been parsed. This is needed
4506 because parsing can be either performed at module creation
4507 or deferred until debug info is consumed. */
4508 SET_MODULE_PARSED (module);
4509}
4510
4511/* Build the list of modules for the specified BFD. */
4512
4513static struct module *
4514build_module_list (bfd *abfd)
4515{
4516 struct module *module, *list = NULL;
4517 asection *dmt;
4518
4519 if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4520 {
4521 /* We have a DMT section so this must be an image. Parse the
4522 section and build the list of modules. This is sufficient
4523 since we can compute the start address and the end address
4524 of every module from the section contents. */
4525 bfd_size_type size = bfd_get_section_size (dmt);
4526 unsigned char *ptr, *end;
4527
4528 ptr = (unsigned char *) bfd_alloc (abfd, size);
4529 if (! ptr)
4530 return NULL;
4531
4532 if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4533 return NULL;
4534
4535 vms_debug2 ((2, "DMT\n"));
4536
4537 end = ptr + size;
4538
4539 while (ptr < end)
4540 {
4541 /* Each header declares a module with its start offset and size
4542 of debug info in the DST section, as well as the count of
4543 program sections (i.e. address spans) it contains. */
4544 int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4545 int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4546 int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4547 ptr += DBG_S_C_DMT_HEADER_SIZE;
4548
4549 vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4550 modbeg, msize, count));
4551
4552 /* We create a 'module' structure for each program section since
4553 we only support contiguous addresses in a 'module' structure.
4554 As a consequence, the actual debug info in the DST section is
4555 shared and can be parsed multiple times; that doesn't seem to
4556 cause problems in practice. */
4557 while (count-- > 0)
4558 {
4559 int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4560 int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4561 module = new_module (abfd);
4562 module->modbeg = modbeg;
4563 module->size = msize;
4564 module->low = start;
4565 module->high = start + length;
4566 module->next = list;
4567 list = module;
4568 ptr += DBG_S_C_DMT_PSECT_SIZE;
4569
4570 vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4571 start, length));
4572 }
4573 }
4574 }
4575 else
4576 {
4577 /* We don't have a DMT section so this must be an object. Parse
4578 the module right now in order to compute its start address and
4579 end address. */
4580 module = new_module (abfd);
4581 parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4582 list = module;
4583 }
4584
4585 return list;
4586}
4587
4588/* Calculate and return the name of the source file and the line nearest
4589 to the wanted location in the specified module. */
4590
4591static bfd_boolean
4592module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4593 const char **file, const char **func,
4594 unsigned int *line)
4595{
4596 struct funcinfo *funcinfo;
4597 struct lineinfo *lineinfo;
4598 struct srecinfo *srecinfo;
4599 bfd_boolean ret = FALSE;
4600
4601 /* Parse this module if that was not done at module creation. */
4602 if (! IS_MODULE_PARSED (module))
4603 {
4604 unsigned int size = module->size;
4605 unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4606 unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4607
4608 if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4609 || bfd_bread (buffer, size, abfd) != size)
4610 {
4611 bfd_set_error (bfd_error_no_debug_section);
4612 return FALSE;
4613 }
4614
4615 parse_module (abfd, module, buffer, size);
4616 free (buffer);
4617 }
4618
4619 /* Find out the function (if any) that contains the address. */
4620 for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4621 if (addr >= funcinfo->low && addr <= funcinfo->high)
4622 {
4623 *func = funcinfo->name;
4624 ret = TRUE;
4625 break;
4626 }
4627
4628 /* Find out the source file and the line nearest to the address. */
4629 for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4630 if (lineinfo->next && addr < lineinfo->next->address)
4631 {
4632 for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4633 if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4634 {
4635 if (srecinfo->sfile > 0)
4636 {
4637 *file = module->file_table[srecinfo->sfile].name;
4638 *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4639 }
4640 else
4641 {
4642 *file = module->name;
4643 *line = lineinfo->line;
4644 }
4645 return TRUE;
4646 }
4647
4648 break;
4649 }
4650
4651 return ret;
4652}
4653
4654/* Provided a BFD, a section and an offset into the section, calculate and
4655 return the name of the source file and the line nearest to the wanted
4656 location. */
4657
4658static bfd_boolean
4659_bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
4660 asymbol **symbols ATTRIBUTE_UNUSED,
4661 bfd_vma offset, const char **file,
4662 const char **func, unsigned int *line)
4663{
4664 struct module *module;
4665
4666 /* What address are we looking for? */
4667 bfd_vma addr = section->vma + offset;
4668
4669 *file = NULL;
4670 *func = NULL;
4671 *line = 0;
4672
4673 if (PRIV (dst_section) == NULL || !(abfd->flags & (EXEC_P | DYNAMIC)))
4674 return FALSE;
4675
4676 if (PRIV (modules) == NULL)
4677 {
4678 PRIV (modules) = build_module_list (abfd);
4679 if (PRIV (modules) == NULL)
4680 return FALSE;
4681 }
4682
4683 for (module = PRIV (modules); module; module = module->next)
4684 if (addr >= module->low && addr <= module->high)
4685 return module_find_nearest_line (abfd, module, addr, file, func, line);
4686
4687 return FALSE;
4688}
4689\f
4690/* Canonicalizations. */
4691/* Set name, value, section and flags of SYM from E. */
4692
4693static bfd_boolean
4694alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4695{
4696 flagword flags;
4697 symvalue value;
4698 asection *sec;
4699 const char *name;
4700
4701 name = e->name;
4702 value = 0;
4703 flags = BSF_NO_FLAGS;
4704 sec = NULL;
4705
4706 switch (e->typ)
4707 {
4708 case EGSD__C_SYM:
4709 if (e->flags & EGSY__V_WEAK)
4710 flags |= BSF_WEAK;
4711
4712 if (e->flags & EGSY__V_DEF)
4713 {
4714 /* Symbol definition. */
4715 flags |= BSF_GLOBAL;
4716 if (e->flags & EGSY__V_NORM)
4717 flags |= BSF_FUNCTION;
4718 value = e->value;
a928f1d7 4719 sec = e->section;
95e34ef7
TG		 4720 }
4721 else
4722 {
4723 /* Symbol reference. */
4724 sec = bfd_und_section_ptr;
4725 }
4726 break;
4727
4728 case EGSD__C_SYMG:
4729 /* A universal symbol is by definition global... */
4730 flags |= BSF_GLOBAL;
4731
4732 /* ...and dynamic in shared libraries. */
4733 if (abfd->flags & DYNAMIC)
4734 flags |= BSF_DYNAMIC;
4735
4736 if (e->flags & EGSY__V_WEAK)
4737 flags |= BSF_WEAK;
4738
4739 if (!(e->flags & EGSY__V_DEF))
4740 abort ();
4741
4742 if (e->flags & EGSY__V_NORM)
4743 flags |= BSF_FUNCTION;
4744
a928f1d7
TG		 4745 value = e->value;
4746 /* sec = e->section; */
95e34ef7 4747 sec = bfd_abs_section_ptr;
95e34ef7
TG		 4748 break;
4749
4750 default:
4751 return FALSE;
4752 }
4753
4754 sym->name = name;
4755 sym->section = sec;
4756 sym->flags = flags;
4757 sym->value = value;
4758 return TRUE;
4759}
4760
4761
4762/* Return the number of bytes required to store a vector of pointers
4763 to asymbols for all the symbols in the BFD abfd, including a
4764 terminal NULL pointer. If there are no symbols in the BFD,
4765 then return 0. If an error occurs, return -1. */
4766
4767static long
4768alpha_vms_get_symtab_upper_bound (bfd *abfd)
4769{
4770 vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4771 abfd, PRIV (gsd_sym_count)));
4772
4773 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4774}
4775
4776/* Read the symbols from the BFD abfd, and fills in the vector
4777 location with pointers to the symbols and a trailing NULL.
4778
4779 Return number of symbols read. */
4780
4781static long
4782alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4783{
4784 unsigned int i;
4785
4786 vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4787
4788 if (PRIV (csymbols) == NULL)
4789 {
4790 PRIV (csymbols) = (asymbol **) bfd_alloc
4791 (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4792
4793 /* Traverse table and fill symbols vector. */
4794 for (i = 0; i < PRIV (gsd_sym_count); i++)
4795 {
4796 struct vms_symbol_entry *e = PRIV (syms)[i];
4797 asymbol *sym;
4798
4799 sym = bfd_make_empty_symbol (abfd);
4800 if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4801 {
4802 bfd_release (abfd, PRIV (csymbols));
4803 PRIV (csymbols) = NULL;
4804 return -1;
4805 }
4806
4807 PRIV (csymbols)[i] = sym;
4808 }
4809 }
4810
4811 if (symbols != NULL)
4812 {
4813 for (i = 0; i < PRIV (gsd_sym_count); i++)
4814 symbols[i] = PRIV (csymbols)[i];
4815 symbols[i] = NULL;
4816 }
4817
4818 return PRIV (gsd_sym_count);
4819}
4820
4821/* Read and convert relocations from ETIR. We do it once for all sections. */
4822
4823static bfd_boolean
4824alpha_vms_slurp_relocs (bfd *abfd)
4825{
4826 int cur_psect = -1;
4827
4828 vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4829
4830 /* We slurp relocs only once, for all sections. */
4831 if (PRIV (reloc_done))
4832 return TRUE;
4833 PRIV (reloc_done) = TRUE;
4834
4835 if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4836 return FALSE;
4837
4838 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4839 return FALSE;
4840
4841 while (1)
4842 {
4843 unsigned char *begin;
4844 unsigned char *end;
4845 unsigned char *ptr;
4846 bfd_reloc_code_real_type reloc_code;
4847 int type;
4848 bfd_vma vaddr = 0;
4849
4850 int length;
4851
4852 bfd_vma cur_address;
4853 int cur_psidx = -1;
4854 unsigned char *cur_sym = NULL;
4855 int prev_cmd = -1;
4856 bfd_vma cur_addend = 0;
4857
4858 /* Skip non-ETIR records. */
4859 type = _bfd_vms_get_object_record (abfd);
4860 if (type == EOBJ__C_EEOM)
4861 break;
4862 if (type != EOBJ__C_ETIR)
4863 continue;
4864
4865 begin = PRIV (recrd.rec) + 4;
4866 end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4867
4868 for (ptr = begin; ptr < end; ptr += length)
4869 {
4870 int cmd;
4871
4872 cmd = bfd_getl16 (ptr);
4873 length = bfd_getl16 (ptr + 2);
4874
4875 cur_address = vaddr;
4876
4877 vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4878 _bfd_vms_etir_name (cmd)));
4879
4880 switch (cmd)
4881 {
4882 case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4883 /* ALPHA_R_REFQUAD und_section, step 1 */
4884 cur_sym = ptr + 4;
4885 prev_cmd = cmd;
4886 continue;
4887
4888 case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4889 cur_psidx = bfd_getl32 (ptr + 4);
4890 cur_addend = bfd_getl64 (ptr + 8);
4891 prev_cmd = cmd;
4892 continue;
4893
4894 case ETIR__C_CTL_SETRB:
4895 if (prev_cmd != ETIR__C_STA_PQ)
4896 {
4897 (*_bfd_error_handler)
4898 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4899 _bfd_vms_etir_name (cmd));
4900 return FALSE;
4901 }
4902 cur_psect = cur_psidx;
4903 vaddr = cur_addend;
4904 cur_psidx = -1;
4905 cur_addend = 0;
4906 continue;
4907
4908 case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4909 /* ALPHA_R_REFLONG und_section, step 2 */
4910 if (prev_cmd != -1)
4911 {
4912 if (prev_cmd != ETIR__C_STA_GBL)
4913 {
4914 (*_bfd_error_handler)
4915 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4916 _bfd_vms_etir_name (ETIR__C_STA_LW));
4917 return FALSE;
4918 }
4919 }
4920 cur_addend = bfd_getl32 (ptr + 4);
4921 prev_cmd = cmd;
4922 continue;
4923
4924 case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4925 /* ALPHA_R_REFQUAD und_section, step 2 */
4926 if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4927 {
4928 (*_bfd_error_handler)
4929 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4930 _bfd_vms_etir_name (ETIR__C_STA_QW));
4931 return FALSE;
4932 }
4933 cur_addend = bfd_getl64 (ptr + 4);
4934 prev_cmd = cmd;
4935 continue;
4936
4937 case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4938 /* ALPHA_R_REFLONG abs_section, step 2 */
4939 /* ALPHA_R_REFLONG others, step 2 */
4940 if (prev_cmd != ETIR__C_OPR_ADD
4941 && prev_cmd != ETIR__C_STA_LW
4942 && prev_cmd != ETIR__C_STA_PQ)
4943 {
4944 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4945 _bfd_vms_etir_name (prev_cmd),
4946 _bfd_vms_etir_name (ETIR__C_STO_LW));
4947 return FALSE;
4948 }
4949 reloc_code = BFD_RELOC_32;
4950 break;
4951
4952 case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
4953 /* ALPHA_R_REFQUAD abs_section, step 2 */
4954 if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
4955 {
4956 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4957 _bfd_vms_etir_name (prev_cmd),
4958 _bfd_vms_etir_name (ETIR__C_STO_QW));
4959 return FALSE;
4960 }
4961 reloc_code = BFD_RELOC_64;
4962 break;
4963
4964 case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
4965 if (prev_cmd != ETIR__C_STA_PQ)
4966 {
4967 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4968 _bfd_vms_etir_name (prev_cmd),
4969 _bfd_vms_etir_name (ETIR__C_STO_OFF));
4970 return FALSE;
4971 }
4972 reloc_code = BFD_RELOC_64;
4973 break;
4974
4975 case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
4976 /* ALPHA_R_REFQUAD und_section, step 3 */
4977 if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
4978 {
4979 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
4980 _bfd_vms_etir_name (prev_cmd),
4981 _bfd_vms_etir_name (ETIR__C_OPR_ADD));
4982 return FALSE;
4983 }
4984 prev_cmd = ETIR__C_OPR_ADD;
4985 continue;
4986
4987 case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
4988 reloc_code = BFD_RELOC_ALPHA_CODEADDR;
4989 cur_sym = ptr + 4;
4990 break;
4991
4992 case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
4993 reloc_code = BFD_RELOC_64;
4994 cur_sym = ptr + 4;
4995 break;
4996
4997 case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
4998 reloc_code = BFD_RELOC_32;
4999 cur_sym = ptr + 4;
5000 break;
5001
5002 case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
5003 reloc_code = BFD_RELOC_ALPHA_LINKAGE;
5004 cur_sym = ptr + 8;
5005 break;
5006
5007 case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
5008 reloc_code = BFD_RELOC_ALPHA_NOP;
5009 goto call_reloc;
5010
5011 case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
5012 reloc_code = BFD_RELOC_ALPHA_BSR;
5013 goto call_reloc;
5014
5015 case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
5016 reloc_code = BFD_RELOC_ALPHA_LDA;
5017 goto call_reloc;
5018
5019 case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
5020 reloc_code = BFD_RELOC_ALPHA_BOH;
5021 goto call_reloc;
5022
5023 call_reloc:
5024 cur_sym = ptr + 4 + 32;
5025 cur_address = bfd_getl64 (ptr + 4 + 8);
5026 cur_addend = bfd_getl64 (ptr + 4 + 24);
5027 break;
5028
5029 case ETIR__C_STO_IMM:
5030 vaddr += bfd_getl32 (ptr + 4);
5031 continue;
5032
5033 default:
5034 (*_bfd_error_handler) (_("Unknown reloc %s"),
5035 _bfd_vms_etir_name (cmd));
5036 return FALSE;
5037 }
5038
5039 {
5040 asection *sec;
5041 struct vms_section_data_struct *vms_sec;
5042 arelent *reloc;
5043
5044 /* Get section to which the relocation applies. */
5045 if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
5046 {
5047 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
5048 return FALSE;
5049 }
5050 sec = PRIV (sections)[cur_psect];
5051 vms_sec = vms_section_data (sec);
5052
5053 /* Allocate a reloc entry. */
5054 if (sec->reloc_count >= vms_sec->reloc_max)
5055 {
5056 if (vms_sec->reloc_max == 0)
5057 {
5058 vms_sec->reloc_max = 64;
5059 sec->relocation = bfd_zmalloc
5060 (vms_sec->reloc_max * sizeof (arelent));
5061 }
5062 else
5063 {
5064 vms_sec->reloc_max *= 2;
5065 sec->relocation = bfd_realloc
5066 (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5067 }
5068 }
5069 reloc = &sec->relocation[sec->reloc_count];
5070 sec->reloc_count++;
5071
5072 reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5073
5074 if (cur_sym != NULL)
5075 {
5076 unsigned int j;
5077 unsigned int symlen = *cur_sym;
5078 asymbol **sym;
5079
5080 /* Linear search. */
5081 symlen = *cur_sym;
5082 cur_sym++;
5083 sym = NULL;
5084
5085 for (j = 0; j < PRIV (gsd_sym_count); j++)
5086 if (PRIV (syms)[j]->namelen == symlen
5087 && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5088 {
5089 sym = &PRIV (csymbols)[j];
5090 break;
5091 }
5092 if (sym == NULL)
5093 {
5094 (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5095 _bfd_vms_etir_name (cmd));
5096 reloc->sym_ptr_ptr = NULL;
5097 }
5098 else
5099 reloc->sym_ptr_ptr = sym;
5100 }
5101 else if (cur_psidx >= 0)
5102 reloc->sym_ptr_ptr =
5103 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5104 else
5105 reloc->sym_ptr_ptr = NULL;
5106
5107 reloc->address = cur_address;
5108 reloc->addend = cur_addend;
5109
5110 vaddr += bfd_get_reloc_size (reloc->howto);
5111 }
5112
5113 cur_addend = 0;
5114 prev_cmd = -1;
5115 cur_sym = NULL;
5116 cur_psidx = -1;
5117 }
5118 }
5119 vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5120
5121 return TRUE;
5122}
5123
5124/* Return the number of bytes required to store the relocation
5125 information associated with the given section. */
5126
5127static long
5128alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5129{
5130 alpha_vms_slurp_relocs (abfd);
5131
5132 return (section->reloc_count + 1) * sizeof (arelent *);
5133}
5134
5135/* Convert relocations from VMS (external) form into BFD internal
5136 form. Return the number of relocations. */
5137
5138static long
5139alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5140 asymbol **symbols ATTRIBUTE_UNUSED)
5141{
5142 arelent *tblptr;
5143 int count;
5144
5145 if (!alpha_vms_slurp_relocs (abfd))
5146 return -1;
5147
5148 count = section->reloc_count;
5149 tblptr = section->relocation;
5150
5151 while (count--)
5152 *relptr++ = tblptr++;
5153
5154 *relptr = (arelent *) NULL;
5155 return section->reloc_count;
5156}
5157\f
5158/* This is just copied from ecoff-alpha, needs to be fixed probably. */
5159
5160/* How to process the various reloc types. */
5161
5162static bfd_reloc_status_type
5163reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5164 arelent *reloc ATTRIBUTE_UNUSED,
5165 asymbol *sym ATTRIBUTE_UNUSED,
5166 void * data ATTRIBUTE_UNUSED,
5167 asection *sec ATTRIBUTE_UNUSED,
5168 bfd *output_bfd ATTRIBUTE_UNUSED,
5169 char **error_message ATTRIBUTE_UNUSED)
5170{
5171#if VMS_DEBUG
5172 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5173 vms_debug (2, "In section %s, symbol %s\n",
5174 sec->name, sym->name);
5175 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5176 reloc->sym_ptr_ptr[0]->name,
5177 (unsigned long)reloc->address,
5178 (unsigned long)reloc->addend, reloc->howto->name);
5179 vms_debug (2, "data at %p\n", data);
5180 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5181#endif
5182
5183 return bfd_reloc_ok;
5184}
5185
5186/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5187 from smaller values. Start with zero, widen, *then* decrement. */
5188#define MINUS_ONE (((bfd_vma)0) - 1)
5189
5190static reloc_howto_type alpha_howto_table[] =
5191{
5192 HOWTO (ALPHA_R_IGNORE, /* Type. */
5193 0, /* Rightshift. */
5194 0, /* Size (0 = byte, 1 = short, 2 = long). */
5195 8, /* Bitsize. */
5196 TRUE, /* PC relative. */
5197 0, /* Bitpos. */
5198 complain_overflow_dont,/* Complain_on_overflow. */
5199 reloc_nil, /* Special_function. */
5200 "IGNORE", /* Name. */
5201 TRUE, /* Partial_inplace. */
5202 0, /* Source mask */
5203 0, /* Dest mask. */
5204 TRUE), /* PC rel offset. */
5205
5206 /* A 64 bit reference to a symbol. */
5207 HOWTO (ALPHA_R_REFQUAD, /* Type. */
5208 0, /* Rightshift. */
5209 4, /* Size (0 = byte, 1 = short, 2 = long). */
5210 64, /* Bitsize. */
5211 FALSE, /* PC relative. */
5212 0, /* Bitpos. */
5213 complain_overflow_bitfield, /* Complain_on_overflow. */
5214 reloc_nil, /* Special_function. */
5215 "REFQUAD", /* Name. */
5216 TRUE, /* Partial_inplace. */
5217 MINUS_ONE, /* Source mask. */
5218 MINUS_ONE, /* Dest mask. */
5219 FALSE), /* PC rel offset. */
5220
5221 /* A 21 bit branch. The native assembler generates these for
5222 branches within the text segment, and also fills in the PC
5223 relative offset in the instruction. */
5224 HOWTO (ALPHA_R_BRADDR, /* Type. */
5225 2, /* Rightshift. */
5226 2, /* Size (0 = byte, 1 = short, 2 = long). */
5227 21, /* Bitsize. */
5228 TRUE, /* PC relative. */
5229 0, /* Bitpos. */
5230 complain_overflow_signed, /* Complain_on_overflow. */
5231 reloc_nil, /* Special_function. */
5232 "BRADDR", /* Name. */
5233 TRUE, /* Partial_inplace. */
5234 0x1fffff, /* Source mask. */
5235 0x1fffff, /* Dest mask. */
5236 FALSE), /* PC rel offset. */
5237
5238 /* A hint for a jump to a register. */
5239 HOWTO (ALPHA_R_HINT, /* Type. */
5240 2, /* Rightshift. */
5241 1, /* Size (0 = byte, 1 = short, 2 = long). */
5242 14, /* Bitsize. */
5243 TRUE, /* PC relative. */
5244 0, /* Bitpos. */
5245 complain_overflow_dont,/* Complain_on_overflow. */
5246 reloc_nil, /* Special_function. */
5247 "HINT", /* Name. */
5248 TRUE, /* Partial_inplace. */
5249 0x3fff, /* Source mask. */
5250 0x3fff, /* Dest mask. */
5251 FALSE), /* PC rel offset. */
5252
5253 /* 16 bit PC relative offset. */
5254 HOWTO (ALPHA_R_SREL16, /* Type. */
5255 0, /* Rightshift. */
5256 1, /* Size (0 = byte, 1 = short, 2 = long). */
5257 16, /* Bitsize. */
5258 TRUE, /* PC relative. */
5259 0, /* Bitpos. */
5260 complain_overflow_signed, /* Complain_on_overflow. */
5261 reloc_nil, /* Special_function. */
5262 "SREL16", /* Name. */
5263 TRUE, /* Partial_inplace. */
5264 0xffff, /* Source mask. */
5265 0xffff, /* Dest mask. */
5266 FALSE), /* PC rel offset. */
5267
5268 /* 32 bit PC relative offset. */
5269 HOWTO (ALPHA_R_SREL32, /* Type. */
5270 0, /* Rightshift. */
5271 2, /* Size (0 = byte, 1 = short, 2 = long). */
5272 32, /* Bitsize. */
5273 TRUE, /* PC relative. */
5274 0, /* Bitpos. */
5275 complain_overflow_signed, /* Complain_on_overflow. */
5276 reloc_nil, /* Special_function. */
5277 "SREL32", /* Name. */
5278 TRUE, /* Partial_inplace. */
5279 0xffffffff, /* Source mask. */
5280 0xffffffff, /* Dest mask. */
5281 FALSE), /* PC rel offset. */
5282
5283 /* A 64 bit PC relative offset. */
5284 HOWTO (ALPHA_R_SREL64, /* Type. */
5285 0, /* Rightshift. */
5286 4, /* Size (0 = byte, 1 = short, 2 = long). */
5287 64, /* Bitsize. */
5288 TRUE, /* PC relative. */
5289 0, /* Bitpos. */
5290 complain_overflow_signed, /* Complain_on_overflow. */
5291 reloc_nil, /* Special_function. */
5292 "SREL64", /* Name. */
5293 TRUE, /* Partial_inplace. */
5294 MINUS_ONE, /* Source mask. */
5295 MINUS_ONE, /* Dest mask. */
5296 FALSE), /* PC rel offset. */
5297
5298 /* Push a value on the reloc evaluation stack. */
5299 HOWTO (ALPHA_R_OP_PUSH, /* Type. */
5300 0, /* Rightshift. */
5301 0, /* Size (0 = byte, 1 = short, 2 = long). */
5302 0, /* Bitsize. */
5303 FALSE, /* PC relative. */
5304 0, /* Bitpos. */
5305 complain_overflow_dont,/* Complain_on_overflow. */
5306 reloc_nil, /* Special_function. */
5307 "OP_PUSH", /* Name. */
5308 FALSE, /* Partial_inplace. */
5309 0, /* Source mask. */
5310 0, /* Dest mask. */
5311 FALSE), /* PC rel offset. */
5312
5313 /* Store the value from the stack at the given address. Store it in
5314 a bitfield of size r_size starting at bit position r_offset. */
5315 HOWTO (ALPHA_R_OP_STORE, /* Type. */
5316 0, /* Rightshift. */
5317 4, /* Size (0 = byte, 1 = short, 2 = long). */
5318 64, /* Bitsize. */
5319 FALSE, /* PC relative. */
5320 0, /* Bitpos. */
5321 complain_overflow_dont,/* Complain_on_overflow. */
5322 reloc_nil, /* Special_function. */
5323 "OP_STORE", /* Name. */
5324 FALSE, /* Partial_inplace. */
5325 0, /* Source mask. */
5326 MINUS_ONE, /* Dest mask. */
5327 FALSE), /* PC rel offset. */
5328
5329 /* Subtract the reloc address from the value on the top of the
5330 relocation stack. */
5331 HOWTO (ALPHA_R_OP_PSUB, /* Type. */
5332 0, /* Rightshift. */
5333 0, /* Size (0 = byte, 1 = short, 2 = long). */
5334 0, /* Bitsize. */
5335 FALSE, /* PC relative. */
5336 0, /* Bitpos. */
5337 complain_overflow_dont,/* Complain_on_overflow. */
5338 reloc_nil, /* Special_function. */
5339 "OP_PSUB", /* Name. */
5340 FALSE, /* Partial_inplace. */
5341 0, /* Source mask. */
5342 0, /* Dest mask. */
5343 FALSE), /* PC rel offset. */
5344
5345 /* Shift the value on the top of the relocation stack right by the
5346 given value. */
5347 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */
5348 0, /* Rightshift. */
5349 0, /* Size (0 = byte, 1 = short, 2 = long). */
5350 0, /* Bitsize. */
5351 FALSE, /* PC relative. */
5352 0, /* Bitpos. */
5353 complain_overflow_dont,/* Complain_on_overflow. */
5354 reloc_nil, /* Special_function. */
5355 "OP_PRSHIFT", /* Name. */
5356 FALSE, /* Partial_inplace. */
5357 0, /* Source mask. */
5358 0, /* Dest mask. */
5359 FALSE), /* PC rel offset. */
5360
5361 /* Hack. Linkage is done by linker. */
5362 HOWTO (ALPHA_R_LINKAGE, /* Type. */
5363 0, /* Rightshift. */
5364 8, /* Size (0 = byte, 1 = short, 2 = long). */
5365 256, /* Bitsize. */
5366 FALSE, /* PC relative. */
5367 0, /* Bitpos. */
5368 complain_overflow_dont,/* Complain_on_overflow. */
5369 reloc_nil, /* Special_function. */
5370 "LINKAGE", /* Name. */
5371 FALSE, /* Partial_inplace. */
5372 0, /* Source mask. */
5373 0, /* Dest mask. */
5374 FALSE), /* PC rel offset. */
5375
5376 /* A 32 bit reference to a symbol. */
5377 HOWTO (ALPHA_R_REFLONG, /* Type. */
5378 0, /* Rightshift. */
5379 2, /* Size (0 = byte, 1 = short, 2 = long). */
5380 32, /* Bitsize. */
5381 FALSE, /* PC relative. */
5382 0, /* Bitpos. */
5383 complain_overflow_bitfield, /* Complain_on_overflow. */
5384 reloc_nil, /* Special_function. */
5385 "REFLONG", /* Name. */
5386 TRUE, /* Partial_inplace. */
5387 0xffffffff, /* Source mask. */
5388 0xffffffff, /* Dest mask. */
5389 FALSE), /* PC rel offset. */
5390
5391 /* A 64 bit reference to a procedure, written as 32 bit value. */
5392 HOWTO (ALPHA_R_CODEADDR, /* Type. */
5393 0, /* Rightshift. */
5394 4, /* Size (0 = byte, 1 = short, 2 = long). */
5395 64, /* Bitsize. */
5396 FALSE, /* PC relative. */
5397 0, /* Bitpos. */
5398 complain_overflow_signed,/* Complain_on_overflow. */
5399 reloc_nil, /* Special_function. */
5400 "CODEADDR", /* Name. */
5401 FALSE, /* Partial_inplace. */
5402 0xffffffff, /* Source mask. */
5403 0xffffffff, /* Dest mask. */
5404 FALSE), /* PC rel offset. */
5405
5406 HOWTO (ALPHA_R_NOP, /* Type. */
5407 0, /* Rightshift. */
5408 3, /* Size (0 = byte, 1 = short, 2 = long). */
5409 0, /* Bitsize. */
5410 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5411 because the calculations for the 3 relocations are the same.
5412 See B.4.5.2 of the OpenVMS Linker Utility Manual. */
5413 TRUE, /* PC relative. */
5414 0, /* Bitpos. */
5415 complain_overflow_dont,/* Complain_on_overflow. */
5416 reloc_nil, /* Special_function. */
5417 "NOP", /* Name. */
5418 FALSE, /* Partial_inplace. */
5419 0xffffffff, /* Source mask. */
5420 0xffffffff, /* Dest mask. */
5421 FALSE), /* PC rel offset. */
5422
5423 HOWTO (ALPHA_R_BSR, /* Type. */
5424 0, /* Rightshift. */
5425 3, /* Size (0 = byte, 1 = short, 2 = long). */
5426 0, /* Bitsize. */
5427 TRUE, /* PC relative. */
5428 0, /* Bitpos. */
5429 complain_overflow_dont,/* Complain_on_overflow. */
5430 reloc_nil, /* Special_function. */
5431 "BSR", /* Name. */
5432 FALSE, /* Partial_inplace. */
5433 0xffffffff, /* Source mask. */
5434 0xffffffff, /* Dest mask. */
5435 FALSE), /* PC rel offset. */
5436
5437 HOWTO (ALPHA_R_LDA, /* Type. */
5438 0, /* Rightshift. */
5439 3, /* Size (0 = byte, 1 = short, 2 = long). */
5440 0, /* Bitsize. */
5441 FALSE, /* PC relative. */
5442 0, /* Bitpos. */
5443 complain_overflow_dont,/* Complain_on_overflow. */
5444 reloc_nil, /* Special_function. */
5445 "LDA", /* Name. */
5446 FALSE, /* Partial_inplace. */
5447 0xffffffff, /* Source mask. */
5448 0xffffffff, /* Dest mask. */
5449 FALSE), /* PC rel offset. */
5450
5451 HOWTO (ALPHA_R_BOH, /* Type. */
5452 0, /* Rightshift. */
5453 3, /* Size (0 = byte, 1 = short, 2 = long, 3 = nil). */
5454 0, /* Bitsize. */
5455 TRUE, /* PC relative. */
5456 0, /* Bitpos. */
5457 complain_overflow_dont,/* Complain_on_overflow. */
5458 reloc_nil, /* Special_function. */
5459 "BOH", /* Name. */
5460 FALSE, /* Partial_inplace. */
5461 0xffffffff, /* Source mask. */
5462 0xffffffff, /* Dest mask. */
5463 FALSE), /* PC rel offset. */
5464};
5465
5466/* Return a pointer to a howto structure which, when invoked, will perform
5467 the relocation code on data from the architecture noted. */
5468
5469static const struct reloc_howto_struct *
5470alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5471 bfd_reloc_code_real_type code)
5472{
5473 int alpha_type;
5474
5475 vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5476
5477 switch (code)
5478 {
5479 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break;
5480 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break;
5481 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break;
5482 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break;
5483 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break;
5484 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break;
5485 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break;
5486 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break;
5487 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break;
5488 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break;
5489 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break;
5490 case BFD_RELOC_ALPHA_NOP: alpha_type = ALPHA_R_NOP; break;
5491 case BFD_RELOC_ALPHA_BSR: alpha_type = ALPHA_R_BSR; break;
5492 case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
5493 case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
5494 default:
5495 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5496 return NULL;
5497 }
5498 vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5499 return & alpha_howto_table[alpha_type];
5500}
5501
5502static reloc_howto_type *
5503alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5504 const char *r_name)
5505{
5506 unsigned int i;
5507
5508 for (i = 0;
5509 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5510 i++)
5511 if (alpha_howto_table[i].name != NULL
5512 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5513 return &alpha_howto_table[i];
5514
5515 return NULL;
5516}
5517\f
5518static long
5519alpha_vms_get_synthetic_symtab (bfd *abfd,
5520 long symcount ATTRIBUTE_UNUSED,
5521 asymbol **usyms ATTRIBUTE_UNUSED,
5522 long dynsymcount ATTRIBUTE_UNUSED,
5523 asymbol **dynsyms ATTRIBUTE_UNUSED,
5524 asymbol **ret)
5525{
5526 asymbol *syms;
5527 unsigned int i;
5528 unsigned int n = 0;
5529
5530 syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5531 *ret = syms;
5532 if (syms == NULL)
5533 return -1;
5534
5535 for (i = 0; i < PRIV (gsd_sym_count); i++)
5536 {
5537 struct vms_symbol_entry *e = PRIV (syms)[i];
5538 asymbol *sym;
5539 flagword flags;
5540 symvalue value;
5541 asection *sec;
5542 const char *name;
5543 char *sname;
5544 int l;
5545
5546 name = e->name;
5547 value = 0;
5548 flags = BSF_LOCAL | BSF_SYNTHETIC;
5549 sec = NULL;
5550
5551 switch (e->typ)
5552 {
5553 case EGSD__C_SYM:
95e34ef7
TG		 5554 case EGSD__C_SYMG:
5555 if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5556 {
95e34ef7 5557 value = e->code_value;
a928f1d7 5558 sec = e->code_section;
95e34ef7
TG		 5559 }
5560 else
5561 continue;
5562 break;
5563
5564 default:
a928f1d7 5565 continue;
95e34ef7
TG		 5566 }
5567
5568 l = strlen (name);
5569 sname = bfd_alloc (abfd, l + 5);
5570 if (sname == NULL)
5571 return FALSE;
5572 memcpy (sname, name, l);
5573 memcpy (sname + l, "..en", 5);
5574
5575 sym = &syms[n++];
5576 sym->name = sname;
5577 sym->section = sec;
5578 sym->flags = flags;
5579 sym->value = value;
5580 sym->udata.p = NULL;
5581 }
5582
5583 return n;
5584}
5585\f
5586/* Private dump. */
5587
5588static const char *
5589vms_time_to_str (unsigned char *buf)
5590{
5591 time_t t = vms_rawtime_to_time_t (buf);
5592 char *res = ctime (&t);
5593
5594 if (!res)
5595 res = "*invalid time*";
5596 else
5597 res[24] = 0;
5598 return res;
5599}
5600
5601static void
5602evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5603{
5604 struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5605 unsigned int subtype;
5606
5607 subtype = (unsigned)bfd_getl16 (emh->subtyp);
5608
5609 fprintf (file, _(" EMH %u (len=%u): "), subtype, rec_len);
5610
5611 switch (subtype)
5612 {
5613 case EMH__C_MHD:
5614 {
5615 struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5616 const char *name;
5617
5618 fprintf (file, _("Module header\n"));
5619 fprintf (file, _(" structure level: %u\n"), mhd->strlvl);
5620 fprintf (file, _(" max record size: %u\n"),
5621 (unsigned)bfd_getl32 (mhd->recsiz));
5622 name = (char *)(mhd + 1);
5623 fprintf (file, _(" module name : %.*s\n"), name[0], name + 1);
5624 name += name[0] + 1;
5625 fprintf (file, _(" module version : %.*s\n"), name[0], name + 1);
5626 name += name[0] + 1;
5627 fprintf (file, _(" compile date : %.17s\n"), name);
5628 }
5629 break;
5630 case EMH__C_LNM:
5631 {
5632 fprintf (file, _("Language Processor Name\n"));
5633 fprintf (file, _(" language name: %.*s\n"),
5634 (int)(rec_len - sizeof (struct vms_emh_common)),
5635 (char *)rec + sizeof (struct vms_emh_common));
5636 }
5637 break;
5638 case EMH__C_SRC:
5639 {
5640 fprintf (file, _("Source Files Header\n"));
5641 fprintf (file, _(" file: %.*s\n"),
5642 (int)(rec_len - sizeof (struct vms_emh_common)),
5643 (char *)rec + sizeof (struct vms_emh_common));
5644 }
5645 break;
5646 case EMH__C_TTL:
5647 {
5648 fprintf (file, _("Title Text Header\n"));
5649 fprintf (file, _(" title: %.*s\n"),
5650 (int)(rec_len - sizeof (struct vms_emh_common)),
5651 (char *)rec + sizeof (struct vms_emh_common));
5652 }
5653 break;
5654 case EMH__C_CPR:
5655 {
5656 fprintf (file, _("Copyright Header\n"));
5657 fprintf (file, _(" copyright: %.*s\n"),
5658 (int)(rec_len - sizeof (struct vms_emh_common)),
5659 (char *)rec + sizeof (struct vms_emh_common));
5660 }
5661 break;
5662 default:
5663 fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5664 break;
5665 }
5666}
5667
5668static void
5669evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5670{
5671 struct vms_eeom *eeom = (struct vms_eeom *)rec;
5672
5673 fprintf (file, _(" EEOM (len=%u):\n"), rec_len);
5674 fprintf (file, _(" number of cond linkage pairs: %u\n"),
5675 (unsigned)bfd_getl32 (eeom->total_lps));
5676 fprintf (file, _(" completion code: %u\n"),
5677 (unsigned)bfd_getl16 (eeom->comcod));
5678 if (rec_len > 10)
5679 {
5680 fprintf (file, _(" transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5681 fprintf (file, _(" transfer addr psect: %u\n"),
5682 (unsigned)bfd_getl32 (eeom->psindx));
5683 fprintf (file, _(" transfer address : 0x%08x\n"),
5684 (unsigned)bfd_getl32 (eeom->tfradr));
5685 }
5686}
5687
5688static void
5689exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5690{
5691 if (flags & EGSY__V_WEAK)
5692 fputs (_(" WEAK"), file);
5693 if (flags & EGSY__V_DEF)
5694 fputs (_(" DEF"), file);
5695 if (flags & EGSY__V_UNI)
5696 fputs (_(" UNI"), file);
5697 if (flags & EGSY__V_REL)
5698 fputs (_(" REL"), file);
5699 if (flags & EGSY__V_COMM)
5700 fputs (_(" COMM"), file);
5701 if (flags & EGSY__V_VECEP)
5702 fputs (_(" VECEP"), file);
5703 if (flags & EGSY__V_NORM)
5704 fputs (_(" NORM"), file);
5705 if (flags & EGSY__V_QUAD_VAL)
5706 fputs (_(" QVAL"), file);
5707}
5708
9a1b4480
TG		 5709static void
5710evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5711{
5712 if (flags & EGPS__V_PIC)
5713 fputs (_(" PIC"), file);
5714 if (flags & EGPS__V_LIB)
5715 fputs (_(" LIB"), file);
5716 if (flags & EGPS__V_OVR)
5717 fputs (_(" OVR"), file);
5718 if (flags & EGPS__V_REL)
5719 fputs (_(" REL"), file);
5720 if (flags & EGPS__V_GBL)
5721 fputs (_(" GBL"), file);
5722 if (flags & EGPS__V_SHR)
5723 fputs (_(" SHR"), file);
5724 if (flags & EGPS__V_EXE)
5725 fputs (_(" EXE"), file);
5726 if (flags & EGPS__V_RD)
5727 fputs (_(" RD"), file);
5728 if (flags & EGPS__V_WRT)
5729 fputs (_(" WRT"), file);
5730 if (flags & EGPS__V_VEC)
5731 fputs (_(" VEC"), file);
5732 if (flags & EGPS__V_NOMOD)
5733 fputs (_(" NOMOD"), file);
5734 if (flags & EGPS__V_COM)
5735 fputs (_(" COM"), file);
5736 if (flags & EGPS__V_ALLOC_64BIT)
5737 fputs (_(" 64B"), file);
5738}
5739
95e34ef7
TG		 5740static void
5741evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5742{
5743 unsigned int off = sizeof (struct vms_egsd);
5744 unsigned int n;
5745
5746 fprintf (file, _(" EGSD (len=%u):\n"), rec_len);
5747
5748 n = 0;
5749 for (off = sizeof (struct vms_egsd); off < rec_len; )
5750 {
5751 struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5752 unsigned int type;
5753 unsigned int len;
5754
5755 type = (unsigned)bfd_getl16 (e->gsdtyp);
5756 len = (unsigned)bfd_getl16 (e->gsdsiz);
5757
5758 fprintf (file, _(" EGSD entry %2u (type: %u, len: %u): "),
5759 n, type, len);
5760 n++;
5761
5762 switch (type)
5763 {
5764 case EGSD__C_PSC:
5765 {
5766 struct vms_egps *egps = (struct vms_egps *)e;
5767 unsigned int flags = bfd_getl16 (egps->flags);
5768 unsigned int l;
5769
5770 fprintf (file, _("PSC - Program section definition\n"));
5771 fprintf (file, _(" alignment : 2**%u\n"), egps->align);
5772 fprintf (file, _(" flags : 0x%04x"), flags);
9a1b4480 5773 evax_bfd_print_egsd_flags (file, flags);
95e34ef7
TG		 5774 fputc ('\n', file);
5775 l = bfd_getl32 (egps->alloc);
5776 fprintf (file, _(" alloc (len): %u (0x%08x)\n"), l, l);
5777 fprintf (file, _(" name : %.*s\n"),
5778 egps->namlng, egps->name);
5779 }
5780 break;
9a1b4480
TG		 5781 case EGSD__C_SPSC:
5782 {
5783 struct vms_esgps *esgps = (struct vms_esgps *)e;
5784 unsigned int flags = bfd_getl16 (esgps->flags);
5785 unsigned int l;
5786
5787 fprintf (file, _("SPSC - Shared Image Program section def\n"));
5788 fprintf (file, _(" alignment : 2**%u\n"), esgps->align);
5789 fprintf (file, _(" flags : 0x%04x"), flags);
5790 evax_bfd_print_egsd_flags (file, flags);
5791 fputc ('\n', file);
5792 l = bfd_getl32 (esgps->alloc);
5793 fprintf (file, _(" alloc (len) : %u (0x%08x)\n"), l, l);
5794 fprintf (file, _(" image offset : 0x%08x\n"),
5795 (unsigned int)bfd_getl32 (esgps->base));
5796 fprintf (file, _(" symvec offset : 0x%08x\n"),
5797 (unsigned int)bfd_getl32 (esgps->value));
5798 fprintf (file, _(" name : %.*s\n"),
5799 esgps->namlng, esgps->name);
5800 }
5801 break;
95e34ef7
TG		 5802 case EGSD__C_SYM:
5803 {
5804 struct vms_egsy *egsy = (struct vms_egsy *)e;
5805 unsigned int flags = bfd_getl16 (egsy->flags);
5806
5807 if (flags & EGSY__V_DEF)
5808 {
5809 struct vms_esdf *esdf = (struct vms_esdf *)e;
5810
5811 fprintf (file, _("SYM - Global symbol definition\n"));
5812 fprintf (file, _(" flags: 0x%04x"), flags);
5813 exav_bfd_print_egsy_flags (flags, file);
5814 fputc ('\n', file);
5815 fprintf (file, _(" psect offset: 0x%08x\n"),
5816 (unsigned)bfd_getl32 (esdf->value));
5817 if (flags & EGSY__V_NORM)
5818 {
5819 fprintf (file, _(" code address: 0x%08x\n"),
5820 (unsigned)bfd_getl32 (esdf->code_address));
5821 fprintf (file, _(" psect index for entry point : %u\n"),
5822 (unsigned)bfd_getl32 (esdf->ca_psindx));
5823 }
5824 fprintf (file, _(" psect index : %u\n"),
5825 (unsigned)bfd_getl32 (esdf->psindx));
5826 fprintf (file, _(" name : %.*s\n"),
5827 esdf->namlng, esdf->name);
5828 }
5829 else
5830 {
5831 struct vms_esrf *esrf = (struct vms_esrf *)e;
5832
5833 fprintf (file, _("SYM - Global symbol reference\n"));
5834 fprintf (file, _(" name : %.*s\n"),
5835 esrf->namlng, esrf->name);
5836 }
5837 }
5838 break;
9a1b4480
TG		 5839 case EGSD__C_IDC:
5840 {
5841 struct vms_eidc *eidc = (struct vms_eidc *)e;
5842 unsigned int flags = bfd_getl32 (eidc->flags);
5843 unsigned char *p;
5844
5845 fprintf (file, _("IDC - Ident Consistency check\n"));
5846 fprintf (file, _(" flags : 0x%08x"), flags);
5847 if (flags & EIDC__V_BINIDENT)
5848 fputs (" BINDENT", file);
5849 fputc ('\n', file);
5850 fprintf (file, _(" id match : %x\n"),
5851 (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5852 fprintf (file, _(" error severity: %x\n"),
5853 (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5854 p = eidc->name;
5855 fprintf (file, _(" entity name : %.*s\n"), p[0], p + 1);
5856 p += 1 + p[0];
5857 fprintf (file, _(" object name : %.*s\n"), p[0], p + 1);
5858 p += 1 + p[0];
5859 if (flags & EIDC__V_BINIDENT)
5860 fprintf (file, _(" binary ident : 0x%08x\n"),
5861 (unsigned)bfd_getl32 (p + 1));
5862 else
5863 fprintf (file, _(" ascii ident : %.*s\n"), p[0], p + 1);
5864 }
5865 break;
95e34ef7
TG		 5866 case EGSD__C_SYMG:
5867 {
5868 struct vms_egst *egst = (struct vms_egst *)e;
5869 unsigned int flags = bfd_getl16 (egst->header.flags);
5870
5871 fprintf (file, _("SYMG - Universal symbol definition\n"));
5872 fprintf (file, _(" flags: 0x%04x"), flags);
5873 exav_bfd_print_egsy_flags (flags, file);
5874 fputc ('\n', file);
5875 fprintf (file, _(" symbol vector offset: 0x%08x\n"),
5876 (unsigned)bfd_getl32 (egst->value));
5877 fprintf (file, _(" entry point: 0x%08x\n"),
5878 (unsigned)bfd_getl32 (egst->lp_1));
5879 fprintf (file, _(" proc descr : 0x%08x\n"),
5880 (unsigned)bfd_getl32 (egst->lp_2));
5881 fprintf (file, _(" psect index: %u\n"),
5882 (unsigned)bfd_getl32 (egst->psindx));
5883 fprintf (file, _(" name : %.*s\n"),
5884 egst->namlng, egst->name);
5885 }
5886 break;
5887 case EGSD__C_SYMV:
5888 {
5889 struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5890 unsigned int flags = bfd_getl16 (esdfv->flags);
5891
5892 fprintf (file, _("SYMV - Vectored symbol definition\n"));
5893 fprintf (file, _(" flags: 0x%04x"), flags);
5894 exav_bfd_print_egsy_flags (flags, file);
5895 fputc ('\n', file);
5896 fprintf (file, _(" vector : 0x%08x\n"),
5897 (unsigned)bfd_getl32 (esdfv->vector));
5898 fprintf (file, _(" psect offset: %u\n"),
5899 (unsigned)bfd_getl32 (esdfv->value));
5900 fprintf (file, _(" psect index : %u\n"),
5901 (unsigned)bfd_getl32 (esdfv->psindx));
5902 fprintf (file, _(" name : %.*s\n"),
5903 esdfv->namlng, esdfv->name);
5904 }
5905 break;
5906 case EGSD__C_SYMM:
5907 {
5908 struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5909 unsigned int flags = bfd_getl16 (esdfm->flags);
5910
5911 fprintf (file, _("SYMM - Global symbol definition with version\n"));
5912 fprintf (file, _(" flags: 0x%04x"), flags);
5913 exav_bfd_print_egsy_flags (flags, file);
5914 fputc ('\n', file);
5915 fprintf (file, _(" version mask: 0x%08x\n"),
5916 (unsigned)bfd_getl32 (esdfm->version_mask));
5917 fprintf (file, _(" psect offset: %u\n"),
5918 (unsigned)bfd_getl32 (esdfm->value));
5919 fprintf (file, _(" psect index : %u\n"),
5920 (unsigned)bfd_getl32 (esdfm->psindx));
5921 fprintf (file, _(" name : %.*s\n"),
5922 esdfm->namlng, esdfm->name);
5923 }
5924 break;
5925 default:
5926 fprintf (file, _("unhandled egsd entry type %u\n"), type);
5927 break;
5928 }
5929 off += len;
5930 }
5931}
5932
5933static void
5934evax_bfd_print_hex (FILE *file, const char *pfx,
5935 const unsigned char *buf, unsigned int len)
5936{
5937 unsigned int i;
5938 unsigned int n;
5939
5940 n = 0;
5941 for (i = 0; i < len; i++)
5942 {
5943 if (n == 0)
5944 fputs (pfx, file);
5945 fprintf (file, " %02x", buf[i]);
5946 n++;
5947 if (n == 16)
5948 {
5949 n = 0;
5950 fputc ('\n', file);
5951 }
5952 }
5953 if (n != 0)
5954 fputc ('\n', file);
5955}
5956
5957static void
5958evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
5959{
5960 fprintf (file, _(" linkage index: %u, replacement insn: 0x%08x\n"),
5961 (unsigned)bfd_getl32 (buf),
5962 (unsigned)bfd_getl32 (buf + 16));
5963 fprintf (file, _(" psect idx 1: %u, offset 1: 0x%08x %08x\n"),
5964 (unsigned)bfd_getl32 (buf + 4),
5965 (unsigned)bfd_getl32 (buf + 12),
5966 (unsigned)bfd_getl32 (buf + 8));
5967 fprintf (file, _(" psect idx 2: %u, offset 2: 0x%08x %08x\n"),
5968 (unsigned)bfd_getl32 (buf + 20),
5969 (unsigned)bfd_getl32 (buf + 28),
5970 (unsigned)bfd_getl32 (buf + 24));
5971 if (is_ps)
5972 fprintf (file, _(" psect idx 3: %u, offset 3: 0x%08x %08x\n"),
5973 (unsigned)bfd_getl32 (buf + 32),
5974 (unsigned)bfd_getl32 (buf + 40),
5975 (unsigned)bfd_getl32 (buf + 36));
5976 else
5977 fprintf (file, _(" global name: %.*s\n"), buf[32], buf + 33);
5978}
5979
5980static void
5981evax_bfd_print_etir (FILE *file, const char *name,
5982 unsigned char *rec, unsigned int rec_len)
5983{
5984 unsigned int off = sizeof (struct vms_egsd);
5985 unsigned int sec_len;
5986
5987 fprintf (file, _(" %s (len=%u+%u):\n"), name,
5988 (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
5989 (unsigned)sizeof (struct vms_eobjrec));
5990
5991 for (off = sizeof (struct vms_eobjrec); off < rec_len; )
5992 {
5993 struct vms_etir *etir = (struct vms_etir *)(rec + off);
5994 unsigned char *buf;
5995 unsigned int type;
5996 unsigned int size;
5997
5998 type = bfd_getl16 (etir->rectyp);
5999 size = bfd_getl16 (etir->size);
6000 buf = rec + off + sizeof (struct vms_etir);
6001
6002 fprintf (file, _(" (type: %3u, size: 4+%3u): "), type, size - 4);
6003 switch (type)
6004 {
6005 case ETIR__C_STA_GBL:
6006 fprintf (file, _("STA_GBL (stack global) %.*s\n"),
6007 buf[0], buf + 1);
6008 break;
6009 case ETIR__C_STA_LW:
6010 fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
6011 (unsigned)bfd_getl32 (buf));
6012 break;
6013 case ETIR__C_STA_QW:
6014 fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
6015 (unsigned)bfd_getl32 (buf + 4),
6016 (unsigned)bfd_getl32 (buf + 0));
6017 break;
6018 case ETIR__C_STA_PQ:
6019 fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
6020 fprintf (file, _(" psect: %u, offset: 0x%08x %08x\n"),
6021 (unsigned)bfd_getl32 (buf + 0),
6022 (unsigned)bfd_getl32 (buf + 8),
6023 (unsigned)bfd_getl32 (buf + 4));
6024 break;
6025 case ETIR__C_STA_LI:
6026 fprintf (file, _("STA_LI (stack literal)\n"));
6027 break;
6028 case ETIR__C_STA_MOD:
6029 fprintf (file, _("STA_MOD (stack module)\n"));
6030 break;
6031 case ETIR__C_STA_CKARG:
6032 fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
6033 break;
6034
6035 case ETIR__C_STO_B:
6036 fprintf (file, _("STO_B (store byte)\n"));
6037 break;
6038 case ETIR__C_STO_W:
6039 fprintf (file, _("STO_W (store word)\n"));
6040 break;
6041 case ETIR__C_STO_LW:
6042 fprintf (file, _("STO_LW (store longword)\n"));
6043 break;
6044 case ETIR__C_STO_QW:
6045 fprintf (file, _("STO_QW (store quadword)\n"));
6046 break;
6047 case ETIR__C_STO_IMMR:
6048 {
6049 unsigned int len = bfd_getl32 (buf);
6050 fprintf (file,
6051 _("STO_IMMR (store immediate repeat) %u bytes\n"),
6052 len);
6053 evax_bfd_print_hex (file, " ", buf + 4, len);
6054 sec_len += len;
6055 }
6056 break;
6057 case ETIR__C_STO_GBL:
6058 fprintf (file, _("STO_GBL (store global) %.*s\n"),
6059 buf[0], buf + 1);
6060 break;
6061 case ETIR__C_STO_CA:
6062 fprintf (file, _("STO_CA (store code address) %.*s\n"),
6063 buf[0], buf + 1);
6064 break;
6065 case ETIR__C_STO_RB:
6066 fprintf (file, _("STO_RB (store relative branch)\n"));
6067 break;
6068 case ETIR__C_STO_AB:
6069 fprintf (file, _("STO_AB (store absolute branch)\n"));
6070 break;
6071 case ETIR__C_STO_OFF:
6072 fprintf (file, _("STO_OFF (store offset to psect)\n"));
6073 break;
6074 case ETIR__C_STO_IMM:
6075 {
6076 unsigned int len = bfd_getl32 (buf);
6077 fprintf (file,
6078 _("STO_IMM (store immediate) %u bytes\n"),
6079 len);
6080 evax_bfd_print_hex (file, " ", buf + 4, len);
6081 sec_len += len;
6082 }
6083 break;
6084 case ETIR__C_STO_LP_PSB:
6085 fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6086 break;
6087 case ETIR__C_STO_HINT_GBL:
6088 fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6089 break;
6090 case ETIR__C_STO_HINT_PS:
6091 fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6092 break;
6093
6094 case ETIR__C_OPR_NOP:
6095 fprintf (file, _("OPR_NOP (no-operation)\n"));
6096 break;
6097 case ETIR__C_OPR_ADD:
6098 fprintf (file, _("OPR_ADD (add)\n"));
6099 break;
6100 case ETIR__C_OPR_SUB:
6101 fprintf (file, _("OPR_SUB (substract)\n"));
6102 break;
6103 case ETIR__C_OPR_MUL:
6104 fprintf (file, _("OPR_MUL (multiply)\n"));
6105 break;
6106 case ETIR__C_OPR_DIV:
6107 fprintf (file, _("OPR_DIV (divide)\n"));
6108 break;
6109 case ETIR__C_OPR_AND:
6110 fprintf (file, _("OPR_AND (logical and)\n"));
6111 break;
6112 case ETIR__C_OPR_IOR:
6113 fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6114 break;
6115 case ETIR__C_OPR_EOR:
6116 fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6117 break;
6118 case ETIR__C_OPR_NEG:
6119 fprintf (file, _("OPR_NEG (negate)\n"));
6120 break;
6121 case ETIR__C_OPR_COM:
6122 fprintf (file, _("OPR_COM (complement)\n"));
6123 break;
6124 case ETIR__C_OPR_INSV:
6125 fprintf (file, _("OPR_INSV (insert field)\n"));
6126 break;
6127 case ETIR__C_OPR_ASH:
6128 fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6129 break;
6130 case ETIR__C_OPR_USH:
6131 fprintf (file, _("OPR_USH (unsigned shift)\n"));
6132 break;
6133 case ETIR__C_OPR_ROT:
6134 fprintf (file, _("OPR_ROT (rotate)\n"));
6135 break;
6136 case ETIR__C_OPR_SEL:
6137 fprintf (file, _("OPR_SEL (select)\n"));
6138 break;
6139 case ETIR__C_OPR_REDEF:
6140 fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6141 break;
6142 case ETIR__C_OPR_DFLIT:
6143 fprintf (file, _("OPR_REDEF (define a literal)\n"));
6144 break;
6145
6146 case ETIR__C_STC_LP:
6147 fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6148 break;
6149 case ETIR__C_STC_LP_PSB:
6150 fprintf (file,
6151 _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6152 fprintf (file, _(" linkage index: %u, procedure: %.*s\n"),
6153 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6154 buf += 4 + 1 + buf[4];
6155 fprintf (file, _(" signature: %.*s\n"), buf[0], buf + 1);
6156 break;
6157 case ETIR__C_STC_GBL:
6158 fprintf (file, _("STC_GBL (store cond global)\n"));
6159 fprintf (file, _(" linkage index: %u, global: %.*s\n"),
6160 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6161 break;
6162 case ETIR__C_STC_GCA:
6163 fprintf (file, _("STC_GCA (store cond code address)\n"));
6164 fprintf (file, _(" linkage index: %u, procedure name: %.*s\n"),
6165 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6166 break;
6167 case ETIR__C_STC_PS:
6168 fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6169 fprintf (file,
6170 _(" linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6171 (unsigned)bfd_getl32 (buf),
6172 (unsigned)bfd_getl32 (buf + 4),
6173 (unsigned)bfd_getl32 (buf + 12),
6174 (unsigned)bfd_getl32 (buf + 8));
6175 break;
6176 case ETIR__C_STC_NOP_GBL:
6177 fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6178 evax_bfd_print_etir_stc_ir (file, buf, 0);
6179 break;
6180 case ETIR__C_STC_NOP_PS:
6181 fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6182 evax_bfd_print_etir_stc_ir (file, buf, 1);
6183 break;
6184 case ETIR__C_STC_BSR_GBL:
6185 fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6186 evax_bfd_print_etir_stc_ir (file, buf, 0);
6187 break;
6188 case ETIR__C_STC_BSR_PS:
6189 fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6190 evax_bfd_print_etir_stc_ir (file, buf, 1);
6191 break;
6192 case ETIR__C_STC_LDA_GBL:
6193 fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6194 evax_bfd_print_etir_stc_ir (file, buf, 0);
6195 break;
6196 case ETIR__C_STC_LDA_PS:
6197 fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6198 evax_bfd_print_etir_stc_ir (file, buf, 1);
6199 break;
6200 case ETIR__C_STC_BOH_GBL:
6201 fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6202 evax_bfd_print_etir_stc_ir (file, buf, 0);
6203 break;
6204 case ETIR__C_STC_BOH_PS:
6205 fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6206 evax_bfd_print_etir_stc_ir (file, buf, 1);
6207 break;
6208 case ETIR__C_STC_NBH_GBL:
6209 fprintf (file,
6210 _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6211 break;
6212 case ETIR__C_STC_NBH_PS:
6213 fprintf (file,
6214 _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6215 break;
6216
6217 case ETIR__C_CTL_SETRB:
6218 fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6219 sec_len += 4;
6220 break;
6221 case ETIR__C_CTL_AUGRB:
6222 {
6223 unsigned int val = bfd_getl32 (buf);
6224 fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6225 }
6226 break;
6227 case ETIR__C_CTL_DFLOC:
6228 fprintf (file, _("CTL_DFLOC (define location)\n"));
6229 break;
6230 case ETIR__C_CTL_STLOC:
6231 fprintf (file, _("CTL_STLOC (set location)\n"));
6232 break;
6233 case ETIR__C_CTL_STKDL:
6234 fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6235 break;
6236 default:
6237 fprintf (file, _("*unhandled*\n"));
6238 break;
6239 }
6240 off += size;
6241 }
6242}
6243
6244static void
6245evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6246{
6247 bfd_boolean is_first = TRUE;
6248 bfd_boolean has_records = FALSE;
6249
6250 while (1)
6251 {
6252 unsigned int rec_len;
6253 unsigned int pad_len;
6254 unsigned char *rec;
6255 unsigned int hdr_size;
6256 unsigned int type;
6257
6258 if (is_first)
6259 {
6260 unsigned char buf[6];
6261
6262 is_first = FALSE;
6263
6264 /* Read 6 bytes. */
6265 if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6266 {
6267 fprintf (file, _("cannot read GST record length\n"));
6268 return;
6269 }
6270 rec_len = bfd_getl16 (buf + 0);
6271 if (rec_len == bfd_getl16 (buf + 4)
6272 && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6273 {
6274 /* The format is raw: record-size, type, record-size. */
6275 has_records = TRUE;
6276 pad_len = (rec_len + 1) & ~1U;
6277 hdr_size = 4;
6278 }
6279 else if (rec_len == EOBJ__C_EMH)
6280 {
6281 has_records = FALSE;
6282 pad_len = bfd_getl16 (buf + 2);
6283 hdr_size = 6;
6284 }
6285 else
6286 {
6287 /* Ill-formed. */
6288 fprintf (file, _("cannot find EMH in first GST record\n"));
6289 return;
6290 }
6291 rec = bfd_malloc (pad_len);
6292 memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6293 }
6294 else
6295 {
6296 unsigned int rec_len2 = 0;
6297 unsigned char hdr[4];
6298
6299 if (has_records)
6300 {
6301 unsigned char buf_len[2];
6302
6303 if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6304 != sizeof (buf_len))
6305 {
6306 fprintf (file, _("cannot read GST record length\n"));
6307 return;
6308 }
6309 rec_len2 = (unsigned)bfd_getl16 (buf_len);
6310 }
6311
6312 if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6313 {
6314 fprintf (file, _("cannot read GST record header\n"));
6315 return;
6316 }
6317 rec_len = (unsigned)bfd_getl16 (hdr + 2);
6318 if (has_records)
6319 pad_len = (rec_len + 1) & ~1U;
6320 else
6321 pad_len = rec_len;
6322 rec = bfd_malloc (pad_len);
6323 memcpy (rec, hdr, sizeof (hdr));
6324 hdr_size = sizeof (hdr);
6325 if (has_records && rec_len2 != rec_len)
6326 {
6327 fprintf (file, _(" corrupted GST\n"));
6328 break;
6329 }
6330 }
6331
6332 if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6333 != pad_len - hdr_size)
6334 {
6335 fprintf (file, _("cannot read GST record\n"));
6336 return;
6337 }
6338
6339 type = (unsigned)bfd_getl16 (rec);
6340
6341 switch (type)
6342 {
6343 case EOBJ__C_EMH:
6344 evax_bfd_print_emh (file, rec, rec_len);
6345 break;
6346 case EOBJ__C_EGSD:
6347 evax_bfd_print_egsd (file, rec, rec_len);
6348 break;
6349 case EOBJ__C_EEOM:
6350 evax_bfd_print_eeom (file, rec, rec_len);
6351 free (rec);
6352 return;
6353 break;
6354 case EOBJ__C_ETIR:
6355 evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6356 break;
6357 case EOBJ__C_EDBG:
6358 evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6359 break;
6360 case EOBJ__C_ETBT:
6361 evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6362 break;
6363 default:
6364 fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6365 break;
6366 }
6367 free (rec);
6368 }
6369}
6370
6371static void
6372evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6373 unsigned int stride)
6374{
6375 while (1)
6376 {
6377 unsigned int base;
6378 unsigned int count;
6379 unsigned int j;
6380
6381 count = bfd_getl32 (rel + 0);
6382
6383 if (count == 0)
6384 break;
6385 base = bfd_getl32 (rel + 4);
6386
6387 fprintf (file, _(" bitcount: %u, base addr: 0x%08x\n"),
6388 count, base);
6389
6390 rel += 8;
6391 for (j = 0; count > 0; j += 4, count -= 32)
6392 {
6393 unsigned int k;
6394 unsigned int n = 0;
6395 unsigned int val;
6396
6397 val = bfd_getl32 (rel);
6398 rel += 4;
6399
6400 fprintf (file, _(" bitmap: 0x%08x (count: %u):\n"), val, count);
6401
6402 for (k = 0; k < 32; k++)
6403 if (val & (1 << k))
6404 {
6405 if (n == 0)
6406 fputs (" ", file);
6407 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6408 n++;
6409 if (n == 8)
6410 {
6411 fputs ("\n", file);
6412 n = 0;
6413 }
6414 }
6415 if (n)
6416 fputs ("\n", file);
6417 }
6418 }
6419}
6420
6421static void
6422evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6423{
6424 while (1)
6425 {
6426 unsigned int j;
6427 unsigned int count;
6428
6429 count = bfd_getl32 (rel + 0);
6430 if (count == 0)
6431 return;
6432 fprintf (file, _(" image %u (%u entries)\n"),
6433 (unsigned)bfd_getl32 (rel + 4), count);
6434 rel += 8;
6435 for (j = 0; j < count; j++)
6436 {
6437 fprintf (file, _(" offset: 0x%08x, val: 0x%08x\n"),
6438 (unsigned)bfd_getl32 (rel + 0),
6439 (unsigned)bfd_getl32 (rel + 4));
6440 rel += 8;
6441 }
6442 }
6443}
6444
6445static void
6446evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6447{
6448 unsigned int count;
6449
6450 while (1)
6451 {
6452 unsigned int j;
6453 unsigned int n = 0;
6454
6455 count = bfd_getl32 (rel + 0);
6456 if (count == 0)
6457 break;
6458 fprintf (file, _(" image %u (%u entries), offsets:\n"),
6459 (unsigned)bfd_getl32 (rel + 4), count);
6460 rel += 8;
6461 for (j = 0; j < count; j++)
6462 {
6463 if (n == 0)
6464 fputs (" ", file);
6465 fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6466 n++;
6467 if (n == 7)
6468 {
6469 fputs ("\n", file);
6470 n = 0;
6471 }
6472 rel += 4;
6473 }
6474 if (n)
6475 fputs ("\n", file);
6476 }
6477}
6478
6479static void
6480evax_bfd_print_indent (int indent, FILE *file)
6481{
6482 for (; indent; indent--)
6483 fputc (' ', file);
6484}
6485
6486static const char *
6487evax_bfd_get_dsc_name (unsigned int v)
6488{
6489 switch (v)
6490 {
6491 case DSC__K_DTYPE_Z:
6492 return "Z (Unspecified)";
6493 case DSC__K_DTYPE_V:
6494 return "V (Bit)";
6495 case DSC__K_DTYPE_BU:
6496 return "BU (Byte logical)";
6497 case DSC__K_DTYPE_WU:
6498 return "WU (Word logical)";
6499 case DSC__K_DTYPE_LU:
6500 return "LU (Longword logical)";
6501 case DSC__K_DTYPE_QU:
6502 return "QU (Quadword logical)";
6503 case DSC__K_DTYPE_B:
6504 return "B (Byte integer)";
6505 case DSC__K_DTYPE_W:
6506 return "W (Word integer)";
6507 case DSC__K_DTYPE_L:
6508 return "L (Longword integer)";
6509 case DSC__K_DTYPE_Q:
6510 return "Q (Quadword integer)";
6511 case DSC__K_DTYPE_F:
6512 return "F (Single-precision floating)";
6513 case DSC__K_DTYPE_D:
6514 return "D (Double-precision floating)";
6515 case DSC__K_DTYPE_FC:
6516 return "FC (Complex)";
6517 case DSC__K_DTYPE_DC:
6518 return "DC (Double-precision Complex)";
6519 case DSC__K_DTYPE_T:
6520 return "T (ASCII text string)";
6521 case DSC__K_DTYPE_NU:
6522 return "NU (Numeric string, unsigned)";
6523 case DSC__K_DTYPE_NL:
6524 return "NL (Numeric string, left separate sign)";
6525 case DSC__K_DTYPE_NLO:
6526 return "NLO (Numeric string, left overpunched sign)";
6527 case DSC__K_DTYPE_NR:
6528 return "NR (Numeric string, right separate sign)";
6529 case DSC__K_DTYPE_NRO:
6530 return "NRO (Numeric string, right overpunched sig)";
6531 case DSC__K_DTYPE_NZ:
6532 return "NZ (Numeric string, zoned sign)";
6533 case DSC__K_DTYPE_P:
6534 return "P (Packed decimal string)";
6535 case DSC__K_DTYPE_ZI:
6536 return "ZI (Sequence of instructions)";
6537 case DSC__K_DTYPE_ZEM:
6538 return "ZEM (Procedure entry mask)";
6539 case DSC__K_DTYPE_DSC:
6540 return "DSC (Descriptor, used for arrays of dyn strings)";
6541 case DSC__K_DTYPE_OU:
6542 return "OU (Octaword logical)";
6543 case DSC__K_DTYPE_O:
6544 return "O (Octaword integer)";
6545 case DSC__K_DTYPE_G:
6546 return "G (Double precision G floating, 64 bit)";
6547 case DSC__K_DTYPE_H:
6548 return "H (Quadruple precision floating, 128 bit)";
6549 case DSC__K_DTYPE_GC:
6550 return "GC (Double precision complex, G floating)";
6551 case DSC__K_DTYPE_HC:
6552 return "HC (Quadruple precision complex, H floating)";
6553 case DSC__K_DTYPE_CIT:
6554 return "CIT (COBOL intermediate temporary)";
6555 case DSC__K_DTYPE_BPV:
6556 return "BPV (Bound Procedure Value)";
6557 case DSC__K_DTYPE_BLV:
6558 return "BLV (Bound Label Value)";
6559 case DSC__K_DTYPE_VU:
6560 return "VU (Bit Unaligned)";
6561 case DSC__K_DTYPE_ADT:
6562 return "ADT (Absolute Date-Time)";
6563 case DSC__K_DTYPE_VT:
6564 return "VT (Varying Text)";
6565 case DSC__K_DTYPE_T2:
6566 return "T2 (16-bit char)";
6567 case DSC__K_DTYPE_VT2:
6568 return "VT2 (16-bit varying char)";
6569 default:
6570 return "?? (unknown)";
6571 }
6572}
6573
6574static void
6575evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6576{
6577 unsigned char bclass = buf[3];
6578 unsigned char dtype = buf[2];
6579 unsigned int len = (unsigned)bfd_getl16 (buf);
6580 unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6581
6582 evax_bfd_print_indent (indent, file);
6583
6584 if (len == 1 && pointer == 0xffffffffUL)
6585 {
6586 /* 64 bits. */
6587 fprintf (file, _("64 bits *unhandled*\n"));
6588 }
6589 else
6590 {
6591 fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6592 bclass, dtype, len, pointer);
6593 switch (bclass)
6594 {
6595 case DSC__K_CLASS_NCA:
6596 {
6597 const struct vms_dsc_nca *dsc = (const void *)buf;
6598 unsigned int i;
6599 const unsigned char *b;
6600
6601 evax_bfd_print_indent (indent, file);
6602 fprintf (file, _("non-contiguous array of %s\n"),
6603 evax_bfd_get_dsc_name (dsc->dtype));
6604 evax_bfd_print_indent (indent + 1, file);
6605 fprintf (file,
6606 _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6607 dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6608 evax_bfd_print_indent (indent + 1, file);
6609 fprintf (file,
6610 _("arsize: %u, a0: 0x%08x\n"),
6611 (unsigned)bfd_getl32 (dsc->arsize),
6612 (unsigned)bfd_getl32 (dsc->a0));
6613 evax_bfd_print_indent (indent + 1, file);
6614 fprintf (file, _("Strides:\n"));
6615 b = buf + sizeof (*dsc);
6616 for (i = 0; i < dsc->dimct; i++)
6617 {
6618 evax_bfd_print_indent (indent + 2, file);
6619 fprintf (file, _("[%u]: %u\n"), i + 1,
6620 (unsigned)bfd_getl32 (b));
6621 b += 4;
6622 }
6623 evax_bfd_print_indent (indent + 1, file);
6624 fprintf (file, _("Bounds:\n"));
6625 b = buf + sizeof (*dsc);
6626 for (i = 0; i < dsc->dimct; i++)
6627 {
6628 evax_bfd_print_indent (indent + 2, file);
6629 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6630 (unsigned)bfd_getl32 (b + 0),
6631 (unsigned)bfd_getl32 (b + 4));
6632 b += 8;
6633 }
6634 }
6635 break;
6636 case DSC__K_CLASS_UBS:
6637 {
6638 const struct vms_dsc_ubs *ubs = (const void *)buf;
6639
6640 evax_bfd_print_indent (indent, file);
6641 fprintf (file, _("unaligned bit-string of %s\n"),
6642 evax_bfd_get_dsc_name (ubs->dtype));
6643 evax_bfd_print_indent (indent + 1, file);
6644 fprintf (file,
6645 _("base: %u, pos: %u\n"),
6646 (unsigned)bfd_getl32 (ubs->base),
6647 (unsigned)bfd_getl32 (ubs->pos));
6648 }
6649 break;
6650 default:
6651 fprintf (file, _("*unhandled*\n"));
6652 break;
6653 }
6654 }
6655}
6656
6657static unsigned int
6658evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6659{
6660 unsigned int vflags = buf[0];
6661 unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6662 unsigned int len = 5;
6663
6664 evax_bfd_print_indent (indent, file);
6665 fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6666 buf += 5;
6667
6668 switch (vflags)
6669 {
6670 case DST__K_VFLAGS_NOVAL:
6671 fprintf (file, _("(no value)\n"));
6672 break;
6673 case DST__K_VFLAGS_NOTACTIVE:
6674 fprintf (file, _("(not active)\n"));
6675 break;
6676 case DST__K_VFLAGS_UNALLOC:
6677 fprintf (file, _("(not allocated)\n"));
6678 break;
6679 case DST__K_VFLAGS_DSC:
6680 fprintf (file, _("(descriptor)\n"));
6681 evax_bfd_print_desc (buf + value, indent + 1, file);
6682 break;
6683 case DST__K_VFLAGS_TVS:
6684 fprintf (file, _("(trailing value)\n"));
6685 break;
6686 case DST__K_VS_FOLLOWS:
6687 fprintf (file, _("(value spec follows)\n"));
6688 break;
6689 case DST__K_VFLAGS_BITOFFS:
6690 fprintf (file, _("(at bit offset %u)\n"), value);
6691 break;
6692 default:
6693 fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6694 (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6695 vflags & DST__K_DISP ? 1 : 0,
6696 vflags & DST__K_INDIR ? 1 : 0);
6697 switch (vflags & DST__K_VALKIND_MASK)
6698 {
6699 case DST__K_VALKIND_LITERAL:
6700 fputs (_("literal"), file);
6701 break;
6702 case DST__K_VALKIND_ADDR:
6703 fputs (_("address"), file);
6704 break;
6705 case DST__K_VALKIND_DESC:
6706 fputs (_("desc"), file);
6707 break;
6708 case DST__K_VALKIND_REG:
6709 fputs (_("reg"), file);
6710 break;
6711 }
6712 fputs (")\n", file);
6713 break;
6714 }
6715 return len;
6716}
6717
6718static void
6719evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6720{
6721 unsigned char kind = buf[2];
6722 unsigned int len = (unsigned)bfd_getl16 (buf);
6723
6724 evax_bfd_print_indent (indent, file);
6725 fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6726 buf += 3;
6727 switch (kind)
6728 {
6729 case DST__K_TS_ATOM:
6730 fprintf (file, ("atomic, type=0x%02x %s\n"),
6731 buf[0], evax_bfd_get_dsc_name (buf[0]));
6732 break;
6733 case DST__K_TS_IND:
6734 fprintf (file, ("indirect, defined at 0x%08x\n"),
6735 (unsigned)bfd_getl32 (buf));
6736 break;
6737 case DST__K_TS_TPTR:
6738 fprintf (file, ("typed pointer\n"));
6739 evax_bfd_print_typspec (buf, indent + 1, file);
6740 break;
6741 case DST__K_TS_PTR:
6742 fprintf (file, ("pointer\n"));
6743 break;
6744 case DST__K_TS_ARRAY:
6745 {
6746 const unsigned char *vs;
6747 unsigned int vec_len;
6748 unsigned int i;
6749
6750 fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6751 vec_len = (buf[0] + 1 + 7) / 8;
6752 for (i = 0; i < vec_len; i++)
6753 fprintf (file, " %02x", buf[i + 1]);
6754 fputc ('\n', file);
6755 vs = buf + 1 + vec_len;
6756 evax_bfd_print_indent (indent, file);
6757 fprintf (file, ("array descriptor:\n"));
6758 vs += evax_bfd_print_valspec (vs, indent + 1, file);
6759 for (i = 0; i < buf[0] + 1U; i++)
6760 if (buf[1 + i / 8] & (1 << (i % 8)))
6761 {
6762 evax_bfd_print_indent (indent, file);
6763 if (i == 0)
6764 fprintf (file, ("type spec for element:\n"));
6765 else
6766 fprintf (file, ("type spec for subscript %u:\n"), i);
6767 evax_bfd_print_typspec (vs, indent + 1, file);
6768 vs += bfd_getl16 (vs);
6769 }
6770 }
6771 break;
6772 default:
6773 fprintf (file, ("*unhandled*\n"));
6774 }
6775}
6776
6777static void
6778evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6779{
6780 unsigned int off = 0;
6781 unsigned int pc = 0;
6782 unsigned int line = 0;
6783
6784 fprintf (file, _("Debug symbol table:\n"));
6785
6786 while (dst_size > 0)
6787 {
6788 struct vms_dst_header dsth;
6789 unsigned int len;
6790 unsigned int type;
6791 unsigned char *buf;
6792
6793 if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6794 {
6795 fprintf (file, _("cannot read DST header\n"));
6796 return;
6797 }
6798 len = bfd_getl16 (dsth.length);
6799 type = bfd_getl16 (dsth.type);
6800 fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6801 type, len, off);
6802 if (len == 0)
6803 {
6804 fputc ('\n', file);
6805 break;
6806 }
6807 len++;
6808 dst_size -= len;
6809 off += len;
6810 len -= sizeof (dsth);
6811 buf = bfd_malloc (len);
6812 if (bfd_bread (buf, len, abfd) != len)
6813 {
6814 fprintf (file, _("cannot read DST symbol\n"));
6815 return;
6816 }
6817 switch (type)
6818 {
6819 case DSC__K_DTYPE_V:
6820 case DSC__K_DTYPE_BU:
6821 case DSC__K_DTYPE_WU:
6822 case DSC__K_DTYPE_LU:
6823 case DSC__K_DTYPE_QU:
6824 case DSC__K_DTYPE_B:
6825 case DSC__K_DTYPE_W:
6826 case DSC__K_DTYPE_L:
6827 case DSC__K_DTYPE_Q:
6828 case DSC__K_DTYPE_F:
6829 case DSC__K_DTYPE_D:
6830 case DSC__K_DTYPE_FC:
6831 case DSC__K_DTYPE_DC:
6832 case DSC__K_DTYPE_T:
6833 case DSC__K_DTYPE_NU:
6834 case DSC__K_DTYPE_NL:
6835 case DSC__K_DTYPE_NLO:
6836 case DSC__K_DTYPE_NR:
6837 case DSC__K_DTYPE_NRO:
6838 case DSC__K_DTYPE_NZ:
6839 case DSC__K_DTYPE_P:
6840 case DSC__K_DTYPE_ZI:
6841 case DSC__K_DTYPE_ZEM:
6842 case DSC__K_DTYPE_DSC:
6843 case DSC__K_DTYPE_OU:
6844 case DSC__K_DTYPE_O:
6845 case DSC__K_DTYPE_G:
6846 case DSC__K_DTYPE_H:
6847 case DSC__K_DTYPE_GC:
6848 case DSC__K_DTYPE_HC:
6849 case DSC__K_DTYPE_CIT:
6850 case DSC__K_DTYPE_BPV:
6851 case DSC__K_DTYPE_BLV:
6852 case DSC__K_DTYPE_VU:
6853 case DSC__K_DTYPE_ADT:
6854 case DSC__K_DTYPE_VT:
6855 case DSC__K_DTYPE_T2:
6856 case DSC__K_DTYPE_VT2:
6857 fprintf (file, _("standard data: %s\n"),
6858 evax_bfd_get_dsc_name (type));
6859 evax_bfd_print_valspec (buf, 4, file);
6860 fprintf (file, _(" name: %.*s\n"), buf[5], buf + 6);
6861 break;
6862 case DST__K_MODBEG:
6863 {
6864 struct vms_dst_modbeg *dst = (void *)buf;
6865 const char *name = (const char *)buf + sizeof (*dst);
6866
6867 fprintf (file, _("modbeg\n"));
6868 fprintf (file, _(" flags: %d, language: %u, "
6869 "major: %u, minor: %u\n"),
6870 dst->flags,
6871 (unsigned)bfd_getl32 (dst->language),
6872 (unsigned)bfd_getl16 (dst->major),
6873 (unsigned)bfd_getl16 (dst->minor));
6874 fprintf (file, _(" module name: %.*s\n"),
6875 name[0], name + 1);
6876 name += name[0] + 1;
6877 fprintf (file, _(" compiler : %.*s\n"),
6878 name[0], name + 1);
6879 }
6880 break;
6881 case DST__K_MODEND:
6882 fprintf (file, _("modend\n"));
6883 break;
6884 case DST__K_RTNBEG:
6885 {
6886 struct vms_dst_rtnbeg *dst = (void *)buf;
6887 const char *name = (const char *)buf + sizeof (*dst);
6888
6889 fputs (_("rtnbeg\n"), file);
6890 fprintf (file, _(" flags: %u, address: 0x%08x, "
6891 "pd-address: 0x%08x\n"),
6892 dst->flags,
6893 (unsigned)bfd_getl32 (dst->address),
6894 (unsigned)bfd_getl32 (dst->pd_address));
6895 fprintf (file, _(" routine name: %.*s\n"),
6896 name[0], name + 1);
6897 }
6898 break;
6899 case DST__K_RTNEND:
6900 {
6901 struct vms_dst_rtnend *dst = (void *)buf;
6902
6903 fprintf (file, _("rtnend: size 0x%08x\n"),
6904 (unsigned)bfd_getl32 (dst->size));
6905 }
6906 break;
6907 case DST__K_PROLOG:
6908 {
6909 struct vms_dst_prolog *dst = (void *)buf;
6910
6911 fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6912 (unsigned)bfd_getl32 (dst->bkpt_addr));
6913 }
6914 break;
6915 case DST__K_EPILOG:
6916 {
6917 struct vms_dst_epilog *dst = (void *)buf;
6918
6919 fprintf (file, _("epilog: flags: %u, count: %u\n"),
6920 dst->flags, (unsigned)bfd_getl32 (dst->count));
6921 }
6922 break;
6923 case DST__K_BLKBEG:
6924 {
6925 struct vms_dst_blkbeg *dst = (void *)buf;
6926 const char *name = (const char *)buf + sizeof (*dst);
6927
6928 fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6929 (unsigned)bfd_getl32 (dst->address),
6930 name[0], name + 1);
6931 }
6932 break;
6933 case DST__K_BLKEND:
6934 {
6935 struct vms_dst_blkend *dst = (void *)buf;
6936
6937 fprintf (file, _("blkend: size: 0x%08x\n"),
6938 (unsigned)bfd_getl32 (dst->size));
6939 }
6940 break;
6941 case DST__K_TYPSPEC:
6942 {
6943 fprintf (file, _("typspec (len: %u)\n"), len);
6944 fprintf (file, _(" name: %.*s\n"), buf[0], buf + 1);
6945 evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
6946 }
6947 break;
6948 case DST__K_SEPTYP:
6949 {
6950 fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
6951 evax_bfd_print_valspec (buf, 4, file);
6952 }
6953 break;
6954 case DST__K_RECBEG:
6955 {
6956 struct vms_dst_recbeg *recbeg = (void *)buf;
6957 const char *name = (const char *)buf + sizeof (*recbeg);
6958
6959 fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
6960 evax_bfd_print_valspec (buf, 4, file);
6961 fprintf (file, (" len: %u bits\n"),
6962 (unsigned)bfd_getl32 (name + 1 + name[0]));
6963 }
6964 break;
6965 case DST__K_RECEND:
6966 fprintf (file, _("recend\n"));
6967 break;
6968 case DST__K_ENUMBEG:
6969 fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
6970 buf[0], buf[1], buf + 2);
6971 break;
6972 case DST__K_ENUMELT:
6973 fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
6974 evax_bfd_print_valspec (buf, 4, file);
6975 break;
6976 case DST__K_ENUMEND:
6977 fprintf (file, _("enumend\n"));
6978 break;
6979 case DST__K_LABEL:
6980 {
6981 struct vms_dst_label *lab = (void *)buf;
6982 fprintf (file, ("label, name: %.*s\n"),
6983 lab->name[0], lab->name + 1);
6984 fprintf (file, (" address: 0x%08x\n"),
6985 (unsigned)bfd_getl32 (lab->value));
6986 }
6987 break;
6988 case DST__K_DIS_RANGE:
6989 {
6990 unsigned int cnt = bfd_getl32 (buf);
6991 unsigned char *rng = buf + 4;
6992 unsigned int i;
6993
6994 fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
6995 for (i = 0; i < cnt; i++, rng += 8)
6996 fprintf (file, _(" address: 0x%08x, size: %u\n"),
6997 (unsigned)bfd_getl32 (rng),
6998 (unsigned)bfd_getl32 (rng + 4));
6999
7000 }
7001 break;
7002 case DST__K_LINE_NUM:
7003 {
7004 unsigned char *buf_orig = buf;
7005
7006 fprintf (file, _("line num (len: %u)\n"), len);
7007
7008 while (len > 0)
7009 {
7010 signed char cmd;
7011 unsigned char cmdlen;
7012 unsigned int val;
7013
7014 cmd = buf[0];
7015 cmdlen = 0;
7016
7017 fputs (" ", file);
7018
7019 switch (cmd)
7020 {
7021 case DST__K_DELTA_PC_W:
7022 val = bfd_getl16 (buf + 1);
7023 fprintf (file, _("delta_pc_w %u\n"), val);
7024 pc += val;
7025 line++;
7026 cmdlen = 3;
7027 break;
7028 case DST__K_INCR_LINUM:
7029 val = buf[1];
0fca53b7 7030 fprintf (file, _("incr_linum(b): +%u\n"), val);
95e34ef7
TG		 7031 line += val;
7032 cmdlen = 2;
7033 break;
7034 case DST__K_INCR_LINUM_W:
7035 val = bfd_getl16 (buf + 1);
0fca53b7 7036 fprintf (file, _("incr_linum_w: +%u\n"), val);
95e34ef7
TG		 7037 line += val;
7038 cmdlen = 3;
7039 break;
0fca53b7
TG		 7040 case DST__K_INCR_LINUM_L:
7041 val = bfd_getl32 (buf + 1);
7042 fprintf (file, _("incr_linum_l: +%u\n"), val);
7043 line += val;
7044 cmdlen = 5;
7045 break;
95e34ef7 7046 case DST__K_SET_LINUM:
0fca53b7
TG		 7047 line = bfd_getl16 (buf + 1);
7048 fprintf (file, _("set_line_num(w) %u\n"), line);
95e34ef7
TG		 7049 cmdlen = 3;
7050 break;
7051 case DST__K_SET_LINUM_B:
7052 line = buf[1];
7053 fprintf (file, _("set_line_num_b %u\n"), line);
7054 cmdlen = 2;
7055 break;
7056 case DST__K_SET_LINUM_L:
0fca53b7 7057 line = bfd_getl32 (buf + 1);
95e34ef7
TG		 7058 fprintf (file, _("set_line_num_l %u\n"), line);
7059 cmdlen = 5;
7060 break;
7061 case DST__K_SET_ABS_PC:
0fca53b7 7062 pc = bfd_getl32 (buf + 1);
95e34ef7
TG		 7063 fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7064 cmdlen = 5;
7065 break;
7066 case DST__K_DELTA_PC_L:
7067 fprintf (file, _("delta_pc_l: +0x%08x\n"),
7068 (unsigned)bfd_getl32 (buf + 1));
7069 cmdlen = 5;
7070 break;
7071 case DST__K_TERM:
0fca53b7 7072 fprintf (file, _("term(b): 0x%02x"), buf[1]);
95e34ef7
TG		 7073 pc += buf[1];
7074 fprintf (file, _(" pc: 0x%08x\n"), pc);
7075 cmdlen = 2;
7076 break;
7077 case DST__K_TERM_W:
7078 val = bfd_getl16 (buf + 1);
7079 fprintf (file, _("term_w: 0x%04x"), val);
7080 pc += val;
7081 fprintf (file, _(" pc: 0x%08x\n"), pc);
7082 cmdlen = 3;
7083 break;
7084 default:
7085 if (cmd <= 0)
7086 {
7087 fprintf (file, _("delta pc +%-4d"), -cmd);
7088 line++; /* FIXME: curr increment. */
7089 pc += -cmd;
7090 fprintf (file, _(" pc: 0x%08x line: %5u\n"),
7091 pc, line);
7092 cmdlen = 1;
7093 }
7094 else
7095 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7096 break;
7097 }
7098 if (cmdlen == 0)
7099 break;
7100 len -= cmdlen;
7101 buf += cmdlen;
7102 }
7103 buf = buf_orig;
7104 }
7105 break;
7106 case DST__K_SOURCE:
7107 {
7108 unsigned char *buf_orig = buf;
7109
7110 fprintf (file, _("source (len: %u)\n"), len);
7111
7112 while (len > 0)
7113 {
7114 signed char cmd = buf[0];
7115 unsigned char cmdlen = 0;
7116
7117 switch (cmd)
7118 {
7119 case DST__K_SRC_DECLFILE:
7120 {
7121 struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7122 const char *name;
7123
7124 fprintf (file, _(" declfile: len: %u, flags: %u, "
7125 "fileid: %u\n"),
7126 src->length, src->flags,
7127 (unsigned)bfd_getl16 (src->fileid));
7128 fprintf (file, _(" rms: cdt: 0x%08x %08x, "
7129 "ebk: 0x%08x, ffb: 0x%04x, "
7130 "rfo: %u\n"),
7131 (unsigned)bfd_getl32 (src->rms_cdt + 4),
7132 (unsigned)bfd_getl32 (src->rms_cdt + 0),
7133 (unsigned)bfd_getl32 (src->rms_ebk),
7134 (unsigned)bfd_getl16 (src->rms_ffb),
7135 src->rms_rfo);
7136 name = (const char *)buf + 1 + sizeof (*src);
7137 fprintf (file, _(" filename : %.*s\n"),
7138 name[0], name + 1);
7139 name += name[0] + 1;
7140 fprintf (file, _(" module name: %.*s\n"),
7141 name[0], name + 1);
7142 cmdlen = 2 + src->length;
7143 }
7144 break;
7145 case DST__K_SRC_SETFILE:
7146 fprintf (file, _(" setfile %u\n"),
7147 (unsigned)bfd_getl16 (buf + 1));
7148 cmdlen = 3;
7149 break;
7150 case DST__K_SRC_SETREC_W:
7151 fprintf (file, _(" setrec %u\n"),
7152 (unsigned)bfd_getl16 (buf + 1));
7153 cmdlen = 3;
7154 break;
7155 case DST__K_SRC_SETREC_L:
7156 fprintf (file, _(" setrec %u\n"),
7157 (unsigned)bfd_getl32 (buf + 1));
7158 cmdlen = 5;
7159 break;
7160 case DST__K_SRC_SETLNUM_W:
7161 fprintf (file, _(" setlnum %u\n"),
7162 (unsigned)bfd_getl16 (buf + 1));
7163 cmdlen = 3;
7164 break;
7165 case DST__K_SRC_SETLNUM_L:
7166 fprintf (file, _(" setlnum %u\n"),
7167 (unsigned)bfd_getl32 (buf + 1));
7168 cmdlen = 5;
7169 break;
7170 case DST__K_SRC_DEFLINES_W:
7171 fprintf (file, _(" deflines %u\n"),
7172 (unsigned)bfd_getl16 (buf + 1));
7173 cmdlen = 3;
7174 break;
7175 case DST__K_SRC_DEFLINES_B:
7176 fprintf (file, _(" deflines %u\n"), buf[1]);
7177 cmdlen = 2;
7178 break;
7179 case DST__K_SRC_FORMFEED:
7180 fprintf (file, _(" formfeed\n"));
7181 cmdlen = 1;
7182 break;
7183 default:
7184 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7185 break;
7186 }
7187 if (cmdlen == 0)
7188 break;
7189 len -= cmdlen;
7190 buf += cmdlen;
7191 }
7192 buf = buf_orig;
7193 }
7194 break;
7195 default:
7196 fprintf (file, _("*unhandled* dst type %u\n"), type);
7197 break;
7198 }
7199 free (buf);
7200 }
7201}
7202
7203static void
7204evax_bfd_print_image (bfd *abfd, FILE *file)
7205{
7206 struct vms_eihd eihd;
7207 const char *name;
7208 unsigned int val;
7209 unsigned int eiha_off;
7210 unsigned int eihi_off;
7211 unsigned int eihs_off;
7212 unsigned int eisd_off;
7213 unsigned int eihef_off = 0;
7214 unsigned int eihnp_off = 0;
7215 unsigned int dmt_vbn = 0;
7216 unsigned int dmt_size = 0;
7217 unsigned int dst_vbn = 0;
7218 unsigned int dst_size = 0;
7219 unsigned int gst_vbn = 0;
7220 unsigned int gst_size = 0;
7221 unsigned int eiaf_vbn = 0;
7222 unsigned int eiaf_size = 0;
7223 unsigned int eihvn_off;
7224
7225 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7226 || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7227 {
7228 fprintf (file, _("cannot read EIHD\n"));
7229 return;
7230 }
7231 fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7232 (unsigned)bfd_getl32 (eihd.size),
7233 (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7234 fprintf (file, _(" majorid: %u, minorid: %u\n"),
7235 (unsigned)bfd_getl32 (eihd.majorid),
7236 (unsigned)bfd_getl32 (eihd.minorid));
7237
7238 val = (unsigned)bfd_getl32 (eihd.imgtype);
7239 switch (val)
7240 {
7241 case EIHD__K_EXE:
7242 name = _("executable");
7243 break;
7244 case EIHD__K_LIM:
7245 name = _("linkable image");
7246 break;
7247 default:
7248 name = _("unknown");
7249 break;
7250 }
7251 fprintf (file, _(" image type: %u (%s)"), val, name);
7252
7253 val = (unsigned)bfd_getl32 (eihd.subtype);
7254 switch (val)
7255 {
7256 case EIHD__C_NATIVE:
7257 name = _("native");
7258 break;
7259 case EIHD__C_CLI:
7260 name = _("CLI");
7261 break;
7262 default:
7263 name = _("unknown");
7264 break;
7265 }
7266 fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7267
7268 eisd_off = bfd_getl32 (eihd.isdoff);
7269 eiha_off = bfd_getl32 (eihd.activoff);
7270 eihi_off = bfd_getl32 (eihd.imgidoff);
7271 eihs_off = bfd_getl32 (eihd.symdbgoff);
7272 fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7273 "imgid: %u, patch: %u\n"),
7274 eisd_off, eiha_off, eihs_off, eihi_off,
7275 (unsigned)bfd_getl32 (eihd.patchoff));
7276 fprintf (file, _(" fixup info rva: "));
7277 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7278 fprintf (file, _(", symbol vector rva: "));
7279 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7280 eihvn_off = bfd_getl32 (eihd.version_array_off);
7281 fprintf (file, _("\n"
7282 " version array off: %u\n"),
7283 eihvn_off);
7284 fprintf (file,
7285 _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7286 (unsigned)bfd_getl32 (eihd.imgiocnt),
7287 (unsigned)bfd_getl32 (eihd.iochancnt),
7288 (unsigned)bfd_getl32 (eihd.privreqs + 4),
7289 (unsigned)bfd_getl32 (eihd.privreqs + 0));
7290 val = (unsigned)bfd_getl32 (eihd.lnkflags);
7291 fprintf (file, _(" linker flags: %08x:"), val);
7292 if (val & EIHD__M_LNKDEBUG)
7293 fprintf (file, " LNKDEBUG");
7294 if (val & EIHD__M_LNKNOTFR)
7295 fprintf (file, " LNKNOTFR");
7296 if (val & EIHD__M_NOP0BUFS)
7297 fprintf (file, " NOP0BUFS");
7298 if (val & EIHD__M_PICIMG)
7299 fprintf (file, " PICIMG");
7300 if (val & EIHD__M_P0IMAGE)
7301 fprintf (file, " P0IMAGE");
7302 if (val & EIHD__M_DBGDMT)
7303 fprintf (file, " DBGDMT");
7304 if (val & EIHD__M_INISHR)
7305 fprintf (file, " INISHR");
7306 if (val & EIHD__M_XLATED)
7307 fprintf (file, " XLATED");
7308 if (val & EIHD__M_BIND_CODE_SEC)
7309 fprintf (file, " BIND_CODE_SEC");
7310 if (val & EIHD__M_BIND_DATA_SEC)
7311 fprintf (file, " BIND_DATA_SEC");
7312 if (val & EIHD__M_MKTHREADS)
7313 fprintf (file, " MKTHREADS");
7314 if (val & EIHD__M_UPCALLS)
7315 fprintf (file, " UPCALLS");
7316 if (val & EIHD__M_OMV_READY)
7317 fprintf (file, " OMV_READY");
7318 if (val & EIHD__M_EXT_BIND_SECT)
7319 fprintf (file, " EXT_BIND_SECT");
7320 fprintf (file, "\n");
7321 fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7322 "match ctrl: %u, symvect_size: %u\n"),
7323 (unsigned)bfd_getl32 (eihd.ident),
7324 (unsigned)bfd_getl32 (eihd.sysver),
7325 eihd.matchctl,
7326 (unsigned)bfd_getl32 (eihd.symvect_size));
7327 fprintf (file, _(" BPAGE: %u"),
7328 (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7329 if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7330 {
7331 eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7332 eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7333 fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7334 eihef_off, eihnp_off);
7335 }
7336 fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7337
7338 if (eihvn_off != 0)
7339 {
7340 struct vms_eihvn eihvn;
7341 unsigned int mask;
7342 unsigned int j;
7343
7344 fprintf (file, _("system version array information:\n"));
7345 if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7346 || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7347 {
7348 fprintf (file, _("cannot read EIHVN header\n"));
7349 return;
7350 }
7351 mask = bfd_getl32 (eihvn.subsystem_mask);
7352 for (j = 0; j < 32; j++)
7353 if (mask & (1 << j))
7354 {
7355 struct vms_eihvn_subversion ver;
7356 if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7357 {
7358 fprintf (file, _("cannot read EIHVN version\n"));
7359 return;
7360 }
7361 fprintf (file, _(" %02u "), j);
7362 switch (j)
7363 {
7364 case EIHVN__BASE_IMAGE_BIT:
7365 fputs (_("BASE_IMAGE "), file);
7366 break;
7367 case EIHVN__MEMORY_MANAGEMENT_BIT:
7368 fputs (_("MEMORY_MANAGEMENT"), file);
7369 break;
7370 case EIHVN__IO_BIT:
7371 fputs (_("IO "), file);
7372 break;
7373 case EIHVN__FILES_VOLUMES_BIT:
7374 fputs (_("FILES_VOLUMES "), file);
7375 break;
7376 case EIHVN__PROCESS_SCHED_BIT:
7377 fputs (_("PROCESS_SCHED "), file);
7378 break;
7379 case EIHVN__SYSGEN_BIT:
7380 fputs (_("SYSGEN "), file);
7381 break;
7382 case EIHVN__CLUSTERS_LOCKMGR_BIT:
7383 fputs (_("CLUSTERS_LOCKMGR "), file);
7384 break;
7385 case EIHVN__LOGICAL_NAMES_BIT:
7386 fputs (_("LOGICAL_NAMES "), file);
7387 break;
7388 case EIHVN__SECURITY_BIT:
7389 fputs (_("SECURITY "), file);
7390 break;
7391 case EIHVN__IMAGE_ACTIVATOR_BIT:
7392 fputs (_("IMAGE_ACTIVATOR "), file);
7393 break;
7394 case EIHVN__NETWORKS_BIT:
7395 fputs (_("NETWORKS "), file);
7396 break;
7397 case EIHVN__COUNTERS_BIT:
7398 fputs (_("COUNTERS "), file);
7399 break;
7400 case EIHVN__STABLE_BIT:
7401 fputs (_("STABLE "), file);
7402 break;
7403 case EIHVN__MISC_BIT:
7404 fputs (_("MISC "), file);
7405 break;
7406 case EIHVN__CPU_BIT:
7407 fputs (_("CPU "), file);
7408 break;
7409 case EIHVN__VOLATILE_BIT:
7410 fputs (_("VOLATILE "), file);
7411 break;
7412 case EIHVN__SHELL_BIT:
7413 fputs (_("SHELL "), file);
7414 break;
7415 case EIHVN__POSIX_BIT:
7416 fputs (_("POSIX "), file);
7417 break;
7418 case EIHVN__MULTI_PROCESSING_BIT:
7419 fputs (_("MULTI_PROCESSING "), file);
7420 break;
7421 case EIHVN__GALAXY_BIT:
7422 fputs (_("GALAXY "), file);
7423 break;
7424 default:
7425 fputs (_("*unknown* "), file);
7426 break;
7427 }
7428 fprintf (file, _(": %u.%u\n"),
7429 (unsigned)bfd_getl16 (ver.major),
7430 (unsigned)bfd_getl16 (ver.minor));
7431 }
7432 }
7433
7434 if (eiha_off != 0)
7435 {
7436 struct vms_eiha eiha;
7437
7438 if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7439 || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7440 {
7441 fprintf (file, _("cannot read EIHA\n"));
7442 return;
7443 }
7444 fprintf (file, _("Image activation: (size=%u)\n"),
7445 (unsigned)bfd_getl32 (eiha.size));
7446 fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7447 (unsigned)bfd_getl32 (eiha.tfradr1_h),
7448 (unsigned)bfd_getl32 (eiha.tfradr1));
7449 fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7450 (unsigned)bfd_getl32 (eiha.tfradr2_h),
7451 (unsigned)bfd_getl32 (eiha.tfradr2));
7452 fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7453 (unsigned)bfd_getl32 (eiha.tfradr3_h),
7454 (unsigned)bfd_getl32 (eiha.tfradr3));
7455 fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7456 (unsigned)bfd_getl32 (eiha.tfradr4_h),
7457 (unsigned)bfd_getl32 (eiha.tfradr4));
7458 fprintf (file, _(" Shared image : 0x%08x 0x%08x\n"),
7459 (unsigned)bfd_getl32 (eiha.inishr_h),
7460 (unsigned)bfd_getl32 (eiha.inishr));
7461 }
7462 if (eihi_off != 0)
7463 {
7464 struct vms_eihi eihi;
7465
7466 if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7467 || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7468 {
7469 fprintf (file, _("cannot read EIHI\n"));
7470 return;
7471 }
7472 fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7473 (unsigned)bfd_getl32 (eihi.majorid),
7474 (unsigned)bfd_getl32 (eihi.minorid));
7475 fprintf (file, _(" image name : %.*s\n"),
7476 eihi.imgnam[0], eihi.imgnam + 1);
7477 fprintf (file, _(" link time : %s\n"),
7478 vms_time_to_str (eihi.linktime));
7479 fprintf (file, _(" image ident : %.*s\n"),
7480 eihi.imgid[0], eihi.imgid + 1);
7481 fprintf (file, _(" linker ident : %.*s\n"),
7482 eihi.linkid[0], eihi.linkid + 1);
7483 fprintf (file, _(" image build ident: %.*s\n"),
7484 eihi.imgbid[0], eihi.imgbid + 1);
7485 }
7486 if (eihs_off != 0)
7487 {
7488 struct vms_eihs eihs;
7489
7490 if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7491 || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7492 {
7493 fprintf (file, _("cannot read EIHS\n"));
7494 return;
7495 }
7496 fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7497 (unsigned)bfd_getl32 (eihs.majorid),
7498 (unsigned)bfd_getl32 (eihs.minorid));
7499 dst_vbn = bfd_getl32 (eihs.dstvbn);
7500 dst_size = bfd_getl32 (eihs.dstsize);
44273c5b
TG		 7501 fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7502 dst_vbn, dst_size, dst_size);
95e34ef7
TG		 7503 gst_vbn = bfd_getl32 (eihs.gstvbn);
7504 gst_size = bfd_getl32 (eihs.gstsize);
7505 fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7506 gst_vbn, gst_size);
7507 dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7508 dmt_size = bfd_getl32 (eihs.dmtsize);
7509 fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7510 dmt_vbn, dmt_size);
7511 }
7512 while (eisd_off != 0)
7513 {
7514 struct vms_eisd eisd;
7515 unsigned int len;
7516
7517 while (1)
7518 {
7519 if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7520 || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7521 {
7522 fprintf (file, _("cannot read EISD\n"));
7523 return;
7524 }
7525 len = (unsigned)bfd_getl32 (eisd.eisdsize);
7526 if (len != (unsigned)-1)
7527 break;
7528
7529 /* Next block. */
7530 eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7531 }
7532 fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7533 "size: %u, offset: %u)\n"),
7534 (unsigned)bfd_getl32 (eisd.majorid),
7535 (unsigned)bfd_getl32 (eisd.minorid),
7536 len, eisd_off);
7537 if (len == 0)
7538 break;
7539 fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7540 (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7541 (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7542 (unsigned)bfd_getl32 (eisd.secsize));
7543 val = (unsigned)bfd_getl32 (eisd.flags);
7544 fprintf (file, _(" flags: 0x%04x"), val);
7545 if (val & EISD__M_GBL)
7546 fprintf (file, " GBL");
7547 if (val & EISD__M_CRF)
7548 fprintf (file, " CRF");
7549 if (val & EISD__M_DZRO)
7550 fprintf (file, " DZRO");
7551 if (val & EISD__M_WRT)
7552 fprintf (file, " WRT");
7553 if (val & EISD__M_INITALCODE)
7554 fprintf (file, " INITALCODE");
7555 if (val & EISD__M_BASED)
7556 fprintf (file, " BASED");
7557 if (val & EISD__M_FIXUPVEC)
7558 fprintf (file, " FIXUPVEC");
7559 if (val & EISD__M_RESIDENT)
7560 fprintf (file, " RESIDENT");
7561 if (val & EISD__M_VECTOR)
7562 fprintf (file, " VECTOR");
7563 if (val & EISD__M_PROTECT)
7564 fprintf (file, " PROTECT");
7565 if (val & EISD__M_LASTCLU)
7566 fprintf (file, " LASTCLU");
7567 if (val & EISD__M_EXE)
7568 fprintf (file, " EXE");
7569 if (val & EISD__M_NONSHRADR)
7570 fprintf (file, " NONSHRADR");
7571 if (val & EISD__M_QUAD_LENGTH)
7572 fprintf (file, " QUAD_LENGTH");
7573 if (val & EISD__M_ALLOC_64BIT)
7574 fprintf (file, " ALLOC_64BIT");
7575 fprintf (file, "\n");
7576 if (val & EISD__M_FIXUPVEC)
7577 {
7578 eiaf_vbn = bfd_getl32 (eisd.vbn);
7579 eiaf_size = bfd_getl32 (eisd.secsize);
7580 }
7581 fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7582 (unsigned)bfd_getl32 (eisd.vbn),
7583 eisd.pfc, eisd.matchctl, eisd.type);
7584 switch (eisd.type)
7585 {
7586 case EISD__K_NORMAL:
7587 fputs (_("NORMAL"), file);
7588 break;
7589 case EISD__K_SHRFXD:
7590 fputs (_("SHRFXD"), file);
7591 break;
7592 case EISD__K_PRVFXD:
7593 fputs (_("PRVFXD"), file);
7594 break;
7595 case EISD__K_SHRPIC:
7596 fputs (_("SHRPIC"), file);
7597 break;
7598 case EISD__K_PRVPIC:
7599 fputs (_("PRVPIC"), file);
7600 break;
7601 case EISD__K_USRSTACK:
7602 fputs (_("USRSTACK"), file);
7603 break;
7604 default:
7605 fputs (_("*unknown*"), file);
7606 break;
7607 }
7608 fputs (_(")\n"), file);
7609 if (val & EISD__M_GBL)
7610 fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7611 (unsigned)bfd_getl32 (eisd.ident),
7612 eisd.gblnam[0], eisd.gblnam + 1);
7613 eisd_off += len;
7614 }
7615
7616 if (dmt_vbn != 0)
7617 {
7618 if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7619 {
7620 fprintf (file, _("cannot read DMT\n"));
7621 return;
7622 }
7623
7624 fprintf (file, _("Debug module table:\n"));
7625
7626 while (dmt_size > 0)
7627 {
7628 struct vms_dmt_header dmth;
7629 unsigned int count;
7630
7631 if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7632 {
7633 fprintf (file, _("cannot read DMT header\n"));
7634 return;
7635 }
7636 count = bfd_getl16 (dmth.psect_count);
7637 fprintf (file,
0fca53b7 7638 _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
95e34ef7
TG		 7639 (unsigned)bfd_getl32 (dmth.modbeg),
7640 (unsigned)bfd_getl32 (dmth.size), count);
7641 dmt_size -= sizeof (dmth);
7642 while (count > 0)
7643 {
7644 struct vms_dmt_psect dmtp;
7645
7646 if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7647 {
7648 fprintf (file, _("cannot read DMT psect\n"));
7649 return;
7650 }
7651 fprintf (file, _(" psect start: 0x%08x, length: %u\n"),
7652 (unsigned)bfd_getl32 (dmtp.start),
7653 (unsigned)bfd_getl32 (dmtp.length));
7654 count--;
7655 dmt_size -= sizeof (dmtp);
7656 }
7657 }
7658 }
7659
7660 if (dst_vbn != 0)
7661 {
7662 if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7663 {
7664 fprintf (file, _("cannot read DST\n"));
7665 return;
7666 }
7667
7668 evax_bfd_print_dst (abfd, dst_size, file);
7669 }
7670 if (gst_vbn != 0)
7671 {
7672 if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7673 {
7674 fprintf (file, _("cannot read GST\n"));
7675 return;
7676 }
7677
7678 fprintf (file, _("Global symbol table:\n"));
7679 evax_bfd_print_eobj (abfd, file);
7680 }
7681 if (eiaf_vbn != 0)
7682 {
7683 unsigned char *buf;
7684 struct vms_eiaf *eiaf;
7685 unsigned int qrelfixoff;
7686 unsigned int lrelfixoff;
7687 unsigned int qdotadroff;
7688 unsigned int ldotadroff;
7689 unsigned int shrimgcnt;
7690 unsigned int shlstoff;
7691 unsigned int codeadroff;
7692 unsigned int lpfixoff;
7693 unsigned int chgprtoff;
7694
7695 buf = bfd_malloc (eiaf_size);
7696
7697 if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7698 || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7699 {
7700 fprintf (file, _("cannot read EIHA\n"));
7701 free (buf);
7702 return;
7703 }
7704 eiaf = (struct vms_eiaf *)buf;
7705 fprintf (file,
7706 _("Image activator fixup: (major: %u, minor: %u)\n"),
7707 (unsigned)bfd_getl32 (eiaf->majorid),
7708 (unsigned)bfd_getl32 (eiaf->minorid));
7709 fprintf (file, _(" iaflink : 0x%08x %08x\n"),
7710 (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7711 (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7712 fprintf (file, _(" fixuplnk: 0x%08x %08x\n"),
7713 (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7714 (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7715 fprintf (file, _(" size : %u\n"),
7716 (unsigned)bfd_getl32 (eiaf->size));
7717 fprintf (file, _(" flags: 0x%08x\n"),
7718 (unsigned)bfd_getl32 (eiaf->flags));
7719 qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7720 lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7721 fprintf (file, _(" qrelfixoff: %5u, lrelfixoff: %5u\n"),
7722 qrelfixoff, lrelfixoff);
7723 qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7724 ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7725 fprintf (file, _(" qdotadroff: %5u, ldotadroff: %5u\n"),
7726 qdotadroff, ldotadroff);
7727 codeadroff = bfd_getl32 (eiaf->codeadroff);
7728 lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7729 fprintf (file, _(" codeadroff: %5u, lpfixoff : %5u\n"),
7730 codeadroff, lpfixoff);
7731 chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7732 fprintf (file, _(" chgprtoff : %5u\n"), chgprtoff);
7733 shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7734 shlstoff = bfd_getl32 (eiaf->shlstoff);
7735 fprintf (file, _(" shlstoff : %5u, shrimgcnt : %5u\n"),
7736 shlstoff, shrimgcnt);
7737 fprintf (file, _(" shlextra : %5u, permctx : %5u\n"),
7738 (unsigned)bfd_getl32 (eiaf->shlextra),
7739 (unsigned)bfd_getl32 (eiaf->permctx));
7740 fprintf (file, _(" base_va : 0x%08x\n"),
7741 (unsigned)bfd_getl32 (eiaf->base_va));
7742 fprintf (file, _(" lppsbfixoff: %5u\n"),
7743 (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7744
7745 if (shlstoff)
7746 {
7747 struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7748 unsigned int j;
7749
7750 fprintf (file, _(" Shareable images:\n"));
7751 for (j = 0; j < shrimgcnt; j++, shl++)
7752 {
7753 fprintf (file,
7754 _(" %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7755 j, shl->size, shl->flags,
7756 shl->imgnam[0], shl->imgnam + 1);
7757 }
7758 }
7759 if (qrelfixoff != 0)
7760 {
7761 fprintf (file, _(" quad-word relocation fixups:\n"));
7762 evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7763 }
7764 if (lrelfixoff != 0)
7765 {
7766 fprintf (file, _(" long-word relocation fixups:\n"));
7767 evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7768 }
7769 if (qdotadroff != 0)
7770 {
7771 fprintf (file, _(" quad-word .address reference fixups:\n"));
7772 evax_bfd_print_address_fixups (file, buf + qdotadroff);
7773 }
7774 if (ldotadroff != 0)
7775 {
7776 fprintf (file, _(" long-word .address reference fixups:\n"));
7777 evax_bfd_print_address_fixups (file, buf + ldotadroff);
7778 }
7779 if (codeadroff != 0)
7780 {
7781 fprintf (file, _(" Code Address Reference Fixups:\n"));
7782 evax_bfd_print_reference_fixups (file, buf + codeadroff);
7783 }
7784 if (lpfixoff != 0)
7785 {
7786 fprintf (file, _(" Linkage Pairs Referece Fixups:\n"));
7787 evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7788 }
7789 if (chgprtoff)
7790 {
7791 unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7792 struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7793 unsigned int j;
7794
7795 fprintf (file, _(" Change Protection (%u entries):\n"), count);
7796 for (j = 0; j < count; j++, eicp++)
7797 {
7798 unsigned int prot = bfd_getl32 (eicp->newprt);
7799 fprintf (file,
7800 _(" base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7801 (unsigned)bfd_getl32 (eicp->baseva + 4),
7802 (unsigned)bfd_getl32 (eicp->baseva + 0),
7803 (unsigned)bfd_getl32 (eicp->size),
7804 (unsigned)bfd_getl32 (eicp->newprt));
7805 switch (prot)
7806 {
7807 case PRT__C_NA:
7808 fprintf (file, "NA");
7809 break;
7810 case PRT__C_RESERVED:
7811 fprintf (file, "RES");
7812 break;
7813 case PRT__C_KW:
7814 fprintf (file, "KW");
7815 break;
7816 case PRT__C_KR:
7817 fprintf (file, "KR");
7818 break;
7819 case PRT__C_UW:
7820 fprintf (file, "UW");
7821 break;
7822 case PRT__C_EW:
7823 fprintf (file, "EW");
7824 break;
7825 case PRT__C_ERKW:
7826 fprintf (file, "ERKW");
7827 break;
7828 case PRT__C_ER:
7829 fprintf (file, "ER");
7830 break;
7831 case PRT__C_SW:
7832 fprintf (file, "SW");
7833 break;
7834 case PRT__C_SREW:
7835 fprintf (file, "SREW");
7836 break;
7837 case PRT__C_SRKW:
7838 fprintf (file, "SRKW");
7839 break;
7840 case PRT__C_SR:
7841 fprintf (file, "SR");
7842 break;
7843 case PRT__C_URSW:
7844 fprintf (file, "URSW");
7845 break;
7846 case PRT__C_UREW:
7847 fprintf (file, "UREW");
7848 break;
7849 case PRT__C_URKW:
7850 fprintf (file, "URKW");
7851 break;
7852 case PRT__C_UR:
7853 fprintf (file, "UR");
7854 break;
7855 default:
7856 fputs ("??", file);
7857 break;
7858 }
7859 fputc ('\n', file);
7860 }
7861 }
7862 free (buf);
7863 }
7864}
7865
7866static bfd_boolean
7867vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7868{
7869 FILE *file = (FILE *)ptr;
7870
7871 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7872 evax_bfd_print_image (abfd, file);
7873 else
7874 {
7875 if (bfd_seek (abfd, 0, SEEK_SET))
7876 return FALSE;
7877 evax_bfd_print_eobj (abfd, file);
7878 }
7879 return TRUE;
7880}
7881\f
7882/* Linking. */
7883
44273c5b 7884/* Slurp ETIR/EDBG/ETBT VMS object records. */
95e34ef7
TG		 7885
7886static bfd_boolean
7887alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7888{
7889 asection *cur_section;
7890 file_ptr cur_offset;
7891 asection *dst_section;
7892 file_ptr dst_offset;
7893
7894 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7895 return FALSE;
7896
95e34ef7
TG		 7897 cur_section = NULL;
7898 cur_offset = 0;
7899
7900 dst_section = PRIV (dst_section);
7901 dst_offset = 0;
7902 if (info)
7903 {
7904 if (info->strip == strip_all || info->strip == strip_debugger)
7905 {
44273c5b 7906 /* Discard the DST section. */
95e34ef7
TG		 7907 dst_offset = 0;
7908 dst_section = NULL;
7909 }
7910 else if (dst_section)
7911 {
7912 dst_offset = dst_section->output_offset;
7913 dst_section = dst_section->output_section;
7914 }
7915 }
7916
7917 while (1)
7918 {
7919 int type;
7920 bfd_boolean res;
7921
7922 type = _bfd_vms_get_object_record (abfd);
7923 if (type < 0)
7924 {
7925 vms_debug2 ((2, "next_record failed\n"));
7926 return FALSE;
7927 }
7928 switch (type)
7929 {
7930 case EOBJ__C_ETIR:
7931 PRIV (image_section) = cur_section;
7932 PRIV (image_offset) = cur_offset;
7933 res = _bfd_vms_slurp_etir (abfd, info);
7934 cur_section = PRIV (image_section);
7935 cur_offset = PRIV (image_offset);
7936 break;
7937 case EOBJ__C_EDBG:
7938 case EOBJ__C_ETBT:
7939 if (dst_section == NULL)
7940 continue;
7941 PRIV (image_section) = dst_section;
7942 PRIV (image_offset) = dst_offset;
95e34ef7 7943 res = _bfd_vms_slurp_etir (abfd, info);
95e34ef7
TG		 7944 dst_offset = PRIV (image_offset);
7945 break;
7946 case EOBJ__C_EEOM:
7947 return TRUE;
7948 default:
7949 continue;
7950 }
7951 if (!res)
7952 {
7953 vms_debug2 ((2, "slurp eobj type %d failed\n", type));
7954 return FALSE;
7955 }
7956 }
7957}
7958
7959static int
7960alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
7961 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7962{
7963 return 0;
7964}
7965
7966/* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
7967
7968static void
7969alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
7970{
7971 struct alpha_vms_shlib_el *sl;
7972 asection *sect = PRIV2 (src, image_section);
7973 file_ptr offset = PRIV2 (src, image_offset);
7974
7975 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7976 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7977 sl->has_fixups = TRUE;
7978 VEC_APPEND_EL (sl->lp, bfd_vma,
7979 sect->output_section->vma + sect->output_offset + offset);
7980}
7981
7982static void
7983alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
7984{
7985 struct alpha_vms_shlib_el *sl;
7986 asection *sect = PRIV2 (src, image_section);
7987 file_ptr offset = PRIV2 (src, image_offset);
7988
7989 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
7990 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
7991 sl->has_fixups = TRUE;
7992 VEC_APPEND_EL (sl->ca, bfd_vma,
7993 sect->output_section->vma + sect->output_offset + offset);
7994}
7995
7996static void
7997alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
7998 bfd *shlib, bfd_vma vec)
7999{
8000 struct alpha_vms_shlib_el *sl;
8001 struct alpha_vms_vma_ref *r;
8002 asection *sect = PRIV2 (src, image_section);
8003 file_ptr offset = PRIV2 (src, image_offset);
8004
8005 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8006 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8007 sl->has_fixups = TRUE;
8008 r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
8009 r->vma = sect->output_section->vma + sect->output_offset + offset;
8010 r->ref = vec;
8011}
8012
8013static void
8014alpha_vms_add_lw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8015 unsigned int shr ATTRIBUTE_UNUSED,
8016 bfd_vma vec ATTRIBUTE_UNUSED)
8017{
8018 abort ();
8019}
8020
8021#if 0
8022static void
8023alpha_vms_add_qw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8024 unsigned int shr ATTRIBUTE_UNUSED,
8025 bfd_vma vec ATTRIBUTE_UNUSED)
8026{
8027 abort ();
8028}
8029#endif
8030
8031static void
8032alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8033{
8034}
8035
8036static void
8037alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8038{
8039}
8040
8041static struct bfd_hash_entry *
8042alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
8043 struct bfd_hash_table *table,
8044 const char *string)
8045{
8046 struct alpha_vms_link_hash_entry *ret =
8047 (struct alpha_vms_link_hash_entry *) entry;
8048
8049 /* Allocate the structure if it has not already been allocated by a
8050 subclass. */
8051 if (ret == NULL)
8052 ret = ((struct alpha_vms_link_hash_entry *)
8053 bfd_hash_allocate (table,
8054 sizeof (struct alpha_vms_link_hash_entry)));
8055 if (ret == NULL)
8056 return NULL;
8057
8058 /* Call the allocation method of the superclass. */
8059 ret = ((struct alpha_vms_link_hash_entry *)
8060 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
8061 table, string));
8062
8063 ret->sym = NULL;
8064
8065 return (struct bfd_hash_entry *) ret;
8066}
8067
8068/* Create an Alpha/VMS link hash table. */
8069
8070static struct bfd_link_hash_table *
8071alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8072{
8073 struct alpha_vms_link_hash_table *ret;
8074 bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8075
8076 ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8077 if (ret == NULL)
8078 return NULL;
8079 if (!_bfd_link_hash_table_init (&ret->root, abfd,
8080 alpha_vms_link_hash_newfunc,
8081 sizeof (struct alpha_vms_link_hash_entry)))
8082 {
8083 free (ret);
8084 return NULL;
8085 }
8086
8087 VEC_INIT (ret->shrlibs);
8088 ret->fixup = NULL;
8089
8090 return &ret->root;
8091}
8092
8093static bfd_boolean
8094alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8095{
8096 unsigned int i;
8097
8098 for (i = 0; i < PRIV (gsd_sym_count); i++)
8099 {
8100 struct vms_symbol_entry *e = PRIV (syms)[i];
8101 struct alpha_vms_link_hash_entry *h;
11afaeda 8102 struct bfd_link_hash_entry *h_root;
95e34ef7
TG		 8103 asymbol sym;
8104
8105 if (!alpha_vms_convert_symbol (abfd, e, &sym))
8106 return FALSE;
8107
8108 if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8109 {
8110 /* In selective_search mode, only add definition that are
8111 required. */
8112 h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8113 (info->hash, sym.name, FALSE, FALSE, FALSE);
8114 if (h == NULL || h->root.type != bfd_link_hash_undefined)
8115 continue;
8116 }
8117 else
8118 h = NULL;
8119
11afaeda 8120 h_root = (struct bfd_link_hash_entry *) h;
95e34ef7
TG		 8121 if (_bfd_generic_link_add_one_symbol
8122 (info, abfd, sym.name, sym.flags, sym.section, sym.value,
11afaeda 8123 NULL, FALSE, FALSE, &h_root) == FALSE)
95e34ef7 8124 return FALSE;
11afaeda 8125 h = (struct alpha_vms_link_hash_entry *) h_root;
95e34ef7
TG		 8126
8127 if ((e->flags & EGSY__V_DEF)
8128 && h->sym == NULL
8129 && abfd->xvec == info->output_bfd->xvec)
8130 h->sym = e;
8131 }
8132
8133 if (abfd->flags & DYNAMIC)
8134 {
8135 struct alpha_vms_shlib_el *shlib;
8136
8137 /* We do not want to include any of the sections in a dynamic
8138 object in the output file. See comment in elflink.c. */
8139 bfd_section_list_clear (abfd);
8140
8141 shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8142 struct alpha_vms_shlib_el);
8143 shlib->abfd = abfd;
8144 VEC_INIT (shlib->ca);
8145 VEC_INIT (shlib->lp);
8146 VEC_INIT (shlib->qr);
8147 PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8148 }
8149
8150 return TRUE;
8151}
8152
8153static bfd_boolean
8154alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8155{
8156 int pass;
8157 struct bfd_link_hash_entry **pundef;
8158 struct bfd_link_hash_entry **next_pundef;
8159
8160 /* We only accept VMS libraries. */
8161 if (info->output_bfd->xvec != abfd->xvec)
8162 {
8163 bfd_set_error (bfd_error_wrong_format);
8164 return FALSE;
8165 }
8166
8167 /* The archive_pass field in the archive itself is used to
8168 initialize PASS, since we may search the same archive multiple
8169 times. */
8170 pass = ++abfd->archive_pass;
8171
8172 /* Look through the list of undefined symbols. */
8173 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8174 {
8175 struct bfd_link_hash_entry *h;
8e57e1d1 8176 symindex symidx;
95e34ef7
TG		 8177 bfd *element;
8178 bfd *orig_element;
8179
8180 h = *pundef;
8181 next_pundef = &(*pundef)->u.undef.next;
8182
8183 /* When a symbol is defined, it is not necessarily removed from
8184 the list. */
8185 if (h->type != bfd_link_hash_undefined
8186 && h->type != bfd_link_hash_common)
8187 {
8188 /* Remove this entry from the list, for general cleanliness
8189 and because we are going to look through the list again
8190 if we search any more libraries. We can't remove the
8191 entry if it is the tail, because that would lose any
8192 entries we add to the list later on. */
8193 if (*pundef != info->hash->undefs_tail)
8194 {
8195 *pundef = *next_pundef;
8196 next_pundef = pundef;
8197 }
8198 continue;
8199 }
8200
8201 /* Look for this symbol in the archive hash table. */
8e57e1d1
TG		 8202 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8203 if (symidx == BFD_NO_MORE_SYMBOLS)
95e34ef7
TG		 8204 {
8205 /* Nothing in this slot. */
8206 continue;
8207 }
8208
8e57e1d1 8209 element = bfd_get_elt_at_index (abfd, symidx);
95e34ef7
TG		 8210 if (element == NULL)
8211 return FALSE;
8212
8213 if (element->archive_pass == -1 || element->archive_pass == pass)
8214 continue;
8215
8216 if (! bfd_check_format (element, bfd_object))
8217 {
8218 element->archive_pass = -1;
8219 return FALSE;
8220 }
8221
8222 orig_element = element;
8223 if (bfd_is_thin_archive (abfd))
8224 {
8225 element = _bfd_vms_lib_get_imagelib_file (element);
8226 if (element == NULL || !bfd_check_format (element, bfd_object))
8227 {
8228 orig_element->archive_pass = -1;
8229 return FALSE;
8230 }
8231 }
8232
8233 /* Unlike the generic linker, we know that this element provides
8234 a definition for an undefined symbol and we know that we want
8235 to include it. We don't need to check anything. */
8236 if (! (*info->callbacks->add_archive_element) (info, element,
8237 h->root.string))
8238 return FALSE;
8239 if (! alpha_vms_link_add_object_symbols (element, info))
8240 return FALSE;
8241
8242 orig_element->archive_pass = pass;
8243 }
8244
8245 return TRUE;
8246}
8247
8248static bfd_boolean
8249alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8250{
8251 switch (bfd_get_format (abfd))
8252 {
8253 case bfd_object:
8254 vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8255 abfd->filename));
8256 return alpha_vms_link_add_object_symbols (abfd, info);
8257 break;
8258 case bfd_archive:
8259 vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8260 abfd->filename));
8261 return alpha_vms_link_add_archive_symbols (abfd, info);
8262 break;
8263 default:
8264 bfd_set_error (bfd_error_wrong_format);
8265 return FALSE;
8266 }
8267}
8268
8269static bfd_boolean
8270alpha_vms_build_fixups (struct bfd_link_info *info)
8271{
8272 struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8273 unsigned char *content;
8274 unsigned int i;
8275 unsigned int sz = 0;
8276 unsigned int lp_sz = 0;
8277 unsigned int ca_sz = 0;
8278 unsigned int qr_sz = 0;
8279 unsigned int shrimg_cnt = 0;
8280 struct vms_eiaf *eiaf;
8281 unsigned int off;
8282 asection *sec;
8283
8284 /* Shared libraries. */
8285 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8286 {
8287 struct alpha_vms_shlib_el *shlib;
8288
8289 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8290
8291 if (!shlib->has_fixups)
8292 continue;
8293
8294 shrimg_cnt++;
8295
8296 if (VEC_COUNT (shlib->ca) > 0)
8297 {
8298 /* Header + entries. */
8299 ca_sz += 8;
8300 ca_sz += VEC_COUNT (shlib->ca) * 4;
8301 }
8302 if (VEC_COUNT (shlib->lp) > 0)
8303 {
8304 /* Header + entries. */
8305 lp_sz += 8;
8306 lp_sz += VEC_COUNT (shlib->lp) * 4;
8307 }
8308 if (VEC_COUNT (shlib->qr) > 0)
8309 {
8310 /* Header + entries. */
8311 qr_sz += 8;
8312 qr_sz += VEC_COUNT (shlib->qr) * 8;
8313 }
8314 }
8315 /* Add markers. */
8316 if (ca_sz > 0)
8317 ca_sz += 8;
8318 if (lp_sz > 0)
8319 lp_sz += 8;
8320 if (qr_sz > 0)
8321 qr_sz += 8;
8322
8323 /* Finish now if there is no content. */
8324 if (ca_sz + lp_sz + qr_sz == 0)
8325 return TRUE;
8326
8327 /* Allocate section content (round-up size) */
8328 sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8329 + ca_sz + lp_sz + qr_sz;
8330 sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8331 content = bfd_zalloc (info->output_bfd, sz);
8332 if (content == NULL)
8333 return FALSE;
8334
8335 sec = alpha_vms_link_hash (info)->fixup;
8336 sec->contents = content;
8337 sec->size = sz;
8338
8339 eiaf = (struct vms_eiaf *)content;
8340 off = sizeof (struct vms_eiaf);
8341 bfd_putl32 (0, eiaf->majorid);
8342 bfd_putl32 (0, eiaf->minorid);
8343 bfd_putl32 (0, eiaf->iaflink);
8344 bfd_putl32 (0, eiaf->fixuplnk);
8345 bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8346 bfd_putl32 (0, eiaf->flags);
8347 bfd_putl32 (0, eiaf->qrelfixoff);
8348 bfd_putl32 (0, eiaf->lrelfixoff);
8349 bfd_putl32 (0, eiaf->qdotadroff);
8350 bfd_putl32 (0, eiaf->ldotadroff);
8351 bfd_putl32 (0, eiaf->codeadroff);
8352 bfd_putl32 (0, eiaf->lpfixoff);
8353 bfd_putl32 (0, eiaf->chgprtoff);
8354 bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8355 bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8356 bfd_putl32 (0, eiaf->shlextra);
8357 bfd_putl32 (0, eiaf->permctx);
8358 bfd_putl32 (0, eiaf->base_va);
8359 bfd_putl32 (0, eiaf->lppsbfixoff);
8360
8361 if (shrimg_cnt)
8362 {
8363 shrimg_cnt = 0;
8364
8365 /* Write shl. */
8366 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8367 {
8368 struct alpha_vms_shlib_el *shlib;
8369 struct vms_shl *shl;
8370
8371 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8372
8373 if (!shlib->has_fixups)
8374 continue;
8375
8376 /* Renumber shared images. */
8377 PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8378
8379 shl = (struct vms_shl *)(content + off);
8380 bfd_putl32 (0, shl->baseva);
8381 bfd_putl32 (0, shl->shlptr);
8382 bfd_putl32 (0, shl->ident);
8383 bfd_putl32 (0, shl->permctx);
8384 shl->size = sizeof (struct vms_shl);
8385 bfd_putl16 (0, shl->fill_1);
8386 shl->flags = 0;
8387 bfd_putl32 (0, shl->icb);
8388 shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8389 memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8390 shl->imgnam[0]);
8391
8392 off += sizeof (struct vms_shl);
8393 }
8394
8395 /* CA fixups. */
8396 if (ca_sz != 0)
8397 {
8398 bfd_putl32 (off, eiaf->codeadroff);
8399
8400 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8401 {
8402 struct alpha_vms_shlib_el *shlib;
8403 unsigned int j;
8404
8405 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8406
8407 if (VEC_COUNT (shlib->ca) == 0)
8408 continue;
8409
8410 bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8411 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8412 off += 8;
8413
8414 for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8415 {
8416 bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8417 content + off);
8418 off += 4;
8419 }
8420 }
8421
8422 bfd_putl32 (0, content + off);
8423 bfd_putl32 (0, content + off + 4);
8424 off += 8;
8425 }
8426
8427 /* LP fixups. */
8428 if (lp_sz != 0)
8429 {
8430 bfd_putl32 (off, eiaf->lpfixoff);
8431
8432 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8433 {
8434 struct alpha_vms_shlib_el *shlib;
8435 unsigned int j;
8436
8437 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8438
8439 if (VEC_COUNT (shlib->lp) == 0)
8440 continue;
8441
8442 bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8443 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8444 off += 8;
8445
8446 for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8447 {
8448 bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8449 content + off);
8450 off += 4;
8451 }
8452 }
8453
8454 bfd_putl32 (0, content + off);
8455 bfd_putl32 (0, content + off + 4);
8456 off += 8;
8457 }
8458
8459 /* QR fixups. */
8460 if (qr_sz != 0)
8461 {
8462 bfd_putl32 (off, eiaf->qdotadroff);
8463
8464 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8465 {
8466 struct alpha_vms_shlib_el *shlib;
8467 unsigned int j;
8468
8469 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8470
8471 if (VEC_COUNT (shlib->qr) == 0)
8472 continue;
8473
8474 bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8475 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8476 off += 8;
8477
8478 for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8479 {
8480 struct alpha_vms_vma_ref *r;
8481 r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8482 bfd_putl32 (r->vma - t->base_addr, content + off);
8483 bfd_putl32 (r->ref, content + off + 4);
8484 off += 8;
8485 }
8486 }
8487
8488 bfd_putl32 (0, content + off);
8489 bfd_putl32 (0, content + off + 4);
8490 off += 8;
8491 }
8492
8493 /* CA fixups. */
8494 }
8495
8496 return TRUE;
8497}
8498
f9eeb9c9
TG		 8499/* Called by bfd_link_hash_traverse to fill the symbol table.
8500 Return FALSE in case of failure. */
8501
8502static bfd_boolean
8503alpha_vms_link_output_symbol (struct bfd_link_hash_entry *hc, void *infov)
8504{
8505 struct bfd_link_info *info = (struct bfd_link_info *)infov;
8506 struct alpha_vms_link_hash_entry *h = (struct alpha_vms_link_hash_entry *)hc;
8507 struct vms_symbol_entry *sym;
8508
8509 switch (h->root.type)
8510 {
8511 case bfd_link_hash_new:
8512 case bfd_link_hash_undefined:
8513 abort ();
8514 case bfd_link_hash_undefweak:
8515 return TRUE;
8516 case bfd_link_hash_defined:
8517 case bfd_link_hash_defweak:
8518 {
8519 asection *sec = h->root.u.def.section;
8520
8521 /* FIXME: this is certainly a symbol from a dynamic library. */
8522 if (bfd_is_abs_section (sec))
8523 return TRUE;
8524
8525 if (sec->owner->flags & DYNAMIC)
8526 return TRUE;
8527 }
8528 break;
8529 case bfd_link_hash_common:
8530 break;
8531 case bfd_link_hash_indirect:
8532 case bfd_link_hash_warning:
8533 return TRUE;
8534 }
8535
8536 /* Do not write not kept symbols. */
8537 if (info->strip == strip_some
8538 && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8539 FALSE, FALSE) != NULL)
8540 return TRUE;
8541
8542 if (h->sym == NULL)
8543 {
8544 /* This symbol doesn't come from a VMS object. So we suppose it is
8545 a data. */
8546 int len = strlen (h->root.root.string);
8547
8548 sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8549 sizeof (*sym) + len);
8550 if (sym == NULL)
8551 abort ();
8552 sym->namelen = len;
8553 memcpy (sym->name, h->root.root.string, len);
8554 sym->name[len] = 0;
8555 sym->owner = info->output_bfd;
8556
8557 sym->typ = EGSD__C_SYMG;
8558 sym->data_type = 0;
8559 sym->flags = EGSY__V_DEF | EGSY__V_REL;
8560 sym->symbol_vector = h->root.u.def.value;
8561 sym->section = h->root.u.def.section;
8562 sym->value = h->root.u.def.value;
8563 }
8564 else
8565 sym = h->sym;
8566
8567 if (!add_symbol_entry (info->output_bfd, sym))
8568 return FALSE;
8569
8570 return TRUE;
8571}
8572
95e34ef7
TG		 8573static bfd_boolean
8574alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8575{
8576 asection *o;
8577 struct bfd_link_order *p;
8578 bfd *sub;
8579 asection *fixupsec;
8580 bfd_vma base_addr;
8581 bfd_vma last_addr;
44273c5b 8582 asection *dst;
fa23f0f4 8583 asection *dmt;
95e34ef7
TG		 8584
8585 bfd_get_outsymbols (abfd) = NULL;
8586 bfd_get_symcount (abfd) = 0;
8587
8588 /* Mark all sections which will be included in the output file. */
8589 for (o = abfd->sections; o != NULL; o = o->next)
8590 for (p = o->map_head.link_order; p != NULL; p = p->next)
8591 if (p->type == bfd_indirect_link_order)
8592 p->u.indirect.section->linker_mark = TRUE;
8593
8594#if 0
8595 /* Handle all the link order information for the sections. */
8596 for (o = abfd->sections; o != NULL; o = o->next)
8597 {
8598 printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8599 o->name, (unsigned)o->vma, (unsigned)o->flags);
8600
8601 for (p = o->map_head.link_order; p != NULL; p = p->next)
8602 {
8603 printf (" at 0x%08x - 0x%08x: ",
8604 (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8605 switch (p->type)
8606 {
8607 case bfd_section_reloc_link_order:
8608 case bfd_symbol_reloc_link_order:
8609 printf (" section/symbol reloc\n");
8610 break;
8611 case bfd_indirect_link_order:
8612 printf (" section %s of %s\n",
8613 p->u.indirect.section->name,
8614 p->u.indirect.section->owner->filename);
8615 break;
8616 case bfd_data_link_order:
8617 printf (" explicit data\n");
8618 break;
8619 default:
8620 printf (" *unknown* type %u\n", p->type);
8621 break;
8622 }
8623 }
8624 }
8625#endif
8626
f9eeb9c9
TG		 8627 /* Generate the symbol table. */
8628 BFD_ASSERT (PRIV (syms) == NULL);
8629 if (info->strip != strip_all)
8630 bfd_link_hash_traverse (info->hash, alpha_vms_link_output_symbol, info);
8631
44273c5b 8632 /* Find the entry point. */
95e34ef7
TG		 8633 if (bfd_get_start_address (abfd) == 0)
8634 {
8635 bfd *startbfd = NULL;
8636
8637 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8638 {
8639 /* Consider only VMS object files. */
8640 if (sub->xvec != abfd->xvec)
8641 continue;
8642
8643 if (!PRIV2 (sub, eom_data).eom_has_transfer)
8644 continue;
8645 if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8646 continue;
8647 if (startbfd != NULL
8648 && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8649 {
8650 (*info->callbacks->einfo)
8651 (_("%P: multiple entry points: in modules %B and %B\n"),
8652 startbfd, sub);
8653 continue;
8654 }
8655 startbfd = sub;
8656 }
8657
8658 if (startbfd)
8659 {
8660 unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8661 bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8662 asection *sec;
8663
8664 sec = PRIV2 (startbfd, sections)[ps_idx];
8665
8666 bfd_set_start_address
8667 (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8668 }
8669 }
8670
44273c5b 8671 /* Allocate contents. */
95e34ef7
TG		 8672 base_addr = (bfd_vma)-1;
8673 last_addr = 0;
8674 for (o = abfd->sections; o != NULL; o = o->next)
8675 {
8676 if (o->flags & SEC_HAS_CONTENTS)
8677 {
8678 o->contents = bfd_alloc (abfd, o->size);
8679 if (o->contents == NULL)
8680 return FALSE;
8681 }
8682 if (o->flags & SEC_LOAD)
8683 {
8684 if (o->vma < base_addr)
8685 base_addr = o->vma;
8686 if (o->vma + o->size > last_addr)
8687 last_addr = o->vma + o->size;
8688 }
8689 }
8690
44273c5b 8691 /* Create the fixup section. */
95e34ef7
TG		 8692 fixupsec = bfd_make_section_anyway_with_flags
8693 (info->output_bfd, "$FIXUP$",
8694 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8695 if (fixupsec == NULL)
8696 return FALSE;
8697 last_addr = (last_addr + 0xffff) & ~0xffff;
8698 fixupsec->vma = last_addr;
8699
8700 alpha_vms_link_hash (info)->fixup = fixupsec;
8701 alpha_vms_link_hash (info)->base_addr = base_addr;
8702
fa23f0f4 8703 /* Create the DMT section, if necessary. */
f9eeb9c9
TG		 8704 BFD_ASSERT (PRIV (dst_section) == NULL);
8705 dst = bfd_get_section_by_name (abfd, "$DST$");
fa23f0f4
TG		 8706 if (dst != NULL && dst->size == 0)
8707 dst = NULL;
8708 if (dst != NULL)
8709 {
f9eeb9c9 8710 PRIV (dst_section) = dst;
fa23f0f4
TG		 8711 dmt = bfd_make_section_anyway_with_flags
8712 (info->output_bfd, "$DMT$",
8713 SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8714 if (dmt == NULL)
8715 return FALSE;
8716 }
8717 else
8718 dmt = NULL;
8719
95e34ef7
TG		 8720 /* Read all sections from the inputs. */
8721 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8722 {
8723 if (sub->flags & DYNAMIC)
8724 {
8725 alpha_vms_create_eisd_for_shared (abfd, sub);
8726 continue;
8727 }
8728
8729 if (!alpha_vms_read_sections_content (sub, info))
8730 return FALSE;
8731 }
8732
fa23f0f4
TG		 8733 /* Handle all the link order information for the sections.
8734 Note: past this point, it is not possible to create new sections. */
95e34ef7
TG		 8735 for (o = abfd->sections; o != NULL; o = o->next)
8736 {
8737 for (p = o->map_head.link_order; p != NULL; p = p->next)
8738 {
8739 switch (p->type)
8740 {
8741 case bfd_section_reloc_link_order:
8742 case bfd_symbol_reloc_link_order:
8743 abort ();
8744 return FALSE;
8745 case bfd_indirect_link_order:
8746 /* Already done. */
8747 break;
8748 default:
8749 if (! _bfd_default_link_order (abfd, info, o, p))
8750 return FALSE;
8751 break;
8752 }
8753 }
8754 }
8755
8756 /* Compute fixups. */
8757 if (!alpha_vms_build_fixups (info))
8758 return FALSE;
8759
44273c5b 8760 /* Compute the DMT. */
fa23f0f4 8761 if (dmt != NULL)
44273c5b 8762 {
44273c5b
TG		 8763 int pass;
8764 unsigned char *contents = NULL;
8765
44273c5b
TG		 8766 /* In pass 1, compute the size. In pass 2, write the DMT contents. */
8767 for (pass = 0; pass < 2; pass++)
8768 {
8769 unsigned int off = 0;
8770
8771 /* For each object file (ie for each module). */
8772 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8773 {
8774 asection *sub_dst;
8775 struct vms_dmt_header *dmth = NULL;
8776 unsigned int psect_count;
8777
8778 /* Skip this module if it has no DST. */
8779 sub_dst = PRIV2 (sub, dst_section);
8780 if (sub_dst == NULL || sub_dst->size == 0)
8781 continue;
8782
8783 if (pass == 1)
8784 {
8785 /* Write the header. */
8786 dmth = (struct vms_dmt_header *)(contents + off);
8787 bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8788 bfd_putl32 (sub_dst->size, dmth->size);
8789 }
8790
8791 off += sizeof (struct vms_dmt_header);
8792 psect_count = 0;
8793
8794 /* For each section (ie for each psect). */
8795 for (o = sub->sections; o != NULL; o = o->next)
8796 {
8797 /* Only consider interesting sections. */
8798 if (!(o->flags & SEC_ALLOC))
8799 continue;
8800 if (o->flags & SEC_LINKER_CREATED)
8801 continue;
8802
8803 if (pass == 1)
8804 {
8805 /* Write an entry. */
8806 struct vms_dmt_psect *dmtp;
8807
8808 dmtp = (struct vms_dmt_psect *)(contents + off);
8809 bfd_putl32 (o->output_offset + o->output_section->vma,
8810 dmtp->start);
8811 bfd_putl32 (o->size, dmtp->length);
8812 psect_count++;
8813 }
8814 off += sizeof (struct vms_dmt_psect);
8815 }
8816 if (pass == 1)
8817 bfd_putl32 (psect_count, dmth->psect_count);
8818 }
8819
8820 if (pass == 0)
8821 {
8822 contents = bfd_zalloc (info->output_bfd, off);
8823 if (contents == NULL)
8824 return FALSE;
8825 dmt->contents = contents;
8826 dmt->size = off;
8827 }
8828 else
8829 {
8830 BFD_ASSERT (off == dmt->size);
8831 }
8832 }
8833 }
8834
95e34ef7
TG		 8835 return TRUE;
8836}
8837
8838/* Read the contents of a section.
8839 buf points to a buffer of buf_size bytes to be filled with
8840 section data (starting at offset into section) */
8841
8842static bfd_boolean
8843alpha_vms_get_section_contents (bfd *abfd, asection *section,
8844 void *buf, file_ptr offset,
8845 bfd_size_type count)
8846{
8847 asection *sec;
8848
8849 /* Image are easy. */
8850 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8851 return _bfd_generic_get_section_contents (abfd, section,
8852 buf, offset, count);
8853
8854 /* Safety check. */
8855 if (offset + count < count
8856 || offset + count > section->size)
8857 {
8858 bfd_set_error (bfd_error_invalid_operation);
8859 return FALSE;
8860 }
8861
8862 /* Alloc in memory and read ETIRs. */
8863 BFD_ASSERT (section->contents == NULL);
8864
8865 for (sec = abfd->sections; sec; sec = sec->next)
8866 {
8867 BFD_ASSERT (sec->contents == NULL);
8868
8869 if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
8870 {
8871 sec->contents = bfd_alloc (abfd, sec->size);
8872 if (sec->contents == NULL)
8873 return FALSE;
8874 }
8875 }
8876 if (!alpha_vms_read_sections_content (abfd, NULL))
8877 return FALSE;
8878 for (sec = abfd->sections; sec; sec = sec->next)
8879 if (section->contents)
8880 section->flags |= SEC_IN_MEMORY;
8881 memcpy (buf, section->contents + offset, count);
8882 return TRUE;
8883}
8884
8885
8886/* Set the format of a file being written. */
8887
8888static bfd_boolean
8889alpha_vms_mkobject (bfd * abfd)
8890{
8891 const bfd_arch_info_type *arch;
8892
8893 vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
8894
8895 if (!vms_initialize (abfd))
8896 return FALSE;
8897
8898 PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
8899 if (PRIV (recwr.buf) == NULL)
8900 return FALSE;
8901
8902 arch = bfd_scan_arch ("alpha");
8903
8904 if (arch == 0)
8905 {
8906 bfd_set_error (bfd_error_wrong_format);
8907 return FALSE;
8908 }
8909
8910 abfd->arch_info = arch;
8911 return TRUE;
8912}
8913
8914
8915/* 4.1, generic. */
8916
8917/* Called when the BFD is being closed to do any necessary cleanup. */
8918
8919static bfd_boolean
8920vms_close_and_cleanup (bfd * abfd)
8921{
8922 vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
8923
8924 if (abfd == NULL || abfd->tdata.any == NULL)
8925 return TRUE;
8926
8927 if (abfd->format == bfd_archive)
8928 {
8929 bfd_release (abfd, abfd->tdata.any);
8930 abfd->tdata.any = NULL;
8931 return TRUE;
8932 }
8933
8934 if (PRIV (recrd.buf) != NULL)
8935 free (PRIV (recrd.buf));
8936
8937 if (PRIV (sections) != NULL)
8938 free (PRIV (sections));
8939
8940 bfd_release (abfd, abfd->tdata.any);
8941 abfd->tdata.any = NULL;
8942
8943#ifdef VMS
8944 if (abfd->direction == write_direction)
8945 {
8946 /* Last step on VMS is to convert the file to variable record length
8947 format. */
8948 if (bfd_cache_close (abfd) != TRUE)
8949 return FALSE;
9fcd9da6 8950 if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
95e34ef7
TG		 8951 return FALSE;
8952 }
8953#endif
8954
8955 return TRUE;
8956}
8957
8958/* Called when a new section is created. */
8959
8960static bfd_boolean
8961vms_new_section_hook (bfd * abfd, asection *section)
8962{
8963 bfd_size_type amt;
8964
c734eb83
TG		 8965 vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
8966 abfd, section->index, section->name));
95e34ef7
TG		 8967
8968 bfd_set_section_alignment (abfd, section, 0);
8969
95e34ef7
TG		 8970 vms_debug2 ((7, "%d: %s\n", section->index, section->name));
8971
8972 amt = sizeof (struct vms_section_data_struct);
8973 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
8974 if (section->used_by_bfd == NULL)
8975 return FALSE;
8976
95e34ef7
TG		 8977 /* Create the section symbol. */
8978 return _bfd_generic_new_section_hook (abfd, section);
8979}
8980
8981/* Part 4.5, symbols. */
8982
8983/* Print symbol to file according to how. how is one of
8984 bfd_print_symbol_name just print the name
8985 bfd_print_symbol_more print more (???)
8986 bfd_print_symbol_all print all we know, which is not much right now :-). */
8987
8988static void
8989vms_print_symbol (bfd * abfd,
8990 void * file,
8991 asymbol *symbol,
8992 bfd_print_symbol_type how)
8993{
8994 vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
8995 abfd, file, symbol, how));
8996
8997 switch (how)
8998 {
8999 case bfd_print_symbol_name:
9000 case bfd_print_symbol_more:
9001 fprintf ((FILE *)file," %s", symbol->name);
9002 break;
9003
9004 case bfd_print_symbol_all:
9005 {
9006 const char *section_name = symbol->section->name;
9007
9008 bfd_print_symbol_vandf (abfd, file, symbol);
9009
9010 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9011 }
9012 break;
9013 }
9014}
9015
9016/* Return information about symbol in ret.
9017
9018 fill type, value and name
9019 type:
9020 A absolute
9021 B bss segment symbol
9022 C common symbol
9023 D data segment symbol
9024 f filename
9025 t a static function symbol
9026 T text segment symbol
9027 U undefined
9028 - debug. */
9029
9030static void
9031vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9032 asymbol *symbol,
9033 symbol_info *ret)
9034{
9035 asection *sec;
9036
9037 vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9038
9039 sec = symbol->section;
9040
9041 if (ret == NULL)
9042 return;
9043
a928f1d7 9044 if (sec == NULL)
95e34ef7
TG		 9045 ret->type = 'U';
9046 else if (bfd_is_com_section (sec))
9047 ret->type = 'C';
9048 else if (bfd_is_abs_section (sec))
9049 ret->type = 'A';
9050 else if (bfd_is_und_section (sec))
9051 ret->type = 'U';
9052 else if (bfd_is_ind_section (sec))
9053 ret->type = 'I';
c068d5be
TG		 9054 else if ((symbol->flags & BSF_FUNCTION)
9055 || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
95e34ef7
TG		 9056 ret->type = 'T';
9057 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9058 ret->type = 'D';
9059 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9060 ret->type = 'B';
9061 else
9062 ret->type = '-';
9063
9064 if (ret->type != 'U')
9065 ret->value = symbol->value + symbol->section->vma;
9066 else
9067 ret->value = 0;
9068 ret->name = symbol->name;
9069}
9070
9071/* Return TRUE if the given symbol sym in the BFD abfd is
9072 a compiler generated local label, else return FALSE. */
9073
9074static bfd_boolean
9075vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9076 const char *name)
9077{
9078 vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
9079 return name[0] == '$';
9080}
9081\f
9082/* Part 4.7, writing an object file. */
9083
9084/* Sets the contents of the section section in BFD abfd to the data starting
9085 in memory at LOCATION. The data is written to the output section starting
9086 at offset offset for count bytes.
9087
9088 Normally TRUE is returned, else FALSE. Possible error returns are:
9089 o bfd_error_no_contents - The output section does not have the
9090 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9091 o and some more too */
9092
9093static bfd_boolean
9094_bfd_vms_set_section_contents (bfd * abfd,
9095 asection *section,
9096 const void * location,
9097 file_ptr offset,
9098 bfd_size_type count)
9099{
9100 if (section->contents == NULL)
9101 {
9102 section->contents = bfd_alloc (abfd, section->size);
9103 if (section->contents == NULL)
9104 return FALSE;
9105
9106 memcpy (section->contents + offset, location, (size_t) count);
9107 }
9108
9109 return TRUE;
9110}
9111
9112/* Set the architecture and machine type in BFD abfd to arch and mach.
9113 Find the correct pointer to a structure and insert it into the arch_info
9114 pointer. */
9115
9116static bfd_boolean
9117alpha_vms_set_arch_mach (bfd *abfd,
9118 enum bfd_architecture arch, unsigned long mach)
9119{
9120 if (arch != bfd_arch_alpha
9121 && arch != bfd_arch_unknown)
9122 return FALSE;
9123
9124 return bfd_default_set_arch_mach (abfd, arch, mach);
9125}
9126
9127/* Set section VMS flags. Clear NO_FLAGS and set FLAGS. */
9128
9129void
9130bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9131 asection *sec, flagword no_flags, flagword flags)
9132{
9133 vms_section_data (sec)->no_flags = no_flags;
9134 vms_section_data (sec)->flags = flags;
9135}
9136
9137struct vms_private_data_struct *
9138bfd_vms_get_data (bfd *abfd)
9139{
9140 return (struct vms_private_data_struct *)abfd->tdata.any;
9141}
9142
9143#define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9144#define vms_bfd_link_just_syms _bfd_generic_link_just_syms
9145#define vms_bfd_copy_link_hash_symbol_type \
9146 _bfd_generic_copy_link_hash_symbol_type
9147#define vms_bfd_is_group_section bfd_generic_is_group_section
9148#define vms_bfd_discard_group bfd_generic_discard_group
9149#define vms_section_already_linked _bfd_generic_section_already_linked
9150#define vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9151#define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
9152
9153#define vms_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
9154#define vms_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
9155#define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9156#define vms_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
9157#define vms_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
9158#define vms_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
9159
9160/* Symbols table. */
9161#define alpha_vms_make_empty_symbol _bfd_generic_make_empty_symbol
9162#define alpha_vms_bfd_is_target_special_symbol \
9163 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9164#define alpha_vms_print_symbol vms_print_symbol
9165#define alpha_vms_get_symbol_info vms_get_symbol_info
9166#define alpha_vms_read_minisymbols _bfd_generic_read_minisymbols
9167#define alpha_vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
9168#define alpha_vms_get_lineno _bfd_nosymbols_get_lineno
9169#define alpha_vms_find_inliner_info _bfd_nosymbols_find_inliner_info
9170#define alpha_vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
9171#define alpha_vms_find_nearest_line _bfd_vms_find_nearest_dst_line
9172#define alpha_vms_bfd_is_local_label_name vms_bfd_is_local_label_name
9173
9174/* Generic table. */
9175#define alpha_vms_close_and_cleanup vms_close_and_cleanup
9176#define alpha_vms_bfd_free_cached_info vms_bfd_free_cached_info
9177#define alpha_vms_new_section_hook vms_new_section_hook
9178#define alpha_vms_set_section_contents _bfd_vms_set_section_contents
9179#define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9180
9181#define alpha_vms_bfd_get_relocated_section_contents \
9182 bfd_generic_get_relocated_section_contents
9183
9184#define alpha_vms_bfd_relax_section bfd_generic_relax_section
9185#define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9186#define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9187#define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9188#define alpha_vms_bfd_discard_group bfd_generic_discard_group
9189#define alpha_vms_section_already_linked \
9190 _bfd_generic_section_already_linked
9191
9192#define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9193#define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
9194#define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9195#define alpha_vms_bfd_copy_link_hash_symbol_type \
9196 _bfd_generic_copy_link_hash_symbol_type
9197
9198#define alpha_vms_bfd_link_split_section _bfd_generic_link_split_section
9199
9200#define alpha_vms_get_dynamic_symtab_upper_bound \
9201 _bfd_nodynamic_get_dynamic_symtab_upper_bound
9202#define alpha_vms_canonicalize_dynamic_symtab \
9203 _bfd_nodynamic_canonicalize_dynamic_symtab
9204#define alpha_vms_get_dynamic_reloc_upper_bound \
9205 _bfd_nodynamic_get_dynamic_reloc_upper_bound
9206#define alpha_vms_canonicalize_dynamic_reloc \
9207 _bfd_nodynamic_canonicalize_dynamic_reloc
9208
9209const bfd_target vms_alpha_vec =
9210{
9211 "vms-alpha", /* Name. */
9212 bfd_target_evax_flavour,
9213 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
9214 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
9215
9216 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9217 | WP_TEXT | D_PAGED), /* Object flags. */
9218 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9219 | SEC_READONLY | SEC_CODE | SEC_DATA
9220 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
9221 0, /* symbol_leading_char. */
9222 ' ', /* ar_pad_char. */
9223 15, /* ar_max_namelen. */
9224 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9225 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9226 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9227 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9228 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9229 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9230
9231 {_bfd_dummy_target, alpha_vms_object_p, /* bfd_check_format. */
9232 _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9233 {bfd_false, alpha_vms_mkobject, /* bfd_set_format. */
7d5ee7d7 9234 _bfd_vms_lib_alpha_mkarchive, bfd_false},
95e34ef7
TG		 9235 {bfd_false, alpha_vms_write_object_contents, /* bfd_write_contents. */
9236 _bfd_vms_lib_write_archive_contents, bfd_false},
9237
9238 BFD_JUMP_TABLE_GENERIC (alpha_vms),
9239 BFD_JUMP_TABLE_COPY (vms),
9240 BFD_JUMP_TABLE_CORE (_bfd_nocore),
9241 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9242 BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9243 BFD_JUMP_TABLE_RELOCS (alpha_vms),
9244 BFD_JUMP_TABLE_WRITE (alpha_vms),
9245 BFD_JUMP_TABLE_LINK (alpha_vms),
9246 BFD_JUMP_TABLE_DYNAMIC (alpha_vms),
9247
9248 NULL,
9249
9250 (PTR) 0
9251};
GDB Binutils - Deliverables
This page took 0.404492 seconds and 4 git commands to generate.