bfd/oasys.c

   1 /* BFD back-end for oasys objects.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2001,
   3    2002, 2003 Free Software Foundation, Inc.
   4    Written by Steve Chamberlain of Cygnus Support, <sac@cygnus.com>.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #define UNDERSCORE_HACK 1
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "safe-ctype.h"
  26 #include "libbfd.h"
  27 #include "oasys.h"
  28 #include "liboasys.h"
  29
  30 static bfd_boolean oasys_slurp_section_data
  31   PARAMS ((bfd * const));
  32 static bfd_boolean oasys_read_record
  33   PARAMS ((bfd *, oasys_record_union_type *));
  34 static bfd_boolean oasys_write_sections
  35   PARAMS ((bfd *));
  36 static bfd_boolean oasys_write_record
  37   PARAMS ((bfd *, oasys_record_enum_type, oasys_record_union_type *, size_t));
  38 static bfd_boolean oasys_write_syms
  39   PARAMS ((bfd *));
  40 static bfd_boolean oasys_write_header
  41   PARAMS ((bfd *));
  42 static bfd_boolean oasys_write_end
  43   PARAMS ((bfd *));
  44 static bfd_boolean oasys_write_data
  45   PARAMS ((bfd *));
  46 static size_t oasys_string_length
  47   PARAMS ((oasys_record_union_type *));
  48 static bfd_boolean oasys_slurp_symbol_table
  49   PARAMS ((bfd *const));
  50 static long int oasys_get_symtab_upper_bound
  51   PARAMS ((bfd *const));
  52 static const bfd_target *oasys_archive_p
  53   PARAMS ((bfd *));
  54 static bfd_boolean oasys_mkobject
  55   PARAMS ((bfd *));
  56 static const bfd_target *oasys_object_p
  57   PARAMS ((bfd *));
  58 static void oasys_get_symbol_info
  59   PARAMS ((bfd *, asymbol *, symbol_info *));
  60 static void oasys_print_symbol
  61   PARAMS ((bfd *, void *, asymbol *, bfd_print_symbol_type));
  62 static bfd_boolean oasys_new_section_hook
  63   PARAMS ((bfd *, asection *));
  64 static long int oasys_get_reloc_upper_bound
  65   PARAMS ((bfd *, sec_ptr));
  66 static bfd_boolean oasys_get_section_contents
  67   PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));
  68 static int comp
  69   PARAMS ((const void *, const void *));
  70 static bfd_boolean oasys_write_object_contents
  71   PARAMS ((bfd *));
  72 static bfd_boolean oasys_set_section_contents
  73   PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));
  74 static asymbol *oasys_make_empty_symbol
  75   PARAMS ((bfd *));
  76 static bfd *oasys_openr_next_archived_file
  77   PARAMS ((bfd *, bfd *));
  78 static bfd_boolean oasys_find_nearest_line
  79   PARAMS ((bfd *, asection *, asymbol **, bfd_vma,
  80            const char **, const char **, unsigned int *));
  81 static int oasys_generic_stat_arch_elt
  82   PARAMS ((bfd *, struct stat *));
  83 static int oasys_sizeof_headers
  84   PARAMS ((bfd *, bfd_boolean));
  85
  86 long oasys_get_symtab
  87   PARAMS ((bfd *, asymbol **));
  88 long oasys_canonicalize_reloc
  89   PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
  90
  91 /* Read in all the section data and relocation stuff too.  */
  92
  93 static bfd_boolean
  94 oasys_read_record (abfd, record)
  95      bfd *abfd;
  96      oasys_record_union_type *record;
  97 {
  98   bfd_size_type amt = sizeof (record->header);
  99   if (bfd_bread ((PTR) record, amt, abfd) != amt)
 100     return FALSE;
 101
 102   amt = record->header.length - sizeof (record->header);
 103   if ((long) amt <= 0)
 104     return TRUE;
 105   if (bfd_bread ((PTR) ((char *) record + sizeof (record->header)), amt, abfd)
 106       != amt)
 107     return FALSE;
 108   return TRUE;
 109 }
 110
 111 static size_t
 112 oasys_string_length (record)
 113      oasys_record_union_type *record;
 114 {
 115   return record->header.length
 116     - ((char *) record->symbol.name - (char *) record);
 117 }
 118
 119 /*****************************************************************************/
 120
 121 /*
 122
 123 Slurp the symbol table by reading in all the records at the start file
 124 till we get to the first section record.
 125
 126 We'll sort the symbolss into  two lists, defined and undefined. The
 127 undefined symbols will be placed into the table according to their
 128 refno.
 129
 130 We do this by placing all undefined symbols at the front of the table
 131 moving in, and the defined symbols at the end of the table moving back.
 132
 133 */
 134
 135 static bfd_boolean
 136 oasys_slurp_symbol_table (abfd)
 137      bfd *const abfd;
 138 {
 139   oasys_record_union_type record;
 140   oasys_data_type *data = OASYS_DATA (abfd);
 141   bfd_boolean loop = TRUE;
 142   asymbol *dest_defined;
 143   asymbol *dest;
 144   char *string_ptr;
 145   bfd_size_type amt;
 146
 147   if (data->symbols != (asymbol *) NULL)
 148     {
 149       return TRUE;
 150     }
 151   /* Buy enough memory for all the symbols and all the names */
 152   amt = abfd->symcount;
 153   amt *= sizeof (asymbol);
 154   data->symbols = (asymbol *) bfd_alloc (abfd, amt);
 155
 156   amt = data->symbol_string_length;
 157 #ifdef UNDERSCORE_HACK
 158   /* buy 1 more char for each symbol to keep the underscore in*/
 159   amt += abfd->symcount;
 160 #endif
 161   data->strings = bfd_alloc (abfd, amt);
 162
 163   if (!data->symbols || !data->strings)
 164     return FALSE;
 165
 166   dest_defined = data->symbols + abfd->symcount - 1;
 167
 168   string_ptr = data->strings;
 169   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 170     return FALSE;
 171   while (loop)
 172     {
 173
 174       if (! oasys_read_record (abfd, &record))
 175         return FALSE;
 176       switch (record.header.type)
 177         {
 178         case oasys_record_is_header_enum:
 179           break;
 180         case oasys_record_is_local_enum:
 181         case oasys_record_is_symbol_enum:
 182           {
 183             int flag = record.header.type == (int) oasys_record_is_local_enum ?
 184             (BSF_LOCAL) : (BSF_GLOBAL | BSF_EXPORT);
 185
 186
 187             size_t length = oasys_string_length (&record);
 188             switch (record.symbol.relb & RELOCATION_TYPE_BITS)
 189               {
 190               case RELOCATION_TYPE_ABS:
 191                 dest = dest_defined--;
 192                 dest->section = bfd_abs_section_ptr;
 193                 dest->flags = 0;
 194
 195                 break;
 196               case RELOCATION_TYPE_REL:
 197                 dest = dest_defined--;
 198                 dest->section =
 199                   OASYS_DATA (abfd)->sections[record.symbol.relb &
 200                                               RELOCATION_SECT_BITS];
 201                 if (record.header.type == (int) oasys_record_is_local_enum)
 202                   {
 203                     dest->flags = BSF_LOCAL;
 204                     if (dest->section == (asection *) (~0))
 205                       {
 206                         /* It seems that sometimes internal symbols are tied up, but
 207                        still get output, even though there is no
 208                        section */
 209                         dest->section = 0;
 210                       }
 211                   }
 212                 else
 213                   {
 214
 215                     dest->flags = flag;
 216                   }
 217                 break;
 218               case RELOCATION_TYPE_UND:
 219                 dest = data->symbols + H_GET_16 (abfd, record.symbol.refno);
 220                 dest->section = bfd_und_section_ptr;
 221                 break;
 222               case RELOCATION_TYPE_COM:
 223                 dest = dest_defined--;
 224                 dest->name = string_ptr;
 225                 dest->the_bfd = abfd;
 226
 227                 dest->section = bfd_com_section_ptr;
 228
 229                 break;
 230               default:
 231                 dest = dest_defined--;
 232                 BFD_ASSERT (0);
 233                 break;
 234               }
 235             dest->name = string_ptr;
 236             dest->the_bfd = abfd;
 237             dest->udata.p = (PTR) NULL;
 238             dest->value = H_GET_32 (abfd, record.symbol.value);
 239
 240 #ifdef UNDERSCORE_HACK
 241             if (record.symbol.name[0] != '_')
 242               {
 243                 string_ptr[0] = '_';
 244                 string_ptr++;
 245               }
 246 #endif
 247             memcpy (string_ptr, record.symbol.name, length);
 248
 249
 250             string_ptr[length] = 0;
 251             string_ptr += length + 1;
 252           }
 253           break;
 254         default:
 255           loop = FALSE;
 256         }
 257     }
 258   return TRUE;
 259 }
 260
 261 static long
 262 oasys_get_symtab_upper_bound (abfd)
 263      bfd *const abfd;
 264 {
 265   if (! oasys_slurp_symbol_table (abfd))
 266     return -1;
 267
 268   return (abfd->symcount + 1) * (sizeof (oasys_symbol_type *));
 269 }
 270
 271 extern const bfd_target oasys_vec;
 272
 273 long
 274 oasys_get_symtab (abfd, location)
 275      bfd *abfd;
 276      asymbol **location;
 277 {
 278   asymbol *symbase;
 279   unsigned int counter;
 280   if (! oasys_slurp_symbol_table (abfd))
 281     {
 282       return -1;
 283     }
 284   symbase = OASYS_DATA (abfd)->symbols;
 285   for (counter = 0; counter < abfd->symcount; counter++)
 286     {
 287       *(location++) = symbase++;
 288     }
 289   *location = 0;
 290   return abfd->symcount;
 291 }
 292
 293 /***********************************************************************
 294 *  archive stuff
 295 */
 296
 297 static const bfd_target *
 298 oasys_archive_p (abfd)
 299      bfd *abfd;
 300 {
 301   oasys_archive_header_type header;
 302   oasys_extarchive_header_type header_ext;
 303   unsigned int i;
 304   file_ptr filepos;
 305   bfd_size_type amt;
 306
 307   amt = sizeof (header_ext);
 308   if (bfd_seek (abfd, (file_ptr) 0, 0) != 0
 309       || bfd_bread ((PTR) &header_ext, amt, abfd) != amt)
 310     {
 311       if (bfd_get_error () != bfd_error_system_call)
 312         bfd_set_error (bfd_error_wrong_format);
 313       return NULL;
 314     }
 315
 316   header.version = H_GET_32 (abfd, header_ext.version);
 317   header.mod_count = H_GET_32 (abfd, header_ext.mod_count);
 318   header.mod_tbl_offset = H_GET_32 (abfd, header_ext.mod_tbl_offset);
 319   header.sym_tbl_size = H_GET_32 (abfd, header_ext.sym_tbl_size);
 320   header.sym_count = H_GET_32 (abfd, header_ext.sym_count);
 321   header.sym_tbl_offset = H_GET_32 (abfd, header_ext.sym_tbl_offset);
 322   header.xref_count = H_GET_32 (abfd, header_ext.xref_count);
 323   header.xref_lst_offset = H_GET_32 (abfd, header_ext.xref_lst_offset);
 324
 325   /*
 326     There isn't a magic number in an Oasys archive, so the best we
 327     can do to verify reasnableness is to make sure that the values in
 328     the header are too weird
 329     */
 330
 331   if (header.version > 10000 ||
 332       header.mod_count > 10000 ||
 333       header.sym_count > 100000 ||
 334       header.xref_count > 100000)
 335     return (const bfd_target *) NULL;
 336
 337   /*
 338     That all worked, let's buy the space for the header and read in
 339     the headers.
 340     */
 341   {
 342     oasys_ar_data_type *ar;
 343     oasys_module_info_type *module;
 344     oasys_module_table_type record;
 345
 346     amt = sizeof (oasys_ar_data_type);
 347     ar = (oasys_ar_data_type *) bfd_alloc (abfd, amt);
 348
 349     amt = header.mod_count;
 350     amt *= sizeof (oasys_module_info_type);
 351     module = (oasys_module_info_type *) bfd_alloc (abfd, amt);
 352
 353     if (!ar || !module)
 354       return NULL;
 355
 356     abfd->tdata.oasys_ar_data = ar;
 357     ar->module = module;
 358     ar->module_count = header.mod_count;
 359
 360     filepos = header.mod_tbl_offset;
 361     for (i = 0; i < header.mod_count; i++)
 362       {
 363         if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
 364           return NULL;
 365
 366         /* There are two ways of specifying the archive header */
 367
 368         if (0)
 369           {
 370             oasys_extmodule_table_type_a_type record_ext;
 371
 372             amt = sizeof (record_ext);
 373             if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)
 374               return NULL;
 375
 376             record.mod_size = H_GET_32 (abfd, record_ext.mod_size);
 377             record.file_offset = H_GET_32 (abfd, record_ext.file_offset);
 378
 379             record.dep_count = H_GET_32 (abfd, record_ext.dep_count);
 380             record.depee_count = H_GET_32 (abfd, record_ext.depee_count);
 381             record.sect_count = H_GET_32 (abfd, record_ext.sect_count);
 382
 383             module[i].name = bfd_alloc (abfd, (bfd_size_type) 33);
 384             if (!module[i].name)
 385               return NULL;
 386
 387             memcpy (module[i].name, record_ext.mod_name, 33);
 388             filepos +=
 389               sizeof (record_ext) +
 390               record.dep_count * 4 +
 391               record.depee_count * 4 +
 392               record.sect_count * 8 + 187;
 393           }
 394         else
 395           {
 396             oasys_extmodule_table_type_b_type record_ext;
 397
 398             amt = sizeof (record_ext);
 399             if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)
 400               return NULL;
 401
 402             record.mod_size = H_GET_32 (abfd, record_ext.mod_size);
 403             record.file_offset = H_GET_32 (abfd, record_ext.file_offset);
 404
 405             record.dep_count = H_GET_32 (abfd, record_ext.dep_count);
 406             record.depee_count = H_GET_32 (abfd, record_ext.depee_count);
 407             record.sect_count = H_GET_32 (abfd, record_ext.sect_count);
 408             record.module_name_size = H_GET_32 (abfd,
 409                                                 record_ext.mod_name_length);
 410
 411             amt = record.module_name_size;
 412             module[i].name = bfd_alloc (abfd, amt + 1);
 413             if (!module[i].name)
 414               return NULL;
 415             if (bfd_bread ((PTR) module[i].name, amt, abfd) != amt)
 416               return NULL;
 417             module[i].name[record.module_name_size] = 0;
 418             filepos += (sizeof (record_ext)
 419                         + record.dep_count * 4
 420                         + record.module_name_size + 1);
 421           }
 422
 423         module[i].size = record.mod_size;
 424         module[i].pos = record.file_offset;
 425         module[i].abfd = 0;
 426       }
 427   }
 428   return abfd->xvec;
 429 }
 430
 431 static bfd_boolean
 432 oasys_mkobject (abfd)
 433      bfd *abfd;
 434 {
 435   bfd_size_type amt = sizeof (oasys_data_type);
 436   abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, amt);
 437   return abfd->tdata.oasys_obj_data != NULL;
 438 }
 439
 440 #define MAX_SECS 16
 441 static const bfd_target *
 442 oasys_object_p (abfd)
 443      bfd *abfd;
 444 {
 445   oasys_data_type *oasys;
 446   oasys_data_type *save = OASYS_DATA (abfd);
 447   bfd_boolean loop = TRUE;
 448   bfd_boolean had_usefull = FALSE;
 449
 450   abfd->tdata.oasys_obj_data = 0;
 451   oasys_mkobject (abfd);
 452   oasys = OASYS_DATA (abfd);
 453   memset ((PTR) oasys->sections, 0xff, sizeof (oasys->sections));
 454
 455   /* Point to the start of the file */
 456   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 457     goto fail;
 458   oasys->symbol_string_length = 0;
 459   /* Inspect the records, but only keep the section info -
 460      remember the size of the symbols
 461      */
 462   oasys->first_data_record = 0;
 463   while (loop)
 464     {
 465       oasys_record_union_type record;
 466       if (! oasys_read_record (abfd, &record))
 467         goto fail;
 468       if ((size_t) record.header.length < (size_t) sizeof (record.header))
 469         goto fail;
 470
 471
 472       switch ((oasys_record_enum_type) (record.header.type))
 473         {
 474         case oasys_record_is_header_enum:
 475           had_usefull = TRUE;
 476           break;
 477         case oasys_record_is_symbol_enum:
 478         case oasys_record_is_local_enum:
 479           /* Count symbols and remember their size for a future malloc   */
 480           abfd->symcount++;
 481           oasys->symbol_string_length += 1 + oasys_string_length (&record);
 482           had_usefull = TRUE;
 483           break;
 484         case oasys_record_is_section_enum:
 485           {
 486             asection *s;
 487             char *buffer;
 488             unsigned int section_number;
 489             if (record.section.header.length != sizeof (record.section))
 490               {
 491                 goto fail;
 492               }
 493             buffer = bfd_alloc (abfd, (bfd_size_type) 3);
 494             if (!buffer)
 495               goto fail;
 496             section_number = record.section.relb & RELOCATION_SECT_BITS;
 497             sprintf (buffer, "%u", section_number);
 498             s = bfd_make_section (abfd, buffer);
 499             oasys->sections[section_number] = s;
 500             switch (record.section.relb & RELOCATION_TYPE_BITS)
 501               {
 502               case RELOCATION_TYPE_ABS:
 503               case RELOCATION_TYPE_REL:
 504                 break;
 505               case RELOCATION_TYPE_UND:
 506               case RELOCATION_TYPE_COM:
 507                 BFD_FAIL ();
 508               }
 509
 510             s->_raw_size = H_GET_32 (abfd, record.section.value);
 511             s->vma = H_GET_32 (abfd, record.section.vma);
 512             s->flags = 0;
 513             had_usefull = TRUE;
 514           }
 515           break;
 516         case oasys_record_is_data_enum:
 517           oasys->first_data_record = bfd_tell (abfd) - record.header.length;
 518         case oasys_record_is_debug_enum:
 519         case oasys_record_is_module_enum:
 520         case oasys_record_is_named_section_enum:
 521         case oasys_record_is_end_enum:
 522           if (! had_usefull)
 523             goto fail;
 524           loop = FALSE;
 525           break;
 526         default:
 527           goto fail;
 528         }
 529     }
 530   oasys->symbols = (asymbol *) NULL;
 531   /*
 532     Oasys support several architectures, but I can't see a simple way
 533     to discover which one is in a particular file - we'll guess
 534     */
 535   bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);
 536   if (abfd->symcount != 0)
 537     {
 538       abfd->flags |= HAS_SYMS;
 539     }
 540
 541   /*
 542     We don't know if a section has data until we've read it..
 543     */
 544
 545   oasys_slurp_section_data (abfd);
 546
 547
 548   return abfd->xvec;
 549
 550 fail:
 551   (void) bfd_release (abfd, oasys);
 552   abfd->tdata.oasys_obj_data = save;
 553   return (const bfd_target *) NULL;
 554 }
 555
 556
 557 static void
 558 oasys_get_symbol_info (ignore_abfd, symbol, ret)
 559      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 560      asymbol *symbol;
 561      symbol_info *ret;
 562 {
 563   bfd_symbol_info (symbol, ret);
 564   if (!symbol->section)
 565     ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
 566 }
 567
 568 static void
 569 oasys_print_symbol (abfd, afile, symbol, how)
 570      bfd *abfd;
 571      PTR afile;
 572      asymbol *symbol;
 573      bfd_print_symbol_type how;
 574 {
 575   FILE *file = (FILE *) afile;
 576
 577   switch (how)
 578     {
 579     case bfd_print_symbol_name:
 580     case bfd_print_symbol_more:
 581       fprintf (file, "%s", symbol->name);
 582       break;
 583     case bfd_print_symbol_all:
 584       {
 585         const char *section_name = symbol->section == (asection *) NULL ?
 586         (const char *) "*abs" : symbol->section->name;
 587
 588         bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
 589
 590         fprintf (file, " %-5s %s",
 591                  section_name,
 592                  symbol->name);
 593       }
 594       break;
 595     }
 596 }
 597 /*
 598  The howto table is build using the top two bits of a reloc byte to
 599  index into it. The bits are PCREL,WORD/LONG
 600 */
 601 static reloc_howto_type howto_table[] =
 602 {
 603
 604   HOWTO (0, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 0, "abs16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
 605   HOWTO (0, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "abs32", TRUE, 0xffffffff, 0xffffffff, FALSE),
 606   HOWTO (0, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0, "pcrel16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
 607   HOWTO (0, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0, "pcrel32", TRUE, 0xffffffff, 0xffffffff, FALSE)
 608 };
 609
 610 /* Read in all the section data and relocation stuff too */
 611 static bfd_boolean
 612 oasys_slurp_section_data (abfd)
 613      bfd *const abfd;
 614 {
 615   oasys_record_union_type record;
 616   oasys_data_type *data = OASYS_DATA (abfd);
 617   bfd_boolean loop = TRUE;
 618   oasys_per_section_type *per;
 619   asection *s;
 620   bfd_size_type amt;
 621
 622   /* See if the data has been slurped already .. */
 623   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
 624     {
 625       per = oasys_per_section (s);
 626       if (per->initialized)
 627         return TRUE;
 628     }
 629
 630   if (data->first_data_record == 0)
 631     return TRUE;
 632
 633   if (bfd_seek (abfd, data->first_data_record, SEEK_SET) != 0)
 634     return FALSE;
 635   while (loop)
 636     {
 637       if (! oasys_read_record (abfd, &record))
 638         return FALSE;
 639       switch (record.header.type)
 640         {
 641         case oasys_record_is_header_enum:
 642           break;
 643         case oasys_record_is_data_enum:
 644           {
 645
 646             bfd_byte *src = record.data.data;
 647             bfd_byte *end_src = ((bfd_byte *) & record) + record.header.length;
 648             bfd_byte *dst_ptr;
 649             bfd_byte *dst_base_ptr;
 650             unsigned int relbit;
 651             unsigned int count;
 652             asection *section =
 653             data->sections[record.data.relb & RELOCATION_SECT_BITS];
 654             bfd_vma dst_offset;
 655
 656             per = oasys_per_section (section);
 657
 658             if (! per->initialized)
 659               {
 660                 per->data = (bfd_byte *) bfd_zalloc (abfd, section->_raw_size);
 661                 if (!per->data)
 662                   return FALSE;
 663                 per->reloc_tail_ptr
 664                   = (oasys_reloc_type **) &section->relocation;
 665                 per->had_vma = FALSE;
 666                 per->initialized = TRUE;
 667                 section->reloc_count = 0;
 668                 section->flags = SEC_ALLOC;
 669               }
 670
 671             dst_offset = H_GET_32 (abfd, record.data.addr);
 672             if (! per->had_vma)
 673               {
 674                 /* Take the first vma we see as the base */
 675                 section->vma = dst_offset;
 676                 per->had_vma = TRUE;
 677               }
 678
 679             dst_offset -= section->vma;
 680
 681             dst_base_ptr = oasys_per_section (section)->data;
 682             dst_ptr = oasys_per_section (section)->data +
 683               dst_offset;
 684
 685             if (src < end_src)
 686               {
 687                 section->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
 688               }
 689             while (src < end_src)
 690               {
 691                 unsigned char mod_byte = *src++;
 692                 size_t gap = end_src - src;
 693
 694                 count = 8;
 695                 if (mod_byte == 0 && gap >= 8)
 696                   {
 697                     dst_ptr[0] = src[0];
 698                     dst_ptr[1] = src[1];
 699                     dst_ptr[2] = src[2];
 700                     dst_ptr[3] = src[3];
 701                     dst_ptr[4] = src[4];
 702                     dst_ptr[5] = src[5];
 703                     dst_ptr[6] = src[6];
 704                     dst_ptr[7] = src[7];
 705                     dst_ptr += 8;
 706                     src += 8;
 707                   }
 708                 else
 709                   {
 710                     for (relbit = 1; count-- != 0 && src < end_src; relbit <<= 1)
 711                       {
 712                         if (relbit & mod_byte)
 713                           {
 714                             unsigned char reloc = *src;
 715                             /* This item needs to be relocated */
 716                             switch (reloc & RELOCATION_TYPE_BITS)
 717                               {
 718                               case RELOCATION_TYPE_ABS:
 719
 720                                 break;
 721
 722                               case RELOCATION_TYPE_REL:
 723                                 {
 724                                   /* Relocate the item relative to the section */
 725                                   oasys_reloc_type *r;
 726
 727                                   amt = sizeof (oasys_reloc_type);
 728                                   r = (oasys_reloc_type *) bfd_alloc (abfd,
 729                                                                       amt);
 730                                   if (!r)
 731                                     return FALSE;
 732                                   *(per->reloc_tail_ptr) = r;
 733                                   per->reloc_tail_ptr = &r->next;
 734                                   r->next = (oasys_reloc_type *) NULL;
 735                                   /* Reference to undefined symbol */
 736                                   src++;
 737                                   /* There is no symbol */
 738                                   r->symbol = 0;
 739                                   /* Work out the howto */
 740                                   abort ();
 741 #if 0
 742                                   r->relent.section =
 743                                     data->sections[reloc &
 744                                                    RELOCATION_SECT_BITS];
 745
 746                                   r->relent.addend = -
 747                                     r->relent.section->vma;
 748 #endif
 749                                   r->relent.address = dst_ptr - dst_base_ptr;
 750                                   r->relent.howto = &howto_table[reloc >> 6];
 751                                   r->relent.sym_ptr_ptr = (asymbol **) NULL;
 752                                   section->reloc_count++;
 753
 754                                   /* Fake up the data to look like
 755                                      it's got the -ve pc in it, this
 756                                      makes it much easier to convert
 757                                      into other formats.  This is done
 758                                      by hitting the addend.  */
 759                                   if (r->relent.howto->pc_relative)
 760                                     r->relent.addend -= dst_ptr - dst_base_ptr;
 761                                 }
 762                                 break;
 763
 764
 765                               case RELOCATION_TYPE_UND:
 766                                 {
 767                                   oasys_reloc_type *r;
 768
 769                                   amt = sizeof (oasys_reloc_type);
 770                                   r = (oasys_reloc_type *) bfd_alloc (abfd,
 771                                                                       amt);
 772                                   if (!r)
 773                                     return FALSE;
 774                                   *(per->reloc_tail_ptr) = r;
 775                                   per->reloc_tail_ptr = &r->next;
 776                                   r->next = (oasys_reloc_type *) NULL;
 777                                   /* Reference to undefined symbol */
 778                                   src++;
 779                                   /* Get symbol number */
 780                                   r->symbol = (src[0] << 8) | src[1];
 781                                   /* Work out the howto */
 782                                   abort ();
 783
 784 #if 0
 785                                   r->relent.section = (asection
 786                                                        *) NULL;
 787 #endif
 788                                   r->relent.addend = 0;
 789                                   r->relent.address = dst_ptr - dst_base_ptr;
 790                                   r->relent.howto = &howto_table[reloc >> 6];
 791                                   r->relent.sym_ptr_ptr = (asymbol **) NULL;
 792                                   section->reloc_count++;
 793
 794                                   src += 2;
 795                                   /* Fake up the data to look like
 796                                      it's got the -ve pc in it, this
 797                                      makes it much easier to convert
 798                                      into other formats.  This is done
 799                                      by hitting the addend.  */
 800                                   if (r->relent.howto->pc_relative)
 801                                     r->relent.addend -= dst_ptr - dst_base_ptr;
 802                                 }
 803                                 break;
 804                               case RELOCATION_TYPE_COM:
 805                                 BFD_FAIL ();
 806                               }
 807                           }
 808                         *dst_ptr++ = *src++;
 809                       }
 810                   }
 811               }
 812           }
 813           break;
 814         case oasys_record_is_local_enum:
 815         case oasys_record_is_symbol_enum:
 816         case oasys_record_is_section_enum:
 817           break;
 818         default:
 819           loop = FALSE;
 820         }
 821     }
 822
 823   return TRUE;
 824
 825 }
 826
 827 static bfd_boolean
 828 oasys_new_section_hook (abfd, newsect)
 829      bfd *abfd;
 830      asection *newsect;
 831 {
 832   newsect->used_by_bfd = (PTR)
 833     bfd_alloc (abfd, (bfd_size_type) sizeof (oasys_per_section_type));
 834   if (!newsect->used_by_bfd)
 835     return FALSE;
 836   oasys_per_section (newsect)->data = (bfd_byte *) NULL;
 837   oasys_per_section (newsect)->section = newsect;
 838   oasys_per_section (newsect)->offset = 0;
 839   oasys_per_section (newsect)->initialized = FALSE;
 840   newsect->alignment_power = 1;
 841   /* Turn the section string into an index */
 842
 843   sscanf (newsect->name, "%u", &newsect->target_index);
 844
 845   return TRUE;
 846 }
 847
 848
 849 static long
 850 oasys_get_reloc_upper_bound (abfd, asect)
 851      bfd *abfd;
 852      sec_ptr asect;
 853 {
 854   if (! oasys_slurp_section_data (abfd))
 855     return -1;
 856   return (asect->reloc_count + 1) * sizeof (arelent *);
 857 }
 858
 859 static bfd_boolean
 860 oasys_get_section_contents (abfd, section, location, offset, count)
 861      bfd *abfd;
 862      sec_ptr section;
 863      PTR location;
 864      file_ptr offset;
 865      bfd_size_type count;
 866 {
 867   oasys_per_section_type *p = oasys_per_section (section);
 868   oasys_slurp_section_data (abfd);
 869   if (! p->initialized)
 870     {
 871       (void) memset (location, 0, (size_t) count);
 872     }
 873   else
 874     {
 875       (void) memcpy (location, (PTR) (p->data + offset), (size_t) count);
 876     }
 877   return TRUE;
 878 }
 879
 880
 881 long
 882 oasys_canonicalize_reloc (ignore_abfd, section, relptr, symbols)
 883      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 884      sec_ptr section;
 885      arelent **relptr;
 886      asymbol **symbols ATTRIBUTE_UNUSED;
 887 {
 888   unsigned int reloc_count = 0;
 889   oasys_reloc_type *src = (oasys_reloc_type *) (section->relocation);
 890   while (src != (oasys_reloc_type *) NULL)
 891     {
 892       abort ();
 893
 894 #if 0
 895       if (src->relent.section == (asection *) NULL)
 896         {
 897           src->relent.sym_ptr_ptr = symbols + src->symbol;
 898         }
 899 #endif
 900
 901       *relptr++ = &src->relent;
 902       src = src->next;
 903       reloc_count++;
 904     }
 905   *relptr = (arelent *) NULL;
 906   return section->reloc_count = reloc_count;
 907 }
 908
 909
 910
 911
 912 /* Writing */
 913
 914
 915 /* Calculate the checksum and write one record */
 916 static bfd_boolean
 917 oasys_write_record (abfd, type, record, size)
 918      bfd *abfd;
 919      oasys_record_enum_type type;
 920      oasys_record_union_type *record;
 921      size_t size;
 922 {
 923   int checksum;
 924   size_t i;
 925   unsigned char *ptr;
 926
 927   record->header.length = size;
 928   record->header.type = (int) type;
 929   record->header.check_sum = 0;
 930   record->header.fill = 0;
 931   ptr = (unsigned char *) &record->pad[0];
 932   checksum = 0;
 933   for (i = 0; i < size; i++)
 934     {
 935       checksum += *ptr++;
 936     }
 937   record->header.check_sum = 0xff & (-checksum);
 938   if (bfd_bwrite ((PTR) record, (bfd_size_type) size, abfd) != size)
 939     return FALSE;
 940   return TRUE;
 941 }
 942
 943
 944 /* Write out all the symbols */
 945 static bfd_boolean
 946 oasys_write_syms (abfd)
 947      bfd *abfd;
 948 {
 949   unsigned int count;
 950   asymbol **generic = bfd_get_outsymbols (abfd);
 951   unsigned int index = 0;
 952   for (count = 0; count < bfd_get_symcount (abfd); count++)
 953     {
 954
 955       oasys_symbol_record_type symbol;
 956       asymbol *const g = generic[count];
 957
 958       const char *src = g->name;
 959       char *dst = symbol.name;
 960       unsigned int l = 0;
 961
 962       if (bfd_is_com_section (g->section))
 963         {
 964           symbol.relb = RELOCATION_TYPE_COM;
 965           H_PUT_16 (abfd, index, symbol.refno);
 966           index++;
 967         }
 968       else if (bfd_is_abs_section (g->section))
 969         {
 970           symbol.relb = RELOCATION_TYPE_ABS;
 971           H_PUT_16 (abfd, 0, symbol.refno);
 972
 973         }
 974       else if (bfd_is_und_section (g->section))
 975         {
 976           symbol.relb = RELOCATION_TYPE_UND;
 977           H_PUT_16 (abfd, index, symbol.refno);
 978           /* Overload the value field with the output index number */
 979           index++;
 980         }
 981       else if (g->flags & BSF_DEBUGGING)
 982         {
 983           /* throw it away */
 984           continue;
 985         }
 986       else
 987         {
 988           if (g->section == (asection *) NULL)
 989             {
 990               /* Sometime, the oasys tools give out a symbol with illegal
 991            bits in it, we'll output it in the same broken way */
 992
 993               symbol.relb = RELOCATION_TYPE_REL | 0;
 994             }
 995           else
 996             {
 997               symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index;
 998             }
 999           H_PUT_16 (abfd, 0, symbol.refno);
1000         }
1001 #ifdef UNDERSCORE_HACK
1002       if (src[l] == '_')
1003         dst[l++] = '.';
1004 #endif
1005       while (src[l])
1006         {
1007           dst[l] = src[l];
1008           l++;
1009         }
1010
1011       H_PUT_32 (abfd, g->value, symbol.value);
1012
1013
1014       if (g->flags & BSF_LOCAL)
1015         {
1016           if (! oasys_write_record (abfd,
1017                                     oasys_record_is_local_enum,
1018                                     (oasys_record_union_type *) & symbol,
1019                                     offsetof (oasys_symbol_record_type,
1020                                               name[0]) + l))
1021             return FALSE;
1022         }
1023       else
1024         {
1025           if (! oasys_write_record (abfd,
1026                                     oasys_record_is_symbol_enum,
1027                                     (oasys_record_union_type *) & symbol,
1028                                     offsetof (oasys_symbol_record_type,
1029                                               name[0]) + l))
1030             return FALSE;
1031         }
1032       g->value = index - 1;
1033     }
1034
1035   return TRUE;
1036 }
1037
1038
1039  /* Write a section header for each section */
1040 static bfd_boolean
1041 oasys_write_sections (abfd)
1042      bfd *abfd;
1043 {
1044   asection *s;
1045   static oasys_section_record_type out;
1046
1047   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1048     {
1049       if (!ISDIGIT (s->name[0]))
1050         {
1051           (*_bfd_error_handler)
1052             (_("%s: can not represent section `%s' in oasys"),
1053              bfd_get_filename (abfd), s->name);
1054           bfd_set_error (bfd_error_nonrepresentable_section);
1055           return FALSE;
1056         }
1057       out.relb = RELOCATION_TYPE_REL | s->target_index;
1058       H_PUT_32 (abfd, s->_cooked_size, out.value);
1059       H_PUT_32 (abfd, s->vma, out.vma);
1060
1061       if (! oasys_write_record (abfd,
1062                                 oasys_record_is_section_enum,
1063                                 (oasys_record_union_type *) & out,
1064                                 sizeof (out)))
1065         return FALSE;
1066     }
1067   return TRUE;
1068 }
1069
1070 static bfd_boolean
1071 oasys_write_header (abfd)
1072      bfd *abfd;
1073 {
1074   /* Create and write the header */
1075   oasys_header_record_type r;
1076   size_t length = strlen (abfd->filename);
1077   if (length > (size_t) sizeof (r.module_name))
1078     {
1079       length = sizeof (r.module_name);
1080     }
1081
1082   (void) memcpy (r.module_name,
1083                  abfd->filename,
1084                  length);
1085   (void) memset (r.module_name + length,
1086                  ' ',
1087                  sizeof (r.module_name) - length);
1088
1089   r.version_number = OASYS_VERSION_NUMBER;
1090   r.rev_number = OASYS_REV_NUMBER;
1091   if (! oasys_write_record (abfd,
1092                             oasys_record_is_header_enum,
1093                             (oasys_record_union_type *) & r,
1094                             offsetof (oasys_header_record_type,
1095                                       description[0])))
1096     return FALSE;
1097
1098   return TRUE;
1099 }
1100
1101 static bfd_boolean
1102 oasys_write_end (abfd)
1103      bfd *abfd;
1104 {
1105   oasys_end_record_type end;
1106   unsigned char null = 0;
1107   end.relb = RELOCATION_TYPE_ABS;
1108   H_PUT_32 (abfd, abfd->start_address, end.entry);
1109   H_PUT_16 (abfd, 0, end.fill);
1110   end.zero = 0;
1111   if (! oasys_write_record (abfd,
1112                             oasys_record_is_end_enum,
1113                             (oasys_record_union_type *) & end,
1114                             sizeof (end)))
1115     return FALSE;
1116   if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1)
1117     return FALSE;
1118   return TRUE;
1119 }
1120
1121 static int
1122 comp (ap, bp)
1123      const PTR ap;
1124      const PTR bp;
1125 {
1126   arelent *a = *((arelent **) ap);
1127   arelent *b = *((arelent **) bp);
1128   return a->address - b->address;
1129 }
1130
1131 /*
1132  Writing data..
1133
1134 */
1135 static bfd_boolean
1136 oasys_write_data (abfd)
1137      bfd *abfd;
1138 {
1139   asection *s;
1140   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1141     {
1142       if (s->flags & SEC_LOAD)
1143         {
1144           bfd_byte *raw_data = oasys_per_section (s)->data;
1145           oasys_data_record_type processed_data;
1146           bfd_size_type current_byte_index = 0;
1147           unsigned int relocs_to_go = s->reloc_count;
1148           arelent **p = s->orelocation;
1149           if (s->reloc_count != 0)
1150             {
1151 /* Sort the reloc records so it's easy to insert the relocs into the
1152            data */
1153
1154               qsort (s->orelocation,
1155                      s->reloc_count,
1156                      sizeof (arelent **),
1157                      comp);
1158             }
1159           current_byte_index = 0;
1160           processed_data.relb = s->target_index | RELOCATION_TYPE_REL;
1161
1162           while (current_byte_index < s->_cooked_size)
1163             {
1164               /* Scan forwards by eight bytes or however much is left and see if
1165                there are any relocations going on */
1166               bfd_byte *mod = &processed_data.data[0];
1167               bfd_byte *dst = &processed_data.data[1];
1168
1169               unsigned int i = 0;
1170               *mod = 0;
1171
1172
1173               H_PUT_32 (abfd, s->vma + current_byte_index,
1174                         processed_data.addr);
1175
1176               /* Don't start a relocation unless you're sure you can finish it
1177                within the same data record.  The worst case relocation is a
1178                4-byte relocatable value which is split across two modification
1179                bytes (1 relocation byte + 2 symbol reference bytes + 2 data +
1180                1 modification byte + 2 data = 8 bytes total).  That's where
1181                the magic number 8 comes from.
1182             */
1183               while (current_byte_index < s->_raw_size && dst <=
1184                      &processed_data.data[sizeof (processed_data.data) - 8])
1185                 {
1186
1187
1188                   if (relocs_to_go != 0)
1189                     {
1190                       arelent *r = *p;
1191                       reloc_howto_type *const how = r->howto;
1192                       /* There is a relocation, is it for this byte ? */
1193                       if (r->address == current_byte_index)
1194                         {
1195                           unsigned char rel_byte;
1196
1197                           p++;
1198                           relocs_to_go--;
1199
1200                           *mod |= (1 << i);
1201                           if (how->pc_relative)
1202                             {
1203                               rel_byte = RELOCATION_PCREL_BIT;
1204
1205                               /* Also patch the raw data so that it doesn't have
1206                          the -ve stuff any more */
1207                               if (how->size != 2)
1208                                 {
1209                                   bfd_put_16 (abfd,
1210                                               bfd_get_16 (abfd, raw_data) +
1211                                               current_byte_index, raw_data);
1212                                 }
1213
1214                               else
1215                                 {
1216                                   bfd_put_32 (abfd,
1217                                               bfd_get_32 (abfd, raw_data) +
1218                                               current_byte_index, raw_data);
1219                                 }
1220                             }
1221                           else
1222                             {
1223                               rel_byte = 0;
1224                             }
1225                           if (how->size == 2)
1226                             {
1227                               rel_byte |= RELOCATION_32BIT_BIT;
1228                             }
1229
1230                           /* Is this a section relative relocation, or a symbol
1231                        relative relocation ? */
1232                           abort ();
1233
1234 #if 0
1235                           if (r->section != (asection *) NULL)
1236                             {
1237                               /* The relent has a section attached, so it must be section
1238                              relative */
1239                               rel_byte |= RELOCATION_TYPE_REL;
1240                               rel_byte |= r->section->output_section->target_index;
1241                               *dst++ = rel_byte;
1242                             }
1243                           else
1244 #endif
1245                             {
1246                               asymbol *sym = *(r->sym_ptr_ptr);
1247
1248                               /* If this symbol has a section attached, then it
1249                              has already been resolved.  Change from a symbol
1250                              ref to a section ref */
1251                               if (sym->section != (asection *) NULL)
1252                                 {
1253                                   rel_byte |= RELOCATION_TYPE_REL;
1254                                   rel_byte |=
1255                                     sym->section->output_section->target_index;
1256                                   *dst++ = rel_byte;
1257                                 }
1258                               else
1259                                 {
1260                                   rel_byte |= RELOCATION_TYPE_UND;
1261                                   *dst++ = rel_byte;
1262                                   /* Next two bytes are a symbol index - we can get
1263                                this from the symbol value which has been zapped
1264                                into the symbol index in the table when the
1265                                symbol table was written
1266                                */
1267                                   *dst++ = sym->value >> 8;
1268                                   *dst++ = sym->value;
1269                                 }
1270                             }
1271 #define ADVANCE { if (++i >= 8) { i = 0; mod = dst++; *mod = 0; } current_byte_index++; }
1272                           /* relocations never occur from an unloadable section,
1273                        so we can assume that raw_data is not NULL
1274                      */
1275                           *dst++ = *raw_data++;
1276                           ADVANCE
1277                             * dst++ = *raw_data++;
1278                           ADVANCE
1279                             if (how->size == 2)
1280                             {
1281                               *dst++ = *raw_data++;
1282                               ADVANCE
1283                                 * dst++ = *raw_data++;
1284                               ADVANCE
1285                             }
1286                           continue;
1287                         }
1288                     }
1289                   /* If this is coming from an unloadable section then copy
1290                    zeros */
1291                   if (raw_data == NULL)
1292                     {
1293                       *dst++ = 0;
1294                     }
1295                   else
1296                     {
1297                       *dst++ = *raw_data++;
1298                     }
1299                   ADVANCE
1300                 }
1301
1302               /* Don't write a useless null modification byte */
1303               if (dst == mod + 1)
1304                 {
1305                   --dst;
1306                 }
1307
1308               if (! (oasys_write_record
1309                      (abfd, oasys_record_is_data_enum,
1310                       ((oasys_record_union_type *) &processed_data),
1311                       (size_t) (dst - (bfd_byte *) &processed_data))))
1312                 return FALSE;
1313             }
1314         }
1315     }
1316
1317   return TRUE;
1318 }
1319
1320 static bfd_boolean
1321 oasys_write_object_contents (abfd)
1322      bfd *abfd;
1323 {
1324   if (! oasys_write_header (abfd))
1325     return FALSE;
1326   if (! oasys_write_syms (abfd))
1327     return FALSE;
1328   if (! oasys_write_sections (abfd))
1329     return FALSE;
1330   if (! oasys_write_data (abfd))
1331     return FALSE;
1332   if (! oasys_write_end (abfd))
1333     return FALSE;
1334   return TRUE;
1335 }
1336
1337
1338
1339
1340 /** exec and core file sections */
1341
1342 /* set section contents is complicated with OASYS since the format is
1343 * not a byte image, but a record stream.
1344 */
1345 static bfd_boolean
1346 oasys_set_section_contents (abfd, section, location, offset, count)
1347      bfd *abfd;
1348      sec_ptr section;
1349      PTR location;
1350      file_ptr offset;
1351      bfd_size_type count;
1352 {
1353   if (count != 0)
1354     {
1355       if (oasys_per_section (section)->data == (bfd_byte *) NULL)
1356         {
1357           oasys_per_section (section)->data =
1358             (bfd_byte *) (bfd_alloc (abfd, section->_cooked_size));
1359           if (!oasys_per_section (section)->data)
1360             return FALSE;
1361         }
1362       (void) memcpy ((PTR) (oasys_per_section (section)->data + offset),
1363                      location,
1364                      (size_t) count);
1365     }
1366   return TRUE;
1367 }
1368
1369
1370
1371 /* Native-level interface to symbols. */
1372
1373 /* We read the symbols into a buffer, which is discarded when this
1374 function exits.  We read the strings into a buffer large enough to
1375 hold them all plus all the cached symbol entries. */
1376
1377 static asymbol *
1378 oasys_make_empty_symbol (abfd)
1379      bfd *abfd;
1380 {
1381   bfd_size_type amt = sizeof (oasys_symbol_type);
1382   oasys_symbol_type *new = (oasys_symbol_type *) bfd_zalloc (abfd, amt);
1383   if (!new)
1384     return NULL;
1385   new->symbol.the_bfd = abfd;
1386   return &new->symbol;
1387 }
1388 \f
1389
1390
1391
1392 /* User should have checked the file flags; perhaps we should return
1393 BFD_NO_MORE_SYMBOLS if there are none? */
1394
1395 static bfd *
1396 oasys_openr_next_archived_file (arch, prev)
1397      bfd *arch;
1398      bfd *prev;
1399 {
1400   oasys_ar_data_type *ar = OASYS_AR_DATA (arch);
1401   oasys_module_info_type *p;
1402   /* take the next one from the arch state, or reset */
1403   if (prev == (bfd *) NULL)
1404     {
1405       /* Reset the index - the first two entries are bogus*/
1406       ar->module_index = 0;
1407     }
1408
1409   p = ar->module + ar->module_index;
1410   ar->module_index++;
1411
1412   if (ar->module_index <= ar->module_count)
1413     {
1414       if (p->abfd == (bfd *) NULL)
1415         {
1416           p->abfd = _bfd_create_empty_archive_element_shell (arch);
1417           p->abfd->origin = p->pos;
1418           p->abfd->filename = p->name;
1419
1420           /* Fixup a pointer to this element for the member */
1421           p->abfd->arelt_data = (PTR) p;
1422         }
1423       return p->abfd;
1424     }
1425   else
1426     {
1427       bfd_set_error (bfd_error_no_more_archived_files);
1428       return (bfd *) NULL;
1429     }
1430 }
1431
1432 static bfd_boolean
1433 oasys_find_nearest_line (abfd, section, symbols, offset,
1434                          filename_ptr, functionname_ptr, line_ptr)
1435      bfd *abfd ATTRIBUTE_UNUSED;
1436      asection *section ATTRIBUTE_UNUSED;
1437      asymbol **symbols ATTRIBUTE_UNUSED;
1438      bfd_vma offset ATTRIBUTE_UNUSED;
1439      const char **filename_ptr ATTRIBUTE_UNUSED;
1440      const char **functionname_ptr ATTRIBUTE_UNUSED;
1441      unsigned int *line_ptr ATTRIBUTE_UNUSED;
1442 {
1443   return FALSE;
1444
1445 }
1446
1447 static int
1448 oasys_generic_stat_arch_elt (abfd, buf)
1449      bfd *abfd;
1450      struct stat *buf;
1451 {
1452   oasys_module_info_type *mod = (oasys_module_info_type *) abfd->arelt_data;
1453   if (mod == (oasys_module_info_type *) NULL)
1454     {
1455       bfd_set_error (bfd_error_invalid_operation);
1456       return -1;
1457     }
1458   else
1459     {
1460       buf->st_size = mod->size;
1461       buf->st_mode = 0666;
1462       return 0;
1463     }
1464 }
1465
1466 static int
1467 oasys_sizeof_headers (abfd, exec)
1468      bfd *abfd ATTRIBUTE_UNUSED;
1469      bfd_boolean exec ATTRIBUTE_UNUSED;
1470 {
1471   return 0;
1472 }
1473
1474 #define oasys_close_and_cleanup _bfd_generic_close_and_cleanup
1475 #define oasys_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1476
1477 #define oasys_slurp_armap bfd_true
1478 #define oasys_slurp_extended_name_table bfd_true
1479 #define oasys_construct_extended_name_table \
1480   ((bfd_boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
1481    bfd_true)
1482 #define oasys_truncate_arname bfd_dont_truncate_arname
1483 #define oasys_write_armap \
1484   ((bfd_boolean (*) \
1485     PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
1486    bfd_true)
1487 #define oasys_read_ar_hdr bfd_nullvoidptr
1488 #define oasys_get_elt_at_index _bfd_generic_get_elt_at_index
1489 #define oasys_update_armap_timestamp bfd_true
1490
1491 #define oasys_bfd_is_local_label_name bfd_generic_is_local_label_name
1492 #define oasys_get_lineno _bfd_nosymbols_get_lineno
1493 #define oasys_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1494 #define oasys_read_minisymbols _bfd_generic_read_minisymbols
1495 #define oasys_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1496
1497 #define oasys_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
1498
1499 #define oasys_set_arch_mach bfd_default_set_arch_mach
1500
1501 #define oasys_get_section_contents_in_window \
1502   _bfd_generic_get_section_contents_in_window
1503
1504 #define oasys_bfd_get_relocated_section_contents \
1505   bfd_generic_get_relocated_section_contents
1506 #define oasys_bfd_relax_section bfd_generic_relax_section
1507 #define oasys_bfd_gc_sections bfd_generic_gc_sections
1508 #define oasys_bfd_merge_sections bfd_generic_merge_sections
1509 #define oasys_bfd_discard_group bfd_generic_discard_group
1510 #define oasys_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1511 #define oasys_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
1512 #define oasys_bfd_link_add_symbols _bfd_generic_link_add_symbols
1513 #define oasys_bfd_link_just_syms _bfd_generic_link_just_syms
1514 #define oasys_bfd_final_link _bfd_generic_final_link
1515 #define oasys_bfd_link_split_section _bfd_generic_link_split_section
1516
1517 /*SUPPRESS 460 */
1518 const bfd_target oasys_vec =
1519 {
1520   "oasys",                      /* name */
1521   bfd_target_oasys_flavour,
1522   BFD_ENDIAN_BIG,               /* target byte order */
1523   BFD_ENDIAN_BIG,               /* target headers byte order */
1524   (HAS_RELOC | EXEC_P |         /* object flags */
1525    HAS_LINENO | HAS_DEBUG |
1526    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1527   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1528    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1529   0,                            /* leading underscore */
1530   ' ',                          /* ar_pad_char */
1531   16,                           /* ar_max_namelen */
1532   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1533   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1534   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
1535   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1536   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1537   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
1538
1539   {_bfd_dummy_target,
1540    oasys_object_p,              /* bfd_check_format */
1541    oasys_archive_p,
1542    _bfd_dummy_target,
1543   },
1544   {                             /* bfd_set_format */
1545     bfd_false,
1546     oasys_mkobject,
1547     _bfd_generic_mkarchive,
1548     bfd_false
1549   },
1550   {                             /* bfd_write_contents */
1551     bfd_false,
1552     oasys_write_object_contents,
1553     _bfd_write_archive_contents,
1554     bfd_false,
1555   },
1556
1557   BFD_JUMP_TABLE_GENERIC (oasys),
1558   BFD_JUMP_TABLE_COPY (_bfd_generic),
1559   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1560   BFD_JUMP_TABLE_ARCHIVE (oasys),
1561   BFD_JUMP_TABLE_SYMBOLS (oasys),
1562   BFD_JUMP_TABLE_RELOCS (oasys),
1563   BFD_JUMP_TABLE_WRITE (oasys),
1564   BFD_JUMP_TABLE_LINK (oasys),
1565   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1566
1567   NULL,
1568
1569   (PTR) 0
1570 };