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