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