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