bfd/vms.c

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