bfd/pef.c

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