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