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