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