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