bfd/pef.c

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