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