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