1/* vms.c -- BFD back-end for VAX (openVMS/VAX) and 2 EVAX (openVMS/Alpha) files. 3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4 2006, 2007 Free Software Foundation, Inc. 5 6 Written by Klaus K"ampf (kkaempf@rmi.de) 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23#include "sysdep.h" 24#include "bfd.h" 25#include "bfdlink.h" 26#include "libbfd.h" 27 28#include "vms.h" 29 30#define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 31#define vms_make_empty_symbol _bfd_generic_make_empty_symbol 32#define vms_bfd_link_just_syms _bfd_generic_link_just_syms 33#define vms_bfd_is_group_section bfd_generic_is_group_section 34#define vms_bfd_discard_group bfd_generic_discard_group 35#define vms_section_already_linked _bfd_generic_section_already_linked 36#define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data 37#define vms_get_synthetic_symtab _bfd_nodynamic_get_synthetic_symtab 38 39static unsigned int priv_section_count; 40extern const bfd_target vms_vax_vec; 41extern const bfd_target vms_alpha_vec; 42 43/* Initialize private data. */ 44 45static bfd_boolean 46vms_initialize (bfd * abfd) 47{ 48 int i; 49 bfd_size_type amt; 50 51 bfd_set_start_address (abfd, (bfd_vma) -1); 52 53 amt = sizeof (struct vms_private_data_struct); 54 abfd->tdata.any = bfd_alloc (abfd, amt); 55 if (abfd->tdata.any == NULL) 56 return FALSE; 57 58#ifdef __ALPHA 59 PRIV (is_vax) = FALSE; 60#else 61 PRIV (is_vax) = TRUE; 62#endif 63 PRIV (vms_buf) = NULL; 64 PRIV (buf_size) = 0; 65 PRIV (rec_length) = 0; 66 PRIV (file_format) = FF_UNKNOWN; 67 PRIV (fixup_done) = FALSE; 68 PRIV (sections) = NULL; 69 70 amt = sizeof (struct stack_struct) * STACKSIZE; 71 PRIV (stack) = bfd_alloc (abfd, amt); 72 if (PRIV (stack) == NULL) 73 goto error_ret1; 74 PRIV (stackptr) = 0; 75 76 amt = sizeof (struct bfd_hash_table); 77 PRIV (vms_symbol_table) = bfd_alloc (abfd, amt); 78 if (PRIV (vms_symbol_table) == NULL) 79 goto error_ret1; 80 81 if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc, 82 sizeof (vms_symbol_entry))) 83 goto error_ret1; 84 85 amt = sizeof (struct location_struct) * LOCATION_SAVE_SIZE; 86 PRIV (location_stack) = bfd_alloc (abfd, amt); 87 if (PRIV (location_stack) == NULL) 88 goto error_ret2; 89 90 for (i = 0; i < VMS_SECTION_COUNT; i++) 91 PRIV (vms_section_table)[i] = NULL; 92 93 amt = MAX_OUTREC_SIZE; 94 PRIV (output_buf) = bfd_alloc (abfd, amt); 95 if (PRIV (output_buf) == NULL) 96 goto error_ret2; 97 98 PRIV (push_level) = 0; 99 PRIV (pushed_size) = 0; 100 PRIV (length_pos) = 2; 101 PRIV (output_size) = 0; 102 PRIV (output_alignment) = 1; 103 104 return TRUE; 105 106 error_ret2: 107 bfd_hash_table_free (PRIV (vms_symbol_table)); 108 error_ret1: 109 bfd_release (abfd, abfd->tdata.any); 110 abfd->tdata.any = NULL; 111 return FALSE; 112} 113 114/* Fill symbol->section with section ptr 115 symbol->section is filled with the section index for defined symbols 116 during reading the GSD/EGSD section. But we need the pointer to the 117 bfd section later. 118 119 It has the correct value for referenced (undefined section) symbols 120 121 called from bfd_hash_traverse in vms_fixup_sections. */ 122 123static bfd_boolean 124fill_section_ptr (struct bfd_hash_entry * entry, void * sections) 125{ 126 asection *sec; 127 asymbol *sym; 128 129 sym = ((vms_symbol_entry *) entry)->symbol; 130 sec = sym->section; 131 132#if VMS_DEBUG 133 vms_debug (6, "fill_section_ptr: sym %p, sec %p\n", sym, sec); 134#endif 135 136 /* Fill forward references (these contain section number, not section ptr). */ 137 if ((unsigned int) (size_t) sec < priv_section_count) 138 sec = ((vms_symbol_entry *) entry)->symbol->section = 139 ((asection **) sections)[(unsigned int) (size_t) sec]; 140 141 if (strcmp (sym->name, sec->name) == 0) 142 sym->flags |= BSF_SECTION_SYM; 143 144 return TRUE; 145} 146 147/* Fixup sections 148 set up all pointers and arrays, counters and sizes are fixed now 149 150 we build a private sections vector for easy access since sections 151 are always referenced by an index number. 152 153 alloc PRIV(sections) according to abfd->section_count 154 copy abfd->sections to PRIV(sections). */ 155 156static bfd_boolean 157vms_fixup_sections (bfd * abfd) 158{ 159 if (PRIV (fixup_done)) 160 return TRUE; 161 162 /* Traverse symbol table and fill in all section pointers. */ 163 164 /* Can't provide section count as argument to fill_section_ptr(). */ 165 priv_section_count = PRIV (section_count); 166 bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, (PRIV (sections))); 167 168 PRIV (fixup_done) = TRUE; 169 170 return TRUE; 171} 172 173/* Check the format for a file being read. 174 Return a (bfd_target *) if it's an object file or zero if not. */ 175 176static const struct bfd_target * 177vms_object_p (bfd * abfd) 178{ 179 int err = 0; 180 int prev_type; 181 const struct bfd_target *target_vector = NULL; 182 const bfd_arch_info_type *arch = NULL; 183 void * tdata_save = abfd->tdata.any; 184 bfd_vma saddr_save = bfd_get_start_address (abfd); 185 186#if VMS_DEBUG 187 vms_debug (1, "vms_object_p (%p)\n", abfd); 188#endif 189 190 if (!vms_initialize (abfd)) 191 goto error_ret; 192 193 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)) 194 goto err_wrong_format; 195 196 prev_type = -1; 197 198 do 199 { 200#if VMS_DEBUG 201 vms_debug (7, "reading at %08lx\n", bfd_tell (abfd)); 202#endif 203 if (_bfd_vms_next_record (abfd) < 0) 204 { 205#if VMS_DEBUG 206 vms_debug (2, "next_record failed\n"); 207#endif 208 goto err_wrong_format; 209 } 210 211 if ((prev_type == EOBJ_S_C_EGSD) 212 && (PRIV (rec_type) != EOBJ_S_C_EGSD)) 213 { 214 if (! vms_fixup_sections (abfd)) 215 { 216#if VMS_DEBUG 217 vms_debug (2, "vms_fixup_sections failed\n"); 218#endif 219 goto err_wrong_format; 220 } 221 } 222 223 prev_type = PRIV (rec_type); 224 225 if (target_vector == NULL) 226 { 227 if (prev_type <= OBJ_S_C_MAXRECTYP) 228 target_vector = & vms_vax_vec; 229 else 230 target_vector = & vms_alpha_vec; 231 } 232 233 switch (prev_type) 234 { 235 case OBJ_S_C_HDR: 236 case EOBJ_S_C_EMH: 237 err = _bfd_vms_slurp_hdr (abfd, prev_type); 238 break; 239 case OBJ_S_C_EOM: 240 case OBJ_S_C_EOMW: 241 case EOBJ_S_C_EEOM: 242 err = _bfd_vms_slurp_eom (abfd, prev_type); 243 break; 244 case OBJ_S_C_GSD: 245 case EOBJ_S_C_EGSD: 246 err = _bfd_vms_slurp_gsd (abfd, prev_type); 247 break; 248 case OBJ_S_C_TIR: 249 case EOBJ_S_C_ETIR: 250 err = _bfd_vms_slurp_tir (abfd, prev_type); 251 break; 252 case OBJ_S_C_DBG: 253 case EOBJ_S_C_EDBG: 254 err = _bfd_vms_slurp_dbg (abfd, prev_type); 255 break; 256 case OBJ_S_C_TBT: 257 case EOBJ_S_C_ETBT: 258 err = _bfd_vms_slurp_tbt (abfd, prev_type); 259 break; 260 case OBJ_S_C_LNK: 261 err = _bfd_vms_slurp_lnk (abfd, prev_type); 262 break; 263 default: 264 err = -1; 265 } 266 if (err != 0) 267 { 268#if VMS_DEBUG 269 vms_debug (2, "slurp type %d failed with %d\n", prev_type, err); 270#endif 271 goto err_wrong_format; 272 } 273 } 274 while ((prev_type != EOBJ_S_C_EEOM) && (prev_type != OBJ_S_C_EOM) && (prev_type != OBJ_S_C_EOMW)); 275 276 if (target_vector == & vms_vax_vec) 277 { 278 if (! vms_fixup_sections (abfd)) 279 { 280#if VMS_DEBUG 281 vms_debug (2, "vms_fixup_sections failed\n"); 282#endif 283 goto err_wrong_format; 284 } 285 286 /* Set arch_info to vax. */ 287 288 arch = bfd_scan_arch ("vax"); 289 PRIV (is_vax) = TRUE; 290#if VMS_DEBUG 291 vms_debug (2, "arch is vax\n"); 292#endif 293 } 294 else if (target_vector == & vms_alpha_vec) 295 { 296 /* Set arch_info to alpha. */ 297 298 arch = bfd_scan_arch ("alpha"); 299 PRIV (is_vax) = FALSE; 300#if VMS_DEBUG 301 vms_debug (2, "arch is alpha\n"); 302#endif 303 } 304 305 if (arch == NULL) 306 { 307#if VMS_DEBUG 308 vms_debug (2, "arch not found\n"); 309#endif 310 goto err_wrong_format; 311 } 312 abfd->arch_info = arch; 313 314 return target_vector; 315 316 err_wrong_format: 317 bfd_set_error (bfd_error_wrong_format); 318 error_ret: 319 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL) 320 bfd_release (abfd, abfd->tdata.any); 321 abfd->tdata.any = tdata_save; 322 bfd_set_start_address (abfd, saddr_save); 323 return NULL; 324} 325 326/* Check the format for a file being read. 327 Return a (bfd_target *) if it's an archive file or zero. */ 328 329static const struct bfd_target * 330vms_archive_p (bfd * abfd ATTRIBUTE_UNUSED) 331{ 332#if VMS_DEBUG 333 vms_debug (1, "vms_archive_p (%p)\n", abfd); 334#endif 335 336 return NULL; 337} 338 339/* Set the format of a file being written. */ 340 341static bfd_boolean 342vms_mkobject (bfd * abfd) 343{ 344#if VMS_DEBUG 345 vms_debug (1, "vms_mkobject (%p)\n", abfd); 346#endif 347 348 if (!vms_initialize (abfd)) 349 return FALSE; 350 351 { 352#ifdef __VAX 353 const bfd_arch_info_type *arch = bfd_scan_arch ("vax"); 354#else 355 const bfd_arch_info_type *arch = bfd_scan_arch ("alpha"); 356#endif 357 if (arch == NULL) 358 { 359 bfd_set_error (bfd_error_wrong_format); 360 return FALSE; 361 } 362 abfd->arch_info = arch; 363 } 364 365 return TRUE; 366} 367 368/* Write cached information into a file being written, at bfd_close. */ 369 370static bfd_boolean 371vms_write_object_contents (bfd * abfd) 372{ 373#if VMS_DEBUG 374 vms_debug (1, "vms_write_object_contents (%p)\n", abfd); 375#endif 376 377 if (abfd->section_count > 0) /* we have sections */ 378 { 379 if (PRIV (is_vax)) 380 { 381 if (_bfd_vms_write_hdr (abfd, OBJ_S_C_HDR) != 0) 382 return FALSE; 383 if (_bfd_vms_write_gsd (abfd, OBJ_S_C_GSD) != 0) 384 return FALSE; 385 if (_bfd_vms_write_tir (abfd, OBJ_S_C_TIR) != 0) 386 return FALSE; 387 if (_bfd_vms_write_tbt (abfd, OBJ_S_C_TBT) != 0) 388 return FALSE; 389 if (_bfd_vms_write_dbg (abfd, OBJ_S_C_DBG) != 0) 390 return FALSE; 391 if (abfd->section_count > 255) 392 { 393 if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOMW) != 0) 394 return FALSE; 395 } 396 else 397 { 398 if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOM) != 0) 399 return FALSE; 400 } 401 } 402 else 403 { 404 if (_bfd_vms_write_hdr (abfd, EOBJ_S_C_EMH) != 0) 405 return FALSE; 406 if (_bfd_vms_write_gsd (abfd, EOBJ_S_C_EGSD) != 0) 407 return FALSE; 408 if (_bfd_vms_write_tir (abfd, EOBJ_S_C_ETIR) != 0) 409 return FALSE; 410 if (_bfd_vms_write_tbt (abfd, EOBJ_S_C_ETBT) != 0) 411 return FALSE; 412 if (_bfd_vms_write_dbg (abfd, EOBJ_S_C_EDBG) != 0) 413 return FALSE; 414 if (_bfd_vms_write_eom (abfd, EOBJ_S_C_EEOM) != 0) 415 return FALSE; 416 } 417 } 418 return TRUE; 419} 420 421/* 4.1, generic. */ 422 423/* Called when the BFD is being closed to do any necessary cleanup. */ 424 425static bfd_boolean 426vms_close_and_cleanup (bfd * abfd) 427{ 428#if VMS_DEBUG 429 vms_debug (1, "vms_close_and_cleanup (%p)\n", abfd); 430#endif 431 if (abfd == NULL) 432 return TRUE; 433 434 if (PRIV (vms_buf) != NULL) 435 free (PRIV (vms_buf)); 436 437 if (PRIV (sections) != NULL) 438 free (PRIV (sections)); 439 440 if (PRIV (vms_symbol_table)) 441 bfd_hash_table_free (PRIV (vms_symbol_table)); 442 443 bfd_release (abfd, abfd->tdata.any); 444 abfd->tdata.any = NULL; 445 446 return TRUE; 447} 448 449/* Ask the BFD to free all cached information. */ 450 451static bfd_boolean 452vms_bfd_free_cached_info (bfd * abfd ATTRIBUTE_UNUSED) 453{ 454#if VMS_DEBUG 455 vms_debug (1, "vms_bfd_free_cached_info (%p)\n", abfd); 456#endif 457 return TRUE; 458} 459 460/* Called when a new section is created. */ 461 462static bfd_boolean 463vms_new_section_hook (bfd * abfd, asection *section) 464{ 465 /* Count hasn't been incremented yet. */ 466 unsigned int section_count = abfd->section_count + 1; 467 468#if VMS_DEBUG 469 vms_debug (1, "vms_new_section_hook (%p, [%d]%s), count %d\n", 470 abfd, section->index, section->name, section_count); 471#endif 472 bfd_set_section_alignment (abfd, section, 4); 473 474 if (section_count > PRIV (section_count)) 475 { 476 bfd_size_type amt = section_count; 477 amt *= sizeof (asection *); 478 PRIV (sections) = bfd_realloc (PRIV (sections), amt); 479 if (PRIV (sections) == NULL) 480 return FALSE; 481 PRIV (section_count) = section_count; 482 } 483#if VMS_DEBUG 484 vms_debug (6, "section_count: %d\n", PRIV (section_count)); 485#endif 486 PRIV (sections)[section->index] = section; 487#if VMS_DEBUG 488 vms_debug (7, "%d: %s\n", section->index, section->name); 489#endif 490 491 return _bfd_generic_new_section_hook (abfd, section); 492} 493 494/* Read the contents of a section. 495 buf points to a buffer of buf_size bytes to be filled with 496 section data (starting at offset into section) */ 497 498static bfd_boolean 499vms_get_section_contents (bfd * abfd ATTRIBUTE_UNUSED, 500 asection *section ATTRIBUTE_UNUSED, 501 void * buf ATTRIBUTE_UNUSED, 502 file_ptr offset ATTRIBUTE_UNUSED, 503 bfd_size_type buf_size ATTRIBUTE_UNUSED) 504{ 505#if VMS_DEBUG 506 vms_debug (1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n", 507 abfd, section->name, buf, offset, (int)buf_size); 508#endif 509 510 /* Shouldn't be called, since all sections are IN_MEMORY. */ 511 return FALSE; 512} 513 514/* Read the contents of a section. 515 buf points to a buffer of buf_size bytes to be filled with 516 section data (starting at offset into section). */ 517 518static bfd_boolean 519vms_get_section_contents_in_window (bfd * abfd ATTRIBUTE_UNUSED, 520 asection *section ATTRIBUTE_UNUSED, 521 bfd_window *w ATTRIBUTE_UNUSED, 522 file_ptr offset ATTRIBUTE_UNUSED, 523 bfd_size_type count ATTRIBUTE_UNUSED) 524{ 525#if VMS_DEBUG 526 vms_debug (1, "vms_get_section_contents_in_window (%p, %s, %p, off %ld, count %d)\n", 527 abfd, section->name, w, offset, (int)count); 528#endif 529 530 /* Shouldn't be called, since all sections are IN_MEMORY. */ 531 return FALSE; 532} 533 534/* Part 4.2, copy private data. */ 535 536/* Called to copy BFD general private data from one object file 537 to another. */ 538 539static bfd_boolean 540vms_bfd_copy_private_bfd_data (bfd *src ATTRIBUTE_UNUSED, 541 bfd *dest ATTRIBUTE_UNUSED) 542{ 543#if VMS_DEBUG 544 vms_debug (1, "vms_bfd_copy_private_bfd_data (%p, %p)\n", src, dest); 545#endif 546 return TRUE; 547} 548 549/* Merge private BFD information from the BFD @var{ibfd} to the 550 the output file BFD @var{obfd} when linking. Return <<TRUE>> 551 on success, <<FALSE>> on error. Possible error returns are: 552 553 o <<bfd_error_no_memory>> - 554 Not enough memory exists to create private data for @var{obfd}. */ 555 556static bfd_boolean 557vms_bfd_merge_private_bfd_data (bfd * ibfd ATTRIBUTE_UNUSED, 558 bfd * obfd ATTRIBUTE_UNUSED) 559{ 560#if VMS_DEBUG 561 vms_debug (1,"vms_bfd_merge_private_bfd_data (%p, %p)\n", ibfd, obfd); 562#endif 563 return TRUE; 564} 565 566/* Set private BFD flag information in the BFD @var{abfd}. 567 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 568 returns are: 569 570 o <<bfd_error_no_memory>> - 571 Not enough memory exists to create private data for @var{obfd}. */ 572 573static bfd_boolean 574vms_bfd_set_private_flags (bfd * abfd ATTRIBUTE_UNUSED, 575 flagword flags ATTRIBUTE_UNUSED) 576{ 577#if VMS_DEBUG 578 vms_debug (1,"vms_bfd_set_private_flags (%p, %lx)\n", abfd, (long)flags); 579#endif 580 return TRUE; 581} 582 583/* Called to copy BFD private section data from one object file 584 to another. */ 585 586static bfd_boolean 587vms_bfd_copy_private_section_data (bfd *srcbfd ATTRIBUTE_UNUSED, 588 asection *srcsec ATTRIBUTE_UNUSED, 589 bfd *dstbfd ATTRIBUTE_UNUSED, 590 asection *dstsec ATTRIBUTE_UNUSED) 591{ 592#if VMS_DEBUG 593 vms_debug (1, "vms_bfd_copy_private_section_data (%p, %s, %p, %s)\n", 594 srcbfd, srcsec->name, dstbfd, dstsec->name); 595#endif 596 return TRUE; 597} 598 599/* Called to copy BFD private symbol data from one object file 600 to another. */ 601 602static bfd_boolean 603vms_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED, 604 asymbol *isym ATTRIBUTE_UNUSED, 605 bfd *obfd ATTRIBUTE_UNUSED, 606 asymbol *osym ATTRIBUTE_UNUSED) 607{ 608#if VMS_DEBUG 609 vms_debug (1, "vms_bfd_copy_private_symbol_data (%p, %s, %p, %s)\n", 610 ibfd, isym->name, obfd, osym->name); 611#endif 612 return TRUE; 613} 614 615/* Part 4.3, core file. */ 616 617/* Return a read-only string explaining which program was running 618 when it failed and produced the core file abfd. */ 619 620static char * 621vms_core_file_failing_command (bfd * abfd ATTRIBUTE_UNUSED) 622{ 623#if VMS_DEBUG 624 vms_debug (1, "vms_core_file_failing_command (%p)\n", abfd); 625#endif 626 return NULL; 627} 628 629/* Returns the signal number which caused the core dump which 630 generated the file the BFD abfd is attached to. */ 631 632static int 633vms_core_file_failing_signal (bfd * abfd ATTRIBUTE_UNUSED) 634{ 635#if VMS_DEBUG 636 vms_debug (1, "vms_core_file_failing_signal (%p)\n", abfd); 637#endif 638 return 0; 639} 640 641/* Return TRUE if the core file attached to core_bfd was generated 642 by a run of the executable file attached to exec_bfd, FALSE otherwise. */ 643 644static bfd_boolean 645vms_core_file_matches_executable_p (bfd * abfd ATTRIBUTE_UNUSED, 646 bfd *bbfd ATTRIBUTE_UNUSED) 647{ 648#if VMS_DEBUG 649 vms_debug (1, "vms_core_file_matches_executable_p (%p, %p)\n", abfd, bbfd); 650#endif 651 return FALSE; 652} 653 654/* Part 4.4, archive. */ 655 656/* ??? do something with an archive map. 657 Return FALSE on error, TRUE otherwise. */ 658 659static bfd_boolean 660vms_slurp_armap (bfd * abfd ATTRIBUTE_UNUSED) 661{ 662#if VMS_DEBUG 663 vms_debug (1, "vms_slurp_armap (%p)\n", abfd); 664#endif 665 return FALSE; 666} 667 668/* ??? do something with an extended name table. 669 Return FALSE on error, TRUE otherwise. */ 670 671static bfd_boolean 672vms_slurp_extended_name_table (bfd * abfd ATTRIBUTE_UNUSED) 673{ 674#if VMS_DEBUG 675 vms_debug (1, "vms_slurp_extended_name_table (%p)\n", abfd); 676#endif 677 return FALSE; 678} 679 680/* ??? do something with an extended name table. 681 Return FALSE on error, TRUE otherwise. */ 682 683static bfd_boolean 684vms_construct_extended_name_table (bfd * abfd ATTRIBUTE_UNUSED, 685 char **tabloc ATTRIBUTE_UNUSED, 686 bfd_size_type *tablen ATTRIBUTE_UNUSED, 687 const char **name ATTRIBUTE_UNUSED) 688{ 689#if VMS_DEBUG 690 vms_debug (1, "vms_construct_extended_name_table (%p)\n", abfd); 691#endif 692 return FALSE; 693} 694 695/* Truncate the name of an archive to match system-dependent restrictions. */ 696 697static void 698vms_truncate_arname (bfd * abfd ATTRIBUTE_UNUSED, 699 const char *pathname ATTRIBUTE_UNUSED, 700 char *arhdr ATTRIBUTE_UNUSED) 701{ 702#if VMS_DEBUG 703 vms_debug (1, "vms_truncate_arname (%p, %s, %s)\n", abfd, pathname, arhdr); 704#endif 705 return; 706} 707 708/* ??? write archive map. */ 709 710static bfd_boolean 711vms_write_armap (bfd *arch ATTRIBUTE_UNUSED, 712 unsigned int elength ATTRIBUTE_UNUSED, 713 struct orl *map ATTRIBUTE_UNUSED, 714 unsigned int orl_count ATTRIBUTE_UNUSED, 715 int stridx ATTRIBUTE_UNUSED) 716{ 717#if VMS_DEBUG 718 vms_debug (1, "vms_write_armap (%p, %d, %p, %d %d)\n", 719 arch, elength, map, orl_count, stridx); 720#endif 721 return TRUE; 722} 723 724/* Read archive header ??? */ 725 726static void * 727vms_read_ar_hdr (bfd * abfd ATTRIBUTE_UNUSED) 728{ 729#if VMS_DEBUG 730 vms_debug (1, "vms_read_ar_hdr (%p)\n", abfd); 731#endif 732 return NULL; 733} 734 735/* Provided a BFD, @var{archive}, containing an archive and NULL, open 736 an input BFD on the first contained element and returns that. 737 Subsequent calls should pass the archive and the previous return value 738 to return a created BFD to the next contained element. 739 NULL is returned when there are no more. */ 740 741static bfd * 742vms_openr_next_archived_file (bfd *arch ATTRIBUTE_UNUSED, 743 bfd *prev ATTRIBUTE_UNUSED) 744{ 745#if VMS_DEBUG 746 vms_debug (1, "vms_openr_next_archived_file (%p, %p)\n", arch, prev); 747#endif 748 return NULL; 749} 750 751/* Return the BFD which is referenced by the symbol in ABFD indexed by 752 INDEX. INDEX should have been returned by bfd_get_next_mapent. */ 753 754static bfd * 755vms_get_elt_at_index (bfd * abfd, symindex index) 756{ 757#if VMS_DEBUG 758 vms_debug (1, "vms_get_elt_at_index (%p, %p)\n", abfd, index); 759#endif 760 return _bfd_generic_get_elt_at_index (abfd, index); 761} 762 763/* ??? 764 -> bfd_generic_stat_arch_elt. */ 765 766static int 767vms_generic_stat_arch_elt (bfd * abfd, struct stat *st) 768{ 769#if VMS_DEBUG 770 vms_debug (1, "vms_generic_stat_arch_elt (%p, %p)\n", abfd, st); 771#endif 772 return bfd_generic_stat_arch_elt (abfd, st); 773} 774 775/* This is a new function in bfd 2.5. */ 776 777static bfd_boolean 778vms_update_armap_timestamp (bfd * abfd ATTRIBUTE_UNUSED) 779{ 780#if VMS_DEBUG 781 vms_debug (1, "vms_update_armap_timestamp (%p)\n", abfd); 782#endif 783 return TRUE; 784} 785 786/* Part 4.5, symbols. */ 787 788/* Return the number of bytes required to store a vector of pointers 789 to asymbols for all the symbols in the BFD abfd, including a 790 terminal NULL pointer. If there are no symbols in the BFD, 791 then return 0. If an error occurs, return -1. */ 792 793static long 794vms_get_symtab_upper_bound (bfd * abfd) 795{ 796#if VMS_DEBUG 797 vms_debug (1, "vms_get_symtab_upper_bound (%p), %d symbols\n", abfd, PRIV (gsd_sym_count)); 798#endif 799 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *); 800} 801 802/* Copy symbols from hash table to symbol vector 803 804 called from bfd_hash_traverse in vms_canonicalize_symtab 805 init counter to 0 if entry == 0. */ 806 807static bfd_boolean 808copy_symbols (struct bfd_hash_entry *entry, void * arg) 809{ 810 bfd * abfd = (bfd *) arg; 811 812 if (entry == NULL) /* Init counter. */ 813 PRIV (symnum) = 0; 814 else /* Fill vector, inc counter. */ 815 PRIV (symcache)[PRIV (symnum)++] = ((vms_symbol_entry *)entry)->symbol; 816 817 return TRUE; 818} 819 820/* Read the symbols from the BFD abfd, and fills in the vector 821 location with pointers to the symbols and a trailing NULL. 822 823 Return number of symbols read. */ 824 825static long 826vms_canonicalize_symtab (bfd * abfd, asymbol **symbols) 827{ 828#if VMS_DEBUG 829 vms_debug (1, "vms_canonicalize_symtab (%p, <ret>)\n", abfd); 830#endif 831 832 /* Init counter. */ 833 copy_symbols (NULL, abfd); 834 835 /* Traverse table and fill symbols vector. */ 836 PRIV (symcache) = symbols; 837 bfd_hash_traverse (PRIV (vms_symbol_table), copy_symbols, abfd); 838 839 symbols[PRIV (gsd_sym_count)] = NULL; 840 841 return PRIV (gsd_sym_count); 842} 843 844/* Print symbol to file according to how. how is one of 845 bfd_print_symbol_name just print the name 846 bfd_print_symbol_more print more (???) 847 bfd_print_symbol_all print all we know, which is not much right now :-). */ 848 849static void 850vms_print_symbol (bfd * abfd, 851 void * file, 852 asymbol *symbol, 853 bfd_print_symbol_type how) 854{ 855#if VMS_DEBUG 856 vms_debug (1, "vms_print_symbol (%p, %p, %p, %d)\n", abfd, file, symbol, how); 857#endif 858 859 switch (how) 860 { 861 case bfd_print_symbol_name: 862 case bfd_print_symbol_more: 863 fprintf ((FILE *)file," %s", symbol->name); 864 break; 865 866 case bfd_print_symbol_all: 867 { 868 const char *section_name = symbol->section->name; 869 870 bfd_print_symbol_vandf (abfd, file, symbol); 871 872 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name); 873 } 874 break; 875 } 876} 877 878/* Return information about symbol in ret. 879 880 fill type, value and name 881 type: 882 A absolute 883 B bss segment symbol 884 C common symbol 885 D data segment symbol 886 f filename 887 t a static function symbol 888 T text segment symbol 889 U undefined 890 - debug. */ 891 892static void 893vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED, 894 asymbol *symbol, 895 symbol_info *ret) 896{ 897 asection *sec; 898 899#if VMS_DEBUG 900 vms_debug (1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret); 901#endif 902 903 sec = symbol->section; 904 905 if (ret == NULL) 906 return; 907 908 if (bfd_is_com_section (sec)) 909 ret->type = 'C'; 910 else if (bfd_is_abs_section (sec)) 911 ret->type = 'A'; 912 else if (bfd_is_und_section (sec)) 913 ret->type = 'U'; 914 else if (bfd_is_ind_section (sec)) 915 ret->type = 'I'; 916 else if (bfd_get_section_flags (abfd, sec) & SEC_CODE) 917 ret->type = 'T'; 918 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA) 919 ret->type = 'D'; 920 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC) 921 ret->type = 'B'; 922 else 923 ret->type = '-'; 924 925 if (ret->type != 'U') 926 ret->value = symbol->value + symbol->section->vma; 927 else 928 ret->value = 0; 929 ret->name = symbol->name; 930} 931 932/* Return TRUE if the given symbol sym in the BFD abfd is 933 a compiler generated local label, else return FALSE. */ 934 935static bfd_boolean 936vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED, 937 const char *name) 938{ 939#if VMS_DEBUG 940 vms_debug (1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name); 941#endif 942 return name[0] == '$'; 943} 944 945/* Get source line number for symbol. */ 946 947static alent * 948vms_get_lineno (bfd * abfd ATTRIBUTE_UNUSED, 949 asymbol *symbol ATTRIBUTE_UNUSED) 950{ 951#if VMS_DEBUG 952 vms_debug (1, "vms_get_lineno (%p, %p)\n", abfd, symbol); 953#endif 954 return NULL; 955} 956 957/* Provided a BFD, a section and an offset into the section, calculate and 958 return the name of the source file and the line nearest to the wanted 959 location. */ 960 961static bfd_boolean 962vms_find_nearest_line (bfd * abfd ATTRIBUTE_UNUSED, 963 asection *section ATTRIBUTE_UNUSED, 964 asymbol **symbols ATTRIBUTE_UNUSED, 965 bfd_vma offset ATTRIBUTE_UNUSED, 966 const char **file ATTRIBUTE_UNUSED, 967 const char **func ATTRIBUTE_UNUSED, 968 unsigned int *line ATTRIBUTE_UNUSED) 969{ 970#if VMS_DEBUG 971 vms_debug (1, "vms_find_nearest_line (%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n", 972 abfd, section->name, symbols, (long int)offset); 973#endif 974 return FALSE; 975} 976 977static bfd_boolean 978vms_find_inliner_info (bfd * abfd ATTRIBUTE_UNUSED, 979 const char **file ATTRIBUTE_UNUSED, 980 const char **func ATTRIBUTE_UNUSED, 981 unsigned int *line ATTRIBUTE_UNUSED) 982{ 983#if VMS_DEBUG 984 vms_debug (1, "vms_find_inliner_info (%p, <ret>, <ret>, <ret>)\n", 985 abfd); 986#endif 987 return FALSE; 988} 989 990/* Back-door to allow format-aware applications to create debug symbols 991 while using BFD for everything else. Currently used by the assembler 992 when creating COFF files. */ 993 994static asymbol * 995vms_bfd_make_debug_symbol (bfd * abfd ATTRIBUTE_UNUSED, 996 void *ptr ATTRIBUTE_UNUSED, 997 unsigned long size ATTRIBUTE_UNUSED) 998{ 999#if VMS_DEBUG 1000 vms_debug (1, "vms_bfd_make_debug_symbol (%p, %p, %ld)\n", abfd, ptr, size); 1001#endif 1002 return NULL; 1003} 1004 1005/* Read minisymbols. For minisymbols, we use the unmodified a.out 1006 symbols. The minisymbol_to_symbol function translates these into 1007 BFD asymbol structures. */ 1008 1009static long 1010vms_read_minisymbols (bfd * abfd, 1011 bfd_boolean dynamic, 1012 void * *minisymsp, 1013 unsigned int *sizep) 1014{ 1015#if VMS_DEBUG 1016 vms_debug (1, "vms_read_minisymbols (%p, %d, %p, %d)\n", abfd, dynamic, minisymsp, *sizep); 1017#endif 1018 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep); 1019} 1020 1021/* Convert a minisymbol to a BFD asymbol. A minisymbol is just an 1022 unmodified a.out symbol. The SYM argument is a structure returned 1023 by bfd_make_empty_symbol, which we fill in here. */ 1024 1025static asymbol * 1026vms_minisymbol_to_symbol (bfd * abfd, 1027 bfd_boolean dynamic, 1028 const void * minisym, 1029 asymbol *sym) 1030{ 1031#if VMS_DEBUG 1032 vms_debug (1, "vms_minisymbol_to_symbol (%p, %d, %p, %p)\n", abfd, dynamic, minisym, sym); 1033#endif 1034 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym); 1035} 1036 1037/* Part 4.6, relocations. */ 1038 1039/* Return the number of bytes required to store the relocation information 1040 associated with section sect attached to bfd abfd. 1041 If an error occurs, return -1. */ 1042 1043static long 1044vms_get_reloc_upper_bound (bfd * abfd ATTRIBUTE_UNUSED, 1045 asection *section ATTRIBUTE_UNUSED) 1046{ 1047#if VMS_DEBUG 1048 vms_debug (1, "vms_get_reloc_upper_bound (%p, %s)\n", abfd, section->name); 1049#endif 1050 return -1L; 1051} 1052 1053/* Call the back end associated with the open BFD abfd and translate the 1054 external form of the relocation information attached to sec into the 1055 internal canonical form. Place the table into memory at loc, which has 1056 been preallocated, usually by a call to bfd_get_reloc_upper_bound. 1057 Returns the number of relocs, or -1 on error. */ 1058 1059static long 1060vms_canonicalize_reloc (bfd * abfd ATTRIBUTE_UNUSED, 1061 asection *section ATTRIBUTE_UNUSED, 1062 arelent **location ATTRIBUTE_UNUSED, 1063 asymbol **symbols ATTRIBUTE_UNUSED) 1064{ 1065#if VMS_DEBUG 1066 vms_debug (1, "vms_canonicalize_reloc (%p, %s, <ret>, <ret>)\n", abfd, section->name); 1067#endif 1068 return FALSE; 1069} 1070 1071/* This is just copied from ecoff-alpha, needs to be fixed probably. */ 1072 1073/* How to process the various reloc types. */ 1074 1075static bfd_reloc_status_type 1076reloc_nil (bfd * abfd ATTRIBUTE_UNUSED, 1077 arelent *reloc ATTRIBUTE_UNUSED, 1078 asymbol *sym ATTRIBUTE_UNUSED, 1079 void * data ATTRIBUTE_UNUSED, 1080 asection *sec ATTRIBUTE_UNUSED, 1081 bfd *output_bfd ATTRIBUTE_UNUSED, 1082 char **error_message ATTRIBUTE_UNUSED) 1083{ 1084#if VMS_DEBUG 1085 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd); 1086 vms_debug (2, "In section %s, symbol %s\n", 1087 sec->name, sym->name); 1088 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n", 1089 reloc->sym_ptr_ptr[0]->name, 1090 (unsigned long)reloc->address, 1091 (unsigned long)reloc->addend, reloc->howto->name); 1092 vms_debug (2, "data at %p\n", data); 1093 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */ 1094#endif 1095 1096 return bfd_reloc_ok; 1097} 1098 1099/* In case we're on a 32-bit machine, construct a 64-bit "-1" value 1100 from smaller values. Start with zero, widen, *then* decrement. */ 1101#define MINUS_ONE (((bfd_vma)0) - 1) 1102 1103static reloc_howto_type alpha_howto_table[] = 1104{ 1105 HOWTO (ALPHA_R_IGNORE, /* Type. */ 1106 0, /* Rightshift. */ 1107 0, /* Size (0 = byte, 1 = short, 2 = long). */ 1108 8, /* Bitsize. */ 1109 TRUE, /* PC relative. */ 1110 0, /* Bitpos. */ 1111 complain_overflow_dont,/* Complain_on_overflow. */ 1112 reloc_nil, /* Special_function. */ 1113 "IGNORE", /* Name. */ 1114 TRUE, /* Partial_inplace. */ 1115 0, /* Source mask */ 1116 0, /* Dest mask. */ 1117 TRUE), /* PC rel offset. */ 1118 1119 /* A 64 bit reference to a symbol. */ 1120 HOWTO (ALPHA_R_REFQUAD, /* Type. */ 1121 0, /* Rightshift. */ 1122 4, /* Size (0 = byte, 1 = short, 2 = long). */ 1123 64, /* Bitsize. */ 1124 FALSE, /* PC relative. */ 1125 0, /* Bitpos. */ 1126 complain_overflow_bitfield, /* Complain_on_overflow. */ 1127 reloc_nil, /* Special_function. */ 1128 "REFQUAD", /* Name. */ 1129 TRUE, /* Partial_inplace. */ 1130 MINUS_ONE, /* Source mask. */ 1131 MINUS_ONE, /* Dest mask. */ 1132 FALSE), /* PC rel offset. */ 1133 1134 /* A 21 bit branch. The native assembler generates these for 1135 branches within the text segment, and also fills in the PC 1136 relative offset in the instruction. */ 1137 HOWTO (ALPHA_R_BRADDR, /* Type. */ 1138 2, /* Rightshift. */ 1139 2, /* Size (0 = byte, 1 = short, 2 = long). */ 1140 21, /* Bitsize. */ 1141 TRUE, /* PC relative. */ 1142 0, /* Bitpos. */ 1143 complain_overflow_signed, /* Complain_on_overflow. */ 1144 reloc_nil, /* Special_function. */ 1145 "BRADDR", /* Name. */ 1146 TRUE, /* Partial_inplace. */ 1147 0x1fffff, /* Source mask. */ 1148 0x1fffff, /* Dest mask. */ 1149 FALSE), /* PC rel offset. */ 1150 1151 /* A hint for a jump to a register. */ 1152 HOWTO (ALPHA_R_HINT, /* Type. */ 1153 2, /* Rightshift. */ 1154 1, /* Size (0 = byte, 1 = short, 2 = long). */ 1155 14, /* Bitsize. */ 1156 TRUE, /* PC relative. */ 1157 0, /* Bitpos. */ 1158 complain_overflow_dont,/* Complain_on_overflow. */ 1159 reloc_nil, /* Special_function. */ 1160 "HINT", /* Name. */ 1161 TRUE, /* Partial_inplace. */ 1162 0x3fff, /* Source mask. */ 1163 0x3fff, /* Dest mask. */ 1164 FALSE), /* PC rel offset. */ 1165 1166 /* 16 bit PC relative offset. */ 1167 HOWTO (ALPHA_R_SREL16, /* Type. */ 1168 0, /* Rightshift. */ 1169 1, /* Size (0 = byte, 1 = short, 2 = long). */ 1170 16, /* Bitsize. */ 1171 TRUE, /* PC relative. */ 1172 0, /* Bitpos. */ 1173 complain_overflow_signed, /* Complain_on_overflow. */ 1174 reloc_nil, /* Special_function. */ 1175 "SREL16", /* Name. */ 1176 TRUE, /* Partial_inplace. */ 1177 0xffff, /* Source mask. */ 1178 0xffff, /* Dest mask. */ 1179 FALSE), /* PC rel offset. */ 1180 1181 /* 32 bit PC relative offset. */ 1182 HOWTO (ALPHA_R_SREL32, /* Type. */ 1183 0, /* Rightshift. */ 1184 2, /* Size (0 = byte, 1 = short, 2 = long). */ 1185 32, /* Bitsize. */ 1186 TRUE, /* PC relative. */ 1187 0, /* Bitpos. */ 1188 complain_overflow_signed, /* Complain_on_overflow. */ 1189 reloc_nil, /* Special_function. */ 1190 "SREL32", /* Name. */ 1191 TRUE, /* Partial_inplace. */ 1192 0xffffffff, /* Source mask. */ 1193 0xffffffff, /* Dest mask. */ 1194 FALSE), /* PC rel offset. */ 1195 1196 /* A 64 bit PC relative offset. */ 1197 HOWTO (ALPHA_R_SREL64, /* Type. */ 1198 0, /* Rightshift. */ 1199 4, /* Size (0 = byte, 1 = short, 2 = long). */ 1200 64, /* Bitsize. */ 1201 TRUE, /* PC relative. */ 1202 0, /* Bitpos. */ 1203 complain_overflow_signed, /* Complain_on_overflow. */ 1204 reloc_nil, /* Special_function. */ 1205 "SREL64", /* Name. */ 1206 TRUE, /* Partial_inplace. */ 1207 MINUS_ONE, /* Source mask. */ 1208 MINUS_ONE, /* Dest mask. */ 1209 FALSE), /* PC rel offset. */ 1210 1211 /* Push a value on the reloc evaluation stack. */ 1212 HOWTO (ALPHA_R_OP_PUSH, /* Type. */ 1213 0, /* Rightshift. */ 1214 0, /* Size (0 = byte, 1 = short, 2 = long). */ 1215 0, /* Bitsize. */ 1216 FALSE, /* PC relative. */ 1217 0, /* Bitpos. */ 1218 complain_overflow_dont,/* Complain_on_overflow. */ 1219 reloc_nil, /* Special_function. */ 1220 "OP_PUSH", /* Name. */ 1221 FALSE, /* Partial_inplace. */ 1222 0, /* Source mask. */ 1223 0, /* Dest mask. */ 1224 FALSE), /* PC rel offset. */ 1225 1226 /* Store the value from the stack at the given address. Store it in 1227 a bitfield of size r_size starting at bit position r_offset. */ 1228 HOWTO (ALPHA_R_OP_STORE, /* Type. */ 1229 0, /* Rightshift. */ 1230 4, /* Size (0 = byte, 1 = short, 2 = long). */ 1231 64, /* Bitsize. */ 1232 FALSE, /* PC relative. */ 1233 0, /* Bitpos. */ 1234 complain_overflow_dont,/* Complain_on_overflow. */ 1235 reloc_nil, /* Special_function. */ 1236 "OP_STORE", /* Name. */ 1237 FALSE, /* Partial_inplace. */ 1238 0, /* Source mask. */ 1239 MINUS_ONE, /* Dest mask. */ 1240 FALSE), /* PC rel offset. */ 1241 1242 /* Subtract the reloc address from the value on the top of the 1243 relocation stack. */ 1244 HOWTO (ALPHA_R_OP_PSUB, /* Type. */ 1245 0, /* Rightshift. */ 1246 0, /* Size (0 = byte, 1 = short, 2 = long). */ 1247 0, /* Bitsize. */ 1248 FALSE, /* PC relative. */ 1249 0, /* Bitpos. */ 1250 complain_overflow_dont,/* Complain_on_overflow. */ 1251 reloc_nil, /* Special_function. */ 1252 "OP_PSUB", /* Name. */ 1253 FALSE, /* Partial_inplace. */ 1254 0, /* Source mask. */ 1255 0, /* Dest mask. */ 1256 FALSE), /* PC rel offset. */ 1257 1258 /* Shift the value on the top of the relocation stack right by the 1259 given value. */ 1260 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */ 1261 0, /* Rightshift. */ 1262 0, /* Size (0 = byte, 1 = short, 2 = long). */ 1263 0, /* Bitsize. */ 1264 FALSE, /* PC relative. */ 1265 0, /* Bitpos. */ 1266 complain_overflow_dont,/* Complain_on_overflow. */ 1267 reloc_nil, /* Special_function. */ 1268 "OP_PRSHIFT", /* Name. */ 1269 FALSE, /* Partial_inplace. */ 1270 0, /* Source mask. */ 1271 0, /* Dest mask. */ 1272 FALSE), /* PC rel offset. */ 1273 1274 /* Hack. Linkage is done by linker. */ 1275 HOWTO (ALPHA_R_LINKAGE, /* Type. */ 1276 0, /* Rightshift. */ 1277 8, /* Size (0 = byte, 1 = short, 2 = long). */ 1278 256, /* Bitsize. */ 1279 FALSE, /* PC relative. */ 1280 0, /* Bitpos. */ 1281 complain_overflow_dont,/* Complain_on_overflow. */ 1282 reloc_nil, /* Special_function. */ 1283 "LINKAGE", /* Name. */ 1284 FALSE, /* Partial_inplace. */ 1285 0, /* Source mask. */ 1286 0, /* Dest mask. */ 1287 FALSE), /* PC rel offset. */ 1288 1289 /* A 32 bit reference to a symbol. */ 1290 HOWTO (ALPHA_R_REFLONG, /* Type. */ 1291 0, /* Rightshift. */ 1292 2, /* Size (0 = byte, 1 = short, 2 = long). */ 1293 32, /* Bitsize. */ 1294 FALSE, /* PC relative. */ 1295 0, /* Bitpos. */ 1296 complain_overflow_bitfield, /* Complain_on_overflow. */ 1297 reloc_nil, /* Special_function. */ 1298 "REFLONG", /* Name. */ 1299 TRUE, /* Partial_inplace. */ 1300 0xffffffff, /* Source mask. */ 1301 0xffffffff, /* Dest mask. */ 1302 FALSE), /* PC rel offset. */ 1303 1304 /* A 64 bit reference to a procedure, written as 32 bit value. */ 1305 HOWTO (ALPHA_R_CODEADDR, /* Type. */ 1306 0, /* Rightshift. */ 1307 4, /* Size (0 = byte, 1 = short, 2 = long). */ 1308 64, /* Bitsize. */ 1309 FALSE, /* PC relative. */ 1310 0, /* Bitpos. */ 1311 complain_overflow_signed,/* Complain_on_overflow. */ 1312 reloc_nil, /* Special_function. */ 1313 "CODEADDR", /* Name. */ 1314 FALSE, /* Partial_inplace. */ 1315 0xffffffff, /* Source mask. */ 1316 0xffffffff, /* Dest mask. */ 1317 FALSE), /* PC rel offset. */ 1318 1319}; 1320 1321/* Return a pointer to a howto structure which, when invoked, will perform 1322 the relocation code on data from the architecture noted. */ 1323 1324static const struct reloc_howto_struct * 1325vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 1326 bfd_reloc_code_real_type code) 1327{ 1328 int alpha_type; 1329 1330#if VMS_DEBUG 1331 vms_debug (1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code); 1332#endif 1333 1334 switch (code) 1335 { 1336 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break; 1337 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break; 1338 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break; 1339 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break; 1340 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break; 1341 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break; 1342 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break; 1343 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break; 1344 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break; 1345 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break; 1346 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break; 1347 default: 1348 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code); 1349 return NULL; 1350 } 1351#if VMS_DEBUG 1352 vms_debug (2, "reloc is %s\n", alpha_howto_table[alpha_type].name); 1353#endif 1354 return & alpha_howto_table[alpha_type]; 1355} 1356 1357static reloc_howto_type * 1358vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1359 const char *r_name) 1360{ 1361 unsigned int i; 1362 1363 for (i = 0; 1364 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]); 1365 i++) 1366 if (alpha_howto_table[i].name != NULL 1367 && strcasecmp (alpha_howto_table[i].name, r_name) == 0) 1368 return &alpha_howto_table[i]; 1369 1370 return NULL; 1371} 1372 1373/* Part 4.7, writing an object file. */ 1374 1375/* Set the architecture and machine type in BFD abfd to arch and mach. 1376 Find the correct pointer to a structure and insert it into the arch_info 1377 pointer. */ 1378 1379static bfd_boolean 1380vms_set_arch_mach (bfd * abfd, 1381 enum bfd_architecture arch ATTRIBUTE_UNUSED, 1382 unsigned long mach ATTRIBUTE_UNUSED) 1383{ 1384#if VMS_DEBUG 1385 vms_debug (1, "vms_set_arch_mach (%p, %d, %ld)\n", abfd, arch, mach); 1386#endif 1387 abfd->arch_info = bfd_scan_arch ("alpha"); 1388 1389 return TRUE; 1390} 1391 1392/* Sets the contents of the section section in BFD abfd to the data starting 1393 in memory at data. The data is written to the output section starting at 1394 offset offset for count bytes. 1395 1396 Normally TRUE is returned, else FALSE. Possible error returns are: 1397 o bfd_error_no_contents - The output section does not have the 1398 SEC_HAS_CONTENTS attribute, so nothing can be written to it. 1399 o and some more too */ 1400 1401static bfd_boolean 1402vms_set_section_contents (bfd * abfd, 1403 asection *section, 1404 const void * location, 1405 file_ptr offset, 1406 bfd_size_type count) 1407{ 1408#if VMS_DEBUG 1409 vms_debug (1, "vms_set_section_contents (%p, sec %s, loc %p, off %ld, count %d)\n", 1410 abfd, section->name, location, (long int)offset, (int)count); 1411 vms_debug (2, "size %d\n", (int) section->size); 1412#endif 1413 return _bfd_save_vms_section (abfd, section, location, offset, count); 1414} 1415 1416/* Part 4.8, linker. */ 1417 1418/* Get the size of the section headers. */ 1419 1420static int 1421vms_sizeof_headers (bfd * abfd ATTRIBUTE_UNUSED, 1422 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1423{ 1424#if VMS_DEBUG 1425 vms_debug (1, "vms_sizeof_headers (%p, %s)\n", abfd, (reloc)?"True":"False"); 1426#endif 1427 return 0; 1428} 1429 1430/* Provides default handling of relocation effort for back ends 1431 which can't be bothered to do it efficiently. */ 1432 1433static bfd_byte * 1434vms_bfd_get_relocated_section_contents (bfd * abfd ATTRIBUTE_UNUSED, 1435 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 1436 struct bfd_link_order *link_order ATTRIBUTE_UNUSED, 1437 bfd_byte *data ATTRIBUTE_UNUSED, 1438 bfd_boolean relocatable ATTRIBUTE_UNUSED, 1439 asymbol **symbols ATTRIBUTE_UNUSED) 1440{ 1441#if VMS_DEBUG 1442 vms_debug (1, "vms_bfd_get_relocated_section_contents (%p, %p, %p, %p, %s, %p)\n", 1443 abfd, link_info, link_order, data, (relocatable)?"True":"False", symbols); 1444#endif 1445 return NULL; 1446} 1447 1448/* ??? */ 1449 1450static bfd_boolean 1451vms_bfd_relax_section (bfd * abfd ATTRIBUTE_UNUSED, 1452 asection *section ATTRIBUTE_UNUSED, 1453 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 1454 bfd_boolean *again ATTRIBUTE_UNUSED) 1455{ 1456#if VMS_DEBUG 1457 vms_debug (1, "vms_bfd_relax_section (%p, %s, %p, <ret>)\n", 1458 abfd, section->name, link_info); 1459#endif 1460 return TRUE; 1461} 1462 1463static bfd_boolean 1464vms_bfd_gc_sections (bfd * abfd ATTRIBUTE_UNUSED, 1465 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 1466{ 1467#if VMS_DEBUG 1468 vms_debug (1, "vms_bfd_gc_sections (%p, %p)\n", abfd, link_info); 1469#endif 1470 return TRUE; 1471} 1472 1473static bfd_boolean 1474vms_bfd_merge_sections (bfd * abfd ATTRIBUTE_UNUSED, 1475 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 1476{ 1477#if VMS_DEBUG 1478 vms_debug (1, "vms_bfd_merge_sections (%p, %p)\n", abfd, link_info); 1479#endif 1480 return TRUE; 1481} 1482 1483/* Create a hash table for the linker. Different backends store 1484 different information in this table. */ 1485 1486static struct bfd_link_hash_table * 1487vms_bfd_link_hash_table_create (bfd * abfd ATTRIBUTE_UNUSED) 1488{ 1489#if VMS_DEBUG 1490 vms_debug (1, "vms_bfd_link_hash_table_create (%p)\n", abfd); 1491#endif 1492 return NULL; 1493} 1494 1495/* Free a linker hash table. */ 1496 1497static void 1498vms_bfd_link_hash_table_free (struct bfd_link_hash_table *hash ATTRIBUTE_UNUSED) 1499{ 1500#if VMS_DEBUG 1501 vms_debug (1, "vms_bfd_link_hash_table_free (%p)\n", abfd); 1502#endif 1503} 1504 1505/* Add symbols from this object file into the hash table. */ 1506 1507static bfd_boolean 1508vms_bfd_link_add_symbols (bfd * abfd ATTRIBUTE_UNUSED, 1509 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 1510{ 1511#if VMS_DEBUG 1512 vms_debug (1, "vms_bfd_link_add_symbols (%p, %p)\n", abfd, link_info); 1513#endif 1514 return FALSE; 1515} 1516 1517/* Do a link based on the link_order structures attached to each 1518 section of the BFD. */ 1519 1520static bfd_boolean 1521vms_bfd_final_link (bfd * abfd ATTRIBUTE_UNUSED, 1522 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 1523{ 1524#if VMS_DEBUG 1525 vms_debug (1, "vms_bfd_final_link (%p, %p)\n", abfd, link_info); 1526#endif 1527 return TRUE; 1528} 1529 1530/* Should this section be split up into smaller pieces during linking. */ 1531 1532static bfd_boolean 1533vms_bfd_link_split_section (bfd * abfd ATTRIBUTE_UNUSED, 1534 asection *section ATTRIBUTE_UNUSED) 1535{ 1536#if VMS_DEBUG 1537 vms_debug (1, "vms_bfd_link_split_section (%p, %s)\n", abfd, section->name); 1538#endif 1539 return FALSE; 1540} 1541 1542/* Part 4.9, dynamic symbols and relocations. */ 1543 1544/* Get the amount of memory required to hold the dynamic symbols. */ 1545 1546static long 1547vms_get_dynamic_symtab_upper_bound (bfd * abfd ATTRIBUTE_UNUSED) 1548{ 1549#if VMS_DEBUG 1550 vms_debug (1, "vms_get_dynamic_symtab_upper_bound (%p)\n", abfd); 1551#endif 1552 return 0; 1553} 1554 1555static bfd_boolean 1556vms_bfd_print_private_bfd_data (bfd * abfd ATTRIBUTE_UNUSED, 1557 void *file ATTRIBUTE_UNUSED) 1558{ 1559#if VMS_DEBUG 1560 vms_debug (1, "vms_bfd_print_private_bfd_data (%p)\n", abfd); 1561#endif 1562 return FALSE; 1563} 1564 1565/* Read in the dynamic symbols. */ 1566 1567static long 1568vms_canonicalize_dynamic_symtab (bfd * abfd ATTRIBUTE_UNUSED, 1569 asymbol **symbols ATTRIBUTE_UNUSED) 1570{ 1571#if VMS_DEBUG 1572 vms_debug (1, "vms_canonicalize_dynamic_symtab (%p, <ret>)\n", abfd); 1573#endif 1574 return 0L; 1575} 1576 1577/* Get the amount of memory required to hold the dynamic relocs. */ 1578 1579static long 1580vms_get_dynamic_reloc_upper_bound (bfd * abfd ATTRIBUTE_UNUSED) 1581{ 1582#if VMS_DEBUG 1583 vms_debug (1, "vms_get_dynamic_reloc_upper_bound (%p)\n", abfd); 1584#endif 1585 return 0L; 1586} 1587 1588/* Read in the dynamic relocs. */ 1589 1590static long 1591vms_canonicalize_dynamic_reloc (bfd * abfd ATTRIBUTE_UNUSED, 1592 arelent **arel ATTRIBUTE_UNUSED, 1593 asymbol **symbols ATTRIBUTE_UNUSED) 1594{ 1595#if VMS_DEBUG 1596 vms_debug (1, "vms_canonicalize_dynamic_reloc (%p)\n", abfd); 1597#endif 1598 return 0L; 1599} 1600 1601const bfd_target vms_alpha_vec = 1602{ 1603 "vms-alpha", /* Name. */ 1604 bfd_target_evax_flavour, 1605 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ 1606 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ 1607 1608 (HAS_RELOC | HAS_SYMS 1609 | WP_TEXT | D_PAGED), /* Object flags. */ 1610 (SEC_ALLOC | SEC_LOAD | SEC_RELOC 1611 | SEC_READONLY | SEC_CODE | SEC_DATA 1612 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */ 1613 0, /* Symbol_leading_char. */ 1614 ' ', /* AR_pad_char. */ 1615 15, /* AR_max_namelen. */ 1616 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1617 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1618 bfd_getl16, bfd_getl_signed_16, bfd_putl16, 1619 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1620 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1621 bfd_getl16, bfd_getl_signed_16, bfd_putl16, 1622 1623 {_bfd_dummy_target, vms_object_p, /* bfd_check_format. */ 1624 vms_archive_p, _bfd_dummy_target}, 1625 {bfd_false, vms_mkobject, /* bfd_set_format. */ 1626 _bfd_generic_mkarchive, bfd_false}, 1627 {bfd_false, vms_write_object_contents, /* bfd_write_contents. */ 1628 _bfd_write_archive_contents, bfd_false}, 1629 1630 BFD_JUMP_TABLE_GENERIC (vms), 1631 BFD_JUMP_TABLE_COPY (vms), 1632 BFD_JUMP_TABLE_CORE (vms), 1633 BFD_JUMP_TABLE_ARCHIVE (vms), 1634 BFD_JUMP_TABLE_SYMBOLS (vms), 1635 BFD_JUMP_TABLE_RELOCS (vms), 1636 BFD_JUMP_TABLE_WRITE (vms), 1637 BFD_JUMP_TABLE_LINK (vms), 1638 BFD_JUMP_TABLE_DYNAMIC (vms), 1639 1640 NULL, 1641 1642 NULL 1643}; 1644 1645const bfd_target vms_vax_vec = 1646{ 1647 "vms-vax", /* Name. */ 1648 bfd_target_ovax_flavour, 1649 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ 1650 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ 1651 1652 (HAS_RELOC | HAS_SYMS /* Object flags. */ 1653 | WP_TEXT | D_PAGED 1654 | HAS_LINENO | HAS_DEBUG | HAS_LOCALS), 1655 1656 (SEC_ALLOC | SEC_LOAD | SEC_RELOC 1657 | SEC_READONLY | SEC_CODE | SEC_DATA 1658 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */ 1659 0, /* Symbol_leading_char. */ 1660 ' ', /* AR_pad_char. */ 1661 15, /* AR_max_namelen. */ 1662 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1663 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1664 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */ 1665 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1666 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1667 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */ 1668 1669 {_bfd_dummy_target, vms_object_p, /* bfd_check_format. */ 1670 vms_archive_p, _bfd_dummy_target}, 1671 {bfd_false, vms_mkobject, /* bfd_set_format. */ 1672 _bfd_generic_mkarchive, bfd_false}, 1673 {bfd_false, vms_write_object_contents, /* bfd_write_contents. */ 1674 _bfd_write_archive_contents, bfd_false}, 1675 1676 BFD_JUMP_TABLE_GENERIC (vms), 1677 BFD_JUMP_TABLE_COPY (vms), 1678 BFD_JUMP_TABLE_CORE (vms), 1679 BFD_JUMP_TABLE_ARCHIVE (vms), 1680 BFD_JUMP_TABLE_SYMBOLS (vms), 1681 BFD_JUMP_TABLE_RELOCS (vms), 1682 BFD_JUMP_TABLE_WRITE (vms), 1683 BFD_JUMP_TABLE_LINK (vms), 1684 BFD_JUMP_TABLE_DYNAMIC (vms), 1685 1686 NULL, 1687 1688 NULL 1689}; 1690