bfd/pef.c

   1 /* PEF support for BFD.
   2    Copyright (C) 1999-2019 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 /* PEF (Preferred Executable Format) is the binary file format for late
  22    classic Mac OS versions (before Darwin).  It is supported by both m68k
  23    and PowerPc.  It is also called CFM (Code Fragment Manager).  */
  24
  25 #include "sysdep.h"
  26 #include "safe-ctype.h"
  27 #include "pef.h"
  28 #include "pef-traceback.h"
  29 #include "bfd.h"
  30 #include "libbfd.h"
  31 #include "libiberty.h"
  32
  33 #ifndef BFD_IO_FUNCS
  34 #define BFD_IO_FUNCS 0
  35 #endif
  36
  37 #define bfd_pef_close_and_cleanup                   _bfd_generic_close_and_cleanup
  38 #define bfd_pef_bfd_free_cached_info                _bfd_generic_bfd_free_cached_info
  39 #define bfd_pef_new_section_hook                    _bfd_generic_new_section_hook
  40 #define bfd_pef_bfd_is_local_label_name             bfd_generic_is_local_label_name
  41 #define bfd_pef_bfd_is_target_special_symbol        _bfd_bool_bfd_asymbol_false
  42 #define bfd_pef_get_lineno                          _bfd_nosymbols_get_lineno
  43 #define bfd_pef_find_nearest_line                   _bfd_nosymbols_find_nearest_line
  44 #define bfd_pef_find_line                           _bfd_nosymbols_find_line
  45 #define bfd_pef_find_inliner_info                   _bfd_nosymbols_find_inliner_info
  46 #define bfd_pef_get_symbol_version_string           _bfd_nosymbols_get_symbol_version_string
  47 #define bfd_pef_bfd_make_debug_symbol               _bfd_nosymbols_bfd_make_debug_symbol
  48 #define bfd_pef_read_minisymbols                    _bfd_generic_read_minisymbols
  49 #define bfd_pef_minisymbol_to_symbol                _bfd_generic_minisymbol_to_symbol
  50 #define bfd_pef_set_arch_mach                       _bfd_generic_set_arch_mach
  51 #define bfd_pef_get_section_contents                _bfd_generic_get_section_contents
  52 #define bfd_pef_set_section_contents                _bfd_generic_set_section_contents
  53 #define bfd_pef_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
  54 #define bfd_pef_bfd_relax_section                   bfd_generic_relax_section
  55 #define bfd_pef_bfd_gc_sections                     bfd_generic_gc_sections
  56 #define bfd_pef_bfd_lookup_section_flags            bfd_generic_lookup_section_flags
  57 #define bfd_pef_bfd_merge_sections                  bfd_generic_merge_sections
  58 #define bfd_pef_bfd_is_group_section                bfd_generic_is_group_section
  59 #define bfd_pef_bfd_group_name                      bfd_generic_group_name
  60 #define bfd_pef_bfd_discard_group                   bfd_generic_discard_group
  61 #define bfd_pef_section_already_linked              _bfd_generic_section_already_linked
  62 #define bfd_pef_bfd_define_common_symbol            bfd_generic_define_common_symbol
  63 #define bfd_pef_bfd_link_hide_symbol                _bfd_generic_link_hide_symbol
  64 #define bfd_pef_bfd_define_start_stop               bfd_generic_define_start_stop
  65 #define bfd_pef_bfd_link_hash_table_create          _bfd_generic_link_hash_table_create
  66 #define bfd_pef_bfd_link_add_symbols                _bfd_generic_link_add_symbols
  67 #define bfd_pef_bfd_link_just_syms                  _bfd_generic_link_just_syms
  68 #define bfd_pef_bfd_copy_link_hash_symbol_type \
  69   _bfd_generic_copy_link_hash_symbol_type
  70 #define bfd_pef_bfd_final_link                      _bfd_generic_final_link
  71 #define bfd_pef_bfd_link_split_section              _bfd_generic_link_split_section
  72 #define bfd_pef_get_section_contents_in_window      _bfd_generic_get_section_contents_in_window
  73 #define bfd_pef_bfd_link_check_relocs               _bfd_generic_link_check_relocs
  74
  75 static int
  76 bfd_pef_parse_traceback_table (bfd *abfd,
  77                                asection *section,
  78                                unsigned char *buf,
  79                                size_t len,
  80                                size_t pos,
  81                                asymbol *sym,
  82                                FILE *file)
  83 {
  84   struct traceback_table table;
  85   size_t offset;
  86   const char *s;
  87   asymbol tmpsymbol;
  88
  89   if (sym == NULL)
  90     sym = & tmpsymbol;
  91
  92   sym->name = NULL;
  93   sym->value = 0;
  94   sym->the_bfd = abfd;
  95   sym->section = section;
  96   sym->flags = 0;
  97   sym->udata.i = 0;
  98
  99   /* memcpy is fine since all fields are unsigned char.  */
 100   if ((pos + 8) > len)
 101     return -1;
 102   memcpy (&table, buf + pos, 8);
 103
 104   /* Calling code relies on returned symbols having a name and
 105      correct offset.  */
 106   if ((table.lang != TB_C) && (table.lang != TB_CPLUSPLUS))
 107     return -1;
 108
 109   if (! (table.flags2 & TB_NAME_PRESENT))
 110     return -1;
 111
 112   if (! (table.flags1 & TB_HAS_TBOFF))
 113     return -1;
 114
 115   offset = 8;
 116
 117   if ((table.flags5 & TB_FLOATPARAMS) || (table.fixedparams))
 118     offset += 4;
 119
 120   if (table.flags1 & TB_HAS_TBOFF)
 121     {
 122       struct traceback_table_tboff off;
 123
 124       if ((pos + offset + 4) > len)
 125         return -1;
 126       off.tb_offset = bfd_getb32 (buf + pos + offset);
 127       offset += 4;
 128
 129       /* Need to subtract 4 because the offset includes the 0x0L
 130          preceding the table.  */
 131       if (file != NULL)
 132         fprintf (file, " [offset = 0x%lx]", off.tb_offset);
 133
 134       if ((file == NULL) && ((off.tb_offset + 4) > (pos + offset)))
 135         return -1;
 136
 137       sym->value = pos - off.tb_offset - 4;
 138     }
 139
 140   if (table.flags2 & TB_INT_HNDL)
 141     offset += 4;
 142
 143   if (table.flags1 & TB_HAS_CTL)
 144     {
 145       struct traceback_table_anchors anchors;
 146
 147       if ((pos + offset + 4) > len)
 148         return -1;
 149       anchors.ctl_info = bfd_getb32 (buf + pos + offset);
 150       offset += 4;
 151
 152       if (anchors.ctl_info > 1024)
 153         return -1;
 154
 155       offset += anchors.ctl_info * 4;
 156     }
 157
 158   if (table.flags2 & TB_NAME_PRESENT)
 159     {
 160       struct traceback_table_routine name;
 161       char *namebuf;
 162
 163       if ((pos + offset + 2) > len)
 164         return -1;
 165       name.name_len = bfd_getb16 (buf + pos + offset);
 166       offset += 2;
 167
 168       if (name.name_len > 4096)
 169         return -1;
 170
 171       if ((pos + offset + name.name_len) > len)
 172         return -1;
 173
 174       namebuf = bfd_alloc (abfd, name.name_len + 1);
 175       if (namebuf == NULL)
 176         return -1;
 177
 178       memcpy (namebuf, buf + pos + offset, name.name_len);
 179       namebuf[name.name_len] = '\0';
 180
 181       /* Strip leading period inserted by compiler.  */
 182       if (namebuf[0] == '.')
 183         memmove (namebuf, namebuf + 1, name.name_len + 1);
 184
 185       sym->name = namebuf;
 186
 187       for (s = sym->name; (*s != '\0'); s++)
 188         if (! ISPRINT (*s))
 189           return -1;
 190
 191       offset += name.name_len;
 192     }
 193
 194   if (table.flags2 & TB_USES_ALLOCA)
 195     offset += 4;
 196
 197   if (table.flags4 & TB_HAS_VEC_INFO)
 198     offset += 4;
 199
 200   if (file != NULL)
 201     fprintf (file, " [length = 0x%lx]", (unsigned long) offset);
 202
 203   return offset;
 204 }
 205
 206 static void
 207 bfd_pef_print_symbol (bfd *abfd,
 208                       void * afile,
 209                       asymbol *symbol,
 210                       bfd_print_symbol_type how)
 211 {
 212   FILE *file = (FILE *) afile;
 213
 214   switch (how)
 215     {
 216     case bfd_print_symbol_name:
 217       fprintf (file, "%s", symbol->name);
 218       break;
 219     default:
 220       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 221       fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
 222       if (CONST_STRNEQ (symbol->name, "__traceback_"))
 223         {
 224           unsigned char *buf;
 225           size_t offset = symbol->value + 4;
 226           size_t len = symbol->udata.i;
 227
 228           buf = bfd_malloc (len);
 229           if (buf == NULL
 230               || !bfd_get_section_contents (abfd, symbol->section, buf,
 231                                             offset, len)
 232               || bfd_pef_parse_traceback_table (abfd, symbol->section, buf,
 233                                                 len, 0, NULL, file) < 0)
 234             fprintf (file, " [ERROR]");
 235           free (buf);
 236         }
 237     }
 238 }
 239
 240 static void
 241 bfd_pef_convert_architecture (unsigned long architecture,
 242                               enum bfd_architecture *type,
 243                               unsigned long *subtype)
 244 {
 245   const unsigned long ARCH_POWERPC = 0x70777063; /* 'pwpc'.  */
 246   const unsigned long ARCH_M68K = 0x6d36386b; /* 'm68k'.  */
 247
 248   *subtype = bfd_arch_unknown;
 249   *type = bfd_arch_unknown;
 250
 251   if (architecture == ARCH_POWERPC)
 252     *type = bfd_arch_powerpc;
 253   else if (architecture == ARCH_M68K)
 254     *type = bfd_arch_m68k;
 255 }
 256
 257 static bfd_boolean
 258 bfd_pef_mkobject (bfd *abfd ATTRIBUTE_UNUSED)
 259 {
 260   return TRUE;
 261 }
 262
 263 static const char *bfd_pef_section_name (bfd_pef_section *section)
 264 {
 265   switch (section->section_kind)
 266     {
 267     case BFD_PEF_SECTION_CODE: return "code";
 268     case BFD_PEF_SECTION_UNPACKED_DATA: return "unpacked-data";
 269     case BFD_PEF_SECTION_PACKED_DATA: return "packed-data";
 270     case BFD_PEF_SECTION_CONSTANT: return "constant";
 271     case BFD_PEF_SECTION_LOADER: return "loader";
 272     case BFD_PEF_SECTION_DEBUG: return "debug";
 273     case BFD_PEF_SECTION_EXEC_DATA: return "exec-data";
 274     case BFD_PEF_SECTION_EXCEPTION: return "exception";
 275     case BFD_PEF_SECTION_TRACEBACK: return "traceback";
 276     default: return "unknown";
 277     }
 278 }
 279
 280 static unsigned long bfd_pef_section_flags (bfd_pef_section *section)
 281 {
 282   switch (section->section_kind)
 283     {
 284     case BFD_PEF_SECTION_CODE:
 285       return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
 286     case BFD_PEF_SECTION_UNPACKED_DATA:
 287     case BFD_PEF_SECTION_PACKED_DATA:
 288     case BFD_PEF_SECTION_CONSTANT:
 289     case BFD_PEF_SECTION_LOADER:
 290     case BFD_PEF_SECTION_DEBUG:
 291     case BFD_PEF_SECTION_EXEC_DATA:
 292     case BFD_PEF_SECTION_EXCEPTION:
 293     case BFD_PEF_SECTION_TRACEBACK:
 294     default:
 295       return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 296     }
 297 }
 298
 299 static asection *
 300 bfd_pef_make_bfd_section (bfd *abfd, bfd_pef_section *section)
 301 {
 302   asection *bfdsec;
 303   const char *name = bfd_pef_section_name (section);
 304
 305   bfdsec = bfd_make_section_anyway (abfd, name);
 306   if (bfdsec == NULL)
 307     return NULL;
 308
 309   bfdsec->vma = section->default_address + section->container_offset;
 310   bfdsec->lma = section->default_address + section->container_offset;
 311   bfdsec->size = section->container_length;
 312   bfdsec->filepos = section->container_offset;
 313   bfdsec->alignment_power = section->alignment;
 314
 315   bfdsec->flags = bfd_pef_section_flags (section);
 316
 317   return bfdsec;
 318 }
 319
 320 int
 321 bfd_pef_parse_loader_header (bfd *abfd ATTRIBUTE_UNUSED,
 322                              unsigned char *buf,
 323                              size_t len,
 324                              bfd_pef_loader_header *header)
 325 {
 326   BFD_ASSERT (len == 56);
 327
 328   header->main_section = bfd_getb32 (buf);
 329   header->main_offset = bfd_getb32 (buf + 4);
 330   header->init_section = bfd_getb32 (buf + 8);
 331   header->init_offset = bfd_getb32 (buf + 12);
 332   header->term_section = bfd_getb32 (buf + 16);
 333   header->term_offset = bfd_getb32 (buf + 20);
 334   header->imported_library_count = bfd_getb32 (buf + 24);
 335   header->total_imported_symbol_count = bfd_getb32 (buf + 28);
 336   header->reloc_section_count = bfd_getb32 (buf + 32);
 337   header->reloc_instr_offset = bfd_getb32 (buf + 36);
 338   header->loader_strings_offset = bfd_getb32 (buf + 40);
 339   header->export_hash_offset = bfd_getb32 (buf + 44);
 340   header->export_hash_table_power = bfd_getb32 (buf + 48);
 341   header->exported_symbol_count = bfd_getb32 (buf + 52);
 342
 343   return 0;
 344 }
 345
 346 int
 347 bfd_pef_parse_imported_library (bfd *abfd ATTRIBUTE_UNUSED,
 348                                 unsigned char *buf,
 349                                 size_t len,
 350                                 bfd_pef_imported_library *header)
 351 {
 352   BFD_ASSERT (len == 24);
 353
 354   header->name_offset = bfd_getb32 (buf);
 355   header->old_implementation_version = bfd_getb32 (buf + 4);
 356   header->current_version = bfd_getb32 (buf + 8);
 357   header->imported_symbol_count = bfd_getb32 (buf + 12);
 358   header->first_imported_symbol = bfd_getb32 (buf + 16);
 359   header->options = buf[20];
 360   header->reserved_a = buf[21];
 361   header->reserved_b = bfd_getb16 (buf + 22);
 362
 363   return 0;
 364 }
 365
 366 int
 367 bfd_pef_parse_imported_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 368                                unsigned char *buf,
 369                                size_t len,
 370                                bfd_pef_imported_symbol *symbol)
 371 {
 372   unsigned long value;
 373
 374   BFD_ASSERT (len == 4);
 375
 376   value = bfd_getb32 (buf);
 377   symbol->symbol_class = value >> 24;
 378   symbol->name = value & 0x00ffffff;
 379
 380   return 0;
 381 }
 382
 383 int
 384 bfd_pef_scan_section (bfd *abfd, bfd_pef_section *section)
 385 {
 386   unsigned char buf[28];
 387
 388   bfd_seek (abfd, section->header_offset, SEEK_SET);
 389   if (bfd_bread ((void *) buf, 28, abfd) != 28)
 390     return -1;
 391
 392   section->name_offset = bfd_h_get_32 (abfd, buf);
 393   section->default_address = bfd_h_get_32 (abfd, buf + 4);
 394   section->total_length = bfd_h_get_32 (abfd, buf + 8);
 395   section->unpacked_length = bfd_h_get_32 (abfd, buf + 12);
 396   section->container_length = bfd_h_get_32 (abfd, buf + 16);
 397   section->container_offset = bfd_h_get_32 (abfd, buf + 20);
 398   section->section_kind = buf[24];
 399   section->share_kind = buf[25];
 400   section->alignment = buf[26];
 401   section->reserved = buf[27];
 402
 403   section->bfd_section = bfd_pef_make_bfd_section (abfd, section);
 404   if (section->bfd_section == NULL)
 405     return -1;
 406
 407   return 0;
 408 }
 409
 410 void
 411 bfd_pef_print_loader_header (bfd *abfd ATTRIBUTE_UNUSED,
 412                              bfd_pef_loader_header *header,
 413                              FILE *file)
 414 {
 415   fprintf (file, "main_section: %ld\n", header->main_section);
 416   fprintf (file, "main_offset: %lu\n", header->main_offset);
 417   fprintf (file, "init_section: %ld\n", header->init_section);
 418   fprintf (file, "init_offset: %lu\n", header->init_offset);
 419   fprintf (file, "term_section: %ld\n", header->term_section);
 420   fprintf (file, "term_offset: %lu\n", header->term_offset);
 421   fprintf (file, "imported_library_count: %lu\n",
 422            header->imported_library_count);
 423   fprintf (file, "total_imported_symbol_count: %lu\n",
 424            header->total_imported_symbol_count);
 425   fprintf (file, "reloc_section_count: %lu\n", header->reloc_section_count);
 426   fprintf (file, "reloc_instr_offset: %lu\n", header->reloc_instr_offset);
 427   fprintf (file, "loader_strings_offset: %lu\n",
 428            header->loader_strings_offset);
 429   fprintf (file, "export_hash_offset: %lu\n", header->export_hash_offset);
 430   fprintf (file, "export_hash_table_power: %lu\n",
 431            header->export_hash_table_power);
 432   fprintf (file, "exported_symbol_count: %lu\n",
 433            header->exported_symbol_count);
 434 }
 435
 436 int
 437 bfd_pef_print_loader_section (bfd *abfd, FILE *file)
 438 {
 439   bfd_pef_loader_header header;
 440   asection *loadersec = NULL;
 441   unsigned char *loaderbuf = NULL;
 442   size_t loaderlen = 0;
 443
 444   loadersec = bfd_get_section_by_name (abfd, "loader");
 445   if (loadersec == NULL)
 446     return -1;
 447
 448   loaderlen = loadersec->size;
 449   loaderbuf = bfd_malloc (loaderlen);
 450
 451   if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0
 452       || bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen
 453       || loaderlen < 56
 454       || bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header) < 0)
 455     {
 456       free (loaderbuf);
 457       return -1;
 458     }
 459
 460   bfd_pef_print_loader_header (abfd, &header, file);
 461   return 0;
 462 }
 463
 464 int
 465 bfd_pef_scan_start_address (bfd *abfd)
 466 {
 467   bfd_pef_loader_header header;
 468   asection *section;
 469
 470   asection *loadersec = NULL;
 471   unsigned char *loaderbuf = NULL;
 472   size_t loaderlen = 0;
 473   int ret;
 474
 475   loadersec = bfd_get_section_by_name (abfd, "loader");
 476   if (loadersec == NULL)
 477     goto end;
 478
 479   loaderlen = loadersec->size;
 480   loaderbuf = bfd_malloc (loaderlen);
 481   if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0)
 482     goto error;
 483   if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen)
 484     goto error;
 485
 486   if (loaderlen < 56)
 487     goto error;
 488   ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header);
 489   if (ret < 0)
 490     goto error;
 491
 492   if (header.main_section < 0)
 493     goto end;
 494
 495   for (section = abfd->sections; section != NULL; section = section->next)
 496     if ((long) (section->index + 1) == header.main_section)
 497       break;
 498
 499   if (section == NULL)
 500     goto error;
 501
 502   abfd->start_address = section->vma + header.main_offset;
 503
 504  end:
 505   if (loaderbuf != NULL)
 506     free (loaderbuf);
 507   return 0;
 508
 509  error:
 510   if (loaderbuf != NULL)
 511     free (loaderbuf);
 512   return -1;
 513 }
 514
 515 int
 516 bfd_pef_scan (bfd *abfd,
 517               bfd_pef_header *header,
 518               bfd_pef_data_struct *mdata)
 519 {
 520   unsigned int i;
 521   enum bfd_architecture cputype;
 522   unsigned long cpusubtype;
 523
 524   mdata->header = *header;
 525
 526   bfd_pef_convert_architecture (header->architecture, &cputype, &cpusubtype);
 527   if (cputype == bfd_arch_unknown)
 528     {
 529       _bfd_error_handler (_("bfd_pef_scan: unknown architecture 0x%lx"),
 530                           header->architecture);
 531       return -1;
 532     }
 533   bfd_set_arch_mach (abfd, cputype, cpusubtype);
 534
 535   mdata->header = *header;
 536
 537   abfd->flags = (abfd->xvec->object_flags
 538                  | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
 539
 540   if (header->section_count != 0)
 541     {
 542       mdata->sections = bfd_alloc (abfd, header->section_count * sizeof (bfd_pef_section));
 543
 544       if (mdata->sections == NULL)
 545         return -1;
 546
 547       for (i = 0; i < header->section_count; i++)
 548         {
 549           bfd_pef_section *cur = &mdata->sections[i];
 550           cur->header_offset = 40 + (i * 28);
 551           if (bfd_pef_scan_section (abfd, cur) < 0)
 552             return -1;
 553         }
 554     }
 555
 556   if (bfd_pef_scan_start_address (abfd) < 0)
 557     return -1;
 558
 559   abfd->tdata.pef_data = mdata;
 560
 561   return 0;
 562 }
 563
 564 static int
 565 bfd_pef_read_header (bfd *abfd, bfd_pef_header *header)
 566 {
 567   unsigned char buf[40];
 568
 569   bfd_seek (abfd, 0, SEEK_SET);
 570
 571   if (bfd_bread ((void *) buf, 40, abfd) != 40)
 572     return -1;
 573
 574   header->tag1 = bfd_getb32 (buf);
 575   header->tag2 = bfd_getb32 (buf + 4);
 576   header->architecture = bfd_getb32 (buf + 8);
 577   header->format_version = bfd_getb32 (buf + 12);
 578   header->timestamp = bfd_getb32 (buf + 16);
 579   header->old_definition_version = bfd_getb32 (buf + 20);
 580   header->old_implementation_version = bfd_getb32 (buf + 24);
 581   header->current_version = bfd_getb32 (buf + 28);
 582   header->section_count = bfd_getb32 (buf + 32) + 1;
 583   header->instantiated_section_count = bfd_getb32 (buf + 34);
 584   header->reserved = bfd_getb32 (buf + 36);
 585
 586   return 0;
 587 }
 588
 589 static const bfd_target *
 590 bfd_pef_object_p (bfd *abfd)
 591 {
 592   bfd_pef_header header;
 593   bfd_pef_data_struct *mdata;
 594
 595   if (bfd_pef_read_header (abfd, &header) != 0)
 596     goto wrong;
 597
 598   if (header.tag1 != BFD_PEF_TAG1 || header.tag2 != BFD_PEF_TAG2)
 599     goto wrong;
 600
 601   mdata = (bfd_pef_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
 602   if (mdata == NULL)
 603     goto fail;
 604
 605   if (bfd_pef_scan (abfd, &header, mdata))
 606     goto wrong;
 607
 608   return abfd->xvec;
 609
 610  wrong:
 611   bfd_set_error (bfd_error_wrong_format);
 612
 613  fail:
 614   return NULL;
 615 }
 616
 617 static int
 618 bfd_pef_parse_traceback_tables (bfd *abfd,
 619                                 asection *sec,
 620                                 unsigned char *buf,
 621                                 size_t len,
 622                                 long *nsym,
 623                                 asymbol **csym)
 624 {
 625   char *name;
 626
 627   asymbol function;
 628   asymbol traceback;
 629
 630   const char *const tbprefix = "__traceback_";
 631   size_t tbnamelen;
 632
 633   size_t pos = 0;
 634   unsigned long count = 0;
 635   int ret;
 636
 637   for (;;)
 638     {
 639       /* We're reading symbols two at a time.  */
 640       if (csym && ((csym[count] == NULL) || (csym[count + 1] == NULL)))
 641         break;
 642
 643       pos += 3;
 644       pos -= (pos % 4);
 645
 646       while ((pos + 4) <= len)
 647         {
 648           if (bfd_getb32 (buf + pos) == 0)
 649             break;
 650           pos += 4;
 651         }
 652
 653       if ((pos + 4) > len)
 654         break;
 655
 656       ret = bfd_pef_parse_traceback_table (abfd, sec, buf, len, pos + 4,
 657                                            &function, 0);
 658       if (ret < 0)
 659         {
 660           /* Skip over 0x0L to advance to next possible traceback table.  */
 661           pos += 4;
 662           continue;
 663         }
 664
 665       BFD_ASSERT (function.name != NULL);
 666
 667       /* Don't bother to compute the name if we are just
 668          counting symbols.  */
 669       if (csym)
 670         {
 671           tbnamelen = strlen (tbprefix) + strlen (function.name);
 672           name = bfd_alloc (abfd, tbnamelen + 1);
 673           if (name == NULL)
 674             {
 675               bfd_release (abfd, (void *) function.name);
 676               function.name = NULL;
 677               break;
 678             }
 679           snprintf (name, tbnamelen + 1, "%s%s", tbprefix, function.name);
 680           traceback.name = name;
 681           traceback.value = pos;
 682           traceback.the_bfd = abfd;
 683           traceback.section = sec;
 684           traceback.flags = 0;
 685           traceback.udata.i = ret;
 686
 687           *(csym[count]) = function;
 688           *(csym[count + 1]) = traceback;
 689         }
 690
 691       pos += ret;
 692       count += 2;
 693     }
 694
 695   *nsym = count;
 696   return 0;
 697 }
 698
 699 static int
 700 bfd_pef_parse_function_stub (bfd *abfd ATTRIBUTE_UNUSED,
 701                              unsigned char *buf,
 702                              size_t len,
 703                              unsigned long *offset)
 704 {
 705   BFD_ASSERT (len == 24);
 706
 707   if ((bfd_getb32 (buf) & 0xffff0000) != 0x81820000)
 708     return -1;
 709   if (bfd_getb32 (buf + 4) != 0x90410014)
 710     return -1;
 711   if (bfd_getb32 (buf + 8) != 0x800c0000)
 712     return -1;
 713   if (bfd_getb32 (buf + 12) != 0x804c0004)
 714     return -1;
 715   if (bfd_getb32 (buf + 16) != 0x7c0903a6)
 716     return -1;
 717   if (bfd_getb32 (buf + 20) != 0x4e800420)
 718     return -1;
 719
 720   if (offset != NULL)
 721     *offset = (bfd_getb32 (buf) & 0x0000ffff) / 4;
 722
 723   return 0;
 724 }
 725
 726 static int
 727 bfd_pef_parse_function_stubs (bfd *abfd,
 728                               asection *codesec,
 729                               unsigned char *codebuf,
 730                               size_t codelen,
 731                               unsigned char *loaderbuf,
 732                               size_t loaderlen,
 733                               unsigned long *nsym,
 734                               asymbol **csym)
 735 {
 736   const char *const sprefix = "__stub_";
 737   size_t codepos = 0;
 738   unsigned long count = 0;
 739   bfd_pef_loader_header header;
 740   bfd_pef_imported_library *libraries = NULL;
 741   bfd_pef_imported_symbol *imports = NULL;
 742   unsigned long i;
 743   int ret;
 744
 745   if (loaderlen < 56)
 746     goto error;
 747
 748   ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header);
 749   if (ret < 0)
 750     goto error;
 751
 752   libraries = bfd_malloc
 753     (header.imported_library_count * sizeof (bfd_pef_imported_library));
 754   imports = bfd_malloc
 755     (header.total_imported_symbol_count * sizeof (bfd_pef_imported_symbol));
 756
 757   if (loaderlen < (56 + (header.imported_library_count * 24)))
 758     goto error;
 759   for (i = 0; i < header.imported_library_count; i++)
 760     {
 761       ret = bfd_pef_parse_imported_library
 762         (abfd, loaderbuf + 56 + (i * 24), 24, &libraries[i]);
 763       if (ret < 0)
 764         goto error;
 765     }
 766
 767   if (loaderlen < (56 + (header.imported_library_count * 24)
 768                    + (header.total_imported_symbol_count * 4)))
 769     goto error;
 770   for (i = 0; i < header.total_imported_symbol_count; i++)
 771     {
 772       ret = (bfd_pef_parse_imported_symbol
 773              (abfd,
 774               loaderbuf + 56 + (header.imported_library_count * 24) + (i * 4),
 775               4, &imports[i]));
 776       if (ret < 0)
 777         goto error;
 778     }
 779
 780   codepos = 0;
 781
 782   for (;;)
 783     {
 784       asymbol sym;
 785       const char *symname;
 786       char *name;
 787       unsigned long sym_index;
 788
 789       if (csym && (csym[count] == NULL))
 790         break;
 791
 792       codepos += 3;
 793       codepos -= (codepos % 4);
 794
 795       while ((codepos + 4) <= codelen)
 796         {
 797           if ((bfd_getb32 (codebuf + codepos) & 0xffff0000) == 0x81820000)
 798             break;
 799           codepos += 4;
 800         }
 801
 802       if ((codepos + 4) > codelen)
 803         break;
 804
 805       ret = bfd_pef_parse_function_stub (abfd, codebuf + codepos, 24, &sym_index);
 806       if (ret < 0)
 807         {
 808           codepos += 24;
 809           continue;
 810         }
 811
 812       if (sym_index >= header.total_imported_symbol_count)
 813         {
 814           codepos += 24;
 815           continue;
 816         }
 817
 818       {
 819         size_t max, namelen;
 820         const char *s;
 821
 822         if (loaderlen < (header.loader_strings_offset + imports[sym_index].name))
 823           goto error;
 824
 825         max = loaderlen - (header.loader_strings_offset + imports[sym_index].name);
 826         symname = (char *) loaderbuf;
 827         symname += header.loader_strings_offset + imports[sym_index].name;
 828         namelen = 0;
 829         for (s = symname; s < (symname + max); s++)
 830           {
 831             if (*s == '\0')
 832               break;
 833             if (! ISPRINT (*s))
 834               goto error;
 835             namelen++;
 836           }
 837         if (*s != '\0')
 838           goto error;
 839
 840         name = bfd_alloc (abfd, strlen (sprefix) + namelen + 1);
 841         if (name == NULL)
 842           break;
 843
 844         snprintf (name, strlen (sprefix) + namelen + 1, "%s%s",
 845                   sprefix, symname);
 846         sym.name = name;
 847       }
 848
 849       sym.value = codepos;
 850       sym.the_bfd = abfd;
 851       sym.section = codesec;
 852       sym.flags = 0;
 853       sym.udata.i = 0;
 854
 855       codepos += 24;
 856
 857       if (csym != NULL)
 858         *(csym[count]) = sym;
 859
 860       count++;
 861     }
 862
 863   goto end;
 864
 865  end:
 866   if (libraries != NULL)
 867     free (libraries);
 868   if (imports != NULL)
 869     free (imports);
 870   *nsym = count;
 871   return 0;
 872
 873  error:
 874   if (libraries != NULL)
 875     free (libraries);
 876   if (imports != NULL)
 877     free (imports);
 878   *nsym = count;
 879   return -1;
 880 }
 881
 882 static long
 883 bfd_pef_parse_symbols (bfd *abfd, asymbol **csym)
 884 {
 885   unsigned long count = 0;
 886
 887   asection *codesec = NULL;
 888   unsigned char *codebuf = NULL;
 889   size_t codelen = 0;
 890
 891   asection *loadersec = NULL;
 892   unsigned char *loaderbuf = NULL;
 893   size_t loaderlen = 0;
 894
 895   codesec = bfd_get_section_by_name (abfd, "code");
 896   if (codesec != NULL)
 897     {
 898       codelen = codesec->size;
 899       codebuf = bfd_malloc (codelen);
 900       if (bfd_seek (abfd, codesec->filepos, SEEK_SET) < 0)
 901         goto end;
 902       if (bfd_bread ((void *) codebuf, codelen, abfd) != codelen)
 903         goto end;
 904     }
 905
 906   loadersec = bfd_get_section_by_name (abfd, "loader");
 907   if (loadersec != NULL)
 908     {
 909       loaderlen = loadersec->size;
 910       loaderbuf = bfd_malloc (loaderlen);
 911       if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0)
 912         goto end;
 913       if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen)
 914         goto end;
 915     }
 916
 917   count = 0;
 918   if (codesec != NULL)
 919     {
 920       long ncount = 0;
 921       bfd_pef_parse_traceback_tables (abfd, codesec, codebuf, codelen,
 922                                       &ncount, csym);
 923       count += ncount;
 924     }
 925
 926   if ((codesec != NULL) && (loadersec != NULL))
 927     {
 928       unsigned long ncount = 0;
 929       bfd_pef_parse_function_stubs
 930         (abfd, codesec, codebuf, codelen, loaderbuf, loaderlen, &ncount,
 931          (csym != NULL) ? (csym + count) : NULL);
 932       count += ncount;
 933     }
 934
 935   if (csym != NULL)
 936     csym[count] = NULL;
 937
 938  end:
 939   if (codebuf != NULL)
 940     free (codebuf);
 941
 942   if (loaderbuf != NULL)
 943     free (loaderbuf);
 944
 945   return count;
 946 }
 947
 948 static long
 949 bfd_pef_count_symbols (bfd *abfd)
 950 {
 951   return bfd_pef_parse_symbols (abfd, NULL);
 952 }
 953
 954 static long
 955 bfd_pef_get_symtab_upper_bound (bfd *abfd)
 956 {
 957   long nsyms = bfd_pef_count_symbols (abfd);
 958
 959   if (nsyms < 0)
 960     return nsyms;
 961   return ((nsyms + 1) * sizeof (asymbol *));
 962 }
 963
 964 static long
 965 bfd_pef_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 966 {
 967   long i;
 968   asymbol *syms;
 969   long ret;
 970   long nsyms = bfd_pef_count_symbols (abfd);
 971
 972   if (nsyms < 0)
 973     return nsyms;
 974
 975   syms = bfd_alloc (abfd, nsyms * sizeof (asymbol));
 976   if (syms == NULL)
 977     return -1;
 978
 979   for (i = 0; i < nsyms; i++)
 980     alocation[i] = &syms[i];
 981
 982   alocation[nsyms] = NULL;
 983
 984   ret = bfd_pef_parse_symbols (abfd, alocation);
 985   if (ret != nsyms)
 986     return 0;
 987
 988   return ret;
 989 }
 990
 991 #define bfd_pef_make_empty_symbol _bfd_generic_make_empty_symbol
 992
 993 static void
 994 bfd_pef_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 995                          asymbol *symbol,
 996                          symbol_info *ret)
 997 {
 998   bfd_symbol_info (symbol, ret);
 999 }
1000
1001 static int
1002 bfd_pef_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1003                         struct bfd_link_info *info ATTRIBUTE_UNUSED)
1004 {
1005   return 0;
1006 }
1007
1008 const bfd_target pef_vec =
1009 {
1010   "pef",                        /* Name.  */
1011   bfd_target_pef_flavour,       /* Flavour.  */
1012   BFD_ENDIAN_BIG,               /* Byteorder.  */
1013   BFD_ENDIAN_BIG,               /* Header_byteorder.  */
1014   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1015    HAS_LINENO | HAS_DEBUG |
1016    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1017   (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
1018    | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags.  */
1019   0,                            /* Symbol_leading_char.  */
1020   ' ',                          /* AR_pad_char.  */
1021   16,                           /* AR_max_namelen.  */
1022   0,                            /* match priority.  */
1023   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1024   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1025   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1026   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1027   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1028   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
1029   {                             /* bfd_check_format.  */
1030     _bfd_dummy_target,
1031     bfd_pef_object_p,           /* bfd_check_format.  */
1032     _bfd_dummy_target,
1033     _bfd_dummy_target,
1034   },
1035   {                             /* bfd_set_format.  */
1036     _bfd_bool_bfd_false_error,
1037     bfd_pef_mkobject,
1038     _bfd_bool_bfd_false_error,
1039     _bfd_bool_bfd_false_error,
1040   },
1041   {                             /* bfd_write_contents.  */
1042     _bfd_bool_bfd_false_error,
1043     _bfd_bool_bfd_true,
1044     _bfd_bool_bfd_false_error,
1045     _bfd_bool_bfd_false_error,
1046   },
1047
1048   BFD_JUMP_TABLE_GENERIC (bfd_pef),
1049   BFD_JUMP_TABLE_COPY (_bfd_generic),
1050   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1051   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1052   BFD_JUMP_TABLE_SYMBOLS (bfd_pef),
1053   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1054   BFD_JUMP_TABLE_WRITE (bfd_pef),
1055   BFD_JUMP_TABLE_LINK (bfd_pef),
1056   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1057
1058   NULL,
1059
1060   NULL
1061 };
1062
1063 #define bfd_pef_xlib_close_and_cleanup              _bfd_generic_close_and_cleanup
1064 #define bfd_pef_xlib_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
1065 #define bfd_pef_xlib_new_section_hook               _bfd_generic_new_section_hook
1066 #define bfd_pef_xlib_get_section_contents           _bfd_generic_get_section_contents
1067 #define bfd_pef_xlib_set_section_contents           _bfd_generic_set_section_contents
1068 #define bfd_pef_xlib_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
1069 #define bfd_pef_xlib_set_section_contents_in_window _bfd_generic_set_section_contents_in_window
1070
1071 static int
1072 bfd_pef_xlib_read_header (bfd *abfd, bfd_pef_xlib_header *header)
1073 {
1074   unsigned char buf[80];
1075
1076   bfd_seek (abfd, 0, SEEK_SET);
1077
1078   if (bfd_bread ((void *) buf, sizeof buf, abfd) != sizeof buf)
1079     return -1;
1080
1081   header->tag1 = bfd_getb32 (buf);
1082   header->tag2 = bfd_getb32 (buf + 4);
1083   header->current_format = bfd_getb32 (buf + 8);
1084   header->container_strings_offset = bfd_getb32 (buf + 12);
1085   header->export_hash_offset = bfd_getb32 (buf + 16);
1086   header->export_key_offset = bfd_getb32 (buf + 20);
1087   header->export_symbol_offset = bfd_getb32 (buf + 24);
1088   header->export_names_offset = bfd_getb32 (buf + 28);
1089   header->export_hash_table_power = bfd_getb32 (buf + 32);
1090   header->exported_symbol_count = bfd_getb32 (buf + 36);
1091   header->frag_name_offset = bfd_getb32 (buf + 40);
1092   header->frag_name_length = bfd_getb32 (buf + 44);
1093   header->dylib_path_offset = bfd_getb32 (buf + 48);
1094   header->dylib_path_length = bfd_getb32 (buf + 52);
1095   header->cpu_family = bfd_getb32 (buf + 56);
1096   header->cpu_model = bfd_getb32 (buf + 60);
1097   header->date_time_stamp = bfd_getb32 (buf + 64);
1098   header->current_version = bfd_getb32 (buf + 68);
1099   header->old_definition_version = bfd_getb32 (buf + 72);
1100   header->old_implementation_version = bfd_getb32 (buf + 76);
1101
1102   return 0;
1103 }
1104
1105 static int
1106 bfd_pef_xlib_scan (bfd *abfd, bfd_pef_xlib_header *header)
1107 {
1108   bfd_pef_xlib_data_struct *mdata = NULL;
1109
1110   mdata = bfd_alloc (abfd, sizeof (* mdata));
1111   if (mdata == NULL)
1112     return -1;
1113
1114   mdata->header = *header;
1115
1116   abfd->flags = (abfd->xvec->object_flags
1117                  | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
1118
1119   abfd->tdata.pef_xlib_data = mdata;
1120
1121   return 0;
1122 }
1123
1124 static const bfd_target *
1125 bfd_pef_xlib_object_p (bfd *abfd)
1126 {
1127   bfd_pef_xlib_header header;
1128
1129   if (bfd_pef_xlib_read_header (abfd, &header) != 0)
1130     {
1131       bfd_set_error (bfd_error_wrong_format);
1132       return NULL;
1133     }
1134
1135   if ((header.tag1 != BFD_PEF_XLIB_TAG1)
1136       || ((header.tag2 != BFD_PEF_VLIB_TAG2)
1137           && (header.tag2 != BFD_PEF_BLIB_TAG2)))
1138     {
1139       bfd_set_error (bfd_error_wrong_format);
1140       return NULL;
1141     }
1142
1143   if (bfd_pef_xlib_scan (abfd, &header) != 0)
1144     {
1145       bfd_set_error (bfd_error_wrong_format);
1146       return NULL;
1147     }
1148
1149   return abfd->xvec;
1150 }
1151
1152 const bfd_target pef_xlib_vec =
1153 {
1154   "pef-xlib",                   /* Name.  */
1155   bfd_target_pef_xlib_flavour,  /* Flavour.  */
1156   BFD_ENDIAN_BIG,               /* Byteorder */
1157   BFD_ENDIAN_BIG,               /* Header_byteorder.  */
1158   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1159    HAS_LINENO | HAS_DEBUG |
1160    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1161   (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
1162    | SEC_ROM | SEC_HAS_CONTENTS),/* Section_flags.  */
1163   0,                            /* Symbol_leading_char.  */
1164   ' ',                          /* AR_pad_char.  */
1165   16,                           /* AR_max_namelen.  */
1166   0,                            /* match priority.  */
1167   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1168   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1169   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1170   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1171   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1172   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
1173   {                             /* bfd_check_format.  */
1174     _bfd_dummy_target,
1175     bfd_pef_xlib_object_p,      /* bfd_check_format.  */
1176     _bfd_dummy_target,
1177     _bfd_dummy_target,
1178   },
1179   {                             /* bfd_set_format.  */
1180     _bfd_bool_bfd_false_error,
1181     bfd_pef_mkobject,
1182     _bfd_bool_bfd_false_error,
1183     _bfd_bool_bfd_false_error,
1184   },
1185   {                             /* bfd_write_contents.  */
1186     _bfd_bool_bfd_false_error,
1187     _bfd_bool_bfd_true,
1188     _bfd_bool_bfd_false_error,
1189     _bfd_bool_bfd_false_error,
1190   },
1191
1192   BFD_JUMP_TABLE_GENERIC (bfd_pef_xlib),
1193   BFD_JUMP_TABLE_COPY (_bfd_generic),
1194   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1195   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1196   BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
1197   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1198   BFD_JUMP_TABLE_WRITE (_bfd_nowrite),
1199   BFD_JUMP_TABLE_LINK (_bfd_nolink),
1200   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1201
1202   NULL,
1203
1204   NULL
1205 };