bfd/oasys.c

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