bfd/pef.c

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