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, 2004 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, const 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_canonicalize_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_canonicalize_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 reasonableness 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->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->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                                   r->relent.address = dst_ptr - dst_base_ptr;
 742                                   r->relent.howto = &howto_table[reloc >> 6];
 743                                   r->relent.sym_ptr_ptr = (asymbol **) NULL;
 744                                   section->reloc_count++;
 745
 746                                   /* Fake up the data to look like
 747                                      it's got the -ve pc in it, this
 748                                      makes it much easier to convert
 749                                      into other formats.  This is done
 750                                      by hitting the addend.  */
 751                                   if (r->relent.howto->pc_relative)
 752                                     r->relent.addend -= dst_ptr - dst_base_ptr;
 753                                 }
 754                                 break;
 755
 756
 757                               case RELOCATION_TYPE_UND:
 758                                 {
 759                                   oasys_reloc_type *r;
 760
 761                                   amt = sizeof (oasys_reloc_type);
 762                                   r = (oasys_reloc_type *) bfd_alloc (abfd,
 763                                                                       amt);
 764                                   if (!r)
 765                                     return FALSE;
 766                                   *(per->reloc_tail_ptr) = r;
 767                                   per->reloc_tail_ptr = &r->next;
 768                                   r->next = (oasys_reloc_type *) NULL;
 769                                   /* Reference to undefined symbol */
 770                                   src++;
 771                                   /* Get symbol number */
 772                                   r->symbol = (src[0] << 8) | src[1];
 773                                   /* Work out the howto */
 774                                   abort ();
 775
 776                                   r->relent.addend = 0;
 777                                   r->relent.address = dst_ptr - dst_base_ptr;
 778                                   r->relent.howto = &howto_table[reloc >> 6];
 779                                   r->relent.sym_ptr_ptr = (asymbol **) NULL;
 780                                   section->reloc_count++;
 781
 782                                   src += 2;
 783                                   /* Fake up the data to look like
 784                                      it's got the -ve pc in it, this
 785                                      makes it much easier to convert
 786                                      into other formats.  This is done
 787                                      by hitting the addend.  */
 788                                   if (r->relent.howto->pc_relative)
 789                                     r->relent.addend -= dst_ptr - dst_base_ptr;
 790                                 }
 791                                 break;
 792                               case RELOCATION_TYPE_COM:
 793                                 BFD_FAIL ();
 794                               }
 795                           }
 796                         *dst_ptr++ = *src++;
 797                       }
 798                   }
 799               }
 800           }
 801           break;
 802         case oasys_record_is_local_enum:
 803         case oasys_record_is_symbol_enum:
 804         case oasys_record_is_section_enum:
 805           break;
 806         default:
 807           loop = FALSE;
 808         }
 809     }
 810
 811   return TRUE;
 812
 813 }
 814
 815 static bfd_boolean
 816 oasys_new_section_hook (abfd, newsect)
 817      bfd *abfd;
 818      asection *newsect;
 819 {
 820   newsect->used_by_bfd = (PTR)
 821     bfd_alloc (abfd, (bfd_size_type) sizeof (oasys_per_section_type));
 822   if (!newsect->used_by_bfd)
 823     return FALSE;
 824   oasys_per_section (newsect)->data = (bfd_byte *) NULL;
 825   oasys_per_section (newsect)->section = newsect;
 826   oasys_per_section (newsect)->offset = 0;
 827   oasys_per_section (newsect)->initialized = FALSE;
 828   newsect->alignment_power = 1;
 829   /* Turn the section string into an index */
 830
 831   sscanf (newsect->name, "%u", &newsect->target_index);
 832
 833   return TRUE;
 834 }
 835
 836
 837 static long
 838 oasys_get_reloc_upper_bound (abfd, asect)
 839      bfd *abfd;
 840      sec_ptr asect;
 841 {
 842   if (! oasys_slurp_section_data (abfd))
 843     return -1;
 844   return (asect->reloc_count + 1) * sizeof (arelent *);
 845 }
 846
 847 static bfd_boolean
 848 oasys_get_section_contents (abfd, section, location, offset, count)
 849      bfd *abfd;
 850      sec_ptr section;
 851      PTR location;
 852      file_ptr offset;
 853      bfd_size_type count;
 854 {
 855   oasys_per_section_type *p = oasys_per_section (section);
 856   oasys_slurp_section_data (abfd);
 857   if (! p->initialized)
 858     {
 859       (void) memset (location, 0, (size_t) count);
 860     }
 861   else
 862     {
 863       (void) memcpy (location, (PTR) (p->data + offset), (size_t) count);
 864     }
 865   return TRUE;
 866 }
 867
 868
 869 long
 870 oasys_canonicalize_reloc (ignore_abfd, section, relptr, symbols)
 871      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 872      sec_ptr section;
 873      arelent **relptr;
 874      asymbol **symbols ATTRIBUTE_UNUSED;
 875 {
 876   unsigned int reloc_count = 0;
 877   oasys_reloc_type *src = (oasys_reloc_type *) (section->relocation);
 878   while (src != (oasys_reloc_type *) NULL)
 879     {
 880       abort ();
 881
 882       *relptr++ = &src->relent;
 883       src = src->next;
 884       reloc_count++;
 885     }
 886   *relptr = (arelent *) NULL;
 887   return section->reloc_count = reloc_count;
 888 }
 889
 890
 891
 892
 893 /* Writing */
 894
 895
 896 /* Calculate the checksum and write one record */
 897 static bfd_boolean
 898 oasys_write_record (abfd, type, record, size)
 899      bfd *abfd;
 900      oasys_record_enum_type type;
 901      oasys_record_union_type *record;
 902      size_t size;
 903 {
 904   int checksum;
 905   size_t i;
 906   unsigned char *ptr;
 907
 908   record->header.length = size;
 909   record->header.type = (int) type;
 910   record->header.check_sum = 0;
 911   record->header.fill = 0;
 912   ptr = (unsigned char *) &record->pad[0];
 913   checksum = 0;
 914   for (i = 0; i < size; i++)
 915     {
 916       checksum += *ptr++;
 917     }
 918   record->header.check_sum = 0xff & (-checksum);
 919   if (bfd_bwrite ((PTR) record, (bfd_size_type) size, abfd) != size)
 920     return FALSE;
 921   return TRUE;
 922 }
 923
 924
 925 /* Write out all the symbols */
 926 static bfd_boolean
 927 oasys_write_syms (abfd)
 928      bfd *abfd;
 929 {
 930   unsigned int count;
 931   asymbol **generic = bfd_get_outsymbols (abfd);
 932   unsigned int index = 0;
 933   for (count = 0; count < bfd_get_symcount (abfd); count++)
 934     {
 935
 936       oasys_symbol_record_type symbol;
 937       asymbol *const g = generic[count];
 938
 939       const char *src = g->name;
 940       char *dst = symbol.name;
 941       unsigned int l = 0;
 942
 943       if (bfd_is_com_section (g->section))
 944         {
 945           symbol.relb = RELOCATION_TYPE_COM;
 946           H_PUT_16 (abfd, index, symbol.refno);
 947           index++;
 948         }
 949       else if (bfd_is_abs_section (g->section))
 950         {
 951           symbol.relb = RELOCATION_TYPE_ABS;
 952           H_PUT_16 (abfd, 0, symbol.refno);
 953
 954         }
 955       else if (bfd_is_und_section (g->section))
 956         {
 957           symbol.relb = RELOCATION_TYPE_UND;
 958           H_PUT_16 (abfd, index, symbol.refno);
 959           /* Overload the value field with the output index number */
 960           index++;
 961         }
 962       else if (g->flags & BSF_DEBUGGING)
 963         {
 964           /* throw it away */
 965           continue;
 966         }
 967       else
 968         {
 969           if (g->section == (asection *) NULL)
 970             {
 971               /* Sometime, the oasys tools give out a symbol with illegal
 972            bits in it, we'll output it in the same broken way */
 973
 974               symbol.relb = RELOCATION_TYPE_REL | 0;
 975             }
 976           else
 977             {
 978               symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index;
 979             }
 980           H_PUT_16 (abfd, 0, symbol.refno);
 981         }
 982 #ifdef UNDERSCORE_HACK
 983       if (src[l] == '_')
 984         dst[l++] = '.';
 985 #endif
 986       while (src[l])
 987         {
 988           dst[l] = src[l];
 989           l++;
 990         }
 991
 992       H_PUT_32 (abfd, g->value, symbol.value);
 993
 994
 995       if (g->flags & BSF_LOCAL)
 996         {
 997           if (! oasys_write_record (abfd,
 998                                     oasys_record_is_local_enum,
 999                                     (oasys_record_union_type *) & symbol,
1000                                     offsetof (oasys_symbol_record_type,
1001                                               name[0]) + l))
1002             return FALSE;
1003         }
1004       else
1005         {
1006           if (! oasys_write_record (abfd,
1007                                     oasys_record_is_symbol_enum,
1008                                     (oasys_record_union_type *) & symbol,
1009                                     offsetof (oasys_symbol_record_type,
1010                                               name[0]) + l))
1011             return FALSE;
1012         }
1013       g->value = index - 1;
1014     }
1015
1016   return TRUE;
1017 }
1018
1019
1020  /* Write a section header for each section */
1021 static bfd_boolean
1022 oasys_write_sections (abfd)
1023      bfd *abfd;
1024 {
1025   asection *s;
1026   static oasys_section_record_type out;
1027
1028   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1029     {
1030       if (!ISDIGIT (s->name[0]))
1031         {
1032           (*_bfd_error_handler)
1033             (_("%s: can not represent section `%s' in oasys"),
1034              bfd_get_filename (abfd), s->name);
1035           bfd_set_error (bfd_error_nonrepresentable_section);
1036           return FALSE;
1037         }
1038       out.relb = RELOCATION_TYPE_REL | s->target_index;
1039       H_PUT_32 (abfd, s->size, out.value);
1040       H_PUT_32 (abfd, s->vma, out.vma);
1041
1042       if (! oasys_write_record (abfd,
1043                                 oasys_record_is_section_enum,
1044                                 (oasys_record_union_type *) & out,
1045                                 sizeof (out)))
1046         return FALSE;
1047     }
1048   return TRUE;
1049 }
1050
1051 static bfd_boolean
1052 oasys_write_header (abfd)
1053      bfd *abfd;
1054 {
1055   /* Create and write the header */
1056   oasys_header_record_type r;
1057   size_t length = strlen (abfd->filename);
1058   if (length > (size_t) sizeof (r.module_name))
1059     {
1060       length = sizeof (r.module_name);
1061     }
1062
1063   (void) memcpy (r.module_name,
1064                  abfd->filename,
1065                  length);
1066   (void) memset (r.module_name + length,
1067                  ' ',
1068                  sizeof (r.module_name) - length);
1069
1070   r.version_number = OASYS_VERSION_NUMBER;
1071   r.rev_number = OASYS_REV_NUMBER;
1072   if (! oasys_write_record (abfd,
1073                             oasys_record_is_header_enum,
1074                             (oasys_record_union_type *) & r,
1075                             offsetof (oasys_header_record_type,
1076                                       description[0])))
1077     return FALSE;
1078
1079   return TRUE;
1080 }
1081
1082 static bfd_boolean
1083 oasys_write_end (abfd)
1084      bfd *abfd;
1085 {
1086   oasys_end_record_type end;
1087   unsigned char null = 0;
1088   end.relb = RELOCATION_TYPE_ABS;
1089   H_PUT_32 (abfd, abfd->start_address, end.entry);
1090   H_PUT_16 (abfd, 0, end.fill);
1091   end.zero = 0;
1092   if (! oasys_write_record (abfd,
1093                             oasys_record_is_end_enum,
1094                             (oasys_record_union_type *) & end,
1095                             sizeof (end)))
1096     return FALSE;
1097   if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1)
1098     return FALSE;
1099   return TRUE;
1100 }
1101
1102 static int
1103 comp (ap, bp)
1104      const PTR ap;
1105      const PTR bp;
1106 {
1107   arelent *a = *((arelent **) ap);
1108   arelent *b = *((arelent **) bp);
1109   return a->address - b->address;
1110 }
1111
1112 /*
1113  Writing data..
1114
1115 */
1116 static bfd_boolean
1117 oasys_write_data (abfd)
1118      bfd *abfd;
1119 {
1120   asection *s;
1121   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1122     {
1123       if (s->flags & SEC_LOAD)
1124         {
1125           bfd_byte *raw_data = oasys_per_section (s)->data;
1126           oasys_data_record_type processed_data;
1127           bfd_size_type current_byte_index = 0;
1128           unsigned int relocs_to_go = s->reloc_count;
1129           arelent **p = s->orelocation;
1130           if (s->reloc_count != 0)
1131             {
1132 /* Sort the reloc records so it's easy to insert the relocs into the
1133            data */
1134
1135               qsort (s->orelocation,
1136                      s->reloc_count,
1137                      sizeof (arelent **),
1138                      comp);
1139             }
1140           current_byte_index = 0;
1141           processed_data.relb = s->target_index | RELOCATION_TYPE_REL;
1142
1143           while (current_byte_index < s->size)
1144             {
1145               /* Scan forwards by eight bytes or however much is left and see if
1146                there are any relocations going on */
1147               bfd_byte *mod = &processed_data.data[0];
1148               bfd_byte *dst = &processed_data.data[1];
1149
1150               unsigned int i = 0;
1151               *mod = 0;
1152
1153
1154               H_PUT_32 (abfd, s->vma + current_byte_index,
1155                         processed_data.addr);
1156
1157               /* Don't start a relocation unless you're sure you can finish it
1158                within the same data record.  The worst case relocation is a
1159                4-byte relocatable value which is split across two modification
1160                bytes (1 relocation byte + 2 symbol reference bytes + 2 data +
1161                1 modification byte + 2 data = 8 bytes total).  That's where
1162                the magic number 8 comes from.
1163             */
1164               while (current_byte_index < s->size && dst <=
1165                      &processed_data.data[sizeof (processed_data.data) - 8])
1166                 {
1167
1168
1169                   if (relocs_to_go != 0)
1170                     {
1171                       arelent *r = *p;
1172                       reloc_howto_type *const how = r->howto;
1173                       /* There is a relocation, is it for this byte ? */
1174                       if (r->address == current_byte_index)
1175                         {
1176                           unsigned char rel_byte;
1177
1178                           p++;
1179                           relocs_to_go--;
1180
1181                           *mod |= (1 << i);
1182                           if (how->pc_relative)
1183                             {
1184                               rel_byte = RELOCATION_PCREL_BIT;
1185
1186                               /* Also patch the raw data so that it doesn't have
1187                          the -ve stuff any more */
1188                               if (how->size != 2)
1189                                 {
1190                                   bfd_put_16 (abfd,
1191                                               bfd_get_16 (abfd, raw_data) +
1192                                               current_byte_index, raw_data);
1193                                 }
1194
1195                               else
1196                                 {
1197                                   bfd_put_32 (abfd,
1198                                               bfd_get_32 (abfd, raw_data) +
1199                                               current_byte_index, raw_data);
1200                                 }
1201                             }
1202                           else
1203                             {
1204                               rel_byte = 0;
1205                             }
1206                           if (how->size == 2)
1207                             {
1208                               rel_byte |= RELOCATION_32BIT_BIT;
1209                             }
1210
1211                           /* Is this a section relative relocation, or a symbol
1212                              relative relocation ? */
1213                           abort ();
1214
1215                             {
1216                               asymbol *sym = *(r->sym_ptr_ptr);
1217
1218                               /* If this symbol has a section attached, then it
1219                              has already been resolved.  Change from a symbol
1220                              ref to a section ref */
1221                               if (sym->section != (asection *) NULL)
1222                                 {
1223                                   rel_byte |= RELOCATION_TYPE_REL;
1224                                   rel_byte |=
1225                                     sym->section->output_section->target_index;
1226                                   *dst++ = rel_byte;
1227                                 }
1228                               else
1229                                 {
1230                                   rel_byte |= RELOCATION_TYPE_UND;
1231                                   *dst++ = rel_byte;
1232                                   /* Next two bytes are a symbol index - we can get
1233                                this from the symbol value which has been zapped
1234                                into the symbol index in the table when the
1235                                symbol table was written
1236                                */
1237                                   *dst++ = sym->value >> 8;
1238                                   *dst++ = sym->value;
1239                                 }
1240                             }
1241 #define ADVANCE { if (++i >= 8) { i = 0; mod = dst++; *mod = 0; } current_byte_index++; }
1242                           /* relocations never occur from an unloadable section,
1243                        so we can assume that raw_data is not NULL
1244                      */
1245                           *dst++ = *raw_data++;
1246                           ADVANCE
1247                             * dst++ = *raw_data++;
1248                           ADVANCE
1249                             if (how->size == 2)
1250                             {
1251                               *dst++ = *raw_data++;
1252                               ADVANCE
1253                                 * dst++ = *raw_data++;
1254                               ADVANCE
1255                             }
1256                           continue;
1257                         }
1258                     }
1259                   /* If this is coming from an unloadable section then copy
1260                    zeros */
1261                   if (raw_data == NULL)
1262                     {
1263                       *dst++ = 0;
1264                     }
1265                   else
1266                     {
1267                       *dst++ = *raw_data++;
1268                     }
1269                   ADVANCE
1270                 }
1271
1272               /* Don't write a useless null modification byte */
1273               if (dst == mod + 1)
1274                 {
1275                   --dst;
1276                 }
1277
1278               if (! (oasys_write_record
1279                      (abfd, oasys_record_is_data_enum,
1280                       ((oasys_record_union_type *) &processed_data),
1281                       (size_t) (dst - (bfd_byte *) &processed_data))))
1282                 return FALSE;
1283             }
1284         }
1285     }
1286
1287   return TRUE;
1288 }
1289
1290 static bfd_boolean
1291 oasys_write_object_contents (abfd)
1292      bfd *abfd;
1293 {
1294   if (! oasys_write_header (abfd))
1295     return FALSE;
1296   if (! oasys_write_syms (abfd))
1297     return FALSE;
1298   if (! oasys_write_sections (abfd))
1299     return FALSE;
1300   if (! oasys_write_data (abfd))
1301     return FALSE;
1302   if (! oasys_write_end (abfd))
1303     return FALSE;
1304   return TRUE;
1305 }
1306
1307
1308
1309
1310 /** exec and core file sections */
1311
1312 /* set section contents is complicated with OASYS since the format is
1313 * not a byte image, but a record stream.
1314 */
1315 static bfd_boolean
1316 oasys_set_section_contents (abfd, section, location, offset, count)
1317      bfd *abfd;
1318      sec_ptr section;
1319      const PTR location;
1320      file_ptr offset;
1321      bfd_size_type count;
1322 {
1323   if (count != 0)
1324     {
1325       if (oasys_per_section (section)->data == (bfd_byte *) NULL)
1326         {
1327           oasys_per_section (section)->data =
1328             (bfd_byte *) (bfd_alloc (abfd, section->size));
1329           if (!oasys_per_section (section)->data)
1330             return FALSE;
1331         }
1332       (void) memcpy ((PTR) (oasys_per_section (section)->data + offset),
1333                      location,
1334                      (size_t) count);
1335     }
1336   return TRUE;
1337 }
1338
1339
1340
1341 /* Native-level interface to symbols. */
1342
1343 /* We read the symbols into a buffer, which is discarded when this
1344 function exits.  We read the strings into a buffer large enough to
1345 hold them all plus all the cached symbol entries. */
1346
1347 static asymbol *
1348 oasys_make_empty_symbol (abfd)
1349      bfd *abfd;
1350 {
1351   bfd_size_type amt = sizeof (oasys_symbol_type);
1352   oasys_symbol_type *new = (oasys_symbol_type *) bfd_zalloc (abfd, amt);
1353   if (!new)
1354     return NULL;
1355   new->symbol.the_bfd = abfd;
1356   return &new->symbol;
1357 }
1358 \f
1359
1360
1361
1362 /* User should have checked the file flags; perhaps we should return
1363 BFD_NO_MORE_SYMBOLS if there are none? */
1364
1365 static bfd *
1366 oasys_openr_next_archived_file (arch, prev)
1367      bfd *arch;
1368      bfd *prev;
1369 {
1370   oasys_ar_data_type *ar = OASYS_AR_DATA (arch);
1371   oasys_module_info_type *p;
1372   /* take the next one from the arch state, or reset */
1373   if (prev == (bfd *) NULL)
1374     {
1375       /* Reset the index - the first two entries are bogus*/
1376       ar->module_index = 0;
1377     }
1378
1379   p = ar->module + ar->module_index;
1380   ar->module_index++;
1381
1382   if (ar->module_index <= ar->module_count)
1383     {
1384       if (p->abfd == (bfd *) NULL)
1385         {
1386           p->abfd = _bfd_create_empty_archive_element_shell (arch);
1387           p->abfd->origin = p->pos;
1388           p->abfd->filename = p->name;
1389
1390           /* Fixup a pointer to this element for the member */
1391           p->abfd->arelt_data = (PTR) p;
1392         }
1393       return p->abfd;
1394     }
1395   else
1396     {
1397       bfd_set_error (bfd_error_no_more_archived_files);
1398       return (bfd *) NULL;
1399     }
1400 }
1401
1402 static bfd_boolean
1403 oasys_find_nearest_line (abfd, section, symbols, offset,
1404                          filename_ptr, functionname_ptr, line_ptr)
1405      bfd *abfd ATTRIBUTE_UNUSED;
1406      asection *section ATTRIBUTE_UNUSED;
1407      asymbol **symbols ATTRIBUTE_UNUSED;
1408      bfd_vma offset ATTRIBUTE_UNUSED;
1409      const char **filename_ptr ATTRIBUTE_UNUSED;
1410      const char **functionname_ptr ATTRIBUTE_UNUSED;
1411      unsigned int *line_ptr ATTRIBUTE_UNUSED;
1412 {
1413   return FALSE;
1414
1415 }
1416
1417 static int
1418 oasys_generic_stat_arch_elt (abfd, buf)
1419      bfd *abfd;
1420      struct stat *buf;
1421 {
1422   oasys_module_info_type *mod = (oasys_module_info_type *) abfd->arelt_data;
1423   if (mod == (oasys_module_info_type *) NULL)
1424     {
1425       bfd_set_error (bfd_error_invalid_operation);
1426       return -1;
1427     }
1428   else
1429     {
1430       buf->st_size = mod->size;
1431       buf->st_mode = 0666;
1432       return 0;
1433     }
1434 }
1435
1436 static int
1437 oasys_sizeof_headers (abfd, exec)
1438      bfd *abfd ATTRIBUTE_UNUSED;
1439      bfd_boolean exec ATTRIBUTE_UNUSED;
1440 {
1441   return 0;
1442 }
1443
1444 #define oasys_close_and_cleanup _bfd_generic_close_and_cleanup
1445 #define oasys_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1446
1447 #define oasys_slurp_armap bfd_true
1448 #define oasys_slurp_extended_name_table bfd_true
1449 #define oasys_construct_extended_name_table \
1450   ((bfd_boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
1451    bfd_true)
1452 #define oasys_truncate_arname bfd_dont_truncate_arname
1453 #define oasys_write_armap \
1454   ((bfd_boolean (*) \
1455     PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
1456    bfd_true)
1457 #define oasys_read_ar_hdr bfd_nullvoidptr
1458 #define oasys_get_elt_at_index _bfd_generic_get_elt_at_index
1459 #define oasys_update_armap_timestamp bfd_true
1460
1461 #define oasys_bfd_is_local_label_name bfd_generic_is_local_label_name
1462 #define oasys_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
1463 #define oasys_get_lineno _bfd_nosymbols_get_lineno
1464 #define oasys_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1465 #define oasys_read_minisymbols _bfd_generic_read_minisymbols
1466 #define oasys_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1467
1468 #define oasys_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
1469
1470 #define oasys_set_arch_mach bfd_default_set_arch_mach
1471
1472 #define oasys_get_section_contents_in_window \
1473   _bfd_generic_get_section_contents_in_window
1474
1475 #define oasys_bfd_get_relocated_section_contents \
1476   bfd_generic_get_relocated_section_contents
1477 #define oasys_bfd_relax_section bfd_generic_relax_section
1478 #define oasys_bfd_gc_sections bfd_generic_gc_sections
1479 #define oasys_bfd_merge_sections bfd_generic_merge_sections
1480 #define oasys_bfd_is_group_section bfd_generic_is_group_section
1481 #define oasys_bfd_discard_group bfd_generic_discard_group
1482 #define oasys_section_already_linked \
1483   _bfd_generic_section_already_linked
1484 #define oasys_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1485 #define oasys_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
1486 #define oasys_bfd_link_add_symbols _bfd_generic_link_add_symbols
1487 #define oasys_bfd_link_just_syms _bfd_generic_link_just_syms
1488 #define oasys_bfd_final_link _bfd_generic_final_link
1489 #define oasys_bfd_link_split_section _bfd_generic_link_split_section
1490
1491 /*SUPPRESS 460 */
1492 const bfd_target oasys_vec =
1493 {
1494   "oasys",                      /* name */
1495   bfd_target_oasys_flavour,
1496   BFD_ENDIAN_BIG,               /* target byte order */
1497   BFD_ENDIAN_BIG,               /* target headers byte order */
1498   (HAS_RELOC | EXEC_P |         /* object flags */
1499    HAS_LINENO | HAS_DEBUG |
1500    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1501   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1502    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1503   0,                            /* leading underscore */
1504   ' ',                          /* ar_pad_char */
1505   16,                           /* ar_max_namelen */
1506   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1507   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1508   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
1509   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1510   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1511   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
1512
1513   {_bfd_dummy_target,
1514    oasys_object_p,              /* bfd_check_format */
1515    oasys_archive_p,
1516    _bfd_dummy_target,
1517   },
1518   {                             /* bfd_set_format */
1519     bfd_false,
1520     oasys_mkobject,
1521     _bfd_generic_mkarchive,
1522     bfd_false
1523   },
1524   {                             /* bfd_write_contents */
1525     bfd_false,
1526     oasys_write_object_contents,
1527     _bfd_write_archive_contents,
1528     bfd_false,
1529   },
1530
1531   BFD_JUMP_TABLE_GENERIC (oasys),
1532   BFD_JUMP_TABLE_COPY (_bfd_generic),
1533   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1534   BFD_JUMP_TABLE_ARCHIVE (oasys),
1535   BFD_JUMP_TABLE_SYMBOLS (oasys),
1536   BFD_JUMP_TABLE_RELOCS (oasys),
1537   BFD_JUMP_TABLE_WRITE (oasys),
1538   BFD_JUMP_TABLE_LINK (oasys),
1539   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1540
1541   NULL,
1542
1543   (PTR) 0
1544 };