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