bfd/oasys.c

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