?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2011-05-25 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / vms-alpha.c
blob3adc00fe3694debb9ae7770e881fed2f362192ce
1 /* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4
5 Initial version written by Klaus Kaempf (kkaempf@rmi.de)
6 Major rewrite by Adacore.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 /* TODO:
24 o overlayed sections
25 o PIC
26 o Generation of shared image
27 o Relocation optimizations
28 o EISD for the stack
29 o Vectors isect
30 o 64 bits sections
31 o Entry point
32 o LIB$INITIALIZE
33 o protected sections (for messages)
34 ...
35 */
36
37 #include "sysdep.h"
38 #include "bfd.h"
39 #include "bfdlink.h"
40 #include "libbfd.h"
41 #include "bfdver.h"
42
43 #include "vms.h"
44 #include "vms/eihd.h"
45 #include "vms/eiha.h"
46 #include "vms/eihi.h"
47 #include "vms/eihs.h"
48 #include "vms/eisd.h"
49 #include "vms/dmt.h"
50 #include "vms/dst.h"
51 #include "vms/eihvn.h"
52 #include "vms/eobjrec.h"
53 #include "vms/egsd.h"
54 #include "vms/egps.h"
55 #include "vms/esgps.h"
56 #include "vms/eeom.h"
57 #include "vms/emh.h"
58 #include "vms/eiaf.h"
59 #include "vms/shl.h"
60 #include "vms/eicp.h"
61 #include "vms/etir.h"
62 #include "vms/egsy.h"
63 #include "vms/esdf.h"
64 #include "vms/esdfm.h"
65 #include "vms/esdfv.h"
66 #include "vms/esrf.h"
67 #include "vms/egst.h"
68 #include "vms/eidc.h"
69 #include "vms/dsc.h"
70 #include "vms/prt.h"
71 #include "vms/internal.h"
72 \f
73
74 #define MIN(a,b) ((a) < (b) ? (a) : (b))
75
76 /* The r_type field in a reloc is one of the following values. */
77 #define ALPHA_R_IGNORE 0
78 #define ALPHA_R_REFQUAD 1
79 #define ALPHA_R_BRADDR 2
80 #define ALPHA_R_HINT 3
81 #define ALPHA_R_SREL16 4
82 #define ALPHA_R_SREL32 5
83 #define ALPHA_R_SREL64 6
84 #define ALPHA_R_OP_PUSH 7
85 #define ALPHA_R_OP_STORE 8
86 #define ALPHA_R_OP_PSUB 9
87 #define ALPHA_R_OP_PRSHIFT 10
88 #define ALPHA_R_LINKAGE 11
89 #define ALPHA_R_REFLONG 12
90 #define ALPHA_R_CODEADDR 13
91 #define ALPHA_R_NOP 14
92 #define ALPHA_R_BSR 15
93 #define ALPHA_R_LDA 16
94 #define ALPHA_R_BOH 17
95
96 /* These are used with DST_S_C_LINE_NUM. */
97 #define DST_S_C_LINE_NUM_HEADER_SIZE 4
98
99 /* These are used with DST_S_C_SOURCE */
100
101 #define DST_S_B_PCLINE_UNSBYTE 1
102 #define DST_S_W_PCLINE_UNSWORD 1
103 #define DST_S_L_PCLINE_UNSLONG 1
104
105 #define DST_S_B_MODBEG_NAME 14
106 #define DST_S_L_RTNBEG_ADDRESS 5
107 #define DST_S_B_RTNBEG_NAME 13
108 #define DST_S_L_RTNEND_SIZE 5
109
110 /* These are used with DST_S_C_SOURCE. */
111 #define DST_S_C_SOURCE_HEADER_SIZE 4
112
113 #define DST_S_B_SRC_DF_LENGTH 1
114 #define DST_S_W_SRC_DF_FILEID 3
115 #define DST_S_B_SRC_DF_FILENAME 20
116 #define DST_S_B_SRC_UNSBYTE 1
117 #define DST_S_W_SRC_UNSWORD 1
118 #define DST_S_L_SRC_UNSLONG 1
119
120 /* Debugger symbol definitions. */
121
122 #define DBG_S_L_DMT_MODBEG 0
123 #define DBG_S_L_DST_SIZE 4
124 #define DBG_S_W_DMT_PSECT_COUNT 8
125 #define DBG_S_C_DMT_HEADER_SIZE 12
126
127 #define DBG_S_L_DMT_PSECT_START 0
128 #define DBG_S_L_DMT_PSECT_LENGTH 4
129 #define DBG_S_C_DMT_PSECT_SIZE 8
130
131 /* VMS module header. */
132
133 struct hdr_struct
134 {
135 char hdr_b_strlvl;
136 int hdr_l_arch1;
137 int hdr_l_arch2;
138 int hdr_l_recsiz;
139 char *hdr_t_name;
140 char *hdr_t_version;
141 char *hdr_t_date;
142 char *hdr_c_lnm;
143 char *hdr_c_src;
144 char *hdr_c_ttl;
145 };
146
147 #define EMH_DATE_LENGTH 17
148
149 /* VMS End-Of-Module records (EOM/EEOM). */
150
151 struct eom_struct
152 {
153 unsigned int eom_l_total_lps;
154 unsigned short eom_w_comcod;
155 bfd_boolean eom_has_transfer;
156 unsigned char eom_b_tfrflg;
157 unsigned int eom_l_psindx;
158 unsigned int eom_l_tfradr;
159 };
160
161 struct vms_symbol_entry
162 {
163 bfd *owner;
164
165 /* Common fields. */
166 unsigned char typ;
167 unsigned char data_type;
168 unsigned short flags;
169
170 /* Section and offset/value of the symbol. */
171 unsigned int value;
172 asection *section;
173
174 /* Section and offset/value for the entry point (only for subprg). */
175 asection *code_section;
176 unsigned int code_value;
177
178 /* Symbol vector offset. */
179 unsigned int symbol_vector;
180
181 /* Length of the name. */
182 unsigned char namelen;
183
184 char name[1];
185 };
186
187 /* Stack value for push/pop commands. */
188
189 struct stack_struct
190 {
191 bfd_vma value;
192 unsigned int reloc;
193 };
194
195 #define STACKSIZE 128
196
197 /* A minimal decoding of DST compilation units. We only decode
198 what's needed to get to the line number information. */
199
200 struct fileinfo
201 {
202 char *name;
203 unsigned int srec;
204 };
205
206 struct srecinfo
207 {
208 struct srecinfo *next;
209 unsigned int line;
210 unsigned int sfile;
211 unsigned int srec;
212 };
213
214 struct lineinfo
215 {
216 struct lineinfo *next;
217 bfd_vma address;
218 unsigned int line;
219 };
220
221 struct funcinfo
222 {
223 struct funcinfo *next;
224 char *name;
225 bfd_vma low;
226 bfd_vma high;
227 };
228
229 struct module
230 {
231 /* Chain the previously read compilation unit. */
232 struct module *next;
233
234 /* The module name. */
235 char *name;
236
237 /* The start offset and size of debug info in the DST section. */
238 unsigned int modbeg;
239 unsigned int size;
240
241 /* The lowest and highest addresses contained in this compilation
242 unit as specified in the compilation unit header. */
243 bfd_vma low;
244 bfd_vma high;
245
246 /* The listing line table. */
247 struct lineinfo *line_table;
248
249 /* The source record table. */
250 struct srecinfo *srec_table;
251
252 /* A list of the functions found in this module. */
253 struct funcinfo *func_table;
254
255 /* Current allocation of file_table. */
256 unsigned int file_table_count;
257
258 /* An array of the files making up this module. */
259 struct fileinfo *file_table;
260 };
261
262 /* BFD private data for alpha-vms. */
263
264 struct vms_private_data_struct
265 {
266 /* If true, relocs have been read. */
267 bfd_boolean reloc_done;
268
269 /* Record input buffer. */
270 struct vms_rec_rd recrd;
271 struct vms_rec_wr recwr;
272
273 struct hdr_struct hdr_data; /* data from HDR/EMH record */
274 struct eom_struct eom_data; /* data from EOM/EEOM record */
275
276 /* Transfer addresses (entry points). */
277 bfd_vma transfer_address[4];
278
279 /* Array of GSD sections to get the correspond BFD one. */
280 unsigned int section_max; /* Size of the sections array. */
281 unsigned int section_count; /* Number of GSD sections. */
282 asection **sections;
283
284 /* Array of raw symbols. */
285 struct vms_symbol_entry **syms;
286
287 /* Canonicalized symbols. */
288 asymbol **csymbols;
289
290 /* Number of symbols. */
291 unsigned int gsd_sym_count;
292 /* Size of the syms array. */
293 unsigned int max_sym_count;
294 /* Number of procedure symbols. */
295 unsigned int norm_sym_count;
296
297 /* Stack used to evaluate TIR/ETIR commands. */
298 struct stack_struct *stack;
299 int stackptr;
300
301 /* Content reading. */
302 asection *image_section; /* section for image_ptr */
303 file_ptr image_offset; /* Offset for image_ptr. */
304
305 struct module *modules; /* list of all compilation units */
306
307 /* 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 libaries. */
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,
3978 (unsigned long) udata->enbsym->section->target_index);
3979 _bfd_vms_output_quad (recwr, rptr->address);
3980 _bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
3981 _bfd_vms_output_long
3982 (recwr,
3983 (unsigned long) udata->enbsym->section->target_index);
3984 _bfd_vms_output_quad (recwr, rptr->addend);
3985 _bfd_vms_output_counted
3986 (recwr, _bfd_vms_length_hash_symbol
3987 (abfd, udata->origname, EOBJ__C_SYMSIZ));
3988 _bfd_vms_output_end_subrec (recwr);
3989 break;
3990
3991 case ALPHA_R_BSR:
3992 (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
3993 break;
3994
3995 case ALPHA_R_LDA:
3996 udata
3997 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
3998 etir_output_check (abfd, section, curr_addr,
3999 32 + 1 + strlen (udata->origname));
4000 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LDA_GBL);
4001 _bfd_vms_output_long
4002 (recwr, (unsigned long) udata->lkindex + 1);
4003 _bfd_vms_output_long
4004 (recwr,
4005 (unsigned long) udata->enbsym->section->target_index);
4006 _bfd_vms_output_quad (recwr, rptr->address);
4007 _bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
4008 _bfd_vms_output_long
4009 (recwr, (unsigned long) udata->bsym->section->target_index);
4010 _bfd_vms_output_quad (recwr, rptr->addend);
4011 _bfd_vms_output_counted
4012 (recwr, _bfd_vms_length_hash_symbol
4013 (abfd, udata->origname, EOBJ__C_SYMSIZ));
4014 _bfd_vms_output_end_subrec (recwr);
4015 break;
4016
4017 case ALPHA_R_BOH:
4018 udata
4019 = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
4020 etir_output_check (abfd, section, curr_addr,
4021 32 + 1 + strlen (udata->origname));
4022 _bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
4023 _bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
4024 _bfd_vms_output_long
4025 (recwr,
4026 (unsigned long) udata->enbsym->section->target_index);
4027 _bfd_vms_output_quad (recwr, rptr->address);
4028 _bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
4029 _bfd_vms_output_long
4030 (recwr,
4031 (unsigned long) udata->enbsym->section->target_index);
4032 _bfd_vms_output_quad (recwr, rptr->addend);
4033 _bfd_vms_output_counted
4034 (recwr, _bfd_vms_length_hash_symbol
4035 (abfd, udata->origname, EOBJ__C_SYMSIZ));
4036 _bfd_vms_output_end_subrec (recwr);
4037 break;
4038
4039 default:
4040 (*_bfd_error_handler) (_("Unhandled relocation %s"),
4041 rptr->howto->name);
4042 break;
4043 }
4044
4045 curr_data += size;
4046 curr_addr += size;
4047 } /* End of relocs loop. */
4048
4049 if (!pass2_in_progress)
4050 {
4051 /* Output rest of section. */
4052 if (curr_addr > section->size)
4053 (*_bfd_error_handler) (_("Size error in section %s"),
4054 section->name);
4055 size = section->size - curr_addr;
4056 sto_imm (abfd, section, size, curr_data, curr_addr);
4057 curr_data += size;
4058 curr_addr += size;
4059
4060 if (pass2_needed)
4061 {
4062 pass2_in_progress = 1;
4063 goto new_pass;
4064 }
4065 }
4066 }
4067
4068 else /* (section->flags & SEC_RELOC) */
4069 sto_imm (abfd, section, section->size, section->contents, 0);
4070
4071 end_etir_record (abfd);
4072 }
4073
4074 _bfd_vms_output_alignment (recwr, 2);
4075 return TRUE;
4076 }
4077
4078 /* Write cached information into a file being written, at bfd_close. */
4079
4080 static bfd_boolean
4081 alpha_vms_write_object_contents (bfd *abfd)
4082 {
4083 vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
4084
4085 if (abfd->flags & (EXEC_P | DYNAMIC))
4086 {
4087 return alpha_vms_write_exec (abfd);
4088 }
4089 else
4090 {
4091 if (abfd->section_count > 0) /* we have sections */
4092 {
4093 if (_bfd_vms_write_ehdr (abfd) != TRUE)
4094 return FALSE;
4095 if (_bfd_vms_write_egsd (abfd) != TRUE)
4096 return FALSE;
4097 if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
4098 return FALSE;
4099 if (_bfd_vms_write_eeom (abfd) != TRUE)
4100 return FALSE;
4101 }
4102 }
4103 return TRUE;
4104 }
4105 \f
4106 /* Debug stuff: nearest line. */
4107
4108 #define SET_MODULE_PARSED(m) \
4109 do { if ((m)->name == NULL) (m)->name = ""; } while (0)
4110 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
4111
4112 /* Build a new module for the specified BFD. */
4113
4114 static struct module *
4115 new_module (bfd *abfd)
4116 {
4117 struct module *module
4118 = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
4119 module->file_table_count = 16; /* Arbitrary. */
4120 module->file_table
4121 = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
4122 return module;
4123 }
4124
4125 /* Parse debug info for a module and internalize it. */
4126
4127 static void
4128 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
4129 int length)
4130 {
4131 unsigned char *maxptr = ptr + length;
4132 unsigned char *src_ptr, *pcl_ptr;
4133 unsigned int prev_linum = 0, curr_linenum = 0;
4134 bfd_vma prev_pc = 0, curr_pc = 0;
4135 struct srecinfo *curr_srec, *srec;
4136 struct lineinfo *curr_line, *line;
4137 struct funcinfo *funcinfo;
4138
4139 /* Initialize tables with zero element. */
4140 curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4141 module->srec_table = curr_srec;
4142
4143 curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4144 module->line_table = curr_line;
4145
4146 while (length == -1 || ptr < maxptr)
4147 {
4148 /* The first byte is not counted in the recorded length. */
4149 int rec_length = bfd_getl16 (ptr) + 1;
4150 int rec_type = bfd_getl16 (ptr + 2);
4151
4152 vms_debug2 ((2, "DST record: leng %d, type %d\n", rec_length, rec_type));
4153
4154 if (length == -1 && rec_type == DST__K_MODEND)
4155 break;
4156
4157 switch (rec_type)
4158 {
4159 case DST__K_MODBEG:
4160 module->name
4161 = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
4162
4163 curr_pc = 0;
4164 prev_pc = 0;
4165 curr_linenum = 0;
4166 prev_linum = 0;
4167
4168 vms_debug2 ((3, "module: %s\n", module->name));
4169 break;
4170
4171 case DST__K_MODEND:
4172 break;
4173
4174 case DST__K_RTNBEG:
4175 funcinfo = (struct funcinfo *)
4176 bfd_zalloc (abfd, sizeof (struct funcinfo));
4177 funcinfo->name
4178 = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
4179 funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
4180 funcinfo->next = module->func_table;
4181 module->func_table = funcinfo;
4182
4183 vms_debug2 ((3, "routine: %s at 0x%lx\n",
4184 funcinfo->name, (unsigned long) funcinfo->low));
4185 break;
4186
4187 case DST__K_RTNEND:
4188 module->func_table->high = module->func_table->low
4189 + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
4190
4191 if (module->func_table->high > module->high)
4192 module->high = module->func_table->high;
4193
4194 vms_debug2 ((3, "end routine\n"));
4195 break;
4196
4197 case DST__K_PROLOG:
4198 vms_debug2 ((3, "prologue\n"));
4199 break;
4200
4201 case DST__K_EPILOG:
4202 vms_debug2 ((3, "epilog\n"));
4203 break;
4204
4205 case DST__K_BLKBEG:
4206 vms_debug2 ((3, "block\n"));
4207 break;
4208
4209 case DST__K_BLKEND:
4210 vms_debug2 ((3, "end block\n"));
4211 break;
4212
4213 case DST__K_SOURCE:
4214 src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
4215
4216 vms_debug2 ((3, "source info\n"));
4217
4218 while (src_ptr < ptr + rec_length)
4219 {
4220 int cmd = src_ptr[0], cmd_length, data;
4221
4222 switch (cmd)
4223 {
4224 case DST__K_SRC_DECLFILE:
4225 {
4226 unsigned int fileid
4227 = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
4228 char *filename
4229 = _bfd_vms_save_counted_string (src_ptr
4230 + DST_S_B_SRC_DF_FILENAME);
4231
4232 while (fileid >= module->file_table_count)
4233 {
4234 module->file_table_count *= 2;
4235 module->file_table
4236 = bfd_realloc (module->file_table,
4237 module->file_table_count
4238 * sizeof (struct fileinfo));
4239 }
4240
4241 module->file_table [fileid].name = filename;
4242 module->file_table [fileid].srec = 1;
4243 cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
4244 vms_debug2 ((4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
4245 fileid, module->file_table [fileid].name));
4246 }
4247 break;
4248
4249 case DST__K_SRC_DEFLINES_B:
4250 /* Perform the association and set the next higher index
4251 to the limit. */
4252 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4253 srec = (struct srecinfo *)
4254 bfd_zalloc (abfd, sizeof (struct srecinfo));
4255 srec->line = curr_srec->line + data;
4256 srec->srec = curr_srec->srec + data;
4257 srec->sfile = curr_srec->sfile;
4258 curr_srec->next = srec;
4259 curr_srec = srec;
4260 cmd_length = 2;
4261 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_B: %d\n", data));
4262 break;
4263
4264 case DST__K_SRC_DEFLINES_W:
4265 /* Perform the association and set the next higher index
4266 to the limit. */
4267 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4268 srec = (struct srecinfo *)
4269 bfd_zalloc (abfd, sizeof (struct srecinfo));
4270 srec->line = curr_srec->line + data;
4271 srec->srec = curr_srec->srec + data,
4272 srec->sfile = curr_srec->sfile;
4273 curr_srec->next = srec;
4274 curr_srec = srec;
4275 cmd_length = 3;
4276 vms_debug2 ((4, "DST_S_C_SRC_DEFLINES_W: %d\n", data));
4277 break;
4278
4279 case DST__K_SRC_INCRLNUM_B:
4280 data = src_ptr[DST_S_B_SRC_UNSBYTE];
4281 curr_srec->line += data;
4282 cmd_length = 2;
4283 vms_debug2 ((4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data));
4284 break;
4285
4286 case DST__K_SRC_SETFILE:
4287 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4288 curr_srec->sfile = data;
4289 curr_srec->srec = module->file_table[data].srec;
4290 cmd_length = 3;
4291 vms_debug2 ((4, "DST_S_C_SRC_SETFILE: %d\n", data));
4292 break;
4293
4294 case DST__K_SRC_SETLNUM_L:
4295 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4296 curr_srec->line = data;
4297 cmd_length = 5;
4298 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_L: %d\n", data));
4299 break;
4300
4301 case DST__K_SRC_SETLNUM_W:
4302 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4303 curr_srec->line = data;
4304 cmd_length = 3;
4305 vms_debug2 ((4, "DST_S_C_SRC_SETLNUM_W: %d\n", data));
4306 break;
4307
4308 case DST__K_SRC_SETREC_L:
4309 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
4310 curr_srec->srec = data;
4311 module->file_table[curr_srec->sfile].srec = data;
4312 cmd_length = 5;
4313 vms_debug2 ((4, "DST_S_C_SRC_SETREC_L: %d\n", data));
4314 break;
4315
4316 case DST__K_SRC_SETREC_W:
4317 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
4318 curr_srec->srec = data;
4319 module->file_table[curr_srec->sfile].srec = data;
4320 cmd_length = 3;
4321 vms_debug2 ((4, "DST_S_C_SRC_SETREC_W: %d\n", data));
4322 break;
4323
4324 case DST__K_SRC_FORMFEED:
4325 cmd_length = 1;
4326 vms_debug2 ((4, "DST_S_C_SRC_FORMFEED\n"));
4327 break;
4328
4329 default:
4330 (*_bfd_error_handler) (_("unknown source command %d"),
4331 cmd);
4332 cmd_length = 2;
4333 break;
4334 }
4335
4336 src_ptr += cmd_length;
4337 }
4338 break;
4339
4340 case DST__K_LINE_NUM:
4341 pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
4342
4343 vms_debug2 ((3, "line info\n"));
4344
4345 while (pcl_ptr < ptr + rec_length)
4346 {
4347 /* The command byte is signed so we must sign-extend it. */
4348 int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
4349
4350 switch (cmd)
4351 {
4352 case DST__K_DELTA_PC_W:
4353 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4354 curr_pc += data;
4355 curr_linenum += 1;
4356 cmd_length = 3;
4357 vms_debug2 ((4, "DST__K_DELTA_PC_W: %d\n", data));
4358 break;
4359
4360 case DST__K_DELTA_PC_L:
4361 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4362 curr_pc += data;
4363 curr_linenum += 1;
4364 cmd_length = 5;
4365 vms_debug2 ((4, "DST__K_DELTA_PC_L: %d\n", data));
4366 break;
4367
4368 case DST__K_INCR_LINUM:
4369 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4370 curr_linenum += data;
4371 cmd_length = 2;
4372 vms_debug2 ((4, "DST__K_INCR_LINUM: %d\n", data));
4373 break;
4374
4375 case DST__K_INCR_LINUM_W:
4376 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4377 curr_linenum += data;
4378 cmd_length = 3;
4379 vms_debug2 ((4, "DST__K_INCR_LINUM_W: %d\n", data));
4380 break;
4381
4382 case DST__K_INCR_LINUM_L:
4383 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4384 curr_linenum += data;
4385 cmd_length = 5;
4386 vms_debug2 ((4, "DST__K_INCR_LINUM_L: %d\n", data));
4387 break;
4388
4389 case DST__K_SET_LINUM_INCR:
4390 (*_bfd_error_handler)
4391 (_("DST__K_SET_LINUM_INCR not implemented"));
4392 cmd_length = 2;
4393 break;
4394
4395 case DST__K_SET_LINUM_INCR_W:
4396 (*_bfd_error_handler)
4397 (_("DST__K_SET_LINUM_INCR_W not implemented"));
4398 cmd_length = 3;
4399 break;
4400
4401 case DST__K_RESET_LINUM_INCR:
4402 (*_bfd_error_handler)
4403 (_("DST__K_RESET_LINUM_INCR not implemented"));
4404 cmd_length = 1;
4405 break;
4406
4407 case DST__K_BEG_STMT_MODE:
4408 (*_bfd_error_handler)
4409 (_("DST__K_BEG_STMT_MODE not implemented"));
4410 cmd_length = 1;
4411 break;
4412
4413 case DST__K_END_STMT_MODE:
4414 (*_bfd_error_handler)
4415 (_("DST__K_END_STMT_MODE not implemented"));
4416 cmd_length = 1;
4417 break;
4418
4419 case DST__K_SET_LINUM_B:
4420 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4421 curr_linenum = data;
4422 cmd_length = 2;
4423 vms_debug2 ((4, "DST__K_SET_LINUM_B: %d\n", data));
4424 break;
4425
4426 case DST__K_SET_LINUM:
4427 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4428 curr_linenum = data;
4429 cmd_length = 3;
4430 vms_debug2 ((4, "DST__K_SET_LINE_NUM: %d\n", data));
4431 break;
4432
4433 case DST__K_SET_LINUM_L:
4434 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4435 curr_linenum = data;
4436 cmd_length = 5;
4437 vms_debug2 ((4, "DST__K_SET_LINUM_L: %d\n", data));
4438 break;
4439
4440 case DST__K_SET_PC:
4441 (*_bfd_error_handler)
4442 (_("DST__K_SET_PC not implemented"));
4443 cmd_length = 2;
4444 break;
4445
4446 case DST__K_SET_PC_W:
4447 (*_bfd_error_handler)
4448 (_("DST__K_SET_PC_W not implemented"));
4449 cmd_length = 3;
4450 break;
4451
4452 case DST__K_SET_PC_L:
4453 (*_bfd_error_handler)
4454 (_("DST__K_SET_PC_L not implemented"));
4455 cmd_length = 5;
4456 break;
4457
4458 case DST__K_SET_STMTNUM:
4459 (*_bfd_error_handler)
4460 (_("DST__K_SET_STMTNUM not implemented"));
4461 cmd_length = 2;
4462 break;
4463
4464 case DST__K_TERM:
4465 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
4466 curr_pc += data;
4467 cmd_length = 2;
4468 vms_debug2 ((4, "DST__K_TERM: %d\n", data));
4469 break;
4470
4471 case DST__K_TERM_W:
4472 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
4473 curr_pc += data;
4474 cmd_length = 3;
4475 vms_debug2 ((4, "DST__K_TERM_W: %d\n", data));
4476 break;
4477
4478 case DST__K_TERM_L:
4479 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4480 curr_pc += data;
4481 cmd_length = 5;
4482 vms_debug2 ((4, "DST__K_TERM_L: %d\n", data));
4483 break;
4484
4485 case DST__K_SET_ABS_PC:
4486 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
4487 curr_pc = data;
4488 cmd_length = 5;
4489 vms_debug2 ((4, "DST__K_SET_ABS_PC: 0x%x\n", data));
4490 break;
4491
4492 default:
4493 if (cmd <= 0)
4494 {
4495 curr_pc -= cmd;
4496 curr_linenum += 1;
4497 cmd_length = 1;
4498 vms_debug2 ((4, "bump pc to 0x%lx and line to %d\n",
4499 (unsigned long)curr_pc, curr_linenum));
4500 }
4501 else
4502 {
4503 (*_bfd_error_handler) (_("unknown line command %d"),
4504 cmd);
4505 cmd_length = 2;
4506 }
4507 break;
4508 }
4509
4510 if ((curr_linenum != prev_linum && curr_pc != prev_pc)
4511 || cmd <= 0
4512 || cmd == DST__K_DELTA_PC_L
4513 || cmd == DST__K_DELTA_PC_W)
4514 {
4515 line = (struct lineinfo *)
4516 bfd_zalloc (abfd, sizeof (struct lineinfo));
4517 line->address = curr_pc;
4518 line->line = curr_linenum;
4519
4520 curr_line->next = line;
4521 curr_line = line;
4522
4523 prev_linum = curr_linenum;
4524 prev_pc = curr_pc;
4525 vms_debug2 ((4, "-> correlate pc 0x%lx with line %d\n",
4526 (unsigned long)curr_pc, curr_linenum));
4527 }
4528
4529 pcl_ptr += cmd_length;
4530 }
4531 break;
4532
4533 case 0x17: /* Undocumented type used by DEC C to declare equates. */
4534 vms_debug2 ((3, "undocumented type 0x17\n"));
4535 break;
4536
4537 default:
4538 vms_debug2 ((3, "ignoring record\n"));
4539 break;
4540
4541 }
4542
4543 ptr += rec_length;
4544 }
4545
4546 /* Finalize tables with EOL marker. */
4547 srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
4548 srec->line = (unsigned int) -1;
4549 srec->srec = (unsigned int) -1;
4550 curr_srec->next = srec;
4551
4552 line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
4553 line->line = (unsigned int) -1;
4554 line->address = (bfd_vma) -1;
4555 curr_line->next = line;
4556
4557 /* Advertise that this module has been parsed. This is needed
4558 because parsing can be either performed at module creation
4559 or deferred until debug info is consumed. */
4560 SET_MODULE_PARSED (module);
4561 }
4562
4563 /* Build the list of modules for the specified BFD. */
4564
4565 static struct module *
4566 build_module_list (bfd *abfd)
4567 {
4568 struct module *module, *list = NULL;
4569 asection *dmt;
4570
4571 if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
4572 {
4573 /* We have a DMT section so this must be an image. Parse the
4574 section and build the list of modules. This is sufficient
4575 since we can compute the start address and the end address
4576 of every module from the section contents. */
4577 bfd_size_type size = bfd_get_section_size (dmt);
4578 unsigned char *ptr, *end;
4579
4580 ptr = (unsigned char *) bfd_alloc (abfd, size);
4581 if (! ptr)
4582 return NULL;
4583
4584 if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
4585 return NULL;
4586
4587 vms_debug2 ((2, "DMT\n"));
4588
4589 end = ptr + size;
4590
4591 while (ptr < end)
4592 {
4593 /* Each header declares a module with its start offset and size
4594 of debug info in the DST section, as well as the count of
4595 program sections (i.e. address spans) it contains. */
4596 int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
4597 int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
4598 int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
4599 ptr += DBG_S_C_DMT_HEADER_SIZE;
4600
4601 vms_debug2 ((3, "module: modbeg = %d, size = %d, count = %d\n",
4602 modbeg, msize, count));
4603
4604 /* We create a 'module' structure for each program section since
4605 we only support contiguous addresses in a 'module' structure.
4606 As a consequence, the actual debug info in the DST section is
4607 shared and can be parsed multiple times; that doesn't seem to
4608 cause problems in practice. */
4609 while (count-- > 0)
4610 {
4611 int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
4612 int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
4613 module = new_module (abfd);
4614 module->modbeg = modbeg;
4615 module->size = msize;
4616 module->low = start;
4617 module->high = start + length;
4618 module->next = list;
4619 list = module;
4620 ptr += DBG_S_C_DMT_PSECT_SIZE;
4621
4622 vms_debug2 ((4, "section: start = 0x%x, length = %d\n",
4623 start, length));
4624 }
4625 }
4626 }
4627 else
4628 {
4629 /* We don't have a DMT section so this must be an object. Parse
4630 the module right now in order to compute its start address and
4631 end address. */
4632 void *dst = PRIV (dst_section)->contents;
4633
4634 if (dst == NULL)
4635 return NULL;
4636
4637 module = new_module (abfd);
4638 parse_module (abfd, module, PRIV (dst_section)->contents, -1);
4639 list = module;
4640 }
4641
4642 return list;
4643 }
4644
4645 /* Calculate and return the name of the source file and the line nearest
4646 to the wanted location in the specified module. */
4647
4648 static bfd_boolean
4649 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
4650 const char **file, const char **func,
4651 unsigned int *line)
4652 {
4653 struct funcinfo *funcinfo;
4654 struct lineinfo *lineinfo;
4655 struct srecinfo *srecinfo;
4656 bfd_boolean ret = FALSE;
4657
4658 /* Parse this module if that was not done at module creation. */
4659 if (! IS_MODULE_PARSED (module))
4660 {
4661 unsigned int size = module->size;
4662 unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
4663 unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
4664
4665 if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
4666 || bfd_bread (buffer, size, abfd) != size)
4667 {
4668 bfd_set_error (bfd_error_no_debug_section);
4669 return FALSE;
4670 }
4671
4672 parse_module (abfd, module, buffer, size);
4673 free (buffer);
4674 }
4675
4676 /* Find out the function (if any) that contains the address. */
4677 for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
4678 if (addr >= funcinfo->low && addr <= funcinfo->high)
4679 {
4680 *func = funcinfo->name;
4681 ret = TRUE;
4682 break;
4683 }
4684
4685 /* Find out the source file and the line nearest to the address. */
4686 for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
4687 if (lineinfo->next && addr < lineinfo->next->address)
4688 {
4689 for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
4690 if (srecinfo->next && lineinfo->line < srecinfo->next->line)
4691 {
4692 if (srecinfo->sfile > 0)
4693 {
4694 *file = module->file_table[srecinfo->sfile].name;
4695 *line = srecinfo->srec + lineinfo->line - srecinfo->line;
4696 }
4697 else
4698 {
4699 *file = module->name;
4700 *line = lineinfo->line;
4701 }
4702 return TRUE;
4703 }
4704
4705 break;
4706 }
4707
4708 return ret;
4709 }
4710
4711 /* Provided a BFD, a section and an offset into the section, calculate and
4712 return the name of the source file and the line nearest to the wanted
4713 location. */
4714
4715 static bfd_boolean
4716 _bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
4717 asymbol **symbols ATTRIBUTE_UNUSED,
4718 bfd_vma offset, const char **file,
4719 const char **func, unsigned int *line)
4720 {
4721 struct module *module;
4722
4723 /* What address are we looking for? */
4724 bfd_vma addr = section->vma + offset;
4725
4726 *file = NULL;
4727 *func = NULL;
4728 *line = 0;
4729
4730 /* We can't do anything if there is no DST (debug symbol table). */
4731 if (PRIV (dst_section) == NULL)
4732 return FALSE;
4733
4734 /* Create the module list - if not already done. */
4735 if (PRIV (modules) == NULL)
4736 {
4737 PRIV (modules) = build_module_list (abfd);
4738 if (PRIV (modules) == NULL)
4739 return FALSE;
4740 }
4741
4742 for (module = PRIV (modules); module; module = module->next)
4743 if (addr >= module->low && addr <= module->high)
4744 return module_find_nearest_line (abfd, module, addr, file, func, line);
4745
4746 return FALSE;
4747 }
4748 \f
4749 /* Canonicalizations. */
4750 /* Set name, value, section and flags of SYM from E. */
4751
4752 static bfd_boolean
4753 alpha_vms_convert_symbol (bfd *abfd, struct vms_symbol_entry *e, asymbol *sym)
4754 {
4755 flagword flags;
4756 symvalue value;
4757 asection *sec;
4758 const char *name;
4759
4760 name = e->name;
4761 value = 0;
4762 flags = BSF_NO_FLAGS;
4763 sec = NULL;
4764
4765 switch (e->typ)
4766 {
4767 case EGSD__C_SYM:
4768 if (e->flags & EGSY__V_WEAK)
4769 flags |= BSF_WEAK;
4770
4771 if (e->flags & EGSY__V_DEF)
4772 {
4773 /* Symbol definition. */
4774 flags |= BSF_GLOBAL;
4775 if (e->flags & EGSY__V_NORM)
4776 flags |= BSF_FUNCTION;
4777 value = e->value;
4778 sec = e->section;
4779 }
4780 else
4781 {
4782 /* Symbol reference. */
4783 sec = bfd_und_section_ptr;
4784 }
4785 break;
4786
4787 case EGSD__C_SYMG:
4788 /* A universal symbol is by definition global... */
4789 flags |= BSF_GLOBAL;
4790
4791 /* ...and dynamic in shared libraries. */
4792 if (abfd->flags & DYNAMIC)
4793 flags |= BSF_DYNAMIC;
4794
4795 if (e->flags & EGSY__V_WEAK)
4796 flags |= BSF_WEAK;
4797
4798 if (!(e->flags & EGSY__V_DEF))
4799 abort ();
4800
4801 if (e->flags & EGSY__V_NORM)
4802 flags |= BSF_FUNCTION;
4803
4804 value = e->value;
4805 /* sec = e->section; */
4806 sec = bfd_abs_section_ptr;
4807 break;
4808
4809 default:
4810 return FALSE;
4811 }
4812
4813 sym->name = name;
4814 sym->section = sec;
4815 sym->flags = flags;
4816 sym->value = value;
4817 return TRUE;
4818 }
4819
4820
4821 /* Return the number of bytes required to store a vector of pointers
4822 to asymbols for all the symbols in the BFD abfd, including a
4823 terminal NULL pointer. If there are no symbols in the BFD,
4824 then return 0. If an error occurs, return -1. */
4825
4826 static long
4827 alpha_vms_get_symtab_upper_bound (bfd *abfd)
4828 {
4829 vms_debug2 ((1, "alpha_vms_get_symtab_upper_bound (%p), %d symbols\n",
4830 abfd, PRIV (gsd_sym_count)));
4831
4832 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
4833 }
4834
4835 /* Read the symbols from the BFD abfd, and fills in the vector
4836 location with pointers to the symbols and a trailing NULL.
4837
4838 Return number of symbols read. */
4839
4840 static long
4841 alpha_vms_canonicalize_symtab (bfd *abfd, asymbol **symbols)
4842 {
4843 unsigned int i;
4844
4845 vms_debug2 ((1, "alpha_vms_canonicalize_symtab (%p, <ret>)\n", abfd));
4846
4847 if (PRIV (csymbols) == NULL)
4848 {
4849 PRIV (csymbols) = (asymbol **) bfd_alloc
4850 (abfd, PRIV (gsd_sym_count) * sizeof (asymbol *));
4851
4852 /* Traverse table and fill symbols vector. */
4853 for (i = 0; i < PRIV (gsd_sym_count); i++)
4854 {
4855 struct vms_symbol_entry *e = PRIV (syms)[i];
4856 asymbol *sym;
4857
4858 sym = bfd_make_empty_symbol (abfd);
4859 if (sym == NULL || !alpha_vms_convert_symbol (abfd, e, sym))
4860 {
4861 bfd_release (abfd, PRIV (csymbols));
4862 PRIV (csymbols) = NULL;
4863 return -1;
4864 }
4865
4866 PRIV (csymbols)[i] = sym;
4867 }
4868 }
4869
4870 if (symbols != NULL)
4871 {
4872 for (i = 0; i < PRIV (gsd_sym_count); i++)
4873 symbols[i] = PRIV (csymbols)[i];
4874 symbols[i] = NULL;
4875 }
4876
4877 return PRIV (gsd_sym_count);
4878 }
4879
4880 /* Read and convert relocations from ETIR. We do it once for all sections. */
4881
4882 static bfd_boolean
4883 alpha_vms_slurp_relocs (bfd *abfd)
4884 {
4885 int cur_psect = -1;
4886
4887 vms_debug2 ((3, "alpha_vms_slurp_relocs\n"));
4888
4889 /* We slurp relocs only once, for all sections. */
4890 if (PRIV (reloc_done))
4891 return TRUE;
4892 PRIV (reloc_done) = TRUE;
4893
4894 if (alpha_vms_canonicalize_symtab (abfd, NULL) < 0)
4895 return FALSE;
4896
4897 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
4898 return FALSE;
4899
4900 while (1)
4901 {
4902 unsigned char *begin;
4903 unsigned char *end;
4904 unsigned char *ptr;
4905 bfd_reloc_code_real_type reloc_code;
4906 int type;
4907 bfd_vma vaddr = 0;
4908
4909 int length;
4910
4911 bfd_vma cur_address;
4912 int cur_psidx = -1;
4913 unsigned char *cur_sym = NULL;
4914 int prev_cmd = -1;
4915 bfd_vma cur_addend = 0;
4916
4917 /* Skip non-ETIR records. */
4918 type = _bfd_vms_get_object_record (abfd);
4919 if (type == EOBJ__C_EEOM)
4920 break;
4921 if (type != EOBJ__C_ETIR)
4922 continue;
4923
4924 begin = PRIV (recrd.rec) + 4;
4925 end = PRIV (recrd.rec) + PRIV (recrd.rec_size);
4926
4927 for (ptr = begin; ptr < end; ptr += length)
4928 {
4929 int cmd;
4930
4931 cmd = bfd_getl16 (ptr);
4932 length = bfd_getl16 (ptr + 2);
4933
4934 cur_address = vaddr;
4935
4936 vms_debug2 ((4, "alpha_vms_slurp_relocs: etir %s\n",
4937 _bfd_vms_etir_name (cmd)));
4938
4939 switch (cmd)
4940 {
4941 case ETIR__C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
4942 /* ALPHA_R_REFQUAD und_section, step 1 */
4943 cur_sym = ptr + 4;
4944 prev_cmd = cmd;
4945 continue;
4946
4947 case ETIR__C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
4948 cur_psidx = bfd_getl32 (ptr + 4);
4949 cur_addend = bfd_getl64 (ptr + 8);
4950 prev_cmd = cmd;
4951 continue;
4952
4953 case ETIR__C_CTL_SETRB:
4954 if (prev_cmd != ETIR__C_STA_PQ)
4955 {
4956 (*_bfd_error_handler)
4957 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
4958 _bfd_vms_etir_name (cmd));
4959 return FALSE;
4960 }
4961 cur_psect = cur_psidx;
4962 vaddr = cur_addend;
4963 cur_psidx = -1;
4964 cur_addend = 0;
4965 continue;
4966
4967 case ETIR__C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
4968 /* ALPHA_R_REFLONG und_section, step 2 */
4969 if (prev_cmd != -1)
4970 {
4971 if (prev_cmd != ETIR__C_STA_GBL)
4972 {
4973 (*_bfd_error_handler)
4974 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4975 _bfd_vms_etir_name (ETIR__C_STA_LW));
4976 return FALSE;
4977 }
4978 }
4979 cur_addend = bfd_getl32 (ptr + 4);
4980 prev_cmd = cmd;
4981 continue;
4982
4983 case ETIR__C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
4984 /* ALPHA_R_REFQUAD und_section, step 2 */
4985 if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
4986 {
4987 (*_bfd_error_handler)
4988 (_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
4989 _bfd_vms_etir_name (ETIR__C_STA_QW));
4990 return FALSE;
4991 }
4992 cur_addend = bfd_getl64 (ptr + 4);
4993 prev_cmd = cmd;
4994 continue;
4995
4996 case ETIR__C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
4997 /* ALPHA_R_REFLONG abs_section, step 2 */
4998 /* ALPHA_R_REFLONG others, step 2 */
4999 if (prev_cmd != ETIR__C_OPR_ADD
5000 && prev_cmd != ETIR__C_STA_LW
5001 && prev_cmd != ETIR__C_STA_PQ)
5002 {
5003 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
5004 _bfd_vms_etir_name (prev_cmd),
5005 _bfd_vms_etir_name (ETIR__C_STO_LW));
5006 return FALSE;
5007 }
5008 reloc_code = BFD_RELOC_32;
5009 break;
5010
5011 case ETIR__C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
5012 /* ALPHA_R_REFQUAD abs_section, step 2 */
5013 if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
5014 {
5015 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
5016 _bfd_vms_etir_name (prev_cmd),
5017 _bfd_vms_etir_name (ETIR__C_STO_QW));
5018 return FALSE;
5019 }
5020 reloc_code = BFD_RELOC_64;
5021 break;
5022
5023 case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
5024 if (prev_cmd != ETIR__C_STA_PQ)
5025 {
5026 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
5027 _bfd_vms_etir_name (prev_cmd),
5028 _bfd_vms_etir_name (ETIR__C_STO_OFF));
5029 return FALSE;
5030 }
5031 reloc_code = BFD_RELOC_64;
5032 break;
5033
5034 case ETIR__C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
5035 /* ALPHA_R_REFQUAD und_section, step 3 */
5036 if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
5037 {
5038 (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
5039 _bfd_vms_etir_name (prev_cmd),
5040 _bfd_vms_etir_name (ETIR__C_OPR_ADD));
5041 return FALSE;
5042 }
5043 prev_cmd = ETIR__C_OPR_ADD;
5044 continue;
5045
5046 case ETIR__C_STO_CA: /* ALPHA_R_CODEADDR */
5047 reloc_code = BFD_RELOC_ALPHA_CODEADDR;
5048 cur_sym = ptr + 4;
5049 break;
5050
5051 case ETIR__C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
5052 reloc_code = BFD_RELOC_64;
5053 cur_sym = ptr + 4;
5054 break;
5055
5056 case ETIR__C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
5057 reloc_code = BFD_RELOC_32;
5058 cur_sym = ptr + 4;
5059 break;
5060
5061 case ETIR__C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
5062 reloc_code = BFD_RELOC_ALPHA_LINKAGE;
5063 cur_sym = ptr + 8;
5064 break;
5065
5066 case ETIR__C_STC_NOP_GBL: /* ALPHA_R_NOP */
5067 reloc_code = BFD_RELOC_ALPHA_NOP;
5068 goto call_reloc;
5069
5070 case ETIR__C_STC_BSR_GBL: /* ALPHA_R_BSR */
5071 reloc_code = BFD_RELOC_ALPHA_BSR;
5072 goto call_reloc;
5073
5074 case ETIR__C_STC_LDA_GBL: /* ALPHA_R_LDA */
5075 reloc_code = BFD_RELOC_ALPHA_LDA;
5076 goto call_reloc;
5077
5078 case ETIR__C_STC_BOH_GBL: /* ALPHA_R_BOH */
5079 reloc_code = BFD_RELOC_ALPHA_BOH;
5080 goto call_reloc;
5081
5082 call_reloc:
5083 cur_sym = ptr + 4 + 32;
5084 cur_address = bfd_getl64 (ptr + 4 + 8);
5085 cur_addend = bfd_getl64 (ptr + 4 + 24);
5086 break;
5087
5088 case ETIR__C_STO_IMM:
5089 vaddr += bfd_getl32 (ptr + 4);
5090 continue;
5091
5092 default:
5093 (*_bfd_error_handler) (_("Unknown reloc %s"),
5094 _bfd_vms_etir_name (cmd));
5095 return FALSE;
5096 }
5097
5098 {
5099 asection *sec;
5100 struct vms_section_data_struct *vms_sec;
5101 arelent *reloc;
5102
5103 /* Get section to which the relocation applies. */
5104 if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
5105 {
5106 (*_bfd_error_handler) (_("Invalid section index in ETIR"));
5107 return FALSE;
5108 }
5109 sec = PRIV (sections)[cur_psect];
5110 vms_sec = vms_section_data (sec);
5111
5112 /* Allocate a reloc entry. */
5113 if (sec->reloc_count >= vms_sec->reloc_max)
5114 {
5115 if (vms_sec->reloc_max == 0)
5116 {
5117 vms_sec->reloc_max = 64;
5118 sec->relocation = bfd_zmalloc
5119 (vms_sec->reloc_max * sizeof (arelent));
5120 }
5121 else
5122 {
5123 vms_sec->reloc_max *= 2;
5124 sec->relocation = bfd_realloc
5125 (sec->relocation, vms_sec->reloc_max * sizeof (arelent));
5126 }
5127 }
5128 reloc = &sec->relocation[sec->reloc_count];
5129 sec->reloc_count++;
5130
5131 reloc->howto = bfd_reloc_type_lookup (abfd, reloc_code);
5132
5133 if (cur_sym != NULL)
5134 {
5135 unsigned int j;
5136 unsigned int symlen = *cur_sym;
5137 asymbol **sym;
5138
5139 /* Linear search. */
5140 symlen = *cur_sym;
5141 cur_sym++;
5142 sym = NULL;
5143
5144 for (j = 0; j < PRIV (gsd_sym_count); j++)
5145 if (PRIV (syms)[j]->namelen == symlen
5146 && memcmp (PRIV (syms)[j]->name, cur_sym, symlen) == 0)
5147 {
5148 sym = &PRIV (csymbols)[j];
5149 break;
5150 }
5151 if (sym == NULL)
5152 {
5153 (*_bfd_error_handler) (_("Unknown symbol in command %s"),
5154 _bfd_vms_etir_name (cmd));
5155 reloc->sym_ptr_ptr = NULL;
5156 }
5157 else
5158 reloc->sym_ptr_ptr = sym;
5159 }
5160 else if (cur_psidx >= 0)
5161 reloc->sym_ptr_ptr =
5162 PRIV (sections)[cur_psidx]->symbol_ptr_ptr;
5163 else
5164 reloc->sym_ptr_ptr = NULL;
5165
5166 reloc->address = cur_address;
5167 reloc->addend = cur_addend;
5168
5169 vaddr += bfd_get_reloc_size (reloc->howto);
5170 }
5171
5172 cur_addend = 0;
5173 prev_cmd = -1;
5174 cur_sym = NULL;
5175 cur_psidx = -1;
5176 }
5177 }
5178 vms_debug2 ((3, "alpha_vms_slurp_relocs: result = TRUE\n"));
5179
5180 return TRUE;
5181 }
5182
5183 /* Return the number of bytes required to store the relocation
5184 information associated with the given section. */
5185
5186 static long
5187 alpha_vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
5188 {
5189 alpha_vms_slurp_relocs (abfd);
5190
5191 return (section->reloc_count + 1) * sizeof (arelent *);
5192 }
5193
5194 /* Convert relocations from VMS (external) form into BFD internal
5195 form. Return the number of relocations. */
5196
5197 static long
5198 alpha_vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
5199 asymbol **symbols ATTRIBUTE_UNUSED)
5200 {
5201 arelent *tblptr;
5202 int count;
5203
5204 if (!alpha_vms_slurp_relocs (abfd))
5205 return -1;
5206
5207 count = section->reloc_count;
5208 tblptr = section->relocation;
5209
5210 while (count--)
5211 *relptr++ = tblptr++;
5212
5213 *relptr = (arelent *) NULL;
5214 return section->reloc_count;
5215 }
5216 \f
5217 /* This is just copied from ecoff-alpha, needs to be fixed probably. */
5218
5219 /* How to process the various reloc types. */
5220
5221 static bfd_reloc_status_type
5222 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
5223 arelent *reloc ATTRIBUTE_UNUSED,
5224 asymbol *sym ATTRIBUTE_UNUSED,
5225 void * data ATTRIBUTE_UNUSED,
5226 asection *sec ATTRIBUTE_UNUSED,
5227 bfd *output_bfd ATTRIBUTE_UNUSED,
5228 char **error_message ATTRIBUTE_UNUSED)
5229 {
5230 #if VMS_DEBUG
5231 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
5232 vms_debug (2, "In section %s, symbol %s\n",
5233 sec->name, sym->name);
5234 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
5235 reloc->sym_ptr_ptr[0]->name,
5236 (unsigned long)reloc->address,
5237 (unsigned long)reloc->addend, reloc->howto->name);
5238 vms_debug (2, "data at %p\n", data);
5239 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
5240 #endif
5241
5242 return bfd_reloc_ok;
5243 }
5244
5245 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
5246 from smaller values. Start with zero, widen, *then* decrement. */
5247 #define MINUS_ONE (((bfd_vma)0) - 1)
5248
5249 static reloc_howto_type alpha_howto_table[] =
5250 {
5251 HOWTO (ALPHA_R_IGNORE, /* Type. */
5252 0, /* Rightshift. */
5253 0, /* Size (0 = byte, 1 = short, 2 = long). */
5254 8, /* Bitsize. */
5255 TRUE, /* PC relative. */
5256 0, /* Bitpos. */
5257 complain_overflow_dont,/* Complain_on_overflow. */
5258 reloc_nil, /* Special_function. */
5259 "IGNORE", /* Name. */
5260 TRUE, /* Partial_inplace. */
5261 0, /* Source mask */
5262 0, /* Dest mask. */
5263 TRUE), /* PC rel offset. */
5264
5265 /* A 64 bit reference to a symbol. */
5266 HOWTO (ALPHA_R_REFQUAD, /* Type. */
5267 0, /* Rightshift. */
5268 4, /* Size (0 = byte, 1 = short, 2 = long). */
5269 64, /* Bitsize. */
5270 FALSE, /* PC relative. */
5271 0, /* Bitpos. */
5272 complain_overflow_bitfield, /* Complain_on_overflow. */
5273 reloc_nil, /* Special_function. */
5274 "REFQUAD", /* Name. */
5275 TRUE, /* Partial_inplace. */
5276 MINUS_ONE, /* Source mask. */
5277 MINUS_ONE, /* Dest mask. */
5278 FALSE), /* PC rel offset. */
5279
5280 /* A 21 bit branch. The native assembler generates these for
5281 branches within the text segment, and also fills in the PC
5282 relative offset in the instruction. */
5283 HOWTO (ALPHA_R_BRADDR, /* Type. */
5284 2, /* Rightshift. */
5285 2, /* Size (0 = byte, 1 = short, 2 = long). */
5286 21, /* Bitsize. */
5287 TRUE, /* PC relative. */
5288 0, /* Bitpos. */
5289 complain_overflow_signed, /* Complain_on_overflow. */
5290 reloc_nil, /* Special_function. */
5291 "BRADDR", /* Name. */
5292 TRUE, /* Partial_inplace. */
5293 0x1fffff, /* Source mask. */
5294 0x1fffff, /* Dest mask. */
5295 FALSE), /* PC rel offset. */
5296
5297 /* A hint for a jump to a register. */
5298 HOWTO (ALPHA_R_HINT, /* Type. */
5299 2, /* Rightshift. */
5300 1, /* Size (0 = byte, 1 = short, 2 = long). */
5301 14, /* Bitsize. */
5302 TRUE, /* PC relative. */
5303 0, /* Bitpos. */
5304 complain_overflow_dont,/* Complain_on_overflow. */
5305 reloc_nil, /* Special_function. */
5306 "HINT", /* Name. */
5307 TRUE, /* Partial_inplace. */
5308 0x3fff, /* Source mask. */
5309 0x3fff, /* Dest mask. */
5310 FALSE), /* PC rel offset. */
5311
5312 /* 16 bit PC relative offset. */
5313 HOWTO (ALPHA_R_SREL16, /* Type. */
5314 0, /* Rightshift. */
5315 1, /* Size (0 = byte, 1 = short, 2 = long). */
5316 16, /* Bitsize. */
5317 TRUE, /* PC relative. */
5318 0, /* Bitpos. */
5319 complain_overflow_signed, /* Complain_on_overflow. */
5320 reloc_nil, /* Special_function. */
5321 "SREL16", /* Name. */
5322 TRUE, /* Partial_inplace. */
5323 0xffff, /* Source mask. */
5324 0xffff, /* Dest mask. */
5325 FALSE), /* PC rel offset. */
5326
5327 /* 32 bit PC relative offset. */
5328 HOWTO (ALPHA_R_SREL32, /* Type. */
5329 0, /* Rightshift. */
5330 2, /* Size (0 = byte, 1 = short, 2 = long). */
5331 32, /* Bitsize. */
5332 TRUE, /* PC relative. */
5333 0, /* Bitpos. */
5334 complain_overflow_signed, /* Complain_on_overflow. */
5335 reloc_nil, /* Special_function. */
5336 "SREL32", /* Name. */
5337 TRUE, /* Partial_inplace. */
5338 0xffffffff, /* Source mask. */
5339 0xffffffff, /* Dest mask. */
5340 FALSE), /* PC rel offset. */
5341
5342 /* A 64 bit PC relative offset. */
5343 HOWTO (ALPHA_R_SREL64, /* Type. */
5344 0, /* Rightshift. */
5345 4, /* Size (0 = byte, 1 = short, 2 = long). */
5346 64, /* Bitsize. */
5347 TRUE, /* PC relative. */
5348 0, /* Bitpos. */
5349 complain_overflow_signed, /* Complain_on_overflow. */
5350 reloc_nil, /* Special_function. */
5351 "SREL64", /* Name. */
5352 TRUE, /* Partial_inplace. */
5353 MINUS_ONE, /* Source mask. */
5354 MINUS_ONE, /* Dest mask. */
5355 FALSE), /* PC rel offset. */
5356
5357 /* Push a value on the reloc evaluation stack. */
5358 HOWTO (ALPHA_R_OP_PUSH, /* Type. */
5359 0, /* Rightshift. */
5360 0, /* Size (0 = byte, 1 = short, 2 = long). */
5361 0, /* Bitsize. */
5362 FALSE, /* PC relative. */
5363 0, /* Bitpos. */
5364 complain_overflow_dont,/* Complain_on_overflow. */
5365 reloc_nil, /* Special_function. */
5366 "OP_PUSH", /* Name. */
5367 FALSE, /* Partial_inplace. */
5368 0, /* Source mask. */
5369 0, /* Dest mask. */
5370 FALSE), /* PC rel offset. */
5371
5372 /* Store the value from the stack at the given address. Store it in
5373 a bitfield of size r_size starting at bit position r_offset. */
5374 HOWTO (ALPHA_R_OP_STORE, /* Type. */
5375 0, /* Rightshift. */
5376 4, /* Size (0 = byte, 1 = short, 2 = long). */
5377 64, /* Bitsize. */
5378 FALSE, /* PC relative. */
5379 0, /* Bitpos. */
5380 complain_overflow_dont,/* Complain_on_overflow. */
5381 reloc_nil, /* Special_function. */
5382 "OP_STORE", /* Name. */
5383 FALSE, /* Partial_inplace. */
5384 0, /* Source mask. */
5385 MINUS_ONE, /* Dest mask. */
5386 FALSE), /* PC rel offset. */
5387
5388 /* Subtract the reloc address from the value on the top of the
5389 relocation stack. */
5390 HOWTO (ALPHA_R_OP_PSUB, /* Type. */
5391 0, /* Rightshift. */
5392 0, /* Size (0 = byte, 1 = short, 2 = long). */
5393 0, /* Bitsize. */
5394 FALSE, /* PC relative. */
5395 0, /* Bitpos. */
5396 complain_overflow_dont,/* Complain_on_overflow. */
5397 reloc_nil, /* Special_function. */
5398 "OP_PSUB", /* Name. */
5399 FALSE, /* Partial_inplace. */
5400 0, /* Source mask. */
5401 0, /* Dest mask. */
5402 FALSE), /* PC rel offset. */
5403
5404 /* Shift the value on the top of the relocation stack right by the
5405 given value. */
5406 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */
5407 0, /* Rightshift. */
5408 0, /* Size (0 = byte, 1 = short, 2 = long). */
5409 0, /* Bitsize. */
5410 FALSE, /* PC relative. */
5411 0, /* Bitpos. */
5412 complain_overflow_dont,/* Complain_on_overflow. */
5413 reloc_nil, /* Special_function. */
5414 "OP_PRSHIFT", /* Name. */
5415 FALSE, /* Partial_inplace. */
5416 0, /* Source mask. */
5417 0, /* Dest mask. */
5418 FALSE), /* PC rel offset. */
5419
5420 /* Hack. Linkage is done by linker. */
5421 HOWTO (ALPHA_R_LINKAGE, /* Type. */
5422 0, /* Rightshift. */
5423 8, /* Size (0 = byte, 1 = short, 2 = long). */
5424 256, /* Bitsize. */
5425 FALSE, /* PC relative. */
5426 0, /* Bitpos. */
5427 complain_overflow_dont,/* Complain_on_overflow. */
5428 reloc_nil, /* Special_function. */
5429 "LINKAGE", /* Name. */
5430 FALSE, /* Partial_inplace. */
5431 0, /* Source mask. */
5432 0, /* Dest mask. */
5433 FALSE), /* PC rel offset. */
5434
5435 /* A 32 bit reference to a symbol. */
5436 HOWTO (ALPHA_R_REFLONG, /* Type. */
5437 0, /* Rightshift. */
5438 2, /* Size (0 = byte, 1 = short, 2 = long). */
5439 32, /* Bitsize. */
5440 FALSE, /* PC relative. */
5441 0, /* Bitpos. */
5442 complain_overflow_bitfield, /* Complain_on_overflow. */
5443 reloc_nil, /* Special_function. */
5444 "REFLONG", /* Name. */
5445 TRUE, /* Partial_inplace. */
5446 0xffffffff, /* Source mask. */
5447 0xffffffff, /* Dest mask. */
5448 FALSE), /* PC rel offset. */
5449
5450 /* A 64 bit reference to a procedure, written as 32 bit value. */
5451 HOWTO (ALPHA_R_CODEADDR, /* Type. */
5452 0, /* Rightshift. */
5453 4, /* Size (0 = byte, 1 = short, 2 = long). */
5454 64, /* Bitsize. */
5455 FALSE, /* PC relative. */
5456 0, /* Bitpos. */
5457 complain_overflow_signed,/* Complain_on_overflow. */
5458 reloc_nil, /* Special_function. */
5459 "CODEADDR", /* Name. */
5460 FALSE, /* Partial_inplace. */
5461 0xffffffff, /* Source mask. */
5462 0xffffffff, /* Dest mask. */
5463 FALSE), /* PC rel offset. */
5464
5465 HOWTO (ALPHA_R_NOP, /* Type. */
5466 0, /* Rightshift. */
5467 3, /* Size (0 = byte, 1 = short, 2 = long). */
5468 0, /* Bitsize. */
5469 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
5470 because the calculations for the 3 relocations are the same.
5471 See B.4.5.2 of the OpenVMS Linker Utility Manual. */
5472 TRUE, /* PC relative. */
5473 0, /* Bitpos. */
5474 complain_overflow_dont,/* Complain_on_overflow. */
5475 reloc_nil, /* Special_function. */
5476 "NOP", /* Name. */
5477 FALSE, /* Partial_inplace. */
5478 0xffffffff, /* Source mask. */
5479 0xffffffff, /* Dest mask. */
5480 FALSE), /* PC rel offset. */
5481
5482 HOWTO (ALPHA_R_BSR, /* Type. */
5483 0, /* Rightshift. */
5484 3, /* Size (0 = byte, 1 = short, 2 = long). */
5485 0, /* Bitsize. */
5486 TRUE, /* PC relative. */
5487 0, /* Bitpos. */
5488 complain_overflow_dont,/* Complain_on_overflow. */
5489 reloc_nil, /* Special_function. */
5490 "BSR", /* Name. */
5491 FALSE, /* Partial_inplace. */
5492 0xffffffff, /* Source mask. */
5493 0xffffffff, /* Dest mask. */
5494 FALSE), /* PC rel offset. */
5495
5496 HOWTO (ALPHA_R_LDA, /* Type. */
5497 0, /* Rightshift. */
5498 3, /* Size (0 = byte, 1 = short, 2 = long). */
5499 0, /* Bitsize. */
5500 FALSE, /* PC relative. */
5501 0, /* Bitpos. */
5502 complain_overflow_dont,/* Complain_on_overflow. */
5503 reloc_nil, /* Special_function. */
5504 "LDA", /* Name. */
5505 FALSE, /* Partial_inplace. */
5506 0xffffffff, /* Source mask. */
5507 0xffffffff, /* Dest mask. */
5508 FALSE), /* PC rel offset. */
5509
5510 HOWTO (ALPHA_R_BOH, /* Type. */
5511 0, /* Rightshift. */
5512 3, /* Size (0 = byte, 1 = short, 2 = long, 3 = nil). */
5513 0, /* Bitsize. */
5514 TRUE, /* PC relative. */
5515 0, /* Bitpos. */
5516 complain_overflow_dont,/* Complain_on_overflow. */
5517 reloc_nil, /* Special_function. */
5518 "BOH", /* Name. */
5519 FALSE, /* Partial_inplace. */
5520 0xffffffff, /* Source mask. */
5521 0xffffffff, /* Dest mask. */
5522 FALSE), /* PC rel offset. */
5523 };
5524
5525 /* Return a pointer to a howto structure which, when invoked, will perform
5526 the relocation code on data from the architecture noted. */
5527
5528 static const struct reloc_howto_struct *
5529 alpha_vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
5530 bfd_reloc_code_real_type code)
5531 {
5532 int alpha_type;
5533
5534 vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
5535
5536 switch (code)
5537 {
5538 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break;
5539 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break;
5540 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break;
5541 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break;
5542 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break;
5543 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break;
5544 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break;
5545 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break;
5546 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break;
5547 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break;
5548 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break;
5549 case BFD_RELOC_ALPHA_NOP: alpha_type = ALPHA_R_NOP; break;
5550 case BFD_RELOC_ALPHA_BSR: alpha_type = ALPHA_R_BSR; break;
5551 case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
5552 case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
5553 default:
5554 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
5555 return NULL;
5556 }
5557 vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
5558 return & alpha_howto_table[alpha_type];
5559 }
5560
5561 static reloc_howto_type *
5562 alpha_vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
5563 const char *r_name)
5564 {
5565 unsigned int i;
5566
5567 for (i = 0;
5568 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
5569 i++)
5570 if (alpha_howto_table[i].name != NULL
5571 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
5572 return &alpha_howto_table[i];
5573
5574 return NULL;
5575 }
5576 \f
5577 static long
5578 alpha_vms_get_synthetic_symtab (bfd *abfd,
5579 long symcount ATTRIBUTE_UNUSED,
5580 asymbol **usyms ATTRIBUTE_UNUSED,
5581 long dynsymcount ATTRIBUTE_UNUSED,
5582 asymbol **dynsyms ATTRIBUTE_UNUSED,
5583 asymbol **ret)
5584 {
5585 asymbol *syms;
5586 unsigned int i;
5587 unsigned int n = 0;
5588
5589 syms = (asymbol *) bfd_malloc (PRIV (norm_sym_count) * sizeof (asymbol));
5590 *ret = syms;
5591 if (syms == NULL)
5592 return -1;
5593
5594 for (i = 0; i < PRIV (gsd_sym_count); i++)
5595 {
5596 struct vms_symbol_entry *e = PRIV (syms)[i];
5597 asymbol *sym;
5598 flagword flags;
5599 symvalue value;
5600 asection *sec;
5601 const char *name;
5602 char *sname;
5603 int l;
5604
5605 name = e->name;
5606 value = 0;
5607 flags = BSF_LOCAL | BSF_SYNTHETIC;
5608 sec = NULL;
5609
5610 switch (e->typ)
5611 {
5612 case EGSD__C_SYM:
5613 case EGSD__C_SYMG:
5614 if ((e->flags & EGSY__V_DEF) && (e->flags & EGSY__V_NORM))
5615 {
5616 value = e->code_value;
5617 sec = e->code_section;
5618 }
5619 else
5620 continue;
5621 break;
5622
5623 default:
5624 continue;
5625 }
5626
5627 l = strlen (name);
5628 sname = bfd_alloc (abfd, l + 5);
5629 if (sname == NULL)
5630 return FALSE;
5631 memcpy (sname, name, l);
5632 memcpy (sname + l, "..en", 5);
5633
5634 sym = &syms[n++];
5635 sym->name = sname;
5636 sym->section = sec;
5637 sym->flags = flags;
5638 sym->value = value;
5639 sym->udata.p = NULL;
5640 }
5641
5642 return n;
5643 }
5644 \f
5645 /* Private dump. */
5646
5647 static const char *
5648 vms_time_to_str (unsigned char *buf)
5649 {
5650 time_t t = vms_rawtime_to_time_t (buf);
5651 char *res = ctime (&t);
5652
5653 if (!res)
5654 res = "*invalid time*";
5655 else
5656 res[24] = 0;
5657 return res;
5658 }
5659
5660 static void
5661 evax_bfd_print_emh (FILE *file, unsigned char *rec, unsigned int rec_len)
5662 {
5663 struct vms_emh_common *emh = (struct vms_emh_common *)rec;
5664 unsigned int subtype;
5665
5666 subtype = (unsigned)bfd_getl16 (emh->subtyp);
5667
5668 fprintf (file, _(" EMH %u (len=%u): "), subtype, rec_len);
5669
5670 switch (subtype)
5671 {
5672 case EMH__C_MHD:
5673 {
5674 struct vms_emh_mhd *mhd = (struct vms_emh_mhd *)rec;
5675 const char *name;
5676
5677 fprintf (file, _("Module header\n"));
5678 fprintf (file, _(" structure level: %u\n"), mhd->strlvl);
5679 fprintf (file, _(" max record size: %u\n"),
5680 (unsigned)bfd_getl32 (mhd->recsiz));
5681 name = (char *)(mhd + 1);
5682 fprintf (file, _(" module name : %.*s\n"), name[0], name + 1);
5683 name += name[0] + 1;
5684 fprintf (file, _(" module version : %.*s\n"), name[0], name + 1);
5685 name += name[0] + 1;
5686 fprintf (file, _(" compile date : %.17s\n"), name);
5687 }
5688 break;
5689 case EMH__C_LNM:
5690 {
5691 fprintf (file, _("Language Processor Name\n"));
5692 fprintf (file, _(" language name: %.*s\n"),
5693 (int)(rec_len - sizeof (struct vms_emh_common)),
5694 (char *)rec + sizeof (struct vms_emh_common));
5695 }
5696 break;
5697 case EMH__C_SRC:
5698 {
5699 fprintf (file, _("Source Files Header\n"));
5700 fprintf (file, _(" file: %.*s\n"),
5701 (int)(rec_len - sizeof (struct vms_emh_common)),
5702 (char *)rec + sizeof (struct vms_emh_common));
5703 }
5704 break;
5705 case EMH__C_TTL:
5706 {
5707 fprintf (file, _("Title Text Header\n"));
5708 fprintf (file, _(" title: %.*s\n"),
5709 (int)(rec_len - sizeof (struct vms_emh_common)),
5710 (char *)rec + sizeof (struct vms_emh_common));
5711 }
5712 break;
5713 case EMH__C_CPR:
5714 {
5715 fprintf (file, _("Copyright Header\n"));
5716 fprintf (file, _(" copyright: %.*s\n"),
5717 (int)(rec_len - sizeof (struct vms_emh_common)),
5718 (char *)rec + sizeof (struct vms_emh_common));
5719 }
5720 break;
5721 default:
5722 fprintf (file, _("unhandled emh subtype %u\n"), subtype);
5723 break;
5724 }
5725 }
5726
5727 static void
5728 evax_bfd_print_eeom (FILE *file, unsigned char *rec, unsigned int rec_len)
5729 {
5730 struct vms_eeom *eeom = (struct vms_eeom *)rec;
5731
5732 fprintf (file, _(" EEOM (len=%u):\n"), rec_len);
5733 fprintf (file, _(" number of cond linkage pairs: %u\n"),
5734 (unsigned)bfd_getl32 (eeom->total_lps));
5735 fprintf (file, _(" completion code: %u\n"),
5736 (unsigned)bfd_getl16 (eeom->comcod));
5737 if (rec_len > 10)
5738 {
5739 fprintf (file, _(" transfer addr flags: 0x%02x\n"), eeom->tfrflg);
5740 fprintf (file, _(" transfer addr psect: %u\n"),
5741 (unsigned)bfd_getl32 (eeom->psindx));
5742 fprintf (file, _(" transfer address : 0x%08x\n"),
5743 (unsigned)bfd_getl32 (eeom->tfradr));
5744 }
5745 }
5746
5747 static void
5748 exav_bfd_print_egsy_flags (unsigned int flags, FILE *file)
5749 {
5750 if (flags & EGSY__V_WEAK)
5751 fputs (_(" WEAK"), file);
5752 if (flags & EGSY__V_DEF)
5753 fputs (_(" DEF"), file);
5754 if (flags & EGSY__V_UNI)
5755 fputs (_(" UNI"), file);
5756 if (flags & EGSY__V_REL)
5757 fputs (_(" REL"), file);
5758 if (flags & EGSY__V_COMM)
5759 fputs (_(" COMM"), file);
5760 if (flags & EGSY__V_VECEP)
5761 fputs (_(" VECEP"), file);
5762 if (flags & EGSY__V_NORM)
5763 fputs (_(" NORM"), file);
5764 if (flags & EGSY__V_QUAD_VAL)
5765 fputs (_(" QVAL"), file);
5766 }
5767
5768 static void
5769 evax_bfd_print_egsd_flags (FILE *file, unsigned int flags)
5770 {
5771 if (flags & EGPS__V_PIC)
5772 fputs (_(" PIC"), file);
5773 if (flags & EGPS__V_LIB)
5774 fputs (_(" LIB"), file);
5775 if (flags & EGPS__V_OVR)
5776 fputs (_(" OVR"), file);
5777 if (flags & EGPS__V_REL)
5778 fputs (_(" REL"), file);
5779 if (flags & EGPS__V_GBL)
5780 fputs (_(" GBL"), file);
5781 if (flags & EGPS__V_SHR)
5782 fputs (_(" SHR"), file);
5783 if (flags & EGPS__V_EXE)
5784 fputs (_(" EXE"), file);
5785 if (flags & EGPS__V_RD)
5786 fputs (_(" RD"), file);
5787 if (flags & EGPS__V_WRT)
5788 fputs (_(" WRT"), file);
5789 if (flags & EGPS__V_VEC)
5790 fputs (_(" VEC"), file);
5791 if (flags & EGPS__V_NOMOD)
5792 fputs (_(" NOMOD"), file);
5793 if (flags & EGPS__V_COM)
5794 fputs (_(" COM"), file);
5795 if (flags & EGPS__V_ALLOC_64BIT)
5796 fputs (_(" 64B"), file);
5797 }
5798
5799 static void
5800 evax_bfd_print_egsd (FILE *file, unsigned char *rec, unsigned int rec_len)
5801 {
5802 unsigned int off = sizeof (struct vms_egsd);
5803 unsigned int n;
5804
5805 fprintf (file, _(" EGSD (len=%u):\n"), rec_len);
5806
5807 n = 0;
5808 for (off = sizeof (struct vms_egsd); off < rec_len; )
5809 {
5810 struct vms_egsd_entry *e = (struct vms_egsd_entry *)(rec + off);
5811 unsigned int type;
5812 unsigned int len;
5813
5814 type = (unsigned)bfd_getl16 (e->gsdtyp);
5815 len = (unsigned)bfd_getl16 (e->gsdsiz);
5816
5817 fprintf (file, _(" EGSD entry %2u (type: %u, len: %u): "),
5818 n, type, len);
5819 n++;
5820
5821 switch (type)
5822 {
5823 case EGSD__C_PSC:
5824 {
5825 struct vms_egps *egps = (struct vms_egps *)e;
5826 unsigned int flags = bfd_getl16 (egps->flags);
5827 unsigned int l;
5828
5829 fprintf (file, _("PSC - Program section definition\n"));
5830 fprintf (file, _(" alignment : 2**%u\n"), egps->align);
5831 fprintf (file, _(" flags : 0x%04x"), flags);
5832 evax_bfd_print_egsd_flags (file, flags);
5833 fputc ('\n', file);
5834 l = bfd_getl32 (egps->alloc);
5835 fprintf (file, _(" alloc (len): %u (0x%08x)\n"), l, l);
5836 fprintf (file, _(" name : %.*s\n"),
5837 egps->namlng, egps->name);
5838 }
5839 break;
5840 case EGSD__C_SPSC:
5841 {
5842 struct vms_esgps *esgps = (struct vms_esgps *)e;
5843 unsigned int flags = bfd_getl16 (esgps->flags);
5844 unsigned int l;
5845
5846 fprintf (file, _("SPSC - Shared Image Program section def\n"));
5847 fprintf (file, _(" alignment : 2**%u\n"), esgps->align);
5848 fprintf (file, _(" flags : 0x%04x"), flags);
5849 evax_bfd_print_egsd_flags (file, flags);
5850 fputc ('\n', file);
5851 l = bfd_getl32 (esgps->alloc);
5852 fprintf (file, _(" alloc (len) : %u (0x%08x)\n"), l, l);
5853 fprintf (file, _(" image offset : 0x%08x\n"),
5854 (unsigned int)bfd_getl32 (esgps->base));
5855 fprintf (file, _(" symvec offset : 0x%08x\n"),
5856 (unsigned int)bfd_getl32 (esgps->value));
5857 fprintf (file, _(" name : %.*s\n"),
5858 esgps->namlng, esgps->name);
5859 }
5860 break;
5861 case EGSD__C_SYM:
5862 {
5863 struct vms_egsy *egsy = (struct vms_egsy *)e;
5864 unsigned int flags = bfd_getl16 (egsy->flags);
5865
5866 if (flags & EGSY__V_DEF)
5867 {
5868 struct vms_esdf *esdf = (struct vms_esdf *)e;
5869
5870 fprintf (file, _("SYM - Global symbol definition\n"));
5871 fprintf (file, _(" flags: 0x%04x"), flags);
5872 exav_bfd_print_egsy_flags (flags, file);
5873 fputc ('\n', file);
5874 fprintf (file, _(" psect offset: 0x%08x\n"),
5875 (unsigned)bfd_getl32 (esdf->value));
5876 if (flags & EGSY__V_NORM)
5877 {
5878 fprintf (file, _(" code address: 0x%08x\n"),
5879 (unsigned)bfd_getl32 (esdf->code_address));
5880 fprintf (file, _(" psect index for entry point : %u\n"),
5881 (unsigned)bfd_getl32 (esdf->ca_psindx));
5882 }
5883 fprintf (file, _(" psect index : %u\n"),
5884 (unsigned)bfd_getl32 (esdf->psindx));
5885 fprintf (file, _(" name : %.*s\n"),
5886 esdf->namlng, esdf->name);
5887 }
5888 else
5889 {
5890 struct vms_esrf *esrf = (struct vms_esrf *)e;
5891
5892 fprintf (file, _("SYM - Global symbol reference\n"));
5893 fprintf (file, _(" name : %.*s\n"),
5894 esrf->namlng, esrf->name);
5895 }
5896 }
5897 break;
5898 case EGSD__C_IDC:
5899 {
5900 struct vms_eidc *eidc = (struct vms_eidc *)e;
5901 unsigned int flags = bfd_getl32 (eidc->flags);
5902 unsigned char *p;
5903
5904 fprintf (file, _("IDC - Ident Consistency check\n"));
5905 fprintf (file, _(" flags : 0x%08x"), flags);
5906 if (flags & EIDC__V_BINIDENT)
5907 fputs (" BINDENT", file);
5908 fputc ('\n', file);
5909 fprintf (file, _(" id match : %x\n"),
5910 (flags >> EIDC__V_IDMATCH_SH) & EIDC__V_IDMATCH_MASK);
5911 fprintf (file, _(" error severity: %x\n"),
5912 (flags >> EIDC__V_ERRSEV_SH) & EIDC__V_ERRSEV_MASK);
5913 p = eidc->name;
5914 fprintf (file, _(" entity name : %.*s\n"), p[0], p + 1);
5915 p += 1 + p[0];
5916 fprintf (file, _(" object name : %.*s\n"), p[0], p + 1);
5917 p += 1 + p[0];
5918 if (flags & EIDC__V_BINIDENT)
5919 fprintf (file, _(" binary ident : 0x%08x\n"),
5920 (unsigned)bfd_getl32 (p + 1));
5921 else
5922 fprintf (file, _(" ascii ident : %.*s\n"), p[0], p + 1);
5923 }
5924 break;
5925 case EGSD__C_SYMG:
5926 {
5927 struct vms_egst *egst = (struct vms_egst *)e;
5928 unsigned int flags = bfd_getl16 (egst->header.flags);
5929
5930 fprintf (file, _("SYMG - Universal symbol definition\n"));
5931 fprintf (file, _(" flags: 0x%04x"), flags);
5932 exav_bfd_print_egsy_flags (flags, file);
5933 fputc ('\n', file);
5934 fprintf (file, _(" symbol vector offset: 0x%08x\n"),
5935 (unsigned)bfd_getl32 (egst->value));
5936 fprintf (file, _(" entry point: 0x%08x\n"),
5937 (unsigned)bfd_getl32 (egst->lp_1));
5938 fprintf (file, _(" proc descr : 0x%08x\n"),
5939 (unsigned)bfd_getl32 (egst->lp_2));
5940 fprintf (file, _(" psect index: %u\n"),
5941 (unsigned)bfd_getl32 (egst->psindx));
5942 fprintf (file, _(" name : %.*s\n"),
5943 egst->namlng, egst->name);
5944 }
5945 break;
5946 case EGSD__C_SYMV:
5947 {
5948 struct vms_esdfv *esdfv = (struct vms_esdfv *)e;
5949 unsigned int flags = bfd_getl16 (esdfv->flags);
5950
5951 fprintf (file, _("SYMV - Vectored symbol definition\n"));
5952 fprintf (file, _(" flags: 0x%04x"), flags);
5953 exav_bfd_print_egsy_flags (flags, file);
5954 fputc ('\n', file);
5955 fprintf (file, _(" vector : 0x%08x\n"),
5956 (unsigned)bfd_getl32 (esdfv->vector));
5957 fprintf (file, _(" psect offset: %u\n"),
5958 (unsigned)bfd_getl32 (esdfv->value));
5959 fprintf (file, _(" psect index : %u\n"),
5960 (unsigned)bfd_getl32 (esdfv->psindx));
5961 fprintf (file, _(" name : %.*s\n"),
5962 esdfv->namlng, esdfv->name);
5963 }
5964 break;
5965 case EGSD__C_SYMM:
5966 {
5967 struct vms_esdfm *esdfm = (struct vms_esdfm *)e;
5968 unsigned int flags = bfd_getl16 (esdfm->flags);
5969
5970 fprintf (file, _("SYMM - Global symbol definition with version\n"));
5971 fprintf (file, _(" flags: 0x%04x"), flags);
5972 exav_bfd_print_egsy_flags (flags, file);
5973 fputc ('\n', file);
5974 fprintf (file, _(" version mask: 0x%08x\n"),
5975 (unsigned)bfd_getl32 (esdfm->version_mask));
5976 fprintf (file, _(" psect offset: %u\n"),
5977 (unsigned)bfd_getl32 (esdfm->value));
5978 fprintf (file, _(" psect index : %u\n"),
5979 (unsigned)bfd_getl32 (esdfm->psindx));
5980 fprintf (file, _(" name : %.*s\n"),
5981 esdfm->namlng, esdfm->name);
5982 }
5983 break;
5984 default:
5985 fprintf (file, _("unhandled egsd entry type %u\n"), type);
5986 break;
5987 }
5988 off += len;
5989 }
5990 }
5991
5992 static void
5993 evax_bfd_print_hex (FILE *file, const char *pfx,
5994 const unsigned char *buf, unsigned int len)
5995 {
5996 unsigned int i;
5997 unsigned int n;
5998
5999 n = 0;
6000 for (i = 0; i < len; i++)
6001 {
6002 if (n == 0)
6003 fputs (pfx, file);
6004 fprintf (file, " %02x", buf[i]);
6005 n++;
6006 if (n == 16)
6007 {
6008 n = 0;
6009 fputc ('\n', file);
6010 }
6011 }
6012 if (n != 0)
6013 fputc ('\n', file);
6014 }
6015
6016 static void
6017 evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
6018 {
6019 fprintf (file, _(" linkage index: %u, replacement insn: 0x%08x\n"),
6020 (unsigned)bfd_getl32 (buf),
6021 (unsigned)bfd_getl32 (buf + 16));
6022 fprintf (file, _(" psect idx 1: %u, offset 1: 0x%08x %08x\n"),
6023 (unsigned)bfd_getl32 (buf + 4),
6024 (unsigned)bfd_getl32 (buf + 12),
6025 (unsigned)bfd_getl32 (buf + 8));
6026 fprintf (file, _(" psect idx 2: %u, offset 2: 0x%08x %08x\n"),
6027 (unsigned)bfd_getl32 (buf + 20),
6028 (unsigned)bfd_getl32 (buf + 28),
6029 (unsigned)bfd_getl32 (buf + 24));
6030 if (is_ps)
6031 fprintf (file, _(" psect idx 3: %u, offset 3: 0x%08x %08x\n"),
6032 (unsigned)bfd_getl32 (buf + 32),
6033 (unsigned)bfd_getl32 (buf + 40),
6034 (unsigned)bfd_getl32 (buf + 36));
6035 else
6036 fprintf (file, _(" global name: %.*s\n"), buf[32], buf + 33);
6037 }
6038
6039 static void
6040 evax_bfd_print_etir (FILE *file, const char *name,
6041 unsigned char *rec, unsigned int rec_len)
6042 {
6043 unsigned int off = sizeof (struct vms_egsd);
6044 unsigned int sec_len;
6045
6046 fprintf (file, _(" %s (len=%u+%u):\n"), name,
6047 (unsigned)(rec_len - sizeof (struct vms_eobjrec)),
6048 (unsigned)sizeof (struct vms_eobjrec));
6049
6050 for (off = sizeof (struct vms_eobjrec); off < rec_len; )
6051 {
6052 struct vms_etir *etir = (struct vms_etir *)(rec + off);
6053 unsigned char *buf;
6054 unsigned int type;
6055 unsigned int size;
6056
6057 type = bfd_getl16 (etir->rectyp);
6058 size = bfd_getl16 (etir->size);
6059 buf = rec + off + sizeof (struct vms_etir);
6060
6061 fprintf (file, _(" (type: %3u, size: 4+%3u): "), type, size - 4);
6062 switch (type)
6063 {
6064 case ETIR__C_STA_GBL:
6065 fprintf (file, _("STA_GBL (stack global) %.*s\n"),
6066 buf[0], buf + 1);
6067 break;
6068 case ETIR__C_STA_LW:
6069 fprintf (file, _("STA_LW (stack longword) 0x%08x\n"),
6070 (unsigned)bfd_getl32 (buf));
6071 break;
6072 case ETIR__C_STA_QW:
6073 fprintf (file, _("STA_QW (stack quadword) 0x%08x %08x\n"),
6074 (unsigned)bfd_getl32 (buf + 4),
6075 (unsigned)bfd_getl32 (buf + 0));
6076 break;
6077 case ETIR__C_STA_PQ:
6078 fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
6079 fprintf (file, _(" psect: %u, offset: 0x%08x %08x\n"),
6080 (unsigned)bfd_getl32 (buf + 0),
6081 (unsigned)bfd_getl32 (buf + 8),
6082 (unsigned)bfd_getl32 (buf + 4));
6083 break;
6084 case ETIR__C_STA_LI:
6085 fprintf (file, _("STA_LI (stack literal)\n"));
6086 break;
6087 case ETIR__C_STA_MOD:
6088 fprintf (file, _("STA_MOD (stack module)\n"));
6089 break;
6090 case ETIR__C_STA_CKARG:
6091 fprintf (file, _("STA_CKARG (compare procedure argument)\n"));
6092 break;
6093
6094 case ETIR__C_STO_B:
6095 fprintf (file, _("STO_B (store byte)\n"));
6096 break;
6097 case ETIR__C_STO_W:
6098 fprintf (file, _("STO_W (store word)\n"));
6099 break;
6100 case ETIR__C_STO_LW:
6101 fprintf (file, _("STO_LW (store longword)\n"));
6102 break;
6103 case ETIR__C_STO_QW:
6104 fprintf (file, _("STO_QW (store quadword)\n"));
6105 break;
6106 case ETIR__C_STO_IMMR:
6107 {
6108 unsigned int len = bfd_getl32 (buf);
6109 fprintf (file,
6110 _("STO_IMMR (store immediate repeat) %u bytes\n"),
6111 len);
6112 evax_bfd_print_hex (file, " ", buf + 4, len);
6113 sec_len += len;
6114 }
6115 break;
6116 case ETIR__C_STO_GBL:
6117 fprintf (file, _("STO_GBL (store global) %.*s\n"),
6118 buf[0], buf + 1);
6119 break;
6120 case ETIR__C_STO_CA:
6121 fprintf (file, _("STO_CA (store code address) %.*s\n"),
6122 buf[0], buf + 1);
6123 break;
6124 case ETIR__C_STO_RB:
6125 fprintf (file, _("STO_RB (store relative branch)\n"));
6126 break;
6127 case ETIR__C_STO_AB:
6128 fprintf (file, _("STO_AB (store absolute branch)\n"));
6129 break;
6130 case ETIR__C_STO_OFF:
6131 fprintf (file, _("STO_OFF (store offset to psect)\n"));
6132 break;
6133 case ETIR__C_STO_IMM:
6134 {
6135 unsigned int len = bfd_getl32 (buf);
6136 fprintf (file,
6137 _("STO_IMM (store immediate) %u bytes\n"),
6138 len);
6139 evax_bfd_print_hex (file, " ", buf + 4, len);
6140 sec_len += len;
6141 }
6142 break;
6143 case ETIR__C_STO_GBL_LW:
6144 fprintf (file, _("STO_GBL_LW (store global longword) %.*s\n"),
6145 buf[0], buf + 1);
6146 break;
6147 case ETIR__C_STO_LP_PSB:
6148 fprintf (file, _("STO_OFF (store LP with procedure signature)\n"));
6149 break;
6150 case ETIR__C_STO_HINT_GBL:
6151 fprintf (file, _("STO_BR_GBL (store branch global) *todo*\n"));
6152 break;
6153 case ETIR__C_STO_HINT_PS:
6154 fprintf (file, _("STO_BR_PS (store branch psect + offset) *todo*\n"));
6155 break;
6156
6157 case ETIR__C_OPR_NOP:
6158 fprintf (file, _("OPR_NOP (no-operation)\n"));
6159 break;
6160 case ETIR__C_OPR_ADD:
6161 fprintf (file, _("OPR_ADD (add)\n"));
6162 break;
6163 case ETIR__C_OPR_SUB:
6164 fprintf (file, _("OPR_SUB (substract)\n"));
6165 break;
6166 case ETIR__C_OPR_MUL:
6167 fprintf (file, _("OPR_MUL (multiply)\n"));
6168 break;
6169 case ETIR__C_OPR_DIV:
6170 fprintf (file, _("OPR_DIV (divide)\n"));
6171 break;
6172 case ETIR__C_OPR_AND:
6173 fprintf (file, _("OPR_AND (logical and)\n"));
6174 break;
6175 case ETIR__C_OPR_IOR:
6176 fprintf (file, _("OPR_IOR (logical inclusive or)\n"));
6177 break;
6178 case ETIR__C_OPR_EOR:
6179 fprintf (file, _("OPR_EOR (logical exclusive or)\n"));
6180 break;
6181 case ETIR__C_OPR_NEG:
6182 fprintf (file, _("OPR_NEG (negate)\n"));
6183 break;
6184 case ETIR__C_OPR_COM:
6185 fprintf (file, _("OPR_COM (complement)\n"));
6186 break;
6187 case ETIR__C_OPR_INSV:
6188 fprintf (file, _("OPR_INSV (insert field)\n"));
6189 break;
6190 case ETIR__C_OPR_ASH:
6191 fprintf (file, _("OPR_ASH (arithmetic shift)\n"));
6192 break;
6193 case ETIR__C_OPR_USH:
6194 fprintf (file, _("OPR_USH (unsigned shift)\n"));
6195 break;
6196 case ETIR__C_OPR_ROT:
6197 fprintf (file, _("OPR_ROT (rotate)\n"));
6198 break;
6199 case ETIR__C_OPR_SEL:
6200 fprintf (file, _("OPR_SEL (select)\n"));
6201 break;
6202 case ETIR__C_OPR_REDEF:
6203 fprintf (file, _("OPR_REDEF (redefine symbol to curr location)\n"));
6204 break;
6205 case ETIR__C_OPR_DFLIT:
6206 fprintf (file, _("OPR_REDEF (define a literal)\n"));
6207 break;
6208
6209 case ETIR__C_STC_LP:
6210 fprintf (file, _("STC_LP (store cond linkage pair)\n"));
6211 break;
6212 case ETIR__C_STC_LP_PSB:
6213 fprintf (file,
6214 _("STC_LP_PSB (store cond linkage pair + signature)\n"));
6215 fprintf (file, _(" linkage index: %u, procedure: %.*s\n"),
6216 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6217 buf += 4 + 1 + buf[4];
6218 fprintf (file, _(" signature: %.*s\n"), buf[0], buf + 1);
6219 break;
6220 case ETIR__C_STC_GBL:
6221 fprintf (file, _("STC_GBL (store cond global)\n"));
6222 fprintf (file, _(" linkage index: %u, global: %.*s\n"),
6223 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6224 break;
6225 case ETIR__C_STC_GCA:
6226 fprintf (file, _("STC_GCA (store cond code address)\n"));
6227 fprintf (file, _(" linkage index: %u, procedure name: %.*s\n"),
6228 (unsigned)bfd_getl32 (buf), buf[4], buf + 5);
6229 break;
6230 case ETIR__C_STC_PS:
6231 fprintf (file, _("STC_PS (store cond psect + offset)\n"));
6232 fprintf (file,
6233 _(" linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
6234 (unsigned)bfd_getl32 (buf),
6235 (unsigned)bfd_getl32 (buf + 4),
6236 (unsigned)bfd_getl32 (buf + 12),
6237 (unsigned)bfd_getl32 (buf + 8));
6238 break;
6239 case ETIR__C_STC_NOP_GBL:
6240 fprintf (file, _("STC_NOP_GBL (store cond NOP at global addr)\n"));
6241 evax_bfd_print_etir_stc_ir (file, buf, 0);
6242 break;
6243 case ETIR__C_STC_NOP_PS:
6244 fprintf (file, _("STC_NOP_PS (store cond NOP at psect + offset)\n"));
6245 evax_bfd_print_etir_stc_ir (file, buf, 1);
6246 break;
6247 case ETIR__C_STC_BSR_GBL:
6248 fprintf (file, _("STC_BSR_GBL (store cond BSR at global addr)\n"));
6249 evax_bfd_print_etir_stc_ir (file, buf, 0);
6250 break;
6251 case ETIR__C_STC_BSR_PS:
6252 fprintf (file, _("STC_BSR_PS (store cond BSR at psect + offset)\n"));
6253 evax_bfd_print_etir_stc_ir (file, buf, 1);
6254 break;
6255 case ETIR__C_STC_LDA_GBL:
6256 fprintf (file, _("STC_LDA_GBL (store cond LDA at global addr)\n"));
6257 evax_bfd_print_etir_stc_ir (file, buf, 0);
6258 break;
6259 case ETIR__C_STC_LDA_PS:
6260 fprintf (file, _("STC_LDA_PS (store cond LDA at psect + offset)\n"));
6261 evax_bfd_print_etir_stc_ir (file, buf, 1);
6262 break;
6263 case ETIR__C_STC_BOH_GBL:
6264 fprintf (file, _("STC_BOH_GBL (store cond BOH at global addr)\n"));
6265 evax_bfd_print_etir_stc_ir (file, buf, 0);
6266 break;
6267 case ETIR__C_STC_BOH_PS:
6268 fprintf (file, _("STC_BOH_PS (store cond BOH at psect + offset)\n"));
6269 evax_bfd_print_etir_stc_ir (file, buf, 1);
6270 break;
6271 case ETIR__C_STC_NBH_GBL:
6272 fprintf (file,
6273 _("STC_NBH_GBL (store cond or hint at global addr)\n"));
6274 break;
6275 case ETIR__C_STC_NBH_PS:
6276 fprintf (file,
6277 _("STC_NBH_PS (store cond or hint at psect + offset)\n"));
6278 break;
6279
6280 case ETIR__C_CTL_SETRB:
6281 fprintf (file, _("CTL_SETRB (set relocation base)\n"));
6282 sec_len += 4;
6283 break;
6284 case ETIR__C_CTL_AUGRB:
6285 {
6286 unsigned int val = bfd_getl32 (buf);
6287 fprintf (file, _("CTL_AUGRB (augment relocation base) %u\n"), val);
6288 }
6289 break;
6290 case ETIR__C_CTL_DFLOC:
6291 fprintf (file, _("CTL_DFLOC (define location)\n"));
6292 break;
6293 case ETIR__C_CTL_STLOC:
6294 fprintf (file, _("CTL_STLOC (set location)\n"));
6295 break;
6296 case ETIR__C_CTL_STKDL:
6297 fprintf (file, _("CTL_STKDL (stack defined location)\n"));
6298 break;
6299 default:
6300 fprintf (file, _("*unhandled*\n"));
6301 break;
6302 }
6303 off += size;
6304 }
6305 }
6306
6307 static void
6308 evax_bfd_print_eobj (struct bfd *abfd, FILE *file)
6309 {
6310 bfd_boolean is_first = TRUE;
6311 bfd_boolean has_records = FALSE;
6312
6313 while (1)
6314 {
6315 unsigned int rec_len;
6316 unsigned int pad_len;
6317 unsigned char *rec;
6318 unsigned int hdr_size;
6319 unsigned int type;
6320
6321 if (is_first)
6322 {
6323 unsigned char buf[6];
6324
6325 is_first = FALSE;
6326
6327 /* Read 6 bytes. */
6328 if (bfd_bread (buf, sizeof (buf), abfd) != sizeof (buf))
6329 {
6330 fprintf (file, _("cannot read GST record length\n"));
6331 return;
6332 }
6333 rec_len = bfd_getl16 (buf + 0);
6334 if (rec_len == bfd_getl16 (buf + 4)
6335 && bfd_getl16 (buf + 2) == EOBJ__C_EMH)
6336 {
6337 /* The format is raw: record-size, type, record-size. */
6338 has_records = TRUE;
6339 pad_len = (rec_len + 1) & ~1U;
6340 hdr_size = 4;
6341 }
6342 else if (rec_len == EOBJ__C_EMH)
6343 {
6344 has_records = FALSE;
6345 pad_len = bfd_getl16 (buf + 2);
6346 hdr_size = 6;
6347 }
6348 else
6349 {
6350 /* Ill-formed. */
6351 fprintf (file, _("cannot find EMH in first GST record\n"));
6352 return;
6353 }
6354 rec = bfd_malloc (pad_len);
6355 memcpy (rec, buf + sizeof (buf) - hdr_size, hdr_size);
6356 }
6357 else
6358 {
6359 unsigned int rec_len2 = 0;
6360 unsigned char hdr[4];
6361
6362 if (has_records)
6363 {
6364 unsigned char buf_len[2];
6365
6366 if (bfd_bread (buf_len, sizeof (buf_len), abfd)
6367 != sizeof (buf_len))
6368 {
6369 fprintf (file, _("cannot read GST record length\n"));
6370 return;
6371 }
6372 rec_len2 = (unsigned)bfd_getl16 (buf_len);
6373 }
6374
6375 if (bfd_bread (hdr, sizeof (hdr), abfd) != sizeof (hdr))
6376 {
6377 fprintf (file, _("cannot read GST record header\n"));
6378 return;
6379 }
6380 rec_len = (unsigned)bfd_getl16 (hdr + 2);
6381 if (has_records)
6382 pad_len = (rec_len + 1) & ~1U;
6383 else
6384 pad_len = rec_len;
6385 rec = bfd_malloc (pad_len);
6386 memcpy (rec, hdr, sizeof (hdr));
6387 hdr_size = sizeof (hdr);
6388 if (has_records && rec_len2 != rec_len)
6389 {
6390 fprintf (file, _(" corrupted GST\n"));
6391 break;
6392 }
6393 }
6394
6395 if (bfd_bread (rec + hdr_size, pad_len - hdr_size, abfd)
6396 != pad_len - hdr_size)
6397 {
6398 fprintf (file, _("cannot read GST record\n"));
6399 return;
6400 }
6401
6402 type = (unsigned)bfd_getl16 (rec);
6403
6404 switch (type)
6405 {
6406 case EOBJ__C_EMH:
6407 evax_bfd_print_emh (file, rec, rec_len);
6408 break;
6409 case EOBJ__C_EGSD:
6410 evax_bfd_print_egsd (file, rec, rec_len);
6411 break;
6412 case EOBJ__C_EEOM:
6413 evax_bfd_print_eeom (file, rec, rec_len);
6414 free (rec);
6415 return;
6416 break;
6417 case EOBJ__C_ETIR:
6418 evax_bfd_print_etir (file, "ETIR", rec, rec_len);
6419 break;
6420 case EOBJ__C_EDBG:
6421 evax_bfd_print_etir (file, "EDBG", rec, rec_len);
6422 break;
6423 case EOBJ__C_ETBT:
6424 evax_bfd_print_etir (file, "ETBT", rec, rec_len);
6425 break;
6426 default:
6427 fprintf (file, _(" unhandled EOBJ record type %u\n"), type);
6428 break;
6429 }
6430 free (rec);
6431 }
6432 }
6433
6434 static void
6435 evax_bfd_print_relocation_records (FILE *file, const unsigned char *rel,
6436 unsigned int stride)
6437 {
6438 while (1)
6439 {
6440 unsigned int base;
6441 unsigned int count;
6442 unsigned int j;
6443
6444 count = bfd_getl32 (rel + 0);
6445
6446 if (count == 0)
6447 break;
6448 base = bfd_getl32 (rel + 4);
6449
6450 fprintf (file, _(" bitcount: %u, base addr: 0x%08x\n"),
6451 count, base);
6452
6453 rel += 8;
6454 for (j = 0; count > 0; j += 4, count -= 32)
6455 {
6456 unsigned int k;
6457 unsigned int n = 0;
6458 unsigned int val;
6459
6460 val = bfd_getl32 (rel);
6461 rel += 4;
6462
6463 fprintf (file, _(" bitmap: 0x%08x (count: %u):\n"), val, count);
6464
6465 for (k = 0; k < 32; k++)
6466 if (val & (1 << k))
6467 {
6468 if (n == 0)
6469 fputs (" ", file);
6470 fprintf (file, _(" %08x"), base + (j * 8 + k) * stride);
6471 n++;
6472 if (n == 8)
6473 {
6474 fputs ("\n", file);
6475 n = 0;
6476 }
6477 }
6478 if (n)
6479 fputs ("\n", file);
6480 }
6481 }
6482 }
6483
6484 static void
6485 evax_bfd_print_address_fixups (FILE *file, const unsigned char *rel)
6486 {
6487 while (1)
6488 {
6489 unsigned int j;
6490 unsigned int count;
6491
6492 count = bfd_getl32 (rel + 0);
6493 if (count == 0)
6494 return;
6495 fprintf (file, _(" image %u (%u entries)\n"),
6496 (unsigned)bfd_getl32 (rel + 4), count);
6497 rel += 8;
6498 for (j = 0; j < count; j++)
6499 {
6500 fprintf (file, _(" offset: 0x%08x, val: 0x%08x\n"),
6501 (unsigned)bfd_getl32 (rel + 0),
6502 (unsigned)bfd_getl32 (rel + 4));
6503 rel += 8;
6504 }
6505 }
6506 }
6507
6508 static void
6509 evax_bfd_print_reference_fixups (FILE *file, const unsigned char *rel)
6510 {
6511 unsigned int count;
6512
6513 while (1)
6514 {
6515 unsigned int j;
6516 unsigned int n = 0;
6517
6518 count = bfd_getl32 (rel + 0);
6519 if (count == 0)
6520 break;
6521 fprintf (file, _(" image %u (%u entries), offsets:\n"),
6522 (unsigned)bfd_getl32 (rel + 4), count);
6523 rel += 8;
6524 for (j = 0; j < count; j++)
6525 {
6526 if (n == 0)
6527 fputs (" ", file);
6528 fprintf (file, _(" 0x%08x"), (unsigned)bfd_getl32 (rel));
6529 n++;
6530 if (n == 7)
6531 {
6532 fputs ("\n", file);
6533 n = 0;
6534 }
6535 rel += 4;
6536 }
6537 if (n)
6538 fputs ("\n", file);
6539 }
6540 }
6541
6542 static void
6543 evax_bfd_print_indent (int indent, FILE *file)
6544 {
6545 for (; indent; indent--)
6546 fputc (' ', file);
6547 }
6548
6549 static const char *
6550 evax_bfd_get_dsc_name (unsigned int v)
6551 {
6552 switch (v)
6553 {
6554 case DSC__K_DTYPE_Z:
6555 return "Z (Unspecified)";
6556 case DSC__K_DTYPE_V:
6557 return "V (Bit)";
6558 case DSC__K_DTYPE_BU:
6559 return "BU (Byte logical)";
6560 case DSC__K_DTYPE_WU:
6561 return "WU (Word logical)";
6562 case DSC__K_DTYPE_LU:
6563 return "LU (Longword logical)";
6564 case DSC__K_DTYPE_QU:
6565 return "QU (Quadword logical)";
6566 case DSC__K_DTYPE_B:
6567 return "B (Byte integer)";
6568 case DSC__K_DTYPE_W:
6569 return "W (Word integer)";
6570 case DSC__K_DTYPE_L:
6571 return "L (Longword integer)";
6572 case DSC__K_DTYPE_Q:
6573 return "Q (Quadword integer)";
6574 case DSC__K_DTYPE_F:
6575 return "F (Single-precision floating)";
6576 case DSC__K_DTYPE_D:
6577 return "D (Double-precision floating)";
6578 case DSC__K_DTYPE_FC:
6579 return "FC (Complex)";
6580 case DSC__K_DTYPE_DC:
6581 return "DC (Double-precision Complex)";
6582 case DSC__K_DTYPE_T:
6583 return "T (ASCII text string)";
6584 case DSC__K_DTYPE_NU:
6585 return "NU (Numeric string, unsigned)";
6586 case DSC__K_DTYPE_NL:
6587 return "NL (Numeric string, left separate sign)";
6588 case DSC__K_DTYPE_NLO:
6589 return "NLO (Numeric string, left overpunched sign)";
6590 case DSC__K_DTYPE_NR:
6591 return "NR (Numeric string, right separate sign)";
6592 case DSC__K_DTYPE_NRO:
6593 return "NRO (Numeric string, right overpunched sig)";
6594 case DSC__K_DTYPE_NZ:
6595 return "NZ (Numeric string, zoned sign)";
6596 case DSC__K_DTYPE_P:
6597 return "P (Packed decimal string)";
6598 case DSC__K_DTYPE_ZI:
6599 return "ZI (Sequence of instructions)";
6600 case DSC__K_DTYPE_ZEM:
6601 return "ZEM (Procedure entry mask)";
6602 case DSC__K_DTYPE_DSC:
6603 return "DSC (Descriptor, used for arrays of dyn strings)";
6604 case DSC__K_DTYPE_OU:
6605 return "OU (Octaword logical)";
6606 case DSC__K_DTYPE_O:
6607 return "O (Octaword integer)";
6608 case DSC__K_DTYPE_G:
6609 return "G (Double precision G floating, 64 bit)";
6610 case DSC__K_DTYPE_H:
6611 return "H (Quadruple precision floating, 128 bit)";
6612 case DSC__K_DTYPE_GC:
6613 return "GC (Double precision complex, G floating)";
6614 case DSC__K_DTYPE_HC:
6615 return "HC (Quadruple precision complex, H floating)";
6616 case DSC__K_DTYPE_CIT:
6617 return "CIT (COBOL intermediate temporary)";
6618 case DSC__K_DTYPE_BPV:
6619 return "BPV (Bound Procedure Value)";
6620 case DSC__K_DTYPE_BLV:
6621 return "BLV (Bound Label Value)";
6622 case DSC__K_DTYPE_VU:
6623 return "VU (Bit Unaligned)";
6624 case DSC__K_DTYPE_ADT:
6625 return "ADT (Absolute Date-Time)";
6626 case DSC__K_DTYPE_VT:
6627 return "VT (Varying Text)";
6628 case DSC__K_DTYPE_T2:
6629 return "T2 (16-bit char)";
6630 case DSC__K_DTYPE_VT2:
6631 return "VT2 (16-bit varying char)";
6632 default:
6633 return "?? (unknown)";
6634 }
6635 }
6636
6637 static void
6638 evax_bfd_print_desc (const unsigned char *buf, int indent, FILE *file)
6639 {
6640 unsigned char bclass = buf[3];
6641 unsigned char dtype = buf[2];
6642 unsigned int len = (unsigned)bfd_getl16 (buf);
6643 unsigned int pointer = (unsigned)bfd_getl32 (buf + 4);
6644
6645 evax_bfd_print_indent (indent, file);
6646
6647 if (len == 1 && pointer == 0xffffffffUL)
6648 {
6649 /* 64 bits. */
6650 fprintf (file, _("64 bits *unhandled*\n"));
6651 }
6652 else
6653 {
6654 fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
6655 bclass, dtype, len, pointer);
6656 switch (bclass)
6657 {
6658 case DSC__K_CLASS_NCA:
6659 {
6660 const struct vms_dsc_nca *dsc = (const void *)buf;
6661 unsigned int i;
6662 const unsigned char *b;
6663
6664 evax_bfd_print_indent (indent, file);
6665 fprintf (file, _("non-contiguous array of %s\n"),
6666 evax_bfd_get_dsc_name (dsc->dtype));
6667 evax_bfd_print_indent (indent + 1, file);
6668 fprintf (file,
6669 _("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
6670 dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
6671 evax_bfd_print_indent (indent + 1, file);
6672 fprintf (file,
6673 _("arsize: %u, a0: 0x%08x\n"),
6674 (unsigned)bfd_getl32 (dsc->arsize),
6675 (unsigned)bfd_getl32 (dsc->a0));
6676 evax_bfd_print_indent (indent + 1, file);
6677 fprintf (file, _("Strides:\n"));
6678 b = buf + sizeof (*dsc);
6679 for (i = 0; i < dsc->dimct; i++)
6680 {
6681 evax_bfd_print_indent (indent + 2, file);
6682 fprintf (file, _("[%u]: %u\n"), i + 1,
6683 (unsigned)bfd_getl32 (b));
6684 b += 4;
6685 }
6686 evax_bfd_print_indent (indent + 1, file);
6687 fprintf (file, _("Bounds:\n"));
6688 b = buf + sizeof (*dsc);
6689 for (i = 0; i < dsc->dimct; i++)
6690 {
6691 evax_bfd_print_indent (indent + 2, file);
6692 fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
6693 (unsigned)bfd_getl32 (b + 0),
6694 (unsigned)bfd_getl32 (b + 4));
6695 b += 8;
6696 }
6697 }
6698 break;
6699 case DSC__K_CLASS_UBS:
6700 {
6701 const struct vms_dsc_ubs *ubs = (const void *)buf;
6702
6703 evax_bfd_print_indent (indent, file);
6704 fprintf (file, _("unaligned bit-string of %s\n"),
6705 evax_bfd_get_dsc_name (ubs->dtype));
6706 evax_bfd_print_indent (indent + 1, file);
6707 fprintf (file,
6708 _("base: %u, pos: %u\n"),
6709 (unsigned)bfd_getl32 (ubs->base),
6710 (unsigned)bfd_getl32 (ubs->pos));
6711 }
6712 break;
6713 default:
6714 fprintf (file, _("*unhandled*\n"));
6715 break;
6716 }
6717 }
6718 }
6719
6720 static unsigned int
6721 evax_bfd_print_valspec (const unsigned char *buf, int indent, FILE *file)
6722 {
6723 unsigned int vflags = buf[0];
6724 unsigned int value = (unsigned)bfd_getl32 (buf + 1);
6725 unsigned int len = 5;
6726
6727 evax_bfd_print_indent (indent, file);
6728 fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
6729 buf += 5;
6730
6731 switch (vflags)
6732 {
6733 case DST__K_VFLAGS_NOVAL:
6734 fprintf (file, _("(no value)\n"));
6735 break;
6736 case DST__K_VFLAGS_NOTACTIVE:
6737 fprintf (file, _("(not active)\n"));
6738 break;
6739 case DST__K_VFLAGS_UNALLOC:
6740 fprintf (file, _("(not allocated)\n"));
6741 break;
6742 case DST__K_VFLAGS_DSC:
6743 fprintf (file, _("(descriptor)\n"));
6744 evax_bfd_print_desc (buf + value, indent + 1, file);
6745 break;
6746 case DST__K_VFLAGS_TVS:
6747 fprintf (file, _("(trailing value)\n"));
6748 break;
6749 case DST__K_VS_FOLLOWS:
6750 fprintf (file, _("(value spec follows)\n"));
6751 break;
6752 case DST__K_VFLAGS_BITOFFS:
6753 fprintf (file, _("(at bit offset %u)\n"), value);
6754 break;
6755 default:
6756 fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
6757 (vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
6758 vflags & DST__K_DISP ? 1 : 0,
6759 vflags & DST__K_INDIR ? 1 : 0);
6760 switch (vflags & DST__K_VALKIND_MASK)
6761 {
6762 case DST__K_VALKIND_LITERAL:
6763 fputs (_("literal"), file);
6764 break;
6765 case DST__K_VALKIND_ADDR:
6766 fputs (_("address"), file);
6767 break;
6768 case DST__K_VALKIND_DESC:
6769 fputs (_("desc"), file);
6770 break;
6771 case DST__K_VALKIND_REG:
6772 fputs (_("reg"), file);
6773 break;
6774 }
6775 fputs (")\n", file);
6776 break;
6777 }
6778 return len;
6779 }
6780
6781 static void
6782 evax_bfd_print_typspec (const unsigned char *buf, int indent, FILE *file)
6783 {
6784 unsigned char kind = buf[2];
6785 unsigned int len = (unsigned)bfd_getl16 (buf);
6786
6787 evax_bfd_print_indent (indent, file);
6788 fprintf (file, ("len: %2u, kind: %2u "), len, kind);
6789 buf += 3;
6790 switch (kind)
6791 {
6792 case DST__K_TS_ATOM:
6793 fprintf (file, ("atomic, type=0x%02x %s\n"),
6794 buf[0], evax_bfd_get_dsc_name (buf[0]));
6795 break;
6796 case DST__K_TS_IND:
6797 fprintf (file, ("indirect, defined at 0x%08x\n"),
6798 (unsigned)bfd_getl32 (buf));
6799 break;
6800 case DST__K_TS_TPTR:
6801 fprintf (file, ("typed pointer\n"));
6802 evax_bfd_print_typspec (buf, indent + 1, file);
6803 break;
6804 case DST__K_TS_PTR:
6805 fprintf (file, ("pointer\n"));
6806 break;
6807 case DST__K_TS_ARRAY:
6808 {
6809 const unsigned char *vs;
6810 unsigned int vec_len;
6811 unsigned int i;
6812
6813 fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
6814 vec_len = (buf[0] + 1 + 7) / 8;
6815 for (i = 0; i < vec_len; i++)
6816 fprintf (file, " %02x", buf[i + 1]);
6817 fputc ('\n', file);
6818 vs = buf + 1 + vec_len;
6819 evax_bfd_print_indent (indent, file);
6820 fprintf (file, ("array descriptor:\n"));
6821 vs += evax_bfd_print_valspec (vs, indent + 1, file);
6822 for (i = 0; i < buf[0] + 1U; i++)
6823 if (buf[1 + i / 8] & (1 << (i % 8)))
6824 {
6825 evax_bfd_print_indent (indent, file);
6826 if (i == 0)
6827 fprintf (file, ("type spec for element:\n"));
6828 else
6829 fprintf (file, ("type spec for subscript %u:\n"), i);
6830 evax_bfd_print_typspec (vs, indent + 1, file);
6831 vs += bfd_getl16 (vs);
6832 }
6833 }
6834 break;
6835 default:
6836 fprintf (file, ("*unhandled*\n"));
6837 }
6838 }
6839
6840 static void
6841 evax_bfd_print_dst (struct bfd *abfd, unsigned int dst_size, FILE *file)
6842 {
6843 unsigned int off = 0;
6844 unsigned int pc = 0;
6845 unsigned int line = 0;
6846
6847 fprintf (file, _("Debug symbol table:\n"));
6848
6849 while (dst_size > 0)
6850 {
6851 struct vms_dst_header dsth;
6852 unsigned int len;
6853 unsigned int type;
6854 unsigned char *buf;
6855
6856 if (bfd_bread (&dsth, sizeof (dsth), abfd) != sizeof (dsth))
6857 {
6858 fprintf (file, _("cannot read DST header\n"));
6859 return;
6860 }
6861 len = bfd_getl16 (dsth.length);
6862 type = bfd_getl16 (dsth.type);
6863 fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
6864 type, len, off);
6865 if (len == 0)
6866 {
6867 fputc ('\n', file);
6868 break;
6869 }
6870 len++;
6871 dst_size -= len;
6872 off += len;
6873 len -= sizeof (dsth);
6874 buf = bfd_malloc (len);
6875 if (bfd_bread (buf, len, abfd) != len)
6876 {
6877 fprintf (file, _("cannot read DST symbol\n"));
6878 return;
6879 }
6880 switch (type)
6881 {
6882 case DSC__K_DTYPE_V:
6883 case DSC__K_DTYPE_BU:
6884 case DSC__K_DTYPE_WU:
6885 case DSC__K_DTYPE_LU:
6886 case DSC__K_DTYPE_QU:
6887 case DSC__K_DTYPE_B:
6888 case DSC__K_DTYPE_W:
6889 case DSC__K_DTYPE_L:
6890 case DSC__K_DTYPE_Q:
6891 case DSC__K_DTYPE_F:
6892 case DSC__K_DTYPE_D:
6893 case DSC__K_DTYPE_FC:
6894 case DSC__K_DTYPE_DC:
6895 case DSC__K_DTYPE_T:
6896 case DSC__K_DTYPE_NU:
6897 case DSC__K_DTYPE_NL:
6898 case DSC__K_DTYPE_NLO:
6899 case DSC__K_DTYPE_NR:
6900 case DSC__K_DTYPE_NRO:
6901 case DSC__K_DTYPE_NZ:
6902 case DSC__K_DTYPE_P:
6903 case DSC__K_DTYPE_ZI:
6904 case DSC__K_DTYPE_ZEM:
6905 case DSC__K_DTYPE_DSC:
6906 case DSC__K_DTYPE_OU:
6907 case DSC__K_DTYPE_O:
6908 case DSC__K_DTYPE_G:
6909 case DSC__K_DTYPE_H:
6910 case DSC__K_DTYPE_GC:
6911 case DSC__K_DTYPE_HC:
6912 case DSC__K_DTYPE_CIT:
6913 case DSC__K_DTYPE_BPV:
6914 case DSC__K_DTYPE_BLV:
6915 case DSC__K_DTYPE_VU:
6916 case DSC__K_DTYPE_ADT:
6917 case DSC__K_DTYPE_VT:
6918 case DSC__K_DTYPE_T2:
6919 case DSC__K_DTYPE_VT2:
6920 fprintf (file, _("standard data: %s\n"),
6921 evax_bfd_get_dsc_name (type));
6922 evax_bfd_print_valspec (buf, 4, file);
6923 fprintf (file, _(" name: %.*s\n"), buf[5], buf + 6);
6924 break;
6925 case DST__K_MODBEG:
6926 {
6927 struct vms_dst_modbeg *dst = (void *)buf;
6928 const char *name = (const char *)buf + sizeof (*dst);
6929
6930 fprintf (file, _("modbeg\n"));
6931 fprintf (file, _(" flags: %d, language: %u, "
6932 "major: %u, minor: %u\n"),
6933 dst->flags,
6934 (unsigned)bfd_getl32 (dst->language),
6935 (unsigned)bfd_getl16 (dst->major),
6936 (unsigned)bfd_getl16 (dst->minor));
6937 fprintf (file, _(" module name: %.*s\n"),
6938 name[0], name + 1);
6939 name += name[0] + 1;
6940 fprintf (file, _(" compiler : %.*s\n"),
6941 name[0], name + 1);
6942 }
6943 break;
6944 case DST__K_MODEND:
6945 fprintf (file, _("modend\n"));
6946 break;
6947 case DST__K_RTNBEG:
6948 {
6949 struct vms_dst_rtnbeg *dst = (void *)buf;
6950 const char *name = (const char *)buf + sizeof (*dst);
6951
6952 fputs (_("rtnbeg\n"), file);
6953 fprintf (file, _(" flags: %u, address: 0x%08x, "
6954 "pd-address: 0x%08x\n"),
6955 dst->flags,
6956 (unsigned)bfd_getl32 (dst->address),
6957 (unsigned)bfd_getl32 (dst->pd_address));
6958 fprintf (file, _(" routine name: %.*s\n"),
6959 name[0], name + 1);
6960 }
6961 break;
6962 case DST__K_RTNEND:
6963 {
6964 struct vms_dst_rtnend *dst = (void *)buf;
6965
6966 fprintf (file, _("rtnend: size 0x%08x\n"),
6967 (unsigned)bfd_getl32 (dst->size));
6968 }
6969 break;
6970 case DST__K_PROLOG:
6971 {
6972 struct vms_dst_prolog *dst = (void *)buf;
6973
6974 fprintf (file, _("prolog: bkpt address 0x%08x\n"),
6975 (unsigned)bfd_getl32 (dst->bkpt_addr));
6976 }
6977 break;
6978 case DST__K_EPILOG:
6979 {
6980 struct vms_dst_epilog *dst = (void *)buf;
6981
6982 fprintf (file, _("epilog: flags: %u, count: %u\n"),
6983 dst->flags, (unsigned)bfd_getl32 (dst->count));
6984 }
6985 break;
6986 case DST__K_BLKBEG:
6987 {
6988 struct vms_dst_blkbeg *dst = (void *)buf;
6989 const char *name = (const char *)buf + sizeof (*dst);
6990
6991 fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
6992 (unsigned)bfd_getl32 (dst->address),
6993 name[0], name + 1);
6994 }
6995 break;
6996 case DST__K_BLKEND:
6997 {
6998 struct vms_dst_blkend *dst = (void *)buf;
6999
7000 fprintf (file, _("blkend: size: 0x%08x\n"),
7001 (unsigned)bfd_getl32 (dst->size));
7002 }
7003 break;
7004 case DST__K_TYPSPEC:
7005 {
7006 fprintf (file, _("typspec (len: %u)\n"), len);
7007 fprintf (file, _(" name: %.*s\n"), buf[0], buf + 1);
7008 evax_bfd_print_typspec (buf + 1 + buf[0], 5, file);
7009 }
7010 break;
7011 case DST__K_SEPTYP:
7012 {
7013 fprintf (file, _("septyp, name: %.*s\n"), buf[5], buf + 6);
7014 evax_bfd_print_valspec (buf, 4, file);
7015 }
7016 break;
7017 case DST__K_RECBEG:
7018 {
7019 struct vms_dst_recbeg *recbeg = (void *)buf;
7020 const char *name = (const char *)buf + sizeof (*recbeg);
7021
7022 fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
7023 evax_bfd_print_valspec (buf, 4, file);
7024 fprintf (file, (" len: %u bits\n"),
7025 (unsigned)bfd_getl32 (name + 1 + name[0]));
7026 }
7027 break;
7028 case DST__K_RECEND:
7029 fprintf (file, _("recend\n"));
7030 break;
7031 case DST__K_ENUMBEG:
7032 fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
7033 buf[0], buf[1], buf + 2);
7034 break;
7035 case DST__K_ENUMELT:
7036 fprintf (file, _("enumelt, name: %.*s\n"), buf[5], buf + 6);
7037 evax_bfd_print_valspec (buf, 4, file);
7038 break;
7039 case DST__K_ENUMEND:
7040 fprintf (file, _("enumend\n"));
7041 break;
7042 case DST__K_LABEL:
7043 {
7044 struct vms_dst_label *lab = (void *)buf;
7045 fprintf (file, ("label, name: %.*s\n"),
7046 lab->name[0], lab->name + 1);
7047 fprintf (file, (" address: 0x%08x\n"),
7048 (unsigned)bfd_getl32 (lab->value));
7049 }
7050 break;
7051 case DST__K_DIS_RANGE:
7052 {
7053 unsigned int cnt = bfd_getl32 (buf);
7054 unsigned char *rng = buf + 4;
7055 unsigned int i;
7056
7057 fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
7058 for (i = 0; i < cnt; i++, rng += 8)
7059 fprintf (file, _(" address: 0x%08x, size: %u\n"),
7060 (unsigned)bfd_getl32 (rng),
7061 (unsigned)bfd_getl32 (rng + 4));
7062
7063 }
7064 break;
7065 case DST__K_LINE_NUM:
7066 {
7067 unsigned char *buf_orig = buf;
7068
7069 fprintf (file, _("line num (len: %u)\n"), len);
7070
7071 while (len > 0)
7072 {
7073 signed char cmd;
7074 unsigned char cmdlen;
7075 unsigned int val;
7076
7077 cmd = buf[0];
7078 cmdlen = 0;
7079
7080 fputs (" ", file);
7081
7082 switch (cmd)
7083 {
7084 case DST__K_DELTA_PC_W:
7085 val = bfd_getl16 (buf + 1);
7086 fprintf (file, _("delta_pc_w %u\n"), val);
7087 pc += val;
7088 line++;
7089 cmdlen = 3;
7090 break;
7091 case DST__K_INCR_LINUM:
7092 val = buf[1];
7093 fprintf (file, _("incr_linum(b): +%u\n"), val);
7094 line += val;
7095 cmdlen = 2;
7096 break;
7097 case DST__K_INCR_LINUM_W:
7098 val = bfd_getl16 (buf + 1);
7099 fprintf (file, _("incr_linum_w: +%u\n"), val);
7100 line += val;
7101 cmdlen = 3;
7102 break;
7103 case DST__K_INCR_LINUM_L:
7104 val = bfd_getl32 (buf + 1);
7105 fprintf (file, _("incr_linum_l: +%u\n"), val);
7106 line += val;
7107 cmdlen = 5;
7108 break;
7109 case DST__K_SET_LINUM:
7110 line = bfd_getl16 (buf + 1);
7111 fprintf (file, _("set_line_num(w) %u\n"), line);
7112 cmdlen = 3;
7113 break;
7114 case DST__K_SET_LINUM_B:
7115 line = buf[1];
7116 fprintf (file, _("set_line_num_b %u\n"), line);
7117 cmdlen = 2;
7118 break;
7119 case DST__K_SET_LINUM_L:
7120 line = bfd_getl32 (buf + 1);
7121 fprintf (file, _("set_line_num_l %u\n"), line);
7122 cmdlen = 5;
7123 break;
7124 case DST__K_SET_ABS_PC:
7125 pc = bfd_getl32 (buf + 1);
7126 fprintf (file, _("set_abs_pc: 0x%08x\n"), pc);
7127 cmdlen = 5;
7128 break;
7129 case DST__K_DELTA_PC_L:
7130 fprintf (file, _("delta_pc_l: +0x%08x\n"),
7131 (unsigned)bfd_getl32 (buf + 1));
7132 cmdlen = 5;
7133 break;
7134 case DST__K_TERM:
7135 fprintf (file, _("term(b): 0x%02x"), buf[1]);
7136 pc += buf[1];
7137 fprintf (file, _(" pc: 0x%08x\n"), pc);
7138 cmdlen = 2;
7139 break;
7140 case DST__K_TERM_W:
7141 val = bfd_getl16 (buf + 1);
7142 fprintf (file, _("term_w: 0x%04x"), val);
7143 pc += val;
7144 fprintf (file, _(" pc: 0x%08x\n"), pc);
7145 cmdlen = 3;
7146 break;
7147 default:
7148 if (cmd <= 0)
7149 {
7150 fprintf (file, _("delta pc +%-4d"), -cmd);
7151 line++; /* FIXME: curr increment. */
7152 pc += -cmd;
7153 fprintf (file, _(" pc: 0x%08x line: %5u\n"),
7154 pc, line);
7155 cmdlen = 1;
7156 }
7157 else
7158 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7159 break;
7160 }
7161 if (cmdlen == 0)
7162 break;
7163 len -= cmdlen;
7164 buf += cmdlen;
7165 }
7166 buf = buf_orig;
7167 }
7168 break;
7169 case DST__K_SOURCE:
7170 {
7171 unsigned char *buf_orig = buf;
7172
7173 fprintf (file, _("source (len: %u)\n"), len);
7174
7175 while (len > 0)
7176 {
7177 signed char cmd = buf[0];
7178 unsigned char cmdlen = 0;
7179
7180 switch (cmd)
7181 {
7182 case DST__K_SRC_DECLFILE:
7183 {
7184 struct vms_dst_src_decl_src *src = (void *)(buf + 1);
7185 const char *name;
7186
7187 fprintf (file, _(" declfile: len: %u, flags: %u, "
7188 "fileid: %u\n"),
7189 src->length, src->flags,
7190 (unsigned)bfd_getl16 (src->fileid));
7191 fprintf (file, _(" rms: cdt: 0x%08x %08x, "
7192 "ebk: 0x%08x, ffb: 0x%04x, "
7193 "rfo: %u\n"),
7194 (unsigned)bfd_getl32 (src->rms_cdt + 4),
7195 (unsigned)bfd_getl32 (src->rms_cdt + 0),
7196 (unsigned)bfd_getl32 (src->rms_ebk),
7197 (unsigned)bfd_getl16 (src->rms_ffb),
7198 src->rms_rfo);
7199 name = (const char *)buf + 1 + sizeof (*src);
7200 fprintf (file, _(" filename : %.*s\n"),
7201 name[0], name + 1);
7202 name += name[0] + 1;
7203 fprintf (file, _(" module name: %.*s\n"),
7204 name[0], name + 1);
7205 cmdlen = 2 + src->length;
7206 }
7207 break;
7208 case DST__K_SRC_SETFILE:
7209 fprintf (file, _(" setfile %u\n"),
7210 (unsigned)bfd_getl16 (buf + 1));
7211 cmdlen = 3;
7212 break;
7213 case DST__K_SRC_SETREC_W:
7214 fprintf (file, _(" setrec %u\n"),
7215 (unsigned)bfd_getl16 (buf + 1));
7216 cmdlen = 3;
7217 break;
7218 case DST__K_SRC_SETREC_L:
7219 fprintf (file, _(" setrec %u\n"),
7220 (unsigned)bfd_getl32 (buf + 1));
7221 cmdlen = 5;
7222 break;
7223 case DST__K_SRC_SETLNUM_W:
7224 fprintf (file, _(" setlnum %u\n"),
7225 (unsigned)bfd_getl16 (buf + 1));
7226 cmdlen = 3;
7227 break;
7228 case DST__K_SRC_SETLNUM_L:
7229 fprintf (file, _(" setlnum %u\n"),
7230 (unsigned)bfd_getl32 (buf + 1));
7231 cmdlen = 5;
7232 break;
7233 case DST__K_SRC_DEFLINES_W:
7234 fprintf (file, _(" deflines %u\n"),
7235 (unsigned)bfd_getl16 (buf + 1));
7236 cmdlen = 3;
7237 break;
7238 case DST__K_SRC_DEFLINES_B:
7239 fprintf (file, _(" deflines %u\n"), buf[1]);
7240 cmdlen = 2;
7241 break;
7242 case DST__K_SRC_FORMFEED:
7243 fprintf (file, _(" formfeed\n"));
7244 cmdlen = 1;
7245 break;
7246 default:
7247 fprintf (file, _(" *unhandled* cmd %u\n"), cmd);
7248 break;
7249 }
7250 if (cmdlen == 0)
7251 break;
7252 len -= cmdlen;
7253 buf += cmdlen;
7254 }
7255 buf = buf_orig;
7256 }
7257 break;
7258 default:
7259 fprintf (file, _("*unhandled* dst type %u\n"), type);
7260 break;
7261 }
7262 free (buf);
7263 }
7264 }
7265
7266 static void
7267 evax_bfd_print_image (bfd *abfd, FILE *file)
7268 {
7269 struct vms_eihd eihd;
7270 const char *name;
7271 unsigned int val;
7272 unsigned int eiha_off;
7273 unsigned int eihi_off;
7274 unsigned int eihs_off;
7275 unsigned int eisd_off;
7276 unsigned int eihef_off = 0;
7277 unsigned int eihnp_off = 0;
7278 unsigned int dmt_vbn = 0;
7279 unsigned int dmt_size = 0;
7280 unsigned int dst_vbn = 0;
7281 unsigned int dst_size = 0;
7282 unsigned int gst_vbn = 0;
7283 unsigned int gst_size = 0;
7284 unsigned int eiaf_vbn = 0;
7285 unsigned int eiaf_size = 0;
7286 unsigned int eihvn_off;
7287
7288 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)
7289 || bfd_bread (&eihd, sizeof (eihd), abfd) != sizeof (eihd))
7290 {
7291 fprintf (file, _("cannot read EIHD\n"));
7292 return;
7293 }
7294 fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
7295 (unsigned)bfd_getl32 (eihd.size),
7296 (unsigned)bfd_getl32 (eihd.hdrblkcnt));
7297 fprintf (file, _(" majorid: %u, minorid: %u\n"),
7298 (unsigned)bfd_getl32 (eihd.majorid),
7299 (unsigned)bfd_getl32 (eihd.minorid));
7300
7301 val = (unsigned)bfd_getl32 (eihd.imgtype);
7302 switch (val)
7303 {
7304 case EIHD__K_EXE:
7305 name = _("executable");
7306 break;
7307 case EIHD__K_LIM:
7308 name = _("linkable image");
7309 break;
7310 default:
7311 name = _("unknown");
7312 break;
7313 }
7314 fprintf (file, _(" image type: %u (%s)"), val, name);
7315
7316 val = (unsigned)bfd_getl32 (eihd.subtype);
7317 switch (val)
7318 {
7319 case EIHD__C_NATIVE:
7320 name = _("native");
7321 break;
7322 case EIHD__C_CLI:
7323 name = _("CLI");
7324 break;
7325 default:
7326 name = _("unknown");
7327 break;
7328 }
7329 fprintf (file, _(", subtype: %u (%s)\n"), val, name);
7330
7331 eisd_off = bfd_getl32 (eihd.isdoff);
7332 eiha_off = bfd_getl32 (eihd.activoff);
7333 eihi_off = bfd_getl32 (eihd.imgidoff);
7334 eihs_off = bfd_getl32 (eihd.symdbgoff);
7335 fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
7336 "imgid: %u, patch: %u\n"),
7337 eisd_off, eiha_off, eihs_off, eihi_off,
7338 (unsigned)bfd_getl32 (eihd.patchoff));
7339 fprintf (file, _(" fixup info rva: "));
7340 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.iafva));
7341 fprintf (file, _(", symbol vector rva: "));
7342 bfd_fprintf_vma (abfd, file, bfd_getl64 (eihd.symvva));
7343 eihvn_off = bfd_getl32 (eihd.version_array_off);
7344 fprintf (file, _("\n"
7345 " version array off: %u\n"),
7346 eihvn_off);
7347 fprintf (file,
7348 _(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
7349 (unsigned)bfd_getl32 (eihd.imgiocnt),
7350 (unsigned)bfd_getl32 (eihd.iochancnt),
7351 (unsigned)bfd_getl32 (eihd.privreqs + 4),
7352 (unsigned)bfd_getl32 (eihd.privreqs + 0));
7353 val = (unsigned)bfd_getl32 (eihd.lnkflags);
7354 fprintf (file, _(" linker flags: %08x:"), val);
7355 if (val & EIHD__M_LNKDEBUG)
7356 fprintf (file, " LNKDEBUG");
7357 if (val & EIHD__M_LNKNOTFR)
7358 fprintf (file, " LNKNOTFR");
7359 if (val & EIHD__M_NOP0BUFS)
7360 fprintf (file, " NOP0BUFS");
7361 if (val & EIHD__M_PICIMG)
7362 fprintf (file, " PICIMG");
7363 if (val & EIHD__M_P0IMAGE)
7364 fprintf (file, " P0IMAGE");
7365 if (val & EIHD__M_DBGDMT)
7366 fprintf (file, " DBGDMT");
7367 if (val & EIHD__M_INISHR)
7368 fprintf (file, " INISHR");
7369 if (val & EIHD__M_XLATED)
7370 fprintf (file, " XLATED");
7371 if (val & EIHD__M_BIND_CODE_SEC)
7372 fprintf (file, " BIND_CODE_SEC");
7373 if (val & EIHD__M_BIND_DATA_SEC)
7374 fprintf (file, " BIND_DATA_SEC");
7375 if (val & EIHD__M_MKTHREADS)
7376 fprintf (file, " MKTHREADS");
7377 if (val & EIHD__M_UPCALLS)
7378 fprintf (file, " UPCALLS");
7379 if (val & EIHD__M_OMV_READY)
7380 fprintf (file, " OMV_READY");
7381 if (val & EIHD__M_EXT_BIND_SECT)
7382 fprintf (file, " EXT_BIND_SECT");
7383 fprintf (file, "\n");
7384 fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
7385 "match ctrl: %u, symvect_size: %u\n"),
7386 (unsigned)bfd_getl32 (eihd.ident),
7387 (unsigned)bfd_getl32 (eihd.sysver),
7388 eihd.matchctl,
7389 (unsigned)bfd_getl32 (eihd.symvect_size));
7390 fprintf (file, _(" BPAGE: %u"),
7391 (unsigned)bfd_getl32 (eihd.virt_mem_block_size));
7392 if (val & (EIHD__M_OMV_READY | EIHD__M_EXT_BIND_SECT))
7393 {
7394 eihef_off = bfd_getl32 (eihd.ext_fixup_off);
7395 eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
7396 fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
7397 eihef_off, eihnp_off);
7398 }
7399 fprintf (file, _(", alias: %u\n"), (unsigned)bfd_getl16 (eihd.alias));
7400
7401 if (eihvn_off != 0)
7402 {
7403 struct vms_eihvn eihvn;
7404 unsigned int mask;
7405 unsigned int j;
7406
7407 fprintf (file, _("system version array information:\n"));
7408 if (bfd_seek (abfd, (file_ptr) eihvn_off, SEEK_SET)
7409 || bfd_bread (&eihvn, sizeof (eihvn), abfd) != sizeof (eihvn))
7410 {
7411 fprintf (file, _("cannot read EIHVN header\n"));
7412 return;
7413 }
7414 mask = bfd_getl32 (eihvn.subsystem_mask);
7415 for (j = 0; j < 32; j++)
7416 if (mask & (1 << j))
7417 {
7418 struct vms_eihvn_subversion ver;
7419 if (bfd_bread (&ver, sizeof (ver), abfd) != sizeof (ver))
7420 {
7421 fprintf (file, _("cannot read EIHVN version\n"));
7422 return;
7423 }
7424 fprintf (file, _(" %02u "), j);
7425 switch (j)
7426 {
7427 case EIHVN__BASE_IMAGE_BIT:
7428 fputs (_("BASE_IMAGE "), file);
7429 break;
7430 case EIHVN__MEMORY_MANAGEMENT_BIT:
7431 fputs (_("MEMORY_MANAGEMENT"), file);
7432 break;
7433 case EIHVN__IO_BIT:
7434 fputs (_("IO "), file);
7435 break;
7436 case EIHVN__FILES_VOLUMES_BIT:
7437 fputs (_("FILES_VOLUMES "), file);
7438 break;
7439 case EIHVN__PROCESS_SCHED_BIT:
7440 fputs (_("PROCESS_SCHED "), file);
7441 break;
7442 case EIHVN__SYSGEN_BIT:
7443 fputs (_("SYSGEN "), file);
7444 break;
7445 case EIHVN__CLUSTERS_LOCKMGR_BIT:
7446 fputs (_("CLUSTERS_LOCKMGR "), file);
7447 break;
7448 case EIHVN__LOGICAL_NAMES_BIT:
7449 fputs (_("LOGICAL_NAMES "), file);
7450 break;
7451 case EIHVN__SECURITY_BIT:
7452 fputs (_("SECURITY "), file);
7453 break;
7454 case EIHVN__IMAGE_ACTIVATOR_BIT:
7455 fputs (_("IMAGE_ACTIVATOR "), file);
7456 break;
7457 case EIHVN__NETWORKS_BIT:
7458 fputs (_("NETWORKS "), file);
7459 break;
7460 case EIHVN__COUNTERS_BIT:
7461 fputs (_("COUNTERS "), file);
7462 break;
7463 case EIHVN__STABLE_BIT:
7464 fputs (_("STABLE "), file);
7465 break;
7466 case EIHVN__MISC_BIT:
7467 fputs (_("MISC "), file);
7468 break;
7469 case EIHVN__CPU_BIT:
7470 fputs (_("CPU "), file);
7471 break;
7472 case EIHVN__VOLATILE_BIT:
7473 fputs (_("VOLATILE "), file);
7474 break;
7475 case EIHVN__SHELL_BIT:
7476 fputs (_("SHELL "), file);
7477 break;
7478 case EIHVN__POSIX_BIT:
7479 fputs (_("POSIX "), file);
7480 break;
7481 case EIHVN__MULTI_PROCESSING_BIT:
7482 fputs (_("MULTI_PROCESSING "), file);
7483 break;
7484 case EIHVN__GALAXY_BIT:
7485 fputs (_("GALAXY "), file);
7486 break;
7487 default:
7488 fputs (_("*unknown* "), file);
7489 break;
7490 }
7491 fprintf (file, _(": %u.%u\n"),
7492 (unsigned)bfd_getl16 (ver.major),
7493 (unsigned)bfd_getl16 (ver.minor));
7494 }
7495 }
7496
7497 if (eiha_off != 0)
7498 {
7499 struct vms_eiha eiha;
7500
7501 if (bfd_seek (abfd, (file_ptr) eiha_off, SEEK_SET)
7502 || bfd_bread (&eiha, sizeof (eiha), abfd) != sizeof (eiha))
7503 {
7504 fprintf (file, _("cannot read EIHA\n"));
7505 return;
7506 }
7507 fprintf (file, _("Image activation: (size=%u)\n"),
7508 (unsigned)bfd_getl32 (eiha.size));
7509 fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
7510 (unsigned)bfd_getl32 (eiha.tfradr1_h),
7511 (unsigned)bfd_getl32 (eiha.tfradr1));
7512 fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
7513 (unsigned)bfd_getl32 (eiha.tfradr2_h),
7514 (unsigned)bfd_getl32 (eiha.tfradr2));
7515 fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
7516 (unsigned)bfd_getl32 (eiha.tfradr3_h),
7517 (unsigned)bfd_getl32 (eiha.tfradr3));
7518 fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
7519 (unsigned)bfd_getl32 (eiha.tfradr4_h),
7520 (unsigned)bfd_getl32 (eiha.tfradr4));
7521 fprintf (file, _(" Shared image : 0x%08x 0x%08x\n"),
7522 (unsigned)bfd_getl32 (eiha.inishr_h),
7523 (unsigned)bfd_getl32 (eiha.inishr));
7524 }
7525 if (eihi_off != 0)
7526 {
7527 struct vms_eihi eihi;
7528
7529 if (bfd_seek (abfd, (file_ptr) eihi_off, SEEK_SET)
7530 || bfd_bread (&eihi, sizeof (eihi), abfd) != sizeof (eihi))
7531 {
7532 fprintf (file, _("cannot read EIHI\n"));
7533 return;
7534 }
7535 fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
7536 (unsigned)bfd_getl32 (eihi.majorid),
7537 (unsigned)bfd_getl32 (eihi.minorid));
7538 fprintf (file, _(" image name : %.*s\n"),
7539 eihi.imgnam[0], eihi.imgnam + 1);
7540 fprintf (file, _(" link time : %s\n"),
7541 vms_time_to_str (eihi.linktime));
7542 fprintf (file, _(" image ident : %.*s\n"),
7543 eihi.imgid[0], eihi.imgid + 1);
7544 fprintf (file, _(" linker ident : %.*s\n"),
7545 eihi.linkid[0], eihi.linkid + 1);
7546 fprintf (file, _(" image build ident: %.*s\n"),
7547 eihi.imgbid[0], eihi.imgbid + 1);
7548 }
7549 if (eihs_off != 0)
7550 {
7551 struct vms_eihs eihs;
7552
7553 if (bfd_seek (abfd, (file_ptr) eihs_off, SEEK_SET)
7554 || bfd_bread (&eihs, sizeof (eihs), abfd) != sizeof (eihs))
7555 {
7556 fprintf (file, _("cannot read EIHS\n"));
7557 return;
7558 }
7559 fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
7560 (unsigned)bfd_getl32 (eihs.majorid),
7561 (unsigned)bfd_getl32 (eihs.minorid));
7562 dst_vbn = bfd_getl32 (eihs.dstvbn);
7563 dst_size = bfd_getl32 (eihs.dstsize);
7564 fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
7565 dst_vbn, dst_size, dst_size);
7566 gst_vbn = bfd_getl32 (eihs.gstvbn);
7567 gst_size = bfd_getl32 (eihs.gstsize);
7568 fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
7569 gst_vbn, gst_size);
7570 dmt_vbn = bfd_getl32 (eihs.dmtvbn);
7571 dmt_size = bfd_getl32 (eihs.dmtsize);
7572 fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
7573 dmt_vbn, dmt_size);
7574 }
7575 while (eisd_off != 0)
7576 {
7577 struct vms_eisd eisd;
7578 unsigned int len;
7579
7580 while (1)
7581 {
7582 if (bfd_seek (abfd, (file_ptr) eisd_off, SEEK_SET)
7583 || bfd_bread (&eisd, sizeof (eisd), abfd) != sizeof (eisd))
7584 {
7585 fprintf (file, _("cannot read EISD\n"));
7586 return;
7587 }
7588 len = (unsigned)bfd_getl32 (eisd.eisdsize);
7589 if (len != (unsigned)-1)
7590 break;
7591
7592 /* Next block. */
7593 eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
7594 }
7595 fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
7596 "size: %u, offset: %u)\n"),
7597 (unsigned)bfd_getl32 (eisd.majorid),
7598 (unsigned)bfd_getl32 (eisd.minorid),
7599 len, eisd_off);
7600 if (len == 0)
7601 break;
7602 fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
7603 (unsigned)bfd_getl32 (eisd.virt_addr + 4),
7604 (unsigned)bfd_getl32 (eisd.virt_addr + 0),
7605 (unsigned)bfd_getl32 (eisd.secsize));
7606 val = (unsigned)bfd_getl32 (eisd.flags);
7607 fprintf (file, _(" flags: 0x%04x"), val);
7608 if (val & EISD__M_GBL)
7609 fprintf (file, " GBL");
7610 if (val & EISD__M_CRF)
7611 fprintf (file, " CRF");
7612 if (val & EISD__M_DZRO)
7613 fprintf (file, " DZRO");
7614 if (val & EISD__M_WRT)
7615 fprintf (file, " WRT");
7616 if (val & EISD__M_INITALCODE)
7617 fprintf (file, " INITALCODE");
7618 if (val & EISD__M_BASED)
7619 fprintf (file, " BASED");
7620 if (val & EISD__M_FIXUPVEC)
7621 fprintf (file, " FIXUPVEC");
7622 if (val & EISD__M_RESIDENT)
7623 fprintf (file, " RESIDENT");
7624 if (val & EISD__M_VECTOR)
7625 fprintf (file, " VECTOR");
7626 if (val & EISD__M_PROTECT)
7627 fprintf (file, " PROTECT");
7628 if (val & EISD__M_LASTCLU)
7629 fprintf (file, " LASTCLU");
7630 if (val & EISD__M_EXE)
7631 fprintf (file, " EXE");
7632 if (val & EISD__M_NONSHRADR)
7633 fprintf (file, " NONSHRADR");
7634 if (val & EISD__M_QUAD_LENGTH)
7635 fprintf (file, " QUAD_LENGTH");
7636 if (val & EISD__M_ALLOC_64BIT)
7637 fprintf (file, " ALLOC_64BIT");
7638 fprintf (file, "\n");
7639 if (val & EISD__M_FIXUPVEC)
7640 {
7641 eiaf_vbn = bfd_getl32 (eisd.vbn);
7642 eiaf_size = bfd_getl32 (eisd.secsize);
7643 }
7644 fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
7645 (unsigned)bfd_getl32 (eisd.vbn),
7646 eisd.pfc, eisd.matchctl, eisd.type);
7647 switch (eisd.type)
7648 {
7649 case EISD__K_NORMAL:
7650 fputs (_("NORMAL"), file);
7651 break;
7652 case EISD__K_SHRFXD:
7653 fputs (_("SHRFXD"), file);
7654 break;
7655 case EISD__K_PRVFXD:
7656 fputs (_("PRVFXD"), file);
7657 break;
7658 case EISD__K_SHRPIC:
7659 fputs (_("SHRPIC"), file);
7660 break;
7661 case EISD__K_PRVPIC:
7662 fputs (_("PRVPIC"), file);
7663 break;
7664 case EISD__K_USRSTACK:
7665 fputs (_("USRSTACK"), file);
7666 break;
7667 default:
7668 fputs (_("*unknown*"), file);
7669 break;
7670 }
7671 fputs (_(")\n"), file);
7672 if (val & EISD__M_GBL)
7673 fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
7674 (unsigned)bfd_getl32 (eisd.ident),
7675 eisd.gblnam[0], eisd.gblnam + 1);
7676 eisd_off += len;
7677 }
7678
7679 if (dmt_vbn != 0)
7680 {
7681 if (bfd_seek (abfd, (file_ptr) (dmt_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7682 {
7683 fprintf (file, _("cannot read DMT\n"));
7684 return;
7685 }
7686
7687 fprintf (file, _("Debug module table:\n"));
7688
7689 while (dmt_size > 0)
7690 {
7691 struct vms_dmt_header dmth;
7692 unsigned int count;
7693
7694 if (bfd_bread (&dmth, sizeof (dmth), abfd) != sizeof (dmth))
7695 {
7696 fprintf (file, _("cannot read DMT header\n"));
7697 return;
7698 }
7699 count = bfd_getl16 (dmth.psect_count);
7700 fprintf (file,
7701 _(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
7702 (unsigned)bfd_getl32 (dmth.modbeg),
7703 (unsigned)bfd_getl32 (dmth.size), count);
7704 dmt_size -= sizeof (dmth);
7705 while (count > 0)
7706 {
7707 struct vms_dmt_psect dmtp;
7708
7709 if (bfd_bread (&dmtp, sizeof (dmtp), abfd) != sizeof (dmtp))
7710 {
7711 fprintf (file, _("cannot read DMT psect\n"));
7712 return;
7713 }
7714 fprintf (file, _(" psect start: 0x%08x, length: %u\n"),
7715 (unsigned)bfd_getl32 (dmtp.start),
7716 (unsigned)bfd_getl32 (dmtp.length));
7717 count--;
7718 dmt_size -= sizeof (dmtp);
7719 }
7720 }
7721 }
7722
7723 if (dst_vbn != 0)
7724 {
7725 if (bfd_seek (abfd, (file_ptr) (dst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7726 {
7727 fprintf (file, _("cannot read DST\n"));
7728 return;
7729 }
7730
7731 evax_bfd_print_dst (abfd, dst_size, file);
7732 }
7733 if (gst_vbn != 0)
7734 {
7735 if (bfd_seek (abfd, (file_ptr) (gst_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET))
7736 {
7737 fprintf (file, _("cannot read GST\n"));
7738 return;
7739 }
7740
7741 fprintf (file, _("Global symbol table:\n"));
7742 evax_bfd_print_eobj (abfd, file);
7743 }
7744 if (eiaf_vbn != 0)
7745 {
7746 unsigned char *buf;
7747 struct vms_eiaf *eiaf;
7748 unsigned int qrelfixoff;
7749 unsigned int lrelfixoff;
7750 unsigned int qdotadroff;
7751 unsigned int ldotadroff;
7752 unsigned int shrimgcnt;
7753 unsigned int shlstoff;
7754 unsigned int codeadroff;
7755 unsigned int lpfixoff;
7756 unsigned int chgprtoff;
7757
7758 buf = bfd_malloc (eiaf_size);
7759
7760 if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
7761 || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
7762 {
7763 fprintf (file, _("cannot read EIHA\n"));
7764 free (buf);
7765 return;
7766 }
7767 eiaf = (struct vms_eiaf *)buf;
7768 fprintf (file,
7769 _("Image activator fixup: (major: %u, minor: %u)\n"),
7770 (unsigned)bfd_getl32 (eiaf->majorid),
7771 (unsigned)bfd_getl32 (eiaf->minorid));
7772 fprintf (file, _(" iaflink : 0x%08x %08x\n"),
7773 (unsigned)bfd_getl32 (eiaf->iaflink + 0),
7774 (unsigned)bfd_getl32 (eiaf->iaflink + 4));
7775 fprintf (file, _(" fixuplnk: 0x%08x %08x\n"),
7776 (unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
7777 (unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
7778 fprintf (file, _(" size : %u\n"),
7779 (unsigned)bfd_getl32 (eiaf->size));
7780 fprintf (file, _(" flags: 0x%08x\n"),
7781 (unsigned)bfd_getl32 (eiaf->flags));
7782 qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
7783 lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
7784 fprintf (file, _(" qrelfixoff: %5u, lrelfixoff: %5u\n"),
7785 qrelfixoff, lrelfixoff);
7786 qdotadroff = bfd_getl32 (eiaf->qdotadroff);
7787 ldotadroff = bfd_getl32 (eiaf->ldotadroff);
7788 fprintf (file, _(" qdotadroff: %5u, ldotadroff: %5u\n"),
7789 qdotadroff, ldotadroff);
7790 codeadroff = bfd_getl32 (eiaf->codeadroff);
7791 lpfixoff = bfd_getl32 (eiaf->lpfixoff);
7792 fprintf (file, _(" codeadroff: %5u, lpfixoff : %5u\n"),
7793 codeadroff, lpfixoff);
7794 chgprtoff = bfd_getl32 (eiaf->chgprtoff);
7795 fprintf (file, _(" chgprtoff : %5u\n"), chgprtoff);
7796 shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
7797 shlstoff = bfd_getl32 (eiaf->shlstoff);
7798 fprintf (file, _(" shlstoff : %5u, shrimgcnt : %5u\n"),
7799 shlstoff, shrimgcnt);
7800 fprintf (file, _(" shlextra : %5u, permctx : %5u\n"),
7801 (unsigned)bfd_getl32 (eiaf->shlextra),
7802 (unsigned)bfd_getl32 (eiaf->permctx));
7803 fprintf (file, _(" base_va : 0x%08x\n"),
7804 (unsigned)bfd_getl32 (eiaf->base_va));
7805 fprintf (file, _(" lppsbfixoff: %5u\n"),
7806 (unsigned)bfd_getl32 (eiaf->lppsbfixoff));
7807
7808 if (shlstoff)
7809 {
7810 struct vms_shl *shl = (struct vms_shl *)(buf + shlstoff);
7811 unsigned int j;
7812
7813 fprintf (file, _(" Shareable images:\n"));
7814 for (j = 0; j < shrimgcnt; j++, shl++)
7815 {
7816 fprintf (file,
7817 _(" %u: size: %u, flags: 0x%02x, name: %.*s\n"),
7818 j, shl->size, shl->flags,
7819 shl->imgnam[0], shl->imgnam + 1);
7820 }
7821 }
7822 if (qrelfixoff != 0)
7823 {
7824 fprintf (file, _(" quad-word relocation fixups:\n"));
7825 evax_bfd_print_relocation_records (file, buf + qrelfixoff, 8);
7826 }
7827 if (lrelfixoff != 0)
7828 {
7829 fprintf (file, _(" long-word relocation fixups:\n"));
7830 evax_bfd_print_relocation_records (file, buf + lrelfixoff, 4);
7831 }
7832 if (qdotadroff != 0)
7833 {
7834 fprintf (file, _(" quad-word .address reference fixups:\n"));
7835 evax_bfd_print_address_fixups (file, buf + qdotadroff);
7836 }
7837 if (ldotadroff != 0)
7838 {
7839 fprintf (file, _(" long-word .address reference fixups:\n"));
7840 evax_bfd_print_address_fixups (file, buf + ldotadroff);
7841 }
7842 if (codeadroff != 0)
7843 {
7844 fprintf (file, _(" Code Address Reference Fixups:\n"));
7845 evax_bfd_print_reference_fixups (file, buf + codeadroff);
7846 }
7847 if (lpfixoff != 0)
7848 {
7849 fprintf (file, _(" Linkage Pairs Referece Fixups:\n"));
7850 evax_bfd_print_reference_fixups (file, buf + lpfixoff);
7851 }
7852 if (chgprtoff)
7853 {
7854 unsigned int count = (unsigned)bfd_getl32 (buf + chgprtoff);
7855 struct vms_eicp *eicp = (struct vms_eicp *)(buf + chgprtoff + 4);
7856 unsigned int j;
7857
7858 fprintf (file, _(" Change Protection (%u entries):\n"), count);
7859 for (j = 0; j < count; j++, eicp++)
7860 {
7861 unsigned int prot = bfd_getl32 (eicp->newprt);
7862 fprintf (file,
7863 _(" base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
7864 (unsigned)bfd_getl32 (eicp->baseva + 4),
7865 (unsigned)bfd_getl32 (eicp->baseva + 0),
7866 (unsigned)bfd_getl32 (eicp->size),
7867 (unsigned)bfd_getl32 (eicp->newprt));
7868 switch (prot)
7869 {
7870 case PRT__C_NA:
7871 fprintf (file, "NA");
7872 break;
7873 case PRT__C_RESERVED:
7874 fprintf (file, "RES");
7875 break;
7876 case PRT__C_KW:
7877 fprintf (file, "KW");
7878 break;
7879 case PRT__C_KR:
7880 fprintf (file, "KR");
7881 break;
7882 case PRT__C_UW:
7883 fprintf (file, "UW");
7884 break;
7885 case PRT__C_EW:
7886 fprintf (file, "EW");
7887 break;
7888 case PRT__C_ERKW:
7889 fprintf (file, "ERKW");
7890 break;
7891 case PRT__C_ER:
7892 fprintf (file, "ER");
7893 break;
7894 case PRT__C_SW:
7895 fprintf (file, "SW");
7896 break;
7897 case PRT__C_SREW:
7898 fprintf (file, "SREW");
7899 break;
7900 case PRT__C_SRKW:
7901 fprintf (file, "SRKW");
7902 break;
7903 case PRT__C_SR:
7904 fprintf (file, "SR");
7905 break;
7906 case PRT__C_URSW:
7907 fprintf (file, "URSW");
7908 break;
7909 case PRT__C_UREW:
7910 fprintf (file, "UREW");
7911 break;
7912 case PRT__C_URKW:
7913 fprintf (file, "URKW");
7914 break;
7915 case PRT__C_UR:
7916 fprintf (file, "UR");
7917 break;
7918 default:
7919 fputs ("??", file);
7920 break;
7921 }
7922 fputc ('\n', file);
7923 }
7924 }
7925 free (buf);
7926 }
7927 }
7928
7929 static bfd_boolean
7930 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
7931 {
7932 FILE *file = (FILE *)ptr;
7933
7934 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
7935 evax_bfd_print_image (abfd, file);
7936 else
7937 {
7938 if (bfd_seek (abfd, 0, SEEK_SET))
7939 return FALSE;
7940 evax_bfd_print_eobj (abfd, file);
7941 }
7942 return TRUE;
7943 }
7944 \f
7945 /* Linking. */
7946
7947 /* Slurp ETIR/EDBG/ETBT VMS object records. */
7948
7949 static bfd_boolean
7950 alpha_vms_read_sections_content (bfd *abfd, struct bfd_link_info *info)
7951 {
7952 asection *cur_section;
7953 file_ptr cur_offset;
7954 asection *dst_section;
7955 file_ptr dst_offset;
7956
7957 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
7958 return FALSE;
7959
7960 cur_section = NULL;
7961 cur_offset = 0;
7962
7963 dst_section = PRIV (dst_section);
7964 dst_offset = 0;
7965 if (info)
7966 {
7967 if (info->strip == strip_all || info->strip == strip_debugger)
7968 {
7969 /* Discard the DST section. */
7970 dst_offset = 0;
7971 dst_section = NULL;
7972 }
7973 else if (dst_section)
7974 {
7975 dst_offset = dst_section->output_offset;
7976 dst_section = dst_section->output_section;
7977 }
7978 }
7979
7980 while (1)
7981 {
7982 int type;
7983 bfd_boolean res;
7984
7985 type = _bfd_vms_get_object_record (abfd);
7986 if (type < 0)
7987 {
7988 vms_debug2 ((2, "next_record failed\n"));
7989 return FALSE;
7990 }
7991 switch (type)
7992 {
7993 case EOBJ__C_ETIR:
7994 PRIV (image_section) = cur_section;
7995 PRIV (image_offset) = cur_offset;
7996 res = _bfd_vms_slurp_etir (abfd, info);
7997 cur_section = PRIV (image_section);
7998 cur_offset = PRIV (image_offset);
7999 break;
8000 case EOBJ__C_EDBG:
8001 case EOBJ__C_ETBT:
8002 if (dst_section == NULL)
8003 continue;
8004 PRIV (image_section) = dst_section;
8005 PRIV (image_offset) = dst_offset;
8006 res = _bfd_vms_slurp_etir (abfd, info);
8007 dst_offset = PRIV (image_offset);
8008 break;
8009 case EOBJ__C_EEOM:
8010 return TRUE;
8011 default:
8012 continue;
8013 }
8014 if (!res)
8015 {
8016 vms_debug2 ((2, "slurp eobj type %d failed\n", type));
8017 return FALSE;
8018 }
8019 }
8020 }
8021
8022 static int
8023 alpha_vms_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
8024 struct bfd_link_info *info ATTRIBUTE_UNUSED)
8025 {
8026 return 0;
8027 }
8028
8029 /* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
8030
8031 static void
8032 alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
8033 {
8034 struct alpha_vms_shlib_el *sl;
8035 asection *sect = PRIV2 (src, image_section);
8036 file_ptr offset = PRIV2 (src, image_offset);
8037
8038 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8039 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8040 sl->has_fixups = TRUE;
8041 VEC_APPEND_EL (sl->lp, bfd_vma,
8042 sect->output_section->vma + sect->output_offset + offset);
8043 sect->output_section->flags |= SEC_RELOC;
8044 }
8045
8046 /* Add a code address fixup at address SECT + OFFSET to SHLIB. */
8047
8048 static void
8049 alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
8050 {
8051 struct alpha_vms_shlib_el *sl;
8052 asection *sect = PRIV2 (src, image_section);
8053 file_ptr offset = PRIV2 (src, image_offset);
8054
8055 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8056 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8057 sl->has_fixups = TRUE;
8058 VEC_APPEND_EL (sl->ca, bfd_vma,
8059 sect->output_section->vma + sect->output_offset + offset);
8060 sect->output_section->flags |= SEC_RELOC;
8061 }
8062
8063 /* Add a quad word relocation fixup at address SECT + OFFSET to SHLIB. */
8064
8065 static void
8066 alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
8067 bfd *shlib, bfd_vma vec)
8068 {
8069 struct alpha_vms_shlib_el *sl;
8070 struct alpha_vms_vma_ref *r;
8071 asection *sect = PRIV2 (src, image_section);
8072 file_ptr offset = PRIV2 (src, image_offset);
8073
8074 sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
8075 struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
8076 sl->has_fixups = TRUE;
8077 r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
8078 r->vma = sect->output_section->vma + sect->output_offset + offset;
8079 r->ref = vec;
8080 sect->output_section->flags |= SEC_RELOC;
8081 }
8082
8083 static void
8084 alpha_vms_add_fixup_lr (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8085 unsigned int shr ATTRIBUTE_UNUSED,
8086 bfd_vma vec ATTRIBUTE_UNUSED)
8087 {
8088 /* Not yet supported. */
8089 abort ();
8090 }
8091
8092 /* Add relocation. FIXME: Not yet emitted. */
8093
8094 static void
8095 alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8096 {
8097 }
8098
8099 static void
8100 alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
8101 {
8102 }
8103
8104 static struct bfd_hash_entry *
8105 alpha_vms_link_hash_newfunc (struct bfd_hash_entry *entry,
8106 struct bfd_hash_table *table,
8107 const char *string)
8108 {
8109 struct alpha_vms_link_hash_entry *ret =
8110 (struct alpha_vms_link_hash_entry *) entry;
8111
8112 /* Allocate the structure if it has not already been allocated by a
8113 subclass. */
8114 if (ret == NULL)
8115 ret = ((struct alpha_vms_link_hash_entry *)
8116 bfd_hash_allocate (table,
8117 sizeof (struct alpha_vms_link_hash_entry)));
8118 if (ret == NULL)
8119 return NULL;
8120
8121 /* Call the allocation method of the superclass. */
8122 ret = ((struct alpha_vms_link_hash_entry *)
8123 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
8124 table, string));
8125
8126 ret->sym = NULL;
8127
8128 return (struct bfd_hash_entry *) ret;
8129 }
8130
8131 /* Create an Alpha/VMS link hash table. */
8132
8133 static struct bfd_link_hash_table *
8134 alpha_vms_bfd_link_hash_table_create (bfd *abfd)
8135 {
8136 struct alpha_vms_link_hash_table *ret;
8137 bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
8138
8139 ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
8140 if (ret == NULL)
8141 return NULL;
8142 if (!_bfd_link_hash_table_init (&ret->root, abfd,
8143 alpha_vms_link_hash_newfunc,
8144 sizeof (struct alpha_vms_link_hash_entry)))
8145 {
8146 free (ret);
8147 return NULL;
8148 }
8149
8150 VEC_INIT (ret->shrlibs);
8151 ret->fixup = NULL;
8152
8153 return &ret->root;
8154 }
8155
8156 static bfd_boolean
8157 alpha_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
8158 {
8159 unsigned int i;
8160
8161 for (i = 0; i < PRIV (gsd_sym_count); i++)
8162 {
8163 struct vms_symbol_entry *e = PRIV (syms)[i];
8164 struct alpha_vms_link_hash_entry *h;
8165 struct bfd_link_hash_entry *h_root;
8166 asymbol sym;
8167
8168 if (!alpha_vms_convert_symbol (abfd, e, &sym))
8169 return FALSE;
8170
8171 if ((e->flags & EGSY__V_DEF) && abfd->selective_search)
8172 {
8173 /* In selective_search mode, only add definition that are
8174 required. */
8175 h = (struct alpha_vms_link_hash_entry *)bfd_link_hash_lookup
8176 (info->hash, sym.name, FALSE, FALSE, FALSE);
8177 if (h == NULL || h->root.type != bfd_link_hash_undefined)
8178 continue;
8179 }
8180 else
8181 h = NULL;
8182
8183 h_root = (struct bfd_link_hash_entry *) h;
8184 if (_bfd_generic_link_add_one_symbol
8185 (info, abfd, sym.name, sym.flags, sym.section, sym.value,
8186 NULL, FALSE, FALSE, &h_root) == FALSE)
8187 return FALSE;
8188 h = (struct alpha_vms_link_hash_entry *) h_root;
8189
8190 if ((e->flags & EGSY__V_DEF)
8191 && h->sym == NULL
8192 && abfd->xvec == info->output_bfd->xvec)
8193 h->sym = e;
8194 }
8195
8196 if (abfd->flags & DYNAMIC)
8197 {
8198 struct alpha_vms_shlib_el *shlib;
8199
8200 /* We do not want to include any of the sections in a dynamic
8201 object in the output file. See comment in elflink.c. */
8202 bfd_section_list_clear (abfd);
8203
8204 shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
8205 struct alpha_vms_shlib_el);
8206 shlib->abfd = abfd;
8207 VEC_INIT (shlib->ca);
8208 VEC_INIT (shlib->lp);
8209 VEC_INIT (shlib->qr);
8210 PRIV (shr_index) = VEC_COUNT (alpha_vms_link_hash (info)->shrlibs) - 1;
8211 }
8212
8213 return TRUE;
8214 }
8215
8216 static bfd_boolean
8217 alpha_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
8218 {
8219 int pass;
8220 struct bfd_link_hash_entry **pundef;
8221 struct bfd_link_hash_entry **next_pundef;
8222
8223 /* We only accept VMS libraries. */
8224 if (info->output_bfd->xvec != abfd->xvec)
8225 {
8226 bfd_set_error (bfd_error_wrong_format);
8227 return FALSE;
8228 }
8229
8230 /* The archive_pass field in the archive itself is used to
8231 initialize PASS, since we may search the same archive multiple
8232 times. */
8233 pass = ++abfd->archive_pass;
8234
8235 /* Look through the list of undefined symbols. */
8236 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
8237 {
8238 struct bfd_link_hash_entry *h;
8239 symindex symidx;
8240 bfd *element;
8241 bfd *orig_element;
8242
8243 h = *pundef;
8244 next_pundef = &(*pundef)->u.undef.next;
8245
8246 /* When a symbol is defined, it is not necessarily removed from
8247 the list. */
8248 if (h->type != bfd_link_hash_undefined
8249 && h->type != bfd_link_hash_common)
8250 {
8251 /* Remove this entry from the list, for general cleanliness
8252 and because we are going to look through the list again
8253 if we search any more libraries. We can't remove the
8254 entry if it is the tail, because that would lose any
8255 entries we add to the list later on. */
8256 if (*pundef != info->hash->undefs_tail)
8257 {
8258 *pundef = *next_pundef;
8259 next_pundef = pundef;
8260 }
8261 continue;
8262 }
8263
8264 /* Look for this symbol in the archive hash table. */
8265 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
8266 if (symidx == BFD_NO_MORE_SYMBOLS)
8267 {
8268 /* Nothing in this slot. */
8269 continue;
8270 }
8271
8272 element = bfd_get_elt_at_index (abfd, symidx);
8273 if (element == NULL)
8274 return FALSE;
8275
8276 if (element->archive_pass == -1 || element->archive_pass == pass)
8277 {
8278 /* Next symbol if this archive is wrong or already handled. */
8279 continue;
8280 }
8281
8282 if (! bfd_check_format (element, bfd_object))
8283 {
8284 element->archive_pass = -1;
8285 return FALSE;
8286 }
8287
8288 orig_element = element;
8289 if (bfd_is_thin_archive (abfd))
8290 {
8291 element = _bfd_vms_lib_get_imagelib_file (element);
8292 if (element == NULL || !bfd_check_format (element, bfd_object))
8293 {
8294 orig_element->archive_pass = -1;
8295 return FALSE;
8296 }
8297 }
8298
8299 /* Unlike the generic linker, we know that this element provides
8300 a definition for an undefined symbol and we know that we want
8301 to include it. We don't need to check anything. */
8302 if (!(*info->callbacks
8303 ->add_archive_element) (info, element, h->root.string, &element))
8304 return FALSE;
8305 if (!alpha_vms_link_add_object_symbols (element, info))
8306 return FALSE;
8307
8308 orig_element->archive_pass = pass;
8309 }
8310
8311 return TRUE;
8312 }
8313
8314 static bfd_boolean
8315 alpha_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
8316 {
8317 switch (bfd_get_format (abfd))
8318 {
8319 case bfd_object:
8320 vms_debug2 ((2, "vms_link_add_symbols for object %s\n",
8321 abfd->filename));
8322 return alpha_vms_link_add_object_symbols (abfd, info);
8323 break;
8324 case bfd_archive:
8325 vms_debug2 ((2, "vms_link_add_symbols for archive %s\n",
8326 abfd->filename));
8327 return alpha_vms_link_add_archive_symbols (abfd, info);
8328 break;
8329 default:
8330 bfd_set_error (bfd_error_wrong_format);
8331 return FALSE;
8332 }
8333 }
8334
8335 static bfd_boolean
8336 alpha_vms_build_fixups (struct bfd_link_info *info)
8337 {
8338 struct alpha_vms_link_hash_table *t = alpha_vms_link_hash (info);
8339 unsigned char *content;
8340 unsigned int i;
8341 unsigned int sz = 0;
8342 unsigned int lp_sz = 0;
8343 unsigned int ca_sz = 0;
8344 unsigned int qr_sz = 0;
8345 unsigned int shrimg_cnt = 0;
8346 unsigned int chgprt_num = 0;
8347 unsigned int chgprt_sz = 0;
8348 struct vms_eiaf *eiaf;
8349 unsigned int off;
8350 asection *sec;
8351
8352 /* Shared libraries. */
8353 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8354 {
8355 struct alpha_vms_shlib_el *shlib;
8356
8357 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8358
8359 if (!shlib->has_fixups)
8360 continue;
8361
8362 shrimg_cnt++;
8363
8364 if (VEC_COUNT (shlib->ca) > 0)
8365 {
8366 /* Header + entries. */
8367 ca_sz += 8;
8368 ca_sz += VEC_COUNT (shlib->ca) * 4;
8369 }
8370 if (VEC_COUNT (shlib->lp) > 0)
8371 {
8372 /* Header + entries. */
8373 lp_sz += 8;
8374 lp_sz += VEC_COUNT (shlib->lp) * 4;
8375 }
8376 if (VEC_COUNT (shlib->qr) > 0)
8377 {
8378 /* Header + entries. */
8379 qr_sz += 8;
8380 qr_sz += VEC_COUNT (shlib->qr) * 8;
8381 }
8382 }
8383 /* Add markers. */
8384 if (ca_sz > 0)
8385 ca_sz += 8;
8386 if (lp_sz > 0)
8387 lp_sz += 8;
8388 if (qr_sz > 0)
8389 qr_sz += 8;
8390
8391 /* Finish now if there is no content. */
8392 if (ca_sz + lp_sz + qr_sz == 0)
8393 return TRUE;
8394
8395 /* Add an eicp entry for the fixup itself. */
8396 chgprt_num = 1;
8397 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8398 {
8399 /* This isect could be made RO or EXE after relocations are applied. */
8400 if ((sec->flags & SEC_RELOC) != 0
8401 && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8402 chgprt_num++;
8403 }
8404 chgprt_sz = 4 + chgprt_num * sizeof (struct vms_eicp);
8405
8406 /* Allocate section content (round-up size) */
8407 sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
8408 + ca_sz + lp_sz + qr_sz + chgprt_sz;
8409 sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
8410 content = bfd_zalloc (info->output_bfd, sz);
8411 if (content == NULL)
8412 return FALSE;
8413
8414 sec = alpha_vms_link_hash (info)->fixup;
8415 sec->contents = content;
8416 sec->size = sz;
8417
8418 eiaf = (struct vms_eiaf *)content;
8419 off = sizeof (struct vms_eiaf);
8420 bfd_putl32 (0, eiaf->majorid);
8421 bfd_putl32 (0, eiaf->minorid);
8422 bfd_putl32 (0, eiaf->iaflink);
8423 bfd_putl32 (0, eiaf->fixuplnk);
8424 bfd_putl32 (sizeof (struct vms_eiaf), eiaf->size);
8425 bfd_putl32 (0, eiaf->flags);
8426 bfd_putl32 (0, eiaf->qrelfixoff);
8427 bfd_putl32 (0, eiaf->lrelfixoff);
8428 bfd_putl32 (0, eiaf->qdotadroff);
8429 bfd_putl32 (0, eiaf->ldotadroff);
8430 bfd_putl32 (0, eiaf->codeadroff);
8431 bfd_putl32 (0, eiaf->lpfixoff);
8432 bfd_putl32 (0, eiaf->chgprtoff);
8433 bfd_putl32 (shrimg_cnt ? off : 0, eiaf->shlstoff);
8434 bfd_putl32 (shrimg_cnt, eiaf->shrimgcnt);
8435 bfd_putl32 (0, eiaf->shlextra);
8436 bfd_putl32 (0, eiaf->permctx);
8437 bfd_putl32 (0, eiaf->base_va);
8438 bfd_putl32 (0, eiaf->lppsbfixoff);
8439
8440 if (shrimg_cnt)
8441 {
8442 shrimg_cnt = 0;
8443
8444 /* Write shl. */
8445 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8446 {
8447 struct alpha_vms_shlib_el *shlib;
8448 struct vms_shl *shl;
8449
8450 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8451
8452 if (!shlib->has_fixups)
8453 continue;
8454
8455 /* Renumber shared images. */
8456 PRIV2 (shlib->abfd, shr_index) = shrimg_cnt++;
8457
8458 shl = (struct vms_shl *)(content + off);
8459 bfd_putl32 (0, shl->baseva);
8460 bfd_putl32 (0, shl->shlptr);
8461 bfd_putl32 (0, shl->ident);
8462 bfd_putl32 (0, shl->permctx);
8463 shl->size = sizeof (struct vms_shl);
8464 bfd_putl16 (0, shl->fill_1);
8465 shl->flags = 0;
8466 bfd_putl32 (0, shl->icb);
8467 shl->imgnam[0] = strlen (PRIV2 (shlib->abfd, hdr_data.hdr_t_name));
8468 memcpy (shl->imgnam + 1, PRIV2 (shlib->abfd, hdr_data.hdr_t_name),
8469 shl->imgnam[0]);
8470
8471 off += sizeof (struct vms_shl);
8472 }
8473
8474 /* CA fixups. */
8475 if (ca_sz != 0)
8476 {
8477 bfd_putl32 (off, eiaf->codeadroff);
8478
8479 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8480 {
8481 struct alpha_vms_shlib_el *shlib;
8482 unsigned int j;
8483
8484 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8485
8486 if (VEC_COUNT (shlib->ca) == 0)
8487 continue;
8488
8489 bfd_putl32 (VEC_COUNT (shlib->ca), content + off);
8490 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8491 off += 8;
8492
8493 for (j = 0; j < VEC_COUNT (shlib->ca); j++)
8494 {
8495 bfd_putl32 (VEC_EL (shlib->ca, bfd_vma, j) - t->base_addr,
8496 content + off);
8497 off += 4;
8498 }
8499 }
8500
8501 bfd_putl32 (0, content + off);
8502 bfd_putl32 (0, content + off + 4);
8503 off += 8;
8504 }
8505
8506 /* LP fixups. */
8507 if (lp_sz != 0)
8508 {
8509 bfd_putl32 (off, eiaf->lpfixoff);
8510
8511 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8512 {
8513 struct alpha_vms_shlib_el *shlib;
8514 unsigned int j;
8515
8516 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8517
8518 if (VEC_COUNT (shlib->lp) == 0)
8519 continue;
8520
8521 bfd_putl32 (VEC_COUNT (shlib->lp), content + off);
8522 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8523 off += 8;
8524
8525 for (j = 0; j < VEC_COUNT (shlib->lp); j++)
8526 {
8527 bfd_putl32 (VEC_EL (shlib->lp, bfd_vma, j) - t->base_addr,
8528 content + off);
8529 off += 4;
8530 }
8531 }
8532
8533 bfd_putl32 (0, content + off);
8534 bfd_putl32 (0, content + off + 4);
8535 off += 8;
8536 }
8537
8538 /* QR fixups. */
8539 if (qr_sz != 0)
8540 {
8541 bfd_putl32 (off, eiaf->qdotadroff);
8542
8543 for (i = 0; i < VEC_COUNT (t->shrlibs); i++)
8544 {
8545 struct alpha_vms_shlib_el *shlib;
8546 unsigned int j;
8547
8548 shlib = &VEC_EL (t->shrlibs, struct alpha_vms_shlib_el, i);
8549
8550 if (VEC_COUNT (shlib->qr) == 0)
8551 continue;
8552
8553 bfd_putl32 (VEC_COUNT (shlib->qr), content + off);
8554 bfd_putl32 (PRIV2 (shlib->abfd, shr_index), content + off + 4);
8555 off += 8;
8556
8557 for (j = 0; j < VEC_COUNT (shlib->qr); j++)
8558 {
8559 struct alpha_vms_vma_ref *r;
8560 r = &VEC_EL (shlib->qr, struct alpha_vms_vma_ref, j);
8561 bfd_putl32 (r->vma - t->base_addr, content + off);
8562 bfd_putl32 (r->ref, content + off + 4);
8563 off += 8;
8564 }
8565 }
8566
8567 bfd_putl32 (0, content + off);
8568 bfd_putl32 (0, content + off + 4);
8569 off += 8;
8570 }
8571 }
8572
8573 /* Write the change protection table. */
8574 bfd_putl32 (off, eiaf->chgprtoff);
8575 bfd_putl32 (chgprt_num, content + off);
8576 off += 4;
8577
8578 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8579 {
8580 struct vms_eicp *eicp;
8581 unsigned int prot;
8582
8583 if ((sec->flags & SEC_LINKER_CREATED) != 0 &&
8584 strcmp (sec->name, "$FIXUP$") == 0)
8585 prot = PRT__C_UREW;
8586 else if ((sec->flags & SEC_RELOC) != 0
8587 && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
8588 prot = PRT__C_UR;
8589 else
8590 continue;
8591
8592 eicp = (struct vms_eicp *)(content + off);
8593 bfd_putl64 (sec->vma - t->base_addr, eicp->baseva);
8594 bfd_putl32 ((sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1),
8595 eicp->size);
8596 bfd_putl32 (prot, eicp->newprt);
8597 off += sizeof (struct vms_eicp);
8598 }
8599
8600 return TRUE;
8601 }
8602
8603 /* Called by bfd_link_hash_traverse to fill the symbol table.
8604 Return FALSE in case of failure. */
8605
8606 static bfd_boolean
8607 alpha_vms_link_output_symbol (struct bfd_link_hash_entry *hc, void *infov)
8608 {
8609 struct bfd_link_info *info = (struct bfd_link_info *)infov;
8610 struct alpha_vms_link_hash_entry *h = (struct alpha_vms_link_hash_entry *)hc;
8611 struct vms_symbol_entry *sym;
8612
8613 switch (h->root.type)
8614 {
8615 case bfd_link_hash_undefined:
8616 return TRUE;
8617 case bfd_link_hash_new:
8618 abort ();
8619 case bfd_link_hash_undefweak:
8620 return TRUE;
8621 case bfd_link_hash_defined:
8622 case bfd_link_hash_defweak:
8623 {
8624 asection *sec = h->root.u.def.section;
8625
8626 /* FIXME: this is certainly a symbol from a dynamic library. */
8627 if (bfd_is_abs_section (sec))
8628 return TRUE;
8629
8630 if (sec->owner->flags & DYNAMIC)
8631 return TRUE;
8632 }
8633 break;
8634 case bfd_link_hash_common:
8635 break;
8636 case bfd_link_hash_indirect:
8637 case bfd_link_hash_warning:
8638 return TRUE;
8639 }
8640
8641 /* Do not write not kept symbols. */
8642 if (info->strip == strip_some
8643 && bfd_hash_lookup (info->keep_hash, h->root.root.string,
8644 FALSE, FALSE) != NULL)
8645 return TRUE;
8646
8647 if (h->sym == NULL)
8648 {
8649 /* This symbol doesn't come from a VMS object. So we suppose it is
8650 a data. */
8651 int len = strlen (h->root.root.string);
8652
8653 sym = (struct vms_symbol_entry *)bfd_zalloc (info->output_bfd,
8654 sizeof (*sym) + len);
8655 if (sym == NULL)
8656 abort ();
8657 sym->namelen = len;
8658 memcpy (sym->name, h->root.root.string, len);
8659 sym->name[len] = 0;
8660 sym->owner = info->output_bfd;
8661
8662 sym->typ = EGSD__C_SYMG;
8663 sym->data_type = 0;
8664 sym->flags = EGSY__V_DEF | EGSY__V_REL;
8665 sym->symbol_vector = h->root.u.def.value;
8666 sym->section = h->root.u.def.section;
8667 sym->value = h->root.u.def.value;
8668 }
8669 else
8670 sym = h->sym;
8671
8672 if (!add_symbol_entry (info->output_bfd, sym))
8673 return FALSE;
8674
8675 return TRUE;
8676 }
8677
8678 static bfd_boolean
8679 alpha_vms_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
8680 {
8681 asection *o;
8682 struct bfd_link_order *p;
8683 bfd *sub;
8684 asection *fixupsec;
8685 bfd_vma base_addr;
8686 bfd_vma last_addr;
8687 asection *dst;
8688 asection *dmt;
8689
8690 if (info->relocatable)
8691 {
8692 /* FIXME: we do not yet support relocatable link. It is not obvious
8693 how to do it for debug infos. */
8694 (*info->callbacks->einfo)(_("%P: relocatable link is not supported\n"));
8695 return FALSE;
8696 }
8697
8698 bfd_get_outsymbols (abfd) = NULL;
8699 bfd_get_symcount (abfd) = 0;
8700
8701 /* Mark all sections which will be included in the output file. */
8702 for (o = abfd->sections; o != NULL; o = o->next)
8703 for (p = o->map_head.link_order; p != NULL; p = p->next)
8704 if (p->type == bfd_indirect_link_order)
8705 p->u.indirect.section->linker_mark = TRUE;
8706
8707 #if 0
8708 /* Handle all the link order information for the sections. */
8709 for (o = abfd->sections; o != NULL; o = o->next)
8710 {
8711 printf ("For section %s (at 0x%08x, flags=0x%08x):\n",
8712 o->name, (unsigned)o->vma, (unsigned)o->flags);
8713
8714 for (p = o->map_head.link_order; p != NULL; p = p->next)
8715 {
8716 printf (" at 0x%08x - 0x%08x: ",
8717 (unsigned)p->offset, (unsigned)(p->offset + p->size - 1));
8718 switch (p->type)
8719 {
8720 case bfd_section_reloc_link_order:
8721 case bfd_symbol_reloc_link_order:
8722 printf (" section/symbol reloc\n");
8723 break;
8724 case bfd_indirect_link_order:
8725 printf (" section %s of %s\n",
8726 p->u.indirect.section->name,
8727 p->u.indirect.section->owner->filename);
8728 break;
8729 case bfd_data_link_order:
8730 printf (" explicit data\n");
8731 break;
8732 default:
8733 printf (" *unknown* type %u\n", p->type);
8734 break;
8735 }
8736 }
8737 }
8738 #endif
8739
8740 /* Generate the symbol table. */
8741 BFD_ASSERT (PRIV (syms) == NULL);
8742 if (info->strip != strip_all)
8743 bfd_link_hash_traverse (info->hash, alpha_vms_link_output_symbol, info);
8744
8745 /* Find the entry point. */
8746 if (bfd_get_start_address (abfd) == 0)
8747 {
8748 bfd *startbfd = NULL;
8749
8750 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8751 {
8752 /* Consider only VMS object files. */
8753 if (sub->xvec != abfd->xvec)
8754 continue;
8755
8756 if (!PRIV2 (sub, eom_data).eom_has_transfer)
8757 continue;
8758 if ((PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR) && startbfd)
8759 continue;
8760 if (startbfd != NULL
8761 && !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
8762 {
8763 (*info->callbacks->einfo)
8764 (_("%P: multiple entry points: in modules %B and %B\n"),
8765 startbfd, sub);
8766 continue;
8767 }
8768 startbfd = sub;
8769 }
8770
8771 if (startbfd)
8772 {
8773 unsigned int ps_idx = PRIV2 (startbfd, eom_data).eom_l_psindx;
8774 bfd_vma tfradr = PRIV2 (startbfd, eom_data).eom_l_tfradr;
8775 asection *sec;
8776
8777 sec = PRIV2 (startbfd, sections)[ps_idx];
8778
8779 bfd_set_start_address
8780 (abfd, sec->output_section->vma + sec->output_offset + tfradr);
8781 }
8782 }
8783
8784 /* Set transfer addresses. */
8785 {
8786 int i;
8787 struct bfd_link_hash_entry *h;
8788
8789 i = 0;
8790 PRIV (transfer_address[i++]) = 0xffffffff00000340ULL; /* SYS$IMGACT */
8791 h = bfd_link_hash_lookup (info->hash, "LIB$INITIALIZE", FALSE, FALSE, TRUE);
8792 if (h != NULL && h->type == bfd_link_hash_defined)
8793 PRIV (transfer_address[i++]) =
8794 alpha_vms_get_sym_value (h->u.def.section, h->u.def.value);
8795 PRIV (transfer_address[i++]) = bfd_get_start_address (abfd);
8796 while (i < 4)
8797 PRIV (transfer_address[i++]) = 0;
8798 }
8799
8800 /* Allocate contents.
8801 Also compute the virtual base address. */
8802 base_addr = (bfd_vma)-1;
8803 last_addr = 0;
8804 for (o = abfd->sections; o != NULL; o = o->next)
8805 {
8806 if (o->flags & SEC_HAS_CONTENTS)
8807 {
8808 o->contents = bfd_alloc (abfd, o->size);
8809 if (o->contents == NULL)
8810 return FALSE;
8811 }
8812 if (o->flags & SEC_LOAD)
8813 {
8814 if (o->vma < base_addr)
8815 base_addr = o->vma;
8816 if (o->vma + o->size > last_addr)
8817 last_addr = o->vma + o->size;
8818 }
8819 /* Clear the RELOC flags. Currently we don't support incremental
8820 linking. We use the RELOC flag for computing the eicp entries. */
8821 o->flags &= ~SEC_RELOC;
8822 }
8823
8824 /* Create the fixup section. */
8825 fixupsec = bfd_make_section_anyway_with_flags
8826 (info->output_bfd, "$FIXUP$",
8827 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8828 if (fixupsec == NULL)
8829 return FALSE;
8830 last_addr = (last_addr + 0xffff) & ~0xffff;
8831 fixupsec->vma = last_addr;
8832
8833 alpha_vms_link_hash (info)->fixup = fixupsec;
8834 alpha_vms_link_hash (info)->base_addr = base_addr;
8835
8836 /* Create the DMT section, if necessary. */
8837 BFD_ASSERT (PRIV (dst_section) == NULL);
8838 dst = bfd_get_section_by_name (abfd, "$DST$");
8839 if (dst != NULL && dst->size == 0)
8840 dst = NULL;
8841 if (dst != NULL)
8842 {
8843 PRIV (dst_section) = dst;
8844 dmt = bfd_make_section_anyway_with_flags
8845 (info->output_bfd, "$DMT$",
8846 SEC_DEBUGGING | SEC_HAS_CONTENTS | SEC_LINKER_CREATED);
8847 if (dmt == NULL)
8848 return FALSE;
8849 }
8850 else
8851 dmt = NULL;
8852
8853 /* Read all sections from the inputs. */
8854 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8855 {
8856 if (sub->flags & DYNAMIC)
8857 {
8858 alpha_vms_create_eisd_for_shared (abfd, sub);
8859 continue;
8860 }
8861
8862 if (!alpha_vms_read_sections_content (sub, info))
8863 return FALSE;
8864 }
8865
8866 /* Handle all the link order information for the sections.
8867 Note: past this point, it is not possible to create new sections. */
8868 for (o = abfd->sections; o != NULL; o = o->next)
8869 {
8870 for (p = o->map_head.link_order; p != NULL; p = p->next)
8871 {
8872 switch (p->type)
8873 {
8874 case bfd_section_reloc_link_order:
8875 case bfd_symbol_reloc_link_order:
8876 abort ();
8877 return FALSE;
8878 case bfd_indirect_link_order:
8879 /* Already done. */
8880 break;
8881 default:
8882 if (! _bfd_default_link_order (abfd, info, o, p))
8883 return FALSE;
8884 break;
8885 }
8886 }
8887 }
8888
8889 /* Compute fixups. */
8890 if (!alpha_vms_build_fixups (info))
8891 return FALSE;
8892
8893 /* Compute the DMT. */
8894 if (dmt != NULL)
8895 {
8896 int pass;
8897 unsigned char *contents = NULL;
8898
8899 /* In pass 1, compute the size. In pass 2, write the DMT contents. */
8900 for (pass = 0; pass < 2; pass++)
8901 {
8902 unsigned int off = 0;
8903
8904 /* For each object file (ie for each module). */
8905 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8906 {
8907 asection *sub_dst;
8908 struct vms_dmt_header *dmth = NULL;
8909 unsigned int psect_count;
8910
8911 /* Skip this module if it has no DST. */
8912 sub_dst = PRIV2 (sub, dst_section);
8913 if (sub_dst == NULL || sub_dst->size == 0)
8914 continue;
8915
8916 if (pass == 1)
8917 {
8918 /* Write the header. */
8919 dmth = (struct vms_dmt_header *)(contents + off);
8920 bfd_putl32 (sub_dst->output_offset, dmth->modbeg);
8921 bfd_putl32 (sub_dst->size, dmth->size);
8922 }
8923
8924 off += sizeof (struct vms_dmt_header);
8925 psect_count = 0;
8926
8927 /* For each section (ie for each psect). */
8928 for (o = sub->sections; o != NULL; o = o->next)
8929 {
8930 /* Only consider interesting sections. */
8931 if (!(o->flags & SEC_ALLOC))
8932 continue;
8933 if (o->flags & SEC_LINKER_CREATED)
8934 continue;
8935
8936 if (pass == 1)
8937 {
8938 /* Write an entry. */
8939 struct vms_dmt_psect *dmtp;
8940
8941 dmtp = (struct vms_dmt_psect *)(contents + off);
8942 bfd_putl32 (o->output_offset + o->output_section->vma,
8943 dmtp->start);
8944 bfd_putl32 (o->size, dmtp->length);
8945 psect_count++;
8946 }
8947 off += sizeof (struct vms_dmt_psect);
8948 }
8949 if (pass == 1)
8950 bfd_putl32 (psect_count, dmth->psect_count);
8951 }
8952
8953 if (pass == 0)
8954 {
8955 contents = bfd_zalloc (info->output_bfd, off);
8956 if (contents == NULL)
8957 return FALSE;
8958 dmt->contents = contents;
8959 dmt->size = off;
8960 }
8961 else
8962 {
8963 BFD_ASSERT (off == dmt->size);
8964 }
8965 }
8966 }
8967
8968 return TRUE;
8969 }
8970
8971 /* Read the contents of a section.
8972 buf points to a buffer of buf_size bytes to be filled with
8973 section data (starting at offset into section) */
8974
8975 static bfd_boolean
8976 alpha_vms_get_section_contents (bfd *abfd, asection *section,
8977 void *buf, file_ptr offset,
8978 bfd_size_type count)
8979 {
8980 asection *sec;
8981
8982 /* Image are easy. */
8983 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
8984 return _bfd_generic_get_section_contents (abfd, section,
8985 buf, offset, count);
8986
8987 /* Safety check. */
8988 if (offset + count < count
8989 || offset + count > section->size)
8990 {
8991 bfd_set_error (bfd_error_invalid_operation);
8992 return FALSE;
8993 }
8994
8995 /* If the section is already in memory, just copy it. */
8996 if (section->flags & SEC_IN_MEMORY)
8997 {
8998 BFD_ASSERT (section->contents != NULL);
8999 memcpy (buf, section->contents + offset, count);
9000 return TRUE;
9001 }
9002 if (section->size == 0)
9003 return TRUE;
9004
9005 /* Alloc in memory and read ETIRs. */
9006 for (sec = abfd->sections; sec; sec = sec->next)
9007 {
9008 BFD_ASSERT (sec->contents == NULL);
9009
9010 if (sec->size != 0 && (sec->flags & SEC_HAS_CONTENTS))
9011 {
9012 sec->contents = bfd_alloc (abfd, sec->size);
9013 if (sec->contents == NULL)
9014 return FALSE;
9015 }
9016 }
9017 if (!alpha_vms_read_sections_content (abfd, NULL))
9018 return FALSE;
9019 for (sec = abfd->sections; sec; sec = sec->next)
9020 if (sec->contents)
9021 sec->flags |= SEC_IN_MEMORY;
9022 memcpy (buf, section->contents + offset, count);
9023 return TRUE;
9024 }
9025
9026
9027 /* Set the format of a file being written. */
9028
9029 static bfd_boolean
9030 alpha_vms_mkobject (bfd * abfd)
9031 {
9032 const bfd_arch_info_type *arch;
9033
9034 vms_debug2 ((1, "alpha_vms_mkobject (%p)\n", abfd));
9035
9036 if (!vms_initialize (abfd))
9037 return FALSE;
9038
9039 PRIV (recwr.buf) = bfd_alloc (abfd, MAX_OUTREC_SIZE);
9040 if (PRIV (recwr.buf) == NULL)
9041 return FALSE;
9042
9043 arch = bfd_scan_arch ("alpha");
9044
9045 if (arch == 0)
9046 {
9047 bfd_set_error (bfd_error_wrong_format);
9048 return FALSE;
9049 }
9050
9051 abfd->arch_info = arch;
9052 return TRUE;
9053 }
9054
9055
9056 /* 4.1, generic. */
9057
9058 /* Called when the BFD is being closed to do any necessary cleanup. */
9059
9060 static bfd_boolean
9061 vms_close_and_cleanup (bfd * abfd)
9062 {
9063 vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
9064
9065 if (abfd == NULL || abfd->tdata.any == NULL)
9066 return TRUE;
9067
9068 if (abfd->format == bfd_archive)
9069 {
9070 bfd_release (abfd, abfd->tdata.any);
9071 abfd->tdata.any = NULL;
9072 return TRUE;
9073 }
9074
9075 if (PRIV (recrd.buf) != NULL)
9076 free (PRIV (recrd.buf));
9077
9078 if (PRIV (sections) != NULL)
9079 free (PRIV (sections));
9080
9081 bfd_release (abfd, abfd->tdata.any);
9082 abfd->tdata.any = NULL;
9083
9084 #ifdef VMS
9085 if (abfd->direction == write_direction)
9086 {
9087 /* Last step on VMS is to convert the file to variable record length
9088 format. */
9089 if (bfd_cache_close (abfd) != TRUE)
9090 return FALSE;
9091 if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
9092 return FALSE;
9093 }
9094 #endif
9095
9096 return TRUE;
9097 }
9098
9099 /* Called when a new section is created. */
9100
9101 static bfd_boolean
9102 vms_new_section_hook (bfd * abfd, asection *section)
9103 {
9104 bfd_size_type amt;
9105
9106 vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
9107 abfd, section->index, section->name));
9108
9109 bfd_set_section_alignment (abfd, section, 0);
9110
9111 vms_debug2 ((7, "%d: %s\n", section->index, section->name));
9112
9113 amt = sizeof (struct vms_section_data_struct);
9114 section->used_by_bfd = bfd_zalloc (abfd, amt);
9115 if (section->used_by_bfd == NULL)
9116 return FALSE;
9117
9118 /* Create the section symbol. */
9119 return _bfd_generic_new_section_hook (abfd, section);
9120 }
9121
9122 /* Part 4.5, symbols. */
9123
9124 /* Print symbol to file according to how. how is one of
9125 bfd_print_symbol_name just print the name
9126 bfd_print_symbol_more print more (???)
9127 bfd_print_symbol_all print all we know, which is not much right now :-). */
9128
9129 static void
9130 vms_print_symbol (bfd * abfd,
9131 void * file,
9132 asymbol *symbol,
9133 bfd_print_symbol_type how)
9134 {
9135 vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
9136 abfd, file, symbol, how));
9137
9138 switch (how)
9139 {
9140 case bfd_print_symbol_name:
9141 case bfd_print_symbol_more:
9142 fprintf ((FILE *)file," %s", symbol->name);
9143 break;
9144
9145 case bfd_print_symbol_all:
9146 {
9147 const char *section_name = symbol->section->name;
9148
9149 bfd_print_symbol_vandf (abfd, file, symbol);
9150
9151 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
9152 }
9153 break;
9154 }
9155 }
9156
9157 /* Return information about symbol in ret.
9158
9159 fill type, value and name
9160 type:
9161 A absolute
9162 B bss segment symbol
9163 C common symbol
9164 D data segment symbol
9165 f filename
9166 t a static function symbol
9167 T text segment symbol
9168 U undefined
9169 - debug. */
9170
9171 static void
9172 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
9173 asymbol *symbol,
9174 symbol_info *ret)
9175 {
9176 asection *sec;
9177
9178 vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
9179
9180 sec = symbol->section;
9181
9182 if (ret == NULL)
9183 return;
9184
9185 if (sec == NULL)
9186 ret->type = 'U';
9187 else if (bfd_is_com_section (sec))
9188 ret->type = 'C';
9189 else if (bfd_is_abs_section (sec))
9190 ret->type = 'A';
9191 else if (bfd_is_und_section (sec))
9192 ret->type = 'U';
9193 else if (bfd_is_ind_section (sec))
9194 ret->type = 'I';
9195 else if ((symbol->flags & BSF_FUNCTION)
9196 || (bfd_get_section_flags (abfd, sec) & SEC_CODE))
9197 ret->type = 'T';
9198 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
9199 ret->type = 'D';
9200 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
9201 ret->type = 'B';
9202 else
9203 ret->type = '?';
9204
9205 if (ret->type != 'U')
9206 ret->value = symbol->value + symbol->section->vma;
9207 else
9208 ret->value = 0;
9209 ret->name = symbol->name;
9210 }
9211
9212 /* Return TRUE if the given symbol sym in the BFD abfd is
9213 a compiler generated local label, else return FALSE. */
9214
9215 static bfd_boolean
9216 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
9217 const char *name)
9218 {
9219 vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
9220 return name[0] == '$';
9221 }
9222 \f
9223 /* Part 4.7, writing an object file. */
9224
9225 /* Sets the contents of the section section in BFD abfd to the data starting
9226 in memory at LOCATION. The data is written to the output section starting
9227 at offset offset for count bytes.
9228
9229 Normally TRUE is returned, else FALSE. Possible error returns are:
9230 o bfd_error_no_contents - The output section does not have the
9231 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
9232 o and some more too */
9233
9234 static bfd_boolean
9235 _bfd_vms_set_section_contents (bfd * abfd,
9236 asection *section,
9237 const void * location,
9238 file_ptr offset,
9239 bfd_size_type count)
9240 {
9241 if (section->contents == NULL)
9242 {
9243 section->contents = bfd_alloc (abfd, section->size);
9244 if (section->contents == NULL)
9245 return FALSE;
9246
9247 memcpy (section->contents + offset, location, (size_t) count);
9248 }
9249
9250 return TRUE;
9251 }
9252
9253 /* Set the architecture and machine type in BFD abfd to arch and mach.
9254 Find the correct pointer to a structure and insert it into the arch_info
9255 pointer. */
9256
9257 static bfd_boolean
9258 alpha_vms_set_arch_mach (bfd *abfd,
9259 enum bfd_architecture arch, unsigned long mach)
9260 {
9261 if (arch != bfd_arch_alpha
9262 && arch != bfd_arch_unknown)
9263 return FALSE;
9264
9265 return bfd_default_set_arch_mach (abfd, arch, mach);
9266 }
9267
9268 /* Set section VMS flags. Clear NO_FLAGS and set FLAGS. */
9269
9270 void
9271 bfd_vms_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
9272 asection *sec, flagword no_flags, flagword flags)
9273 {
9274 vms_section_data (sec)->no_flags = no_flags;
9275 vms_section_data (sec)->flags = flags;
9276 }
9277
9278 struct vms_private_data_struct *
9279 bfd_vms_get_data (bfd *abfd)
9280 {
9281 return (struct vms_private_data_struct *)abfd->tdata.any;
9282 }
9283
9284 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9285 #define vms_bfd_link_just_syms _bfd_generic_link_just_syms
9286 #define vms_bfd_copy_link_hash_symbol_type \
9287 _bfd_generic_copy_link_hash_symbol_type
9288 #define vms_bfd_is_group_section bfd_generic_is_group_section
9289 #define vms_bfd_discard_group bfd_generic_discard_group
9290 #define vms_section_already_linked _bfd_generic_section_already_linked
9291 #define vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9292 #define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
9293
9294 #define vms_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
9295 #define vms_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
9296 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
9297 #define vms_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
9298 #define vms_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
9299 #define vms_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
9300
9301 /* Symbols table. */
9302 #define alpha_vms_make_empty_symbol _bfd_generic_make_empty_symbol
9303 #define alpha_vms_bfd_is_target_special_symbol \
9304 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
9305 #define alpha_vms_print_symbol vms_print_symbol
9306 #define alpha_vms_get_symbol_info vms_get_symbol_info
9307 #define alpha_vms_read_minisymbols _bfd_generic_read_minisymbols
9308 #define alpha_vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
9309 #define alpha_vms_get_lineno _bfd_nosymbols_get_lineno
9310 #define alpha_vms_find_inliner_info _bfd_nosymbols_find_inliner_info
9311 #define alpha_vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
9312 #define alpha_vms_find_nearest_line _bfd_vms_find_nearest_dst_line
9313 #define alpha_vms_bfd_is_local_label_name vms_bfd_is_local_label_name
9314
9315 /* Generic table. */
9316 #define alpha_vms_close_and_cleanup vms_close_and_cleanup
9317 #define alpha_vms_bfd_free_cached_info vms_bfd_free_cached_info
9318 #define alpha_vms_new_section_hook vms_new_section_hook
9319 #define alpha_vms_set_section_contents _bfd_vms_set_section_contents
9320 #define alpha_vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
9321
9322 #define alpha_vms_bfd_get_relocated_section_contents \
9323 bfd_generic_get_relocated_section_contents
9324
9325 #define alpha_vms_bfd_relax_section bfd_generic_relax_section
9326 #define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
9327 #define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
9328 #define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
9329 #define alpha_vms_bfd_discard_group bfd_generic_discard_group
9330 #define alpha_vms_section_already_linked \
9331 _bfd_generic_section_already_linked
9332
9333 #define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
9334 #define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
9335 #define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
9336 #define alpha_vms_bfd_copy_link_hash_symbol_type \
9337 _bfd_generic_copy_link_hash_symbol_type
9338
9339 #define alpha_vms_bfd_link_split_section _bfd_generic_link_split_section
9340
9341 #define alpha_vms_get_dynamic_symtab_upper_bound \
9342 _bfd_nodynamic_get_dynamic_symtab_upper_bound
9343 #define alpha_vms_canonicalize_dynamic_symtab \
9344 _bfd_nodynamic_canonicalize_dynamic_symtab
9345 #define alpha_vms_get_dynamic_reloc_upper_bound \
9346 _bfd_nodynamic_get_dynamic_reloc_upper_bound
9347 #define alpha_vms_canonicalize_dynamic_reloc \
9348 _bfd_nodynamic_canonicalize_dynamic_reloc
9349
9350 const bfd_target vms_alpha_vec =
9351 {
9352 "vms-alpha", /* Name. */
9353 bfd_target_evax_flavour,
9354 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
9355 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
9356
9357 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
9358 | WP_TEXT | D_PAGED), /* Object flags. */
9359 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
9360 | SEC_READONLY | SEC_CODE | SEC_DATA
9361 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
9362 0, /* symbol_leading_char. */
9363 ' ', /* ar_pad_char. */
9364 15, /* ar_max_namelen. */
9365 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9366 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9367 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9368 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
9369 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
9370 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
9371
9372 {_bfd_dummy_target, alpha_vms_object_p, /* bfd_check_format. */
9373 _bfd_vms_lib_alpha_archive_p, _bfd_dummy_target},
9374 {bfd_false, alpha_vms_mkobject, /* bfd_set_format. */
9375 _bfd_vms_lib_alpha_mkarchive, bfd_false},
9376 {bfd_false, alpha_vms_write_object_contents, /* bfd_write_contents. */
9377 _bfd_vms_lib_write_archive_contents, bfd_false},
9378
9379 BFD_JUMP_TABLE_GENERIC (alpha_vms),
9380 BFD_JUMP_TABLE_COPY (vms),
9381 BFD_JUMP_TABLE_CORE (_bfd_nocore),
9382 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
9383 BFD_JUMP_TABLE_SYMBOLS (alpha_vms),
9384 BFD_JUMP_TABLE_RELOCS (alpha_vms),
9385 BFD_JUMP_TABLE_WRITE (alpha_vms),
9386 BFD_JUMP_TABLE_LINK (alpha_vms),
9387 BFD_JUMP_TABLE_DYNAMIC (alpha_vms),
9388
9389 NULL,
9390
9391 NULL
9392 };
git-cvsimport of binutils cvsroot