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