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