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