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