bfd/pef.c

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