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