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