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