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