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