bfd/evax-alpha.c

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