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