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