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