bfd/vms.c

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