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