binutils/od-macho.c

   1 /* od-macho.c -- dump information about an Mach-O object file.
   2    Copyright (C) 2011-2018 Free Software Foundation, Inc.
   3    Written by Tristan Gingold, Adacore.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include <stddef.h>
  24 #include <time.h>
  25 #include "safe-ctype.h"
  26 #include "bfd.h"
  27 #include "objdump.h"
  28 #include "bucomm.h"
  29 #include "dwarf.h"
  30 #include "bfdlink.h"
  31 #include "mach-o.h"
  32 #include "mach-o/external.h"
  33 #include "mach-o/codesign.h"
  34 #include "mach-o/unwind.h"
  35
  36 /* Index of the options in the options[] array.  */
  37 #define OPT_HEADER 0
  38 #define OPT_SECTION 1
  39 #define OPT_MAP 2
  40 #define OPT_LOAD 3
  41 #define OPT_DYSYMTAB 4
  42 #define OPT_CODESIGN 5
  43 #define OPT_SEG_SPLIT_INFO 6
  44 #define OPT_COMPACT_UNWIND 7
  45 #define OPT_FUNCTION_STARTS 8
  46 #define OPT_DATA_IN_CODE 9
  47 #define OPT_TWOLEVEL_HINTS 10
  48 #define OPT_DYLD_INFO 11
  49
  50 /* List of actions.  */
  51 static struct objdump_private_option options[] =
  52   {
  53     { "header", 0 },
  54     { "section", 0 },
  55     { "map", 0 },
  56     { "load", 0 },
  57     { "dysymtab", 0 },
  58     { "codesign", 0 },
  59     { "seg_split_info", 0 },
  60     { "compact_unwind", 0 },
  61     { "function_starts", 0 },
  62     { "data_in_code", 0 },
  63     { "twolevel_hints", 0 },
  64     { "dyld_info", 0 },
  65     { NULL, 0 }
  66   };
  67
  68 /* Display help.  */
  69
  70 static void
  71 mach_o_help (FILE *stream)
  72 {
  73   fprintf (stream, _("\
  74 For Mach-O files:\n\
  75   header           Display the file header\n\
  76   section          Display the segments and sections commands\n\
  77   map              Display the section map\n\
  78   load             Display the load commands\n\
  79   dysymtab         Display the dynamic symbol table\n\
  80   codesign         Display code signature\n\
  81   seg_split_info   Display segment split info\n\
  82   compact_unwind   Display compact unwinding info\n\
  83   function_starts  Display start address of functions\n\
  84   data_in_code     Display data in code entries\n\
  85   twolevel_hints   Display the two-level namespace lookup hints table\n\
  86   dyld_info        Display dyld information\n\
  87 "));
  88 }
  89
  90 /* Return TRUE if ABFD is handled.  */
  91
  92 static int
  93 mach_o_filter (bfd *abfd)
  94 {
  95   return bfd_get_flavour (abfd) == bfd_target_mach_o_flavour;
  96 }
  97 \f
  98 static const bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] =
  99 {
 100   { "vax", BFD_MACH_O_CPU_TYPE_VAX },
 101   { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 },
 102   { "i386", BFD_MACH_O_CPU_TYPE_I386 },
 103   { "mips", BFD_MACH_O_CPU_TYPE_MIPS },
 104   { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 },
 105   { "hppa", BFD_MACH_O_CPU_TYPE_HPPA },
 106   { "arm", BFD_MACH_O_CPU_TYPE_ARM },
 107   { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 },
 108   { "sparc", BFD_MACH_O_CPU_TYPE_SPARC },
 109   { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA },
 110   { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC },
 111   { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 },
 112   { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 },
 113   { "arm64", BFD_MACH_O_CPU_TYPE_ARM64 },
 114   { NULL, 0}
 115 };
 116
 117 static const bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] =
 118 {
 119   { "object", BFD_MACH_O_MH_OBJECT },
 120   { "execute", BFD_MACH_O_MH_EXECUTE },
 121   { "fvmlib", BFD_MACH_O_MH_FVMLIB },
 122   { "core", BFD_MACH_O_MH_CORE },
 123   { "preload", BFD_MACH_O_MH_PRELOAD },
 124   { "dylib", BFD_MACH_O_MH_DYLIB },
 125   { "dylinker", BFD_MACH_O_MH_DYLINKER },
 126   { "bundle", BFD_MACH_O_MH_BUNDLE },
 127   { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB },
 128   { "dym", BFD_MACH_O_MH_DSYM },
 129   { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE },
 130   { NULL, 0}
 131 };
 132
 133 static const bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] =
 134 {
 135   { "noundefs", BFD_MACH_O_MH_NOUNDEFS },
 136   { "incrlink", BFD_MACH_O_MH_INCRLINK },
 137   { "dyldlink", BFD_MACH_O_MH_DYLDLINK },
 138   { "bindatload", BFD_MACH_O_MH_BINDATLOAD },
 139   { "prebound", BFD_MACH_O_MH_PREBOUND },
 140   { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS },
 141   { "lazy_init", BFD_MACH_O_MH_LAZY_INIT },
 142   { "twolevel", BFD_MACH_O_MH_TWOLEVEL },
 143   { "force_flat", BFD_MACH_O_MH_FORCE_FLAT },
 144   { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS },
 145   { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING },
 146   { "prebindable", BFD_MACH_O_MH_PREBINDABLE },
 147   { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND },
 148   { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS },
 149   { "canonical", BFD_MACH_O_MH_CANONICAL },
 150   { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES },
 151   { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK },
 152   { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION },
 153   { "root_safe", BFD_MACH_O_MH_ROOT_SAFE },
 154   { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE },
 155   { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS },
 156   { "pie", BFD_MACH_O_MH_PIE },
 157   { "dead_strippable_dylib", BFD_MACH_O_MH_DEAD_STRIPPABLE_DYLIB },
 158   { "has_tlv", BFD_MACH_O_MH_HAS_TLV_DESCRIPTORS },
 159   { "no_heap_execution", BFD_MACH_O_MH_NO_HEAP_EXECUTION },
 160   { "app_extension_safe", BFD_MACH_O_MH_APP_EXTENSION_SAFE },
 161   { NULL, 0}
 162 };
 163
 164 static const bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] =
 165 {
 166   { "segment", BFD_MACH_O_LC_SEGMENT},
 167   { "symtab", BFD_MACH_O_LC_SYMTAB},
 168   { "symseg", BFD_MACH_O_LC_SYMSEG},
 169   { "thread", BFD_MACH_O_LC_THREAD},
 170   { "unixthread", BFD_MACH_O_LC_UNIXTHREAD},
 171   { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB},
 172   { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB},
 173   { "ident", BFD_MACH_O_LC_IDENT},
 174   { "fvmfile", BFD_MACH_O_LC_FVMFILE},
 175   { "prepage", BFD_MACH_O_LC_PREPAGE},
 176   { "dysymtab", BFD_MACH_O_LC_DYSYMTAB},
 177   { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB},
 178   { "id_dylib", BFD_MACH_O_LC_ID_DYLIB},
 179   { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER},
 180   { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER},
 181   { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB},
 182   { "routines", BFD_MACH_O_LC_ROUTINES},
 183   { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK},
 184   { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA},
 185   { "sub_client", BFD_MACH_O_LC_SUB_CLIENT},
 186   { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY},
 187   { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS},
 188   { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM},
 189   { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB},
 190   { "segment_64", BFD_MACH_O_LC_SEGMENT_64},
 191   { "routines_64", BFD_MACH_O_LC_ROUTINES_64},
 192   { "uuid", BFD_MACH_O_LC_UUID},
 193   { "rpath", BFD_MACH_O_LC_RPATH},
 194   { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE},
 195   { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO},
 196   { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB},
 197   { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB},
 198   { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO},
 199   { "dyld_info", BFD_MACH_O_LC_DYLD_INFO},
 200   { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB},
 201   { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX},
 202   { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS},
 203   { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS},
 204   { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT},
 205   { "main", BFD_MACH_O_LC_MAIN},
 206   { "data_in_code", BFD_MACH_O_LC_DATA_IN_CODE},
 207   { "source_version", BFD_MACH_O_LC_SOURCE_VERSION},
 208   { "dylib_code_sign_drs", BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS},
 209   { "encryption_info_64", BFD_MACH_O_LC_ENCRYPTION_INFO_64},
 210   { "linker_options", BFD_MACH_O_LC_LINKER_OPTIONS},
 211   { "linker_optimization_hint", BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT},
 212   { NULL, 0}
 213 };
 214
 215 static const bfd_mach_o_xlat_name bfd_mach_o_thread_x86_name[] =
 216 {
 217   { "thread_state32", BFD_MACH_O_x86_THREAD_STATE32},
 218   { "float_state32", BFD_MACH_O_x86_FLOAT_STATE32},
 219   { "exception_state32", BFD_MACH_O_x86_EXCEPTION_STATE32},
 220   { "thread_state64", BFD_MACH_O_x86_THREAD_STATE64},
 221   { "float_state64", BFD_MACH_O_x86_FLOAT_STATE64},
 222   { "exception_state64", BFD_MACH_O_x86_EXCEPTION_STATE64},
 223   { "thread_state", BFD_MACH_O_x86_THREAD_STATE},
 224   { "float_state", BFD_MACH_O_x86_FLOAT_STATE},
 225   { "exception_state", BFD_MACH_O_x86_EXCEPTION_STATE},
 226   { "debug_state32", BFD_MACH_O_x86_DEBUG_STATE32},
 227   { "debug_state64", BFD_MACH_O_x86_DEBUG_STATE64},
 228   { "debug_state", BFD_MACH_O_x86_DEBUG_STATE},
 229   { "state_none", BFD_MACH_O_x86_THREAD_STATE_NONE},
 230   { NULL, 0 }
 231 };
 232 \f
 233 static void
 234 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table,
 235                         unsigned long val)
 236 {
 237   int first = 1;
 238
 239   for (; table->name; table++)
 240     {
 241       if (table->val & val)
 242         {
 243           if (!first)
 244             printf ("+");
 245           printf ("%s", table->name);
 246           val &= ~table->val;
 247           first = 0;
 248         }
 249     }
 250   if (val)
 251     {
 252       if (!first)
 253         printf ("+");
 254       printf ("0x%lx", val);
 255       return;
 256     }
 257   if (first)
 258     printf ("-");
 259 }
 260
 261 /* Print a bfd_uint64_t, using a platform independent style.  */
 262
 263 static void
 264 printf_uint64 (bfd_uint64_t v)
 265 {
 266   printf ("0x%08lx%08lx",
 267           (unsigned long)((v >> 16) >> 16), (unsigned long)(v & 0xffffffffUL));
 268 }
 269
 270 static const char *
 271 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name *table,
 272                              unsigned long val)
 273 {
 274   for (; table->name; table++)
 275     if (table->val == val)
 276       return table->name;
 277   return NULL;
 278 }
 279
 280 static const char *
 281 bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val)
 282 {
 283   const char *res = bfd_mach_o_get_name_or_null (table, val);
 284
 285   if (res == NULL)
 286     return "*UNKNOWN*";
 287   else
 288     return res;
 289 }
 290
 291 static void
 292 dump_header (bfd *abfd)
 293 {
 294   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 295   bfd_mach_o_header *h = &mdata->header;
 296
 297   fputs (_("Mach-O header:\n"), stdout);
 298   printf (_(" magic     : %08lx\n"), h->magic);
 299   printf (_(" cputype   : %08lx (%s)\n"), h->cputype,
 300           bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype));
 301   printf (_(" cpusubtype: %08lx\n"), h->cpusubtype);
 302   printf (_(" filetype  : %08lx (%s)\n"),
 303           h->filetype,
 304           bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype));
 305   printf (_(" ncmds     : %08lx (%lu)\n"), h->ncmds, h->ncmds);
 306   printf (_(" sizeofcmds: %08lx (%lu)\n"), h->sizeofcmds, h->sizeofcmds);
 307   printf (_(" flags     : %08lx ("), h->flags);
 308   bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags);
 309   fputs (_(")\n"), stdout);
 310   printf (_(" reserved  : %08x\n"), h->reserved);
 311   putchar ('\n');
 312 }
 313
 314 static void
 315 disp_segment_prot (unsigned int prot)
 316 {
 317   putchar (prot & BFD_MACH_O_PROT_READ ? 'r' : '-');
 318   putchar (prot & BFD_MACH_O_PROT_WRITE ? 'w' : '-');
 319   putchar (prot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-');
 320 }
 321
 322 static void
 323 dump_section_map (bfd *abfd)
 324 {
 325   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 326   bfd_mach_o_load_command *cmd;
 327   unsigned int sec_nbr = 0;
 328
 329   fputs (_("Segments and Sections:\n"), stdout);
 330   fputs (_(" #: Segment name     Section name     Address\n"), stdout);
 331
 332   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
 333     {
 334       bfd_mach_o_segment_command *seg;
 335       bfd_mach_o_section *sec;
 336
 337       if (cmd->type != BFD_MACH_O_LC_SEGMENT
 338           && cmd->type != BFD_MACH_O_LC_SEGMENT_64)
 339         continue;
 340
 341       seg = &cmd->command.segment;
 342
 343       printf ("[Segment %-16s ", seg->segname);
 344       printf_vma (seg->vmaddr);
 345       putchar ('-');
 346       printf_vma  (seg->vmaddr + seg->vmsize - 1);
 347       putchar (' ');
 348       disp_segment_prot (seg->initprot);
 349       printf ("]\n");
 350
 351       for (sec = seg->sect_head; sec != NULL; sec = sec->next)
 352         {
 353           printf ("%02u: %-16s %-16s ", ++sec_nbr,
 354                   sec->segname, sec->sectname);
 355           printf_vma (sec->addr);
 356           putchar (' ');
 357           printf_vma  (sec->size);
 358           printf (" %08lx\n", sec->flags);
 359         }
 360     }
 361 }
 362
 363 static void
 364 dump_section_header (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_section *sec)
 365 {
 366   printf (" Section: %-16s %-16s (bfdname: %s)\n",
 367            sec->sectname, sec->segname, sec->bfdsection->name);
 368   printf ("  addr: ");
 369   printf_vma (sec->addr);
 370   printf (" size: ");
 371   printf_vma (sec->size);
 372   printf (" offset: ");
 373   printf_vma (sec->offset);
 374   printf ("\n");
 375   printf ("  align: %ld", sec->align);
 376   printf ("  nreloc: %lu  reloff: ", sec->nreloc);
 377   printf_vma (sec->reloff);
 378   printf ("\n");
 379   printf ("  flags: %08lx (type: %s", sec->flags,
 380           bfd_mach_o_get_name (bfd_mach_o_section_type_name,
 381                                sec->flags & BFD_MACH_O_SECTION_TYPE_MASK));
 382   printf (" attr: ");
 383   bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name,
 384                           sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK);
 385   printf (")\n");
 386   switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 387     {
 388     case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 389     case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 390     case BFD_MACH_O_S_SYMBOL_STUBS:
 391       printf ("  first indirect sym: %lu", sec->reserved1);
 392       printf (" (%u entries)",
 393                bfd_mach_o_section_get_nbr_indirect (abfd, sec));
 394       break;
 395     default:
 396       printf ("  reserved1: 0x%lx", sec->reserved1);
 397       break;
 398     }
 399   switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 400     {
 401     case BFD_MACH_O_S_SYMBOL_STUBS:
 402       printf ("  stub size: %lu", sec->reserved2);
 403       break;
 404     default:
 405       printf ("  reserved2: 0x%lx", sec->reserved2);
 406       break;
 407     }
 408   printf ("  reserved3: 0x%lx\n", sec->reserved3);
 409 }
 410
 411 static void
 412 dump_segment (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)
 413 {
 414   bfd_mach_o_segment_command *seg = &cmd->command.segment;
 415   bfd_mach_o_section *sec;
 416
 417   printf ("     name: %16s", *seg->segname ? seg->segname : "*none*");
 418   printf ("  nsects: %lu", seg->nsects);
 419   printf ("  flags: %lx", seg->flags);
 420   printf ("  initprot: ");
 421   disp_segment_prot (seg->initprot);
 422   printf ("  maxprot: ");
 423   disp_segment_prot (seg->maxprot);
 424   printf ("\n");
 425   printf ("   vmaddr: ");
 426   printf_vma (seg->vmaddr);
 427   printf ("   vmsize: ");
 428   printf_vma  (seg->vmsize);
 429   printf ("\n");
 430   printf ("  fileoff: ");
 431   printf_vma (seg->fileoff);
 432   printf (" filesize: ");
 433   printf_vma ((bfd_vma)seg->filesize);
 434   printf (" endoff: ");
 435   printf_vma ((bfd_vma)(seg->fileoff + seg->filesize));
 436   printf ("\n");
 437   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
 438     dump_section_header (abfd, sec);
 439 }
 440
 441 static void
 442 dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose)
 443 {
 444   bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
 445   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 446   unsigned int i;
 447
 448   printf ("              local symbols: idx: %10lu  num: %-8lu",
 449           dysymtab->ilocalsym, dysymtab->nlocalsym);
 450   printf (" (nxtidx: %lu)\n",
 451           dysymtab->ilocalsym + dysymtab->nlocalsym);
 452   printf ("           external symbols: idx: %10lu  num: %-8lu",
 453           dysymtab->iextdefsym, dysymtab->nextdefsym);
 454   printf (" (nxtidx: %lu)\n",
 455           dysymtab->iextdefsym + dysymtab->nextdefsym);
 456   printf ("          undefined symbols: idx: %10lu  num: %-8lu",
 457           dysymtab->iundefsym, dysymtab->nundefsym);
 458   printf (" (nxtidx: %lu)\n",
 459           dysymtab->iundefsym + dysymtab->nundefsym);
 460   printf ("           table of content: off: 0x%08lx  num: %-8lu",
 461           dysymtab->tocoff, dysymtab->ntoc);
 462   printf (" (endoff: 0x%08lx)\n",
 463           dysymtab->tocoff + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE);
 464   printf ("               module table: off: 0x%08lx  num: %-8lu",
 465           dysymtab->modtaboff, dysymtab->nmodtab);
 466   printf (" (endoff: 0x%08lx)\n",
 467           dysymtab->modtaboff + dysymtab->nmodtab
 468           * (mdata->header.version == 2 ?
 469              BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE));
 470   printf ("   external reference table: off: 0x%08lx  num: %-8lu",
 471           dysymtab->extrefsymoff, dysymtab->nextrefsyms);
 472   printf (" (endoff: 0x%08lx)\n",
 473           dysymtab->extrefsymoff
 474           + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE);
 475   printf ("      indirect symbol table: off: 0x%08lx  num: %-8lu",
 476           dysymtab->indirectsymoff, dysymtab->nindirectsyms);
 477   printf (" (endoff: 0x%08lx)\n",
 478           dysymtab->indirectsymoff
 479           + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE);
 480   printf ("  external relocation table: off: 0x%08lx  num: %-8lu",
 481           dysymtab->extreloff, dysymtab->nextrel);
 482   printf (" (endoff: 0x%08lx)\n",
 483           dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE);
 484   printf ("     local relocation table: off: 0x%08lx  num: %-8lu",
 485           dysymtab->locreloff, dysymtab->nlocrel);
 486   printf (" (endoff: 0x%08lx)\n",
 487           dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE);
 488
 489   if (!verbose)
 490     return;
 491
 492   if (dysymtab->ntoc > 0
 493       || dysymtab->nindirectsyms > 0
 494       || dysymtab->nextrefsyms > 0)
 495     {
 496       /* Try to read the symbols to display the toc or indirect symbols.  */
 497       bfd_mach_o_read_symtab_symbols (abfd);
 498     }
 499   else if (dysymtab->nmodtab > 0)
 500     {
 501       /* Try to read the strtab to display modules name.  */
 502       bfd_mach_o_read_symtab_strtab (abfd);
 503     }
 504
 505   for (i = 0; i < dysymtab->nmodtab; i++)
 506     {
 507       bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i];
 508       printf ("  module %u:\n", i);
 509       printf ("   name: %lu", module->module_name_idx);
 510       if (mdata->symtab && mdata->symtab->strtab)
 511         printf (": %s",
 512                  mdata->symtab->strtab + module->module_name_idx);
 513       printf ("\n");
 514       printf ("   extdefsym: idx: %8lu  num: %lu\n",
 515                module->iextdefsym, module->nextdefsym);
 516       printf ("      refsym: idx: %8lu  num: %lu\n",
 517                module->irefsym, module->nrefsym);
 518       printf ("    localsym: idx: %8lu  num: %lu\n",
 519                module->ilocalsym, module->nlocalsym);
 520       printf ("      extrel: idx: %8lu  num: %lu\n",
 521                module->iextrel, module->nextrel);
 522       printf ("        init: idx: %8u  num: %u\n",
 523                module->iinit, module->ninit);
 524       printf ("        term: idx: %8u  num: %u\n",
 525                module->iterm, module->nterm);
 526       printf ("   objc_module_info: addr: ");
 527       printf_vma (module->objc_module_info_addr);
 528       printf ("  size: %lu\n", module->objc_module_info_size);
 529     }
 530
 531   if (dysymtab->ntoc > 0)
 532     {
 533       bfd_mach_o_symtab_command *symtab = mdata->symtab;
 534
 535       printf ("  table of content: (symbol/module)\n");
 536       for (i = 0; i < dysymtab->ntoc; i++)
 537         {
 538           bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i];
 539
 540           printf ("   %4u: ", i);
 541           if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms)
 542             {
 543               const char *name = symtab->symbols[toc->symbol_index].symbol.name;
 544               printf ("%s (%lu)", name ? name : "*invalid*",
 545                        toc->symbol_index);
 546             }
 547           else
 548             printf ("%lu", toc->symbol_index);
 549
 550           printf (" / ");
 551           if (symtab && symtab->strtab
 552               && toc->module_index < dysymtab->nmodtab)
 553             {
 554               bfd_mach_o_dylib_module *mod;
 555               mod = &dysymtab->dylib_module[toc->module_index];
 556               printf ("%s (%lu)",
 557                        symtab->strtab + mod->module_name_idx,
 558                        toc->module_index);
 559             }
 560           else
 561             printf ("%lu", toc->module_index);
 562
 563           printf ("\n");
 564         }
 565     }
 566
 567   if (dysymtab->nindirectsyms != 0)
 568     {
 569       printf ("  indirect symbols:\n");
 570
 571       for (i = 0; i < mdata->nsects; i++)
 572         {
 573           bfd_mach_o_section *sec = mdata->sections[i];
 574           unsigned int j, first, last;
 575           bfd_mach_o_symtab_command *symtab = mdata->symtab;
 576           bfd_vma addr;
 577           bfd_vma entry_size;
 578
 579           switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 580             {
 581             case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 582             case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 583             case BFD_MACH_O_S_SYMBOL_STUBS:
 584               first = sec->reserved1;
 585               last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
 586               addr = sec->addr;
 587               entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
 588               printf ("  for section %s.%s:\n",
 589                        sec->segname, sec->sectname);
 590               for (j = first; j < last; j++)
 591                 {
 592                   unsigned int isym = dysymtab->indirect_syms[j];
 593
 594                   printf ("   ");
 595                   printf_vma (addr);
 596                   printf (" %5u: 0x%08x", j, isym);
 597                   if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL)
 598                     printf (" LOCAL");
 599                   if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS)
 600                     printf (" ABSOLUTE");
 601                   if (symtab && symtab->symbols
 602                       && isym < symtab->nsyms
 603                       && symtab->symbols[isym].symbol.name)
 604                     printf (" %s", symtab->symbols[isym].symbol.name);
 605                   printf ("\n");
 606                   addr += entry_size;
 607                 }
 608               break;
 609             default:
 610               break;
 611             }
 612         }
 613     }
 614   if (dysymtab->nextrefsyms > 0)
 615     {
 616       bfd_mach_o_symtab_command *symtab = mdata->symtab;
 617
 618       printf ("  external reference table: (symbol flags)\n");
 619       for (i = 0; i < dysymtab->nextrefsyms; i++)
 620         {
 621           bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i];
 622
 623           printf ("   %4u: %5lu 0x%02lx", i, ref->isym, ref->flags);
 624           if (symtab && symtab->symbols
 625               && ref->isym < symtab->nsyms
 626               && symtab->symbols[ref->isym].symbol.name)
 627             printf (" %s", symtab->symbols[ref->isym].symbol.name);
 628           printf ("\n");
 629         }
 630     }
 631
 632 }
 633
 634 static bfd_boolean
 635 load_and_dump (bfd *abfd, ufile_ptr off, unsigned int len,
 636                void (*dump)(bfd *abfd, unsigned char *buf, unsigned int len,
 637                             ufile_ptr off))
 638 {
 639   unsigned char *buf;
 640
 641   if (len == 0)
 642     return TRUE;
 643
 644   buf = xmalloc (len);
 645
 646   if (bfd_seek (abfd, off, SEEK_SET) == 0
 647       && bfd_bread (buf, len, abfd) == len)
 648     dump (abfd, buf, len, off);
 649   else
 650     return FALSE;
 651
 652   free (buf);
 653   return TRUE;
 654 }
 655
 656 static const bfd_mach_o_xlat_name bfd_mach_o_dyld_rebase_type_name[] =
 657 {
 658   { "pointer",      BFD_MACH_O_REBASE_TYPE_POINTER },
 659   { "text_abs32",   BFD_MACH_O_REBASE_TYPE_TEXT_ABSOLUTE32 },
 660   { "text_pcrel32", BFD_MACH_O_REBASE_TYPE_TEXT_PCREL32 },
 661   { NULL, 0 }
 662 };
 663
 664 static void
 665 dump_dyld_info_rebase (bfd *abfd, unsigned char *buf, unsigned int len,
 666                        ufile_ptr off ATTRIBUTE_UNUSED)
 667 {
 668   unsigned int i;
 669   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 670   unsigned int ptrsize = mdata->header.version == 2 ? 8 : 4;
 671
 672   for (i = 0; i < len; )
 673     {
 674       unsigned char b = buf[i++];
 675       unsigned char imm = b & BFD_MACH_O_REBASE_IMMEDIATE_MASK;
 676       bfd_vma leb;
 677       unsigned int leblen;
 678
 679       printf ("   [0x%04x] 0x%02x: ", i, b);
 680       switch (b & BFD_MACH_O_REBASE_OPCODE_MASK)
 681         {
 682         case BFD_MACH_O_REBASE_OPCODE_DONE:
 683           printf ("done\n");
 684           return;
 685         case BFD_MACH_O_REBASE_OPCODE_SET_TYPE_IMM:
 686           printf ("set_type %s\n",
 687                   bfd_mach_o_get_name (bfd_mach_o_dyld_rebase_type_name, imm));
 688           break;
 689         case BFD_MACH_O_REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
 690           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 691           printf ("set segment: %u and offset: 0x%08x\n",
 692                   imm, (unsigned) leb);
 693           i += leblen;
 694           break;
 695         case BFD_MACH_O_REBASE_OPCODE_ADD_ADDR_ULEB:
 696           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 697           printf ("add addr uleb: 0x%08x\n", (unsigned) leb);
 698           i += leblen;
 699           break;
 700         case BFD_MACH_O_REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
 701           printf ("add addr imm scaled: %u\n", imm * ptrsize);
 702           break;
 703         case BFD_MACH_O_REBASE_OPCODE_DO_REBASE_IMM_TIMES:
 704           printf ("rebase imm times: %u\n", imm);
 705           break;
 706         case BFD_MACH_O_REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
 707           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 708           printf ("rebase uleb times: %u\n", (unsigned) leb);
 709           i += leblen;
 710           break;
 711         case BFD_MACH_O_REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
 712           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 713           printf ("rebase add addr uleb: %u\n", (unsigned) leb);
 714           i += leblen;
 715           break;
 716         case BFD_MACH_O_REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
 717           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 718           printf ("rebase uleb times (%u)", (unsigned) leb);
 719           i += leblen;
 720           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 721           printf (" skipping uleb (%u)\n", (unsigned) leb);
 722           i += leblen;
 723           break;
 724         default:
 725           printf ("unknown\n");
 726           return;
 727         }
 728     }
 729   printf ("   rebase commands without end!\n");
 730 }
 731
 732 static void
 733 dump_dyld_info_bind (bfd *abfd, unsigned char *buf, unsigned int len,
 734                      ufile_ptr off ATTRIBUTE_UNUSED)
 735 {
 736   unsigned int i;
 737   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 738   unsigned int ptrsize = mdata->header.version == 2 ? 8 : 4;
 739
 740   for (i = 0; i < len; )
 741     {
 742       unsigned char b = buf[i++];
 743       unsigned char imm = b & BFD_MACH_O_BIND_IMMEDIATE_MASK;
 744       bfd_vma leb;
 745       unsigned int leblen;
 746
 747       printf ("   [0x%04x] 0x%02x: ", i, b);
 748       switch (b & BFD_MACH_O_BIND_OPCODE_MASK)
 749         {
 750         case BFD_MACH_O_BIND_OPCODE_DONE:
 751           printf ("done\n");
 752           return;
 753         case BFD_MACH_O_BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
 754           printf ("set dylib ordinal imm: %u\n", imm);
 755           break;
 756         case BFD_MACH_O_BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
 757           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 758           printf ("set dylib ordinal uleb: %u\n", imm);
 759           i += leblen;
 760           break;
 761         case BFD_MACH_O_BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
 762           imm = (imm != 0) ? imm | BFD_MACH_O_BIND_OPCODE_MASK : imm;
 763           printf ("set dylib special imm: %d\n", imm);
 764           break;
 765         case BFD_MACH_O_BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
 766           printf ("set symbol trailing flags imm: 0x%02x, ", imm);
 767           for (; i < len && buf[i] != 0; i++)
 768             putchar (buf[i] >= ' ' && buf[i] < 0x7f ? buf[i] : '?');
 769           putchar ('\n');
 770           i++;
 771           break;
 772         case BFD_MACH_O_BIND_OPCODE_SET_TYPE_IMM:
 773           /* Kludge: use the same table as rebase type.  */
 774           printf ("set_type %s\n",
 775                   bfd_mach_o_get_name (bfd_mach_o_dyld_rebase_type_name, imm));
 776           break;
 777         case BFD_MACH_O_BIND_OPCODE_SET_ADDEND_SLEB:
 778           {
 779             bfd_signed_vma svma;
 780             svma = read_leb128 (buf + i, &leblen, 0, buf + len);
 781             printf ("set addend sleb: 0x%08x\n", (unsigned) svma);
 782             i += leblen;
 783           }
 784           break;
 785         case BFD_MACH_O_BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
 786           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 787           printf ("set segment: %u and offset: 0x%08x\n",
 788                   imm, (unsigned) leb);
 789           i += leblen;
 790           break;
 791         case BFD_MACH_O_BIND_OPCODE_ADD_ADDR_ULEB:
 792           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 793           printf ("add addr uleb: 0x%08x\n", (unsigned) leb);
 794           i += leblen;
 795           break;
 796         case BFD_MACH_O_BIND_OPCODE_DO_BIND:
 797           printf ("do bind\n");
 798           break;
 799         case BFD_MACH_O_BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
 800           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 801           printf ("do bind add addr uleb: 0x%08x\n", (unsigned) leb);
 802           i += leblen;
 803           break;
 804         case BFD_MACH_O_BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
 805           printf ("do bind add addr imm scaled: %u\n", imm * ptrsize);
 806           break;
 807         case BFD_MACH_O_BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
 808           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 809           printf ("do bind uleb times (%u)", (unsigned) leb);
 810           i += leblen;
 811           leb = read_leb128 (buf + i, &leblen, 0, buf + len);
 812           printf (" skipping uleb (%u)\n", (unsigned) leb);
 813           i += leblen;
 814           break;
 815         default:
 816           printf ("unknown\n");
 817           return;
 818         }
 819     }
 820   printf ("   bind commands without end!\n");
 821 }
 822
 823 struct export_info_data
 824 {
 825   const unsigned char *name;
 826   struct export_info_data *next;
 827 };
 828
 829 static void
 830 dump_dyld_info_export_1 (bfd *abfd, unsigned char *buf, unsigned int len,
 831                          unsigned int off, struct export_info_data *parent,
 832                          struct export_info_data *base)
 833 {
 834   bfd_vma size;
 835   unsigned int leblen;
 836   unsigned int child_count;
 837   unsigned int i;
 838
 839   size = read_leb128 (buf + off, &leblen, 0, buf + len);
 840   off += leblen;
 841
 842   if (size != 0)
 843     {
 844       bfd_vma flags;
 845       struct export_info_data *d;
 846
 847       flags = read_leb128 (buf + off, &leblen, 0, buf + len);
 848       off += leblen;
 849
 850       fputs ("   ", stdout);
 851       switch (flags & BFD_MACH_O_EXPORT_SYMBOL_FLAGS_KIND_MASK)
 852         {
 853         case BFD_MACH_O_EXPORT_SYMBOL_FLAGS_KIND_REGULAR:
 854           putchar ('-');
 855           break;
 856         case BFD_MACH_O_EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL:
 857           putchar ('T');
 858           break;
 859         default:
 860           putchar ('?');
 861           break;
 862         }
 863       putchar ((flags & BFD_MACH_O_EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION) ?
 864                'W' : '-');
 865
 866       if (flags & BFD_MACH_O_EXPORT_SYMBOL_FLAGS_REEXPORT)
 867         {
 868           bfd_vma lib;
 869
 870           lib = read_leb128 (buf + off, &leblen, 0, buf + len);
 871           off += leblen;
 872
 873           fputs (" [reexport] ", stdout);
 874           for (d = base; d != NULL; d = d->next)
 875             printf ("%s", d->name);
 876
 877           fputs (" (", stdout);
 878           if (buf[off] != 0)
 879             {
 880               fputs ((const char *)buf + off, stdout);
 881               putchar (' ');
 882               off += strlen ((const char *)buf + off);
 883             }
 884           printf ("from dylib %u)\n", (unsigned) lib);
 885           off++;
 886         }
 887       else
 888         {
 889           bfd_vma offset;
 890           bfd_vma resolv = 0;
 891
 892           offset = read_leb128 (buf + off, &leblen, 0, buf + len);
 893           off += leblen;
 894
 895           if (flags & BFD_MACH_O_EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
 896             {
 897               resolv = read_leb128 (buf + off, &leblen, 0, buf + len);
 898               off += leblen;
 899             }
 900
 901           printf (" 0x%08x ", (unsigned) offset);
 902           for (d = base; d != NULL; d = d->next)
 903             printf ("%s", d->name);
 904           if (flags & BFD_MACH_O_EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
 905             printf (" [resolv: 0x%08x]", (unsigned) resolv);
 906           printf ("\n");
 907         }
 908     }
 909
 910   child_count = read_leb128 (buf + off, &leblen, 0, buf + len);
 911   off += leblen;
 912
 913   for (i = 0; i < child_count; i++)
 914     {
 915       struct export_info_data sub_data;
 916       bfd_vma sub_off;
 917
 918       sub_data.name = buf + off;
 919       sub_data.next = NULL;
 920       parent->next = &sub_data;
 921
 922       off += strlen ((const char *)buf + off) + 1;
 923
 924       sub_off = read_leb128 (buf + off, &leblen, 0, buf + len);
 925       off += leblen;
 926
 927       dump_dyld_info_export_1 (abfd, buf, len, sub_off, &sub_data, base);
 928     }
 929 }
 930
 931 static void
 932 dump_dyld_info_export (bfd *abfd, unsigned char *buf, unsigned int len,
 933                        ufile_ptr off ATTRIBUTE_UNUSED)
 934 {
 935   struct export_info_data data;
 936
 937   data.name = (const unsigned char *) "";
 938   data.next = NULL;
 939
 940   printf ("   fl offset     sym        (Flags: Tls Weak)\n");
 941   dump_dyld_info_export_1 (abfd, buf, len, 0, &data, &data);
 942 }
 943
 944 static void
 945 dump_dyld_info (bfd *abfd, bfd_mach_o_load_command *cmd,
 946                 bfd_boolean verbose)
 947 {
 948   bfd_mach_o_dyld_info_command *dinfo = &cmd->command.dyld_info;
 949
 950   printf ("       rebase: off: 0x%08x  size: %-8u   (endoff: 0x%08x)\n",
 951           dinfo->rebase_off, dinfo->rebase_size,
 952           dinfo->rebase_off + dinfo->rebase_size);
 953   printf ("         bind: off: 0x%08x  size: %-8u   (endoff: 0x%08x)\n",
 954           dinfo->bind_off, dinfo->bind_size,
 955           dinfo->bind_off + dinfo->bind_size);
 956   printf ("    weak bind: off: 0x%08x  size: %-8u   (endoff: 0x%08x)\n",
 957           dinfo->weak_bind_off, dinfo->weak_bind_size,
 958           dinfo->weak_bind_off + dinfo->weak_bind_size);
 959   printf ("    lazy bind: off: 0x%08x  size: %-8u   (endoff: 0x%08x)\n",
 960           dinfo->lazy_bind_off, dinfo->lazy_bind_size,
 961           dinfo->lazy_bind_off + dinfo->lazy_bind_size);
 962   printf ("       export: off: 0x%08x  size: %-8u   (endoff: 0x%08x)\n",
 963           dinfo->export_off, dinfo->export_size,
 964           dinfo->export_off + dinfo->export_size);
 965
 966   if (!verbose)
 967     return;
 968
 969   printf ("   rebase:\n");
 970   if (!load_and_dump (abfd, dinfo->rebase_off, dinfo->rebase_size,
 971                       dump_dyld_info_rebase))
 972     non_fatal (_("cannot read rebase dyld info"));
 973
 974   printf ("   bind:\n");
 975   if (!load_and_dump (abfd, dinfo->bind_off, dinfo->bind_size,
 976                       dump_dyld_info_bind))
 977     non_fatal (_("cannot read bind dyld info"));
 978
 979   printf ("   weak bind:\n");
 980   if (!load_and_dump (abfd, dinfo->weak_bind_off, dinfo->weak_bind_size,
 981                       dump_dyld_info_bind))
 982     non_fatal (_("cannot read weak bind dyld info"));
 983
 984   printf ("   lazy bind:\n");
 985   if (!load_and_dump (abfd, dinfo->lazy_bind_off, dinfo->lazy_bind_size,
 986                       dump_dyld_info_bind))
 987     non_fatal (_("cannot read lazy bind dyld info"));
 988
 989   printf ("   exported symbols:\n");
 990   if (!load_and_dump (abfd, dinfo->export_off, dinfo->export_size,
 991                       dump_dyld_info_export))
 992     non_fatal (_("cannot read export symbols dyld info"));
 993 }
 994
 995 static void
 996 dump_thread (bfd *abfd, bfd_mach_o_load_command *cmd)
 997 {
 998   bfd_mach_o_thread_command *thread = &cmd->command.thread;
 999   unsigned int j;
1000   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1001   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1002
1003   printf (" nflavours: %lu\n", thread->nflavours);
1004   for (j = 0; j < thread->nflavours; j++)
1005     {
1006       bfd_mach_o_thread_flavour *flavour = &thread->flavours[j];
1007       const bfd_mach_o_xlat_name *name_table;
1008
1009       printf ("  %2u: flavour: 0x%08lx", j, flavour->flavour);
1010       switch (mdata->header.cputype)
1011         {
1012         case BFD_MACH_O_CPU_TYPE_I386:
1013         case BFD_MACH_O_CPU_TYPE_X86_64:
1014           name_table = bfd_mach_o_thread_x86_name;
1015           break;
1016         default:
1017           name_table = NULL;
1018           break;
1019         }
1020       if (name_table != NULL)
1021         printf (": %s", bfd_mach_o_get_name (name_table, flavour->flavour));
1022       putchar ('\n');
1023
1024       printf ("       offset: 0x%08lx  size: 0x%08lx\n",
1025               flavour->offset, flavour->size);
1026       if (bed->_bfd_mach_o_print_thread)
1027         {
1028           char *buf = xmalloc (flavour->size);
1029
1030           if (bfd_seek (abfd, flavour->offset, SEEK_SET) == 0
1031               && bfd_bread (buf, flavour->size, abfd) == flavour->size)
1032             (*bed->_bfd_mach_o_print_thread)(abfd, flavour, stdout, buf);
1033
1034           free (buf);
1035         }
1036     }
1037 }
1038
1039 static const bfd_mach_o_xlat_name bfd_mach_o_cs_magic[] =
1040 {
1041   { "embedded signature", BFD_MACH_O_CS_MAGIC_EMBEDDED_SIGNATURE },
1042   { "requirement", BFD_MACH_O_CS_MAGIC_REQUIREMENT },
1043   { "requirements", BFD_MACH_O_CS_MAGIC_REQUIREMENTS },
1044   { "code directory", BFD_MACH_O_CS_MAGIC_CODEDIRECTORY },
1045   { "embedded entitlements", BFD_MACH_O_CS_MAGIC_EMBEDDED_ENTITLEMENTS },
1046   { "blob wrapper", BFD_MACH_O_CS_MAGIC_BLOB_WRAPPER },
1047   { NULL, 0 }
1048 };
1049
1050 static const bfd_mach_o_xlat_name bfd_mach_o_cs_hash_type[] =
1051 {
1052   { "no-hash", BFD_MACH_O_CS_NO_HASH },
1053   { "sha1", BFD_MACH_O_CS_HASH_SHA1 },
1054   { "sha256", BFD_MACH_O_CS_HASH_SHA256 },
1055   { "skein 160", BFD_MACH_O_CS_HASH_PRESTANDARD_SKEIN_160x256 },
1056   { "skein 256", BFD_MACH_O_CS_HASH_PRESTANDARD_SKEIN_256x512 },
1057   { NULL, 0 }
1058 };
1059
1060 static unsigned int
1061 dump_code_signature_blob (bfd *abfd, const unsigned char *buf, unsigned int len);
1062
1063 static void
1064 dump_code_signature_superblob (bfd *abfd ATTRIBUTE_UNUSED,
1065                                const unsigned char *buf, unsigned int len)
1066 {
1067   unsigned int count;
1068   unsigned int i;
1069
1070   if (len < 12)
1071     {
1072       printf (_("  [bad block length]\n"));
1073       return;
1074     }
1075   count = bfd_getb32 (buf + 8);
1076   printf (ngettext ("  %u index entry:\n",
1077                     "  %u index entries:\n",
1078                     count),
1079           count);
1080   if (len < 12 + 8 * count)
1081     {
1082       printf (_("  [bad block length]\n"));
1083       return;
1084     }
1085   for (i = 0; i < count; i++)
1086     {
1087       unsigned int type;
1088       unsigned int off;
1089
1090       type = bfd_getb32 (buf + 12 + 8 * i);
1091       off = bfd_getb32 (buf + 12 + 8 * i + 4);
1092       printf (_("  index entry %u: type: %08x, offset: %08x\n"),
1093               i, type, off);
1094
1095       dump_code_signature_blob (abfd, buf + off, len - off);
1096     }
1097 }
1098
1099 static void
1100 swap_code_codedirectory_v1_in
1101   (const struct mach_o_codesign_codedirectory_external_v1 *src,
1102    struct mach_o_codesign_codedirectory_v1 *dst)
1103 {
1104   dst->version = bfd_getb32 (src->version);
1105   dst->flags = bfd_getb32 (src->flags);
1106   dst->hash_offset = bfd_getb32 (src->hash_offset);
1107   dst->ident_offset = bfd_getb32 (src->ident_offset);
1108   dst->nbr_special_slots = bfd_getb32 (src->nbr_special_slots);
1109   dst->nbr_code_slots = bfd_getb32 (src->nbr_code_slots);
1110   dst->code_limit = bfd_getb32 (src->code_limit);
1111   dst->hash_size = src->hash_size[0];
1112   dst->hash_type = src->hash_type[0];
1113   dst->spare1 = src->spare1[0];
1114   dst->page_size = src->page_size[0];
1115   dst->spare2 = bfd_getb32 (src->spare2);
1116 }
1117
1118 static void
1119 hexdump (unsigned int start, unsigned int len,
1120          const unsigned char *buf)
1121 {
1122   unsigned int i, j;
1123
1124   for (i = 0; i < len; i += 16)
1125     {
1126       printf ("%08x:", start + i);
1127       for (j = 0; j < 16; j++)
1128         {
1129           fputc (j == 8 ? '-' : ' ', stdout);
1130           if (i + j < len)
1131             printf ("%02x", buf[i + j]);
1132           else
1133             fputs ("  ", stdout);
1134         }
1135       fputc (' ', stdout);
1136       for (j = 0; j < 16; j++)
1137         {
1138           if (i + j < len)
1139             fputc (ISPRINT (buf[i + j]) ? buf[i + j] : '.', stdout);
1140           else
1141             fputc (' ', stdout);
1142         }
1143       fputc ('\n', stdout);
1144     }
1145 }
1146
1147 static void
1148 dump_code_signature_codedirectory (bfd *abfd ATTRIBUTE_UNUSED,
1149                                    const unsigned char *buf, unsigned int len)
1150 {
1151   struct mach_o_codesign_codedirectory_v1 cd;
1152   const char *id;
1153
1154   if (len < sizeof (struct mach_o_codesign_codedirectory_external_v1))
1155     {
1156       printf (_("  [bad block length]\n"));
1157       return;
1158     }
1159
1160   swap_code_codedirectory_v1_in
1161     ((const struct mach_o_codesign_codedirectory_external_v1 *) (buf + 8), &cd);
1162
1163   printf (_("  version:           %08x\n"), cd.version);
1164   printf (_("  flags:             %08x\n"), cd.flags);
1165   printf (_("  hash offset:       %08x\n"), cd.hash_offset);
1166   id = (const char *) buf + cd.ident_offset;
1167   printf (_("  ident offset:      %08x (- %08x)\n"),
1168           cd.ident_offset, cd.ident_offset + (unsigned) strlen (id) + 1);
1169   printf (_("   identity: %s\n"), id);
1170   printf (_("  nbr special slots: %08x (at offset %08x)\n"),
1171           cd.nbr_special_slots,
1172           cd.hash_offset - cd.nbr_special_slots * cd.hash_size);
1173   printf (_("  nbr code slots:    %08x\n"), cd.nbr_code_slots);
1174   printf (_("  code limit:        %08x\n"), cd.code_limit);
1175   printf (_("  hash size:         %02x\n"), cd.hash_size);
1176   printf (_("  hash type:         %02x (%s)\n"),
1177           cd.hash_type,
1178           bfd_mach_o_get_name (bfd_mach_o_cs_hash_type, cd.hash_type));
1179   printf (_("  spare1:            %02x\n"), cd.spare1);
1180   printf (_("  page size:         %02x\n"), cd.page_size);
1181   printf (_("  spare2:            %08x\n"), cd.spare2);
1182   if (cd.version >= 0x20100)
1183     printf (_("  scatter offset:    %08x\n"),
1184             (unsigned) bfd_getb32 (buf + 44));
1185 }
1186
1187 static unsigned int
1188 dump_code_signature_blob (bfd *abfd, const unsigned char *buf, unsigned int len)
1189 {
1190   unsigned int magic;
1191   unsigned int length;
1192
1193   if (len < 8)
1194     {
1195       printf (_("  [truncated block]\n"));
1196       return 0;
1197     }
1198   magic = bfd_getb32 (buf);
1199   length = bfd_getb32 (buf + 4);
1200   if (magic == 0 || length == 0)
1201     return 0;
1202
1203   printf (_(" magic : %08x (%s)\n"), magic,
1204           bfd_mach_o_get_name (bfd_mach_o_cs_magic, magic));
1205   printf (_(" length: %08x\n"), length);
1206   if (length > len)
1207     {
1208       printf (_("  [bad block length]\n"));
1209       return 0;
1210     }
1211
1212   switch (magic)
1213     {
1214     case BFD_MACH_O_CS_MAGIC_EMBEDDED_SIGNATURE:
1215       dump_code_signature_superblob (abfd, buf, length);
1216       break;
1217     case BFD_MACH_O_CS_MAGIC_CODEDIRECTORY:
1218       dump_code_signature_codedirectory (abfd, buf, length);
1219       break;
1220     default:
1221       hexdump (0, length - 8, buf + 8);
1222       break;
1223     }
1224   return length;
1225 }
1226
1227 static void
1228 dump_code_signature (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
1229 {
1230   unsigned char *buf = xmalloc (cmd->datasize);
1231   unsigned int off;
1232
1233   if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
1234       || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
1235     {
1236       non_fatal (_("cannot read code signature data"));
1237       free (buf);
1238       return;
1239     }
1240   for (off = 0; off < cmd->datasize;)
1241     {
1242       unsigned int len;
1243
1244       len = dump_code_signature_blob (abfd, buf + off, cmd->datasize - off);
1245
1246       if (len == 0)
1247         break;
1248       off += len;
1249     }
1250   free (buf);
1251 }
1252
1253 static void
1254 dump_segment_split_info (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
1255 {
1256   unsigned char *buf = xmalloc (cmd->datasize);
1257   unsigned char *p;
1258   unsigned int len;
1259   bfd_vma addr = 0;
1260
1261   if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
1262       || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
1263     {
1264       non_fatal (_("cannot read segment split info"));
1265       free (buf);
1266       return;
1267     }
1268   if (buf[cmd->datasize - 1] != 0)
1269     {
1270       non_fatal (_("segment split info is not nul terminated"));
1271       free (buf);
1272       return;
1273     }
1274
1275   switch (buf[0])
1276     {
1277     case 0:
1278       printf (_("  32 bit pointers:\n"));
1279       break;
1280     case 1:
1281       printf (_("  64 bit pointers:\n"));
1282       break;
1283     case 2:
1284       printf (_("  PPC hi-16:\n"));
1285       break;
1286     default:
1287       printf (_("  Unhandled location type %u\n"), buf[0]);
1288       break;
1289     }
1290   for (p = buf + 1; *p != 0; p += len)
1291     {
1292       addr += read_leb128 (p, &len, 0, buf + cmd->datasize);
1293       fputs ("    ", stdout);
1294       bfd_printf_vma (abfd, addr);
1295       putchar ('\n');
1296     }
1297   free (buf);
1298 }
1299
1300 static void
1301 dump_function_starts (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
1302 {
1303   unsigned char *buf = xmalloc (cmd->datasize);
1304   unsigned char *end_buf = buf + cmd->datasize;
1305   unsigned char *p;
1306   bfd_vma addr;
1307
1308   if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
1309       || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
1310     {
1311       non_fatal (_("cannot read function starts"));
1312       free (buf);
1313       return;
1314     }
1315
1316   /* Function starts are delta encoded, starting from the base address.  */
1317   addr = bfd_mach_o_get_base_address (abfd);
1318
1319   for (p = buf; ;)
1320     {
1321       bfd_vma delta = 0;
1322       unsigned int shift = 0;
1323
1324       if (*p == 0 || p == end_buf)
1325         break;
1326       while (1)
1327         {
1328           unsigned char b = *p++;
1329
1330           delta |= (b & 0x7f) << shift;
1331           if ((b & 0x80) == 0)
1332             break;
1333           if (p == end_buf)
1334             {
1335               fputs ("   [truncated]\n", stdout);
1336               break;
1337             }
1338           shift += 7;
1339         }
1340
1341       addr += delta;
1342       fputs ("    ", stdout);
1343       bfd_printf_vma (abfd, addr);
1344       putchar ('\n');
1345     }
1346   free (buf);
1347 }
1348
1349 static const bfd_mach_o_xlat_name data_in_code_kind_name[] =
1350 {
1351   { "data", BFD_MACH_O_DICE_KIND_DATA },
1352   { "1 byte jump table", BFD_MACH_O_DICE_JUMP_TABLES8 },
1353   { "2 bytes jump table", BFD_MACH_O_DICE_JUMP_TABLES16 },
1354   { "4 bytes jump table", BFD_MACH_O_DICE_JUMP_TABLES32 },
1355   { "4 bytes abs jump table", BFD_MACH_O_DICE_ABS_JUMP_TABLES32 },
1356   { NULL, 0 }
1357 };
1358
1359 static void
1360 dump_data_in_code (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
1361 {
1362   unsigned char *buf;
1363   unsigned char *p;
1364
1365   if (cmd->datasize == 0)
1366     {
1367       printf ("   no data_in_code entries\n");
1368       return;
1369     }
1370
1371   buf = xmalloc (cmd->datasize);
1372   if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
1373       || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
1374     {
1375       non_fatal (_("cannot read data_in_code"));
1376       free (buf);
1377       return;
1378     }
1379
1380   printf ("   offset     length kind\n");
1381   for (p = buf; p < buf + cmd->datasize; )
1382     {
1383       struct mach_o_data_in_code_entry_external *dice;
1384       unsigned int offset;
1385       unsigned int length;
1386       unsigned int kind;
1387
1388       dice = (struct mach_o_data_in_code_entry_external *) p;
1389
1390       offset = bfd_get_32 (abfd, dice->offset);
1391       length = bfd_get_16 (abfd, dice->length);
1392       kind = bfd_get_16 (abfd, dice->kind);
1393
1394       printf ("   0x%08x 0x%04x 0x%04x %s\n", offset, length, kind,
1395               bfd_mach_o_get_name (data_in_code_kind_name, kind));
1396
1397       p += sizeof (*dice);
1398     }
1399   free (buf);
1400 }
1401
1402 static void
1403 dump_twolevel_hints (bfd *abfd, bfd_mach_o_twolevel_hints_command *cmd)
1404 {
1405   size_t sz = 4 * cmd->nhints;
1406   unsigned char *buf;
1407   unsigned char *p;
1408
1409   buf = xmalloc (sz);
1410   if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
1411       || bfd_bread (buf, sz, abfd) != sz)
1412     {
1413       non_fatal (_("cannot read twolevel hints"));
1414       free (buf);
1415       return;
1416     }
1417
1418   for (p = buf; p < buf + sz; p += 4)
1419     {
1420       unsigned int v;
1421       unsigned int isub_image;
1422       unsigned int itoc;
1423
1424       v = bfd_get_32 (abfd, p);
1425       if (bfd_big_endian (abfd))
1426         {
1427           isub_image = (v >> 24) & 0xff;
1428           itoc = v & 0xffffff;
1429         }
1430       else
1431         {
1432           isub_image = v & 0xff;
1433           itoc = (v >> 8) & 0xffffff;
1434         }
1435
1436       printf ("  %3u %8u\n", isub_image, itoc);
1437     }
1438   free (buf);
1439 }
1440
1441 static void
1442 dump_load_command (bfd *abfd, bfd_mach_o_load_command *cmd,
1443                    unsigned int idx, bfd_boolean verbose)
1444 {
1445   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1446   const char *cmd_name;
1447
1448   cmd_name = bfd_mach_o_get_name_or_null
1449     (bfd_mach_o_load_command_name, cmd->type);
1450   printf ("Load command #%-2u (size: %3u, offset: %4u): ",
1451           idx, cmd->len, cmd->offset);
1452   if (cmd_name == NULL)
1453     printf ("0x%02x\n", cmd->type);
1454   else
1455     printf ("%s\n", cmd_name);
1456
1457   switch (cmd->type)
1458     {
1459     case BFD_MACH_O_LC_SEGMENT:
1460     case BFD_MACH_O_LC_SEGMENT_64:
1461       dump_segment (abfd, cmd);
1462       break;
1463     case BFD_MACH_O_LC_UUID:
1464       {
1465         bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
1466         unsigned int j;
1467
1468         printf ("   ");
1469         for (j = 0; j < sizeof (uuid->uuid); j ++)
1470           printf (" %02x", uuid->uuid[j]);
1471         putchar ('\n');
1472       }
1473       break;
1474     case BFD_MACH_O_LC_LOAD_DYLIB:
1475     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
1476     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1477     case BFD_MACH_O_LC_REEXPORT_DYLIB:
1478     case BFD_MACH_O_LC_ID_DYLIB:
1479     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
1480       {
1481         bfd_mach_o_dylib_command *dylib = &cmd->command.dylib;
1482         printf ("  name: %s\n", dylib->name_str);
1483         printf ("            time stamp: 0x%08lx\n",
1484                 dylib->timestamp);
1485         printf ("       current version: 0x%08lx\n",
1486                 dylib->current_version);
1487         printf ("  comptibility version: 0x%08lx\n",
1488                 dylib->compatibility_version);
1489       }
1490       break;
1491     case BFD_MACH_O_LC_LOAD_DYLINKER:
1492     case BFD_MACH_O_LC_ID_DYLINKER:
1493       printf ("    %s\n", cmd->command.dylinker.name_str);
1494       break;
1495     case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
1496       printf ("    %s\n", cmd->command.dylinker.name_str);
1497       break;
1498     case BFD_MACH_O_LC_SYMTAB:
1499       {
1500         bfd_mach_o_symtab_command *symtab = &cmd->command.symtab;
1501         printf ("   symoff: 0x%08x    nsyms: %8u  (endoff: 0x%08x)\n",
1502                 symtab->symoff, symtab->nsyms,
1503                 symtab->symoff + symtab->nsyms
1504                 * (mdata->header.version == 2
1505                    ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE));
1506         printf ("   stroff: 0x%08x  strsize: %8u  (endoff: 0x%08x)\n",
1507                 symtab->stroff, symtab->strsize,
1508                 symtab->stroff + symtab->strsize);
1509         break;
1510       }
1511     case BFD_MACH_O_LC_DYSYMTAB:
1512       dump_dysymtab (abfd, cmd, verbose);
1513       break;
1514     case BFD_MACH_O_LC_LOADFVMLIB:
1515     case BFD_MACH_O_LC_IDFVMLIB:
1516       {
1517         bfd_mach_o_fvmlib_command *fvmlib = &cmd->command.fvmlib;
1518         printf ("                fvmlib: %s\n", fvmlib->name_str);
1519         printf ("         minor version: 0x%08x\n", fvmlib->minor_version);
1520         printf ("        header address: 0x%08x\n", fvmlib->header_addr);
1521       }
1522       break;
1523     case BFD_MACH_O_LC_CODE_SIGNATURE:
1524     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
1525     case BFD_MACH_O_LC_FUNCTION_STARTS:
1526     case BFD_MACH_O_LC_DATA_IN_CODE:
1527     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
1528       {
1529         bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit;
1530         printf
1531           ("  dataoff: 0x%08lx  datasize: 0x%08lx  (endoff: 0x%08lx)\n",
1532            linkedit->dataoff, linkedit->datasize,
1533            linkedit->dataoff + linkedit->datasize);
1534
1535         if (verbose)
1536           switch (cmd->type)
1537             {
1538             case BFD_MACH_O_LC_CODE_SIGNATURE:
1539               dump_code_signature (abfd, linkedit);
1540               break;
1541             case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
1542               dump_segment_split_info (abfd, linkedit);
1543               break;
1544             case BFD_MACH_O_LC_FUNCTION_STARTS:
1545               dump_function_starts (abfd, linkedit);
1546               break;
1547             case BFD_MACH_O_LC_DATA_IN_CODE:
1548               dump_data_in_code (abfd, linkedit);
1549               break;
1550             default:
1551               break;
1552             }
1553       }
1554       break;
1555     case BFD_MACH_O_LC_SUB_FRAMEWORK:
1556     case BFD_MACH_O_LC_SUB_UMBRELLA:
1557     case BFD_MACH_O_LC_SUB_LIBRARY:
1558     case BFD_MACH_O_LC_SUB_CLIENT:
1559     case BFD_MACH_O_LC_RPATH:
1560       {
1561         bfd_mach_o_str_command *strc = &cmd->command.str;
1562         printf ("    %s\n", strc->str);
1563         break;
1564       }
1565     case BFD_MACH_O_LC_THREAD:
1566     case BFD_MACH_O_LC_UNIXTHREAD:
1567       dump_thread (abfd, cmd);
1568       break;
1569     case BFD_MACH_O_LC_ENCRYPTION_INFO:
1570       {
1571         bfd_mach_o_encryption_info_command *cryp =
1572           &cmd->command.encryption_info;
1573         printf ("  cryptoff: 0x%08x  cryptsize: 0x%08x (endoff 0x%08x)"
1574                 " cryptid: %u\n",
1575                 cryp->cryptoff, cryp->cryptsize,
1576                 cryp->cryptoff + cryp->cryptsize,
1577                 cryp->cryptid);
1578       }
1579       break;
1580     case BFD_MACH_O_LC_DYLD_INFO:
1581       dump_dyld_info (abfd, cmd, verbose);
1582       break;
1583     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
1584     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
1585       {
1586         bfd_mach_o_version_min_command *ver = &cmd->command.version_min;
1587
1588         printf ("    %u.%u.%u\n", ver->rel, ver->maj, ver->min);
1589       }
1590       break;
1591     case BFD_MACH_O_LC_SOURCE_VERSION:
1592       {
1593         bfd_mach_o_source_version_command *version =
1594           &cmd->command.source_version;
1595         printf ("   version a.b.c.d.e: %u.%u.%u.%u.%u\n",
1596                 version->a, version->b, version->c, version->d, version->e);
1597         break;
1598       }
1599     case BFD_MACH_O_LC_PREBOUND_DYLIB:
1600       {
1601         bfd_mach_o_prebound_dylib_command *pbdy = &cmd->command.prebound_dylib;
1602         unsigned char *lm = pbdy->linked_modules;
1603         unsigned int j;
1604         unsigned int last;
1605
1606         printf ("      dylib: %s\n", pbdy->name_str);
1607         printf ("   nmodules: %u\n", pbdy->nmodules);
1608         printf ("   linked modules (at %u): ",
1609                 pbdy->linked_modules_offset - cmd->offset);
1610         last = pbdy->nmodules > 32 ? 32 : pbdy->nmodules;
1611         for (j = 0; j < last; j++)
1612           printf ("%u", (lm[j >> 3] >> (j & 7)) & 1);
1613         if (last < pbdy->nmodules)
1614           printf ("...");
1615         putchar ('\n');
1616         break;
1617       }
1618     case BFD_MACH_O_LC_PREBIND_CKSUM:
1619       {
1620         bfd_mach_o_prebind_cksum_command *cksum = &cmd->command.prebind_cksum;
1621         printf ("   0x%08x\n", cksum->cksum);
1622         break;
1623       }
1624     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
1625       {
1626         bfd_mach_o_twolevel_hints_command *hints =
1627           &cmd->command.twolevel_hints;
1628
1629         printf ("   table offset: 0x%08x  nbr hints: %u\n",
1630                 hints->offset, hints->nhints);
1631         if (verbose)
1632           dump_twolevel_hints (abfd, hints);
1633         break;
1634       }
1635     case BFD_MACH_O_LC_MAIN:
1636       {
1637         bfd_mach_o_main_command *entry = &cmd->command.main;
1638         printf ("   entry offset: ");
1639         printf_uint64 (entry->entryoff);
1640         printf ("\n"
1641                 "   stack size:   ");
1642         printf_uint64 (entry->stacksize);
1643         printf ("\n");
1644         break;
1645       }
1646     default:
1647       break;
1648     }
1649   putchar ('\n');
1650 }
1651
1652 static void
1653 dump_load_commands (bfd *abfd, unsigned int cmd32, unsigned int cmd64)
1654 {
1655   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1656   bfd_mach_o_load_command *cmd;
1657   unsigned int i;
1658
1659   for (cmd = mdata->first_command, i = 0; cmd != NULL; cmd = cmd->next, i++)
1660     {
1661       if (cmd32 == 0)
1662         dump_load_command (abfd, cmd, i, FALSE);
1663       else if (cmd->type == cmd32 || cmd->type == cmd64)
1664         dump_load_command (abfd, cmd, i, TRUE);
1665     }
1666 }
1667
1668 static const char * const unwind_x86_64_regs[] =
1669   {"", "rbx", "r12", "r13", "r14", "r15", "rbp", "???" };
1670
1671 static const char * const unwind_x86_regs[] =
1672   {"", "ebx", "ecx", "edx", "edi", "edi", "ebp", "???" };
1673
1674 /* Dump x86 or x86-64 compact unwind encoding.  Works for both architecture,
1675    as the encoding is the same (but not register names).  */
1676
1677 static void
1678 dump_unwind_encoding_x86 (unsigned int encoding, unsigned int sz,
1679                           const char * const regs_name[])
1680 {
1681   unsigned int mode;
1682
1683   mode = encoding & MACH_O_UNWIND_X86_64_MODE_MASK;
1684   switch (mode)
1685     {
1686     case MACH_O_UNWIND_X86_64_MODE_RBP_FRAME:
1687       {
1688         unsigned int regs;
1689         char pfx = sz == 8 ? 'R' : 'E';
1690
1691         regs = encoding & MACH_O_UNWIND_X86_64_RBP_FRAME_REGISTERS;
1692         printf (" %cSP frame", pfx);
1693         if (regs != 0)
1694           {
1695             unsigned int offset;
1696             int i;
1697
1698             offset = (encoding & MACH_O_UNWIND_X86_64_RBP_FRAME_OFFSET) >> 16;
1699             printf (" at %cBP-%u:", pfx, offset * sz);
1700             for (i = 0; i < 5; i++)
1701               {
1702                 unsigned int reg = (regs >> (i * 3)) & 0x7;
1703                 if (reg != MACH_O_UNWIND_X86_64_REG_NONE)
1704                   printf (" %s", regs_name[reg]);
1705               }
1706           }
1707       }
1708       break;
1709     case MACH_O_UNWIND_X86_64_MODE_STACK_IMMD:
1710     case MACH_O_UNWIND_X86_64_MODE_STACK_IND:
1711       {
1712         unsigned int stack_size;
1713         unsigned int reg_count;
1714         unsigned int reg_perm;
1715         unsigned int regs[6];
1716         int i, j;
1717
1718         printf (" frameless");
1719         stack_size =
1720           (encoding & MACH_O_UNWIND_X86_64_FRAMELESS_STACK_SIZE) >> 16;
1721         reg_count =
1722           (encoding & MACH_O_UNWIND_X86_64_FRAMELESS_REG_COUNT) >> 10;
1723         reg_perm = encoding & MACH_O_UNWIND_X86_64_FRAMELESS_REG_PERMUTATION;
1724
1725         if (mode == MACH_O_UNWIND_X86_64_MODE_STACK_IMMD)
1726           printf (" size: 0x%03x", stack_size * sz);
1727         else
1728           {
1729             unsigned int stack_adj;
1730
1731             stack_adj =
1732               (encoding & MACH_O_UNWIND_X86_64_FRAMELESS_STACK_ADJUST) >> 13;
1733             printf (" size at 0x%03x + 0x%02x", stack_size, stack_adj * sz);
1734           }
1735         /* Registers are coded using arithmetic compression: the register
1736            is indexed in range 0-6, the second in range 0-5, the third in
1737            range 0-4, etc.  Already used registers are removed in next
1738            ranges.  */
1739 #define DO_PERM(R, NUM) R = reg_perm / NUM; reg_perm -= R * NUM
1740         switch (reg_count)
1741           {
1742           case 6:
1743           case 5:
1744             DO_PERM (regs[0], 120);
1745             DO_PERM (regs[1], 24);
1746             DO_PERM (regs[2], 6);
1747             DO_PERM (regs[3], 2);
1748             DO_PERM (regs[4], 1);
1749             regs[5] = 0; /* Not used if reg_count = 5.  */
1750             break;
1751           case 4:
1752             DO_PERM (regs[0], 60);
1753             DO_PERM (regs[1], 12);
1754             DO_PERM (regs[2], 3);
1755             DO_PERM (regs[3], 1);
1756             break;
1757           case 3:
1758             DO_PERM (regs[0], 20);
1759             DO_PERM (regs[1], 4);
1760             DO_PERM (regs[2], 1);
1761             break;
1762           case 2:
1763             DO_PERM (regs[0], 5);
1764             DO_PERM (regs[1], 1);
1765             break;
1766           case 1:
1767             DO_PERM (regs[0], 1);
1768             break;
1769           case 0:
1770             break;
1771           default:
1772             printf (" [bad reg count]");
1773             return;
1774           }
1775 #undef DO_PERM
1776         /* Renumber.  */
1777         for (i = reg_count - 1; i >= 0; i--)
1778           {
1779             unsigned int inc = 1;
1780             for (j = 0; j < i; j++)
1781               if (regs[i] >= regs[j])
1782                 inc++;
1783             regs[i] += inc;
1784           }
1785         /* Display.  */
1786         for (i = 0; i < (int) reg_count; i++)
1787           printf (" %s", regs_name[regs[i]]);
1788       }
1789       break;
1790     case MACH_O_UNWIND_X86_64_MODE_DWARF:
1791       printf (" Dwarf offset: 0x%06x",
1792               encoding & MACH_O_UNWIND_X86_64_DWARF_SECTION_OFFSET);
1793       break;
1794     default:
1795       printf (" [unhandled mode]");
1796       break;
1797     }
1798 }
1799
1800 /* Dump arm64 compact unwind entries.  */
1801
1802 static void
1803 dump_unwind_encoding_arm64 (unsigned int encoding)
1804 {
1805   switch (encoding & MACH_O_UNWIND_ARM64_MODE_MASK)
1806     {
1807     case MACH_O_UNWIND_ARM64_MODE_FRAMELESS:
1808       printf (" frameless");
1809       break;
1810     case MACH_O_UNWIND_ARM64_MODE_DWARF:
1811       printf (" Dwarf offset: 0x%06x",
1812               encoding & MACH_O_UNWIND_ARM64_DWARF_SECTION_OFFSET);
1813       return;
1814     case MACH_O_UNWIND_ARM64_MODE_FRAME:
1815       printf (" frame");
1816       break;
1817     default:
1818       printf (" [unhandled mode]");
1819       return;
1820     }
1821   switch (encoding & MACH_O_UNWIND_ARM64_MODE_MASK)
1822     {
1823     case MACH_O_UNWIND_ARM64_MODE_FRAMELESS:
1824     case MACH_O_UNWIND_ARM64_MODE_FRAME:
1825       if (encoding & MACH_O_UNWIND_ARM64_FRAME_X19_X20_PAIR)
1826         printf (" x19-x20");
1827       if (encoding & MACH_O_UNWIND_ARM64_FRAME_X21_X22_PAIR)
1828         printf (" x21-x22");
1829       if (encoding & MACH_O_UNWIND_ARM64_FRAME_X23_X24_PAIR)
1830         printf (" x23-x24");
1831       if (encoding & MACH_O_UNWIND_ARM64_FRAME_X25_X26_PAIR)
1832         printf (" x25-x26");
1833       if (encoding & MACH_O_UNWIND_ARM64_FRAME_X27_X28_PAIR)
1834         printf (" x27-x28");
1835       break;
1836     }
1837   switch (encoding & MACH_O_UNWIND_ARM64_MODE_MASK)
1838     {
1839     case MACH_O_UNWIND_ARM64_MODE_FRAME:
1840       if (encoding & MACH_O_UNWIND_ARM64_FRAME_D8_D9_PAIR)
1841         printf (" d8-d9");
1842       if (encoding & MACH_O_UNWIND_ARM64_FRAME_D10_D11_PAIR)
1843         printf (" d10-d11");
1844       if (encoding & MACH_O_UNWIND_ARM64_FRAME_D12_D13_PAIR)
1845         printf (" d12-d13");
1846       if (encoding & MACH_O_UNWIND_ARM64_FRAME_D14_D15_PAIR)
1847         printf (" d14-d15");
1848       break;
1849     case MACH_O_UNWIND_ARM64_MODE_FRAMELESS:
1850       printf (" size: %u",
1851               (encoding & MACH_O_UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK) >> 8);
1852       break;
1853     }
1854 }
1855
1856 static void
1857 dump_unwind_encoding (bfd_mach_o_data_struct *mdata, unsigned int encoding)
1858 {
1859   printf ("0x%08x", encoding);
1860   if (encoding == 0)
1861     return;
1862
1863   switch (mdata->header.cputype)
1864     {
1865     case BFD_MACH_O_CPU_TYPE_X86_64:
1866       dump_unwind_encoding_x86 (encoding, 8, unwind_x86_64_regs);
1867       break;
1868     case BFD_MACH_O_CPU_TYPE_I386:
1869       dump_unwind_encoding_x86 (encoding, 4, unwind_x86_regs);
1870       break;
1871     case BFD_MACH_O_CPU_TYPE_ARM64:
1872       dump_unwind_encoding_arm64 (encoding);
1873       break;
1874     default:
1875       printf (" [unhandled cpu]");
1876       break;
1877     }
1878   if (encoding & MACH_O_UNWIND_HAS_LSDA)
1879     printf (" LSDA");
1880   if (encoding & MACH_O_UNWIND_PERSONALITY_MASK)
1881     printf (" PERS(%u)",
1882             ((encoding & MACH_O_UNWIND_PERSONALITY_MASK)
1883              >> MACH_O_UNWIND_PERSONALITY_SHIFT));
1884 }
1885
1886 static void
1887 dump_obj_compact_unwind (bfd *abfd,
1888                          const unsigned char *content, bfd_size_type size)
1889 {
1890   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1891   int is_64 = mdata->header.version == 2;
1892   const unsigned char *p;
1893
1894   printf ("Compact unwind info:\n");
1895   printf (" start            length   personality      lsda\n");
1896
1897   if (is_64)
1898     {
1899       struct mach_o_compact_unwind_64 *e =
1900         (struct mach_o_compact_unwind_64 *) content;
1901
1902       for (p = content; p < content + size; p += sizeof (*e))
1903         {
1904           e = (struct mach_o_compact_unwind_64 *) p;
1905
1906           putchar (' ');
1907           printf_uint64 (bfd_get_64 (abfd, e->start));
1908           printf (" %08lx", bfd_get_32 (abfd, e->length));
1909           putchar (' ');
1910           printf_uint64 (bfd_get_64 (abfd, e->personality));
1911           putchar (' ');
1912           printf_uint64 (bfd_get_64 (abfd, e->lsda));
1913           putchar ('\n');
1914
1915           printf ("  encoding: ");
1916           dump_unwind_encoding (mdata, bfd_get_32 (abfd, e->encoding));
1917           putchar ('\n');
1918         }
1919     }
1920   else
1921     {
1922       printf ("unhandled\n");
1923     }
1924 }
1925
1926 static void
1927 dump_exe_compact_unwind (bfd *abfd,
1928                          const unsigned char *content, bfd_size_type size)
1929 {
1930   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1931   struct mach_o_unwind_info_header *hdr;
1932   unsigned int version;
1933   unsigned int encodings_offset;
1934   unsigned int encodings_count;
1935   unsigned int personality_offset;
1936   unsigned int personality_count;
1937   unsigned int index_offset;
1938   unsigned int index_count;
1939   struct mach_o_unwind_index_entry *index_entry;
1940   unsigned int i;
1941
1942   /* The header.  */
1943   printf ("Compact unwind info:\n");
1944
1945   hdr = (struct mach_o_unwind_info_header *) content;
1946   if (size < sizeof (*hdr))
1947     {
1948       printf ("  truncated!\n");
1949       return;
1950     }
1951
1952   version = bfd_get_32 (abfd, hdr->version);
1953   if (version != MACH_O_UNWIND_SECTION_VERSION)
1954     {
1955       printf ("  unknown version: %u\n", version);
1956       return;
1957     }
1958   encodings_offset = bfd_get_32 (abfd, hdr->encodings_array_offset);
1959   encodings_count = bfd_get_32 (abfd, hdr->encodings_array_count);
1960   personality_offset = bfd_get_32 (abfd, hdr->personality_array_offset);
1961   personality_count = bfd_get_32 (abfd, hdr->personality_array_count);
1962   index_offset = bfd_get_32 (abfd, hdr->index_offset);
1963   index_count = bfd_get_32 (abfd, hdr->index_count);
1964   printf ("   %u encodings, %u personalities, %u level-1 indexes:\n",
1965           encodings_count, personality_count, index_count);
1966
1967   /* Personality.  */
1968   if (personality_count > 0)
1969     {
1970       const unsigned char *pers = content + personality_offset;
1971
1972       printf ("   personalities\n");
1973       for (i = 0; i < personality_count; i++)
1974         printf ("     %u: 0x%08x\n", i,
1975                 (unsigned) bfd_get_32 (abfd, pers + 4 * i));
1976     }
1977
1978   /* Level-1 index.  */
1979   printf ("   idx function   level2 off lsda off\n");
1980
1981   index_entry = (struct mach_o_unwind_index_entry *) (content + index_offset);
1982   for (i = 0; i < index_count; i++)
1983     {
1984       unsigned int func_offset;
1985       unsigned int level2_offset;
1986       unsigned int lsda_offset;
1987
1988       func_offset = bfd_get_32 (abfd, index_entry->function_offset);
1989       level2_offset = bfd_get_32 (abfd, index_entry->second_level_offset);
1990       lsda_offset = bfd_get_32 (abfd, index_entry->lsda_index_offset);
1991       printf ("   %3u 0x%08x 0x%08x 0x%08x\n",
1992               i, func_offset, level2_offset, lsda_offset);
1993       index_entry++;
1994     }
1995
1996   /* Level-1 index.  */
1997   index_entry = (struct mach_o_unwind_index_entry *) (content + index_offset);
1998   for (i = 0; i < index_count; i++)
1999     {
2000       unsigned int func_offset;
2001       unsigned int level2_offset;
2002       const unsigned char *level2;
2003       unsigned int kind;
2004
2005       func_offset = bfd_get_32 (abfd, index_entry->function_offset);
2006       level2_offset = bfd_get_32 (abfd, index_entry->second_level_offset);
2007
2008       /* No level-2 for this index (should be the last index).  */
2009       if (level2_offset == 0)
2010         continue;
2011
2012       level2 = content + level2_offset;
2013       kind = bfd_get_32 (abfd, level2);
2014       switch (kind)
2015         {
2016         case MACH_O_UNWIND_SECOND_LEVEL_COMPRESSED:
2017           {
2018             struct mach_o_unwind_compressed_second_level_page_header *l2;
2019             unsigned int entry_offset;
2020             unsigned int entry_count;
2021             unsigned int l2_encodings_offset;
2022             unsigned int l2_encodings_count;
2023             const unsigned char *en;
2024             unsigned int j;
2025
2026             l2 = (struct mach_o_unwind_compressed_second_level_page_header *)
2027               level2;
2028             entry_offset = bfd_get_16 (abfd, l2->entry_page_offset);
2029             entry_count = bfd_get_16 (abfd, l2->entry_count);
2030             l2_encodings_offset = bfd_get_16 (abfd, l2->encodings_offset);
2031             l2_encodings_count = bfd_get_16 (abfd, l2->encodings_count);
2032
2033             printf ("   index %2u: compressed second level: "
2034                     "%u entries, %u encodings (at 0x%08x)\n",
2035                     i, entry_count, l2_encodings_count, l2_encodings_offset);
2036             printf ("   #    function   eidx  encoding\n");
2037
2038             en = level2 + entry_offset;
2039             for (j = 0; j < entry_count; j++)
2040               {
2041                 unsigned int entry;
2042                 unsigned int en_func;
2043                 unsigned int enc_idx;
2044                 unsigned int encoding;
2045                 const unsigned char *enc_addr;
2046
2047                 entry = bfd_get_32 (abfd, en);
2048                 en_func =
2049                   MACH_O_UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET (entry);
2050                 enc_idx =
2051                   MACH_O_UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX (entry);
2052                 if (enc_idx < encodings_count)
2053                   enc_addr = content + encodings_offset
2054                     + 4 * enc_idx;
2055                 else
2056                   enc_addr = level2 + l2_encodings_offset
2057                     + 4 * (enc_idx - encodings_count);
2058                 encoding = bfd_get_32 (abfd, enc_addr);
2059
2060                 printf ("   %4u 0x%08x [%3u] ", j,
2061                         func_offset + en_func, enc_idx);
2062                 dump_unwind_encoding (mdata, encoding);
2063                 putchar ('\n');
2064
2065                 en += 4;
2066               }
2067           }
2068           break;
2069
2070         case MACH_O_UNWIND_SECOND_LEVEL_REGULAR:
2071           {
2072             struct mach_o_unwind_regular_second_level_page_header *l2;
2073             struct mach_o_unwind_regular_second_level_entry *en;
2074             unsigned int entry_offset;
2075             unsigned int entry_count;
2076             unsigned int j;
2077
2078             l2 = (struct mach_o_unwind_regular_second_level_page_header *)
2079               level2;
2080
2081             entry_offset = bfd_get_16 (abfd, l2->entry_page_offset);
2082             entry_count = bfd_get_16 (abfd, l2->entry_count);
2083             printf ("   index %2u: regular level 2 at 0x%04x, %u entries\n",
2084                     i, entry_offset, entry_count);
2085             printf ("   #    function   encoding\n");
2086
2087             en = (struct mach_o_unwind_regular_second_level_entry *)
2088               (level2 + entry_offset);
2089             for (j = 0; j < entry_count; j++)
2090               {
2091                 unsigned int en_func;
2092                 unsigned int encoding;
2093
2094                 en_func = bfd_get_32 (abfd, en->function_offset);
2095                 encoding = bfd_get_32 (abfd, en->encoding);
2096                 printf ("   %-4u 0x%08x ", j, en_func);
2097                 dump_unwind_encoding (mdata, encoding);
2098                 putchar ('\n');
2099                 en++;
2100               }
2101           }
2102           break;
2103
2104         default:
2105           printf ("   index %2u: unhandled second level format (%u)\n",
2106                   i, kind);
2107           break;
2108         }
2109
2110       {
2111         struct mach_o_unwind_lsda_index_entry *lsda;
2112         unsigned int lsda_offset;
2113         unsigned int next_lsda_offset;
2114         unsigned int nbr_lsda;
2115         unsigned int j;
2116
2117         lsda_offset = bfd_get_32 (abfd, index_entry->lsda_index_offset);
2118         next_lsda_offset = bfd_get_32 (abfd, index_entry[1].lsda_index_offset);
2119         lsda = (struct mach_o_unwind_lsda_index_entry *)
2120           (content + lsda_offset);
2121         nbr_lsda = (next_lsda_offset - lsda_offset) / sizeof (*lsda);
2122         for (j = 0; j < nbr_lsda; j++)
2123           {
2124             printf ("   lsda %3u: function 0x%08x lsda 0x%08x\n",
2125                     j, (unsigned int) bfd_get_32 (abfd, lsda->function_offset),
2126                     (unsigned int) bfd_get_32 (abfd, lsda->lsda_offset));
2127             lsda++;
2128           }
2129       }
2130       index_entry++;
2131     }
2132 }
2133
2134 static void
2135 dump_section_content (bfd *abfd,
2136                       const char *segname, const char *sectname,
2137                       void (*dump)(bfd*, const unsigned char*, bfd_size_type))
2138 {
2139   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2140   bfd_mach_o_load_command *cmd;
2141
2142   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2143     {
2144       if (cmd->type == BFD_MACH_O_LC_SEGMENT
2145           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
2146         {
2147           bfd_mach_o_segment_command *seg = &cmd->command.segment;
2148           bfd_mach_o_section *sec;
2149           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
2150             if (strcmp (sec->segname, segname) == 0
2151                 && strcmp (sec->sectname, sectname) == 0)
2152               {
2153                 bfd_size_type size;
2154                 asection *bfdsec = sec->bfdsection;
2155                 unsigned char *content;
2156
2157                 size = bfd_get_section_size (bfdsec);
2158                 content = (unsigned char *) xmalloc (size);
2159                 bfd_get_section_contents (abfd, bfdsec, content, 0, size);
2160
2161                 (*dump)(abfd, content, size);
2162
2163                 free (content);
2164               }
2165         }
2166     }
2167 }
2168
2169 /* Dump ABFD (according to the options[] array).  */
2170
2171 static void
2172 mach_o_dump (bfd *abfd)
2173 {
2174   if (options[OPT_HEADER].selected)
2175     dump_header (abfd);
2176   if (options[OPT_SECTION].selected)
2177     dump_load_commands (abfd, BFD_MACH_O_LC_SEGMENT, BFD_MACH_O_LC_SEGMENT_64);
2178   if (options[OPT_MAP].selected)
2179     dump_section_map (abfd);
2180   if (options[OPT_LOAD].selected)
2181     dump_load_commands (abfd, 0, 0);
2182   if (options[OPT_DYSYMTAB].selected)
2183     dump_load_commands (abfd, BFD_MACH_O_LC_DYSYMTAB, 0);
2184   if (options[OPT_CODESIGN].selected)
2185     dump_load_commands (abfd, BFD_MACH_O_LC_CODE_SIGNATURE, 0);
2186   if (options[OPT_SEG_SPLIT_INFO].selected)
2187     dump_load_commands (abfd, BFD_MACH_O_LC_SEGMENT_SPLIT_INFO, 0);
2188   if (options[OPT_FUNCTION_STARTS].selected)
2189     dump_load_commands (abfd, BFD_MACH_O_LC_FUNCTION_STARTS, 0);
2190   if (options[OPT_DATA_IN_CODE].selected)
2191     dump_load_commands (abfd, BFD_MACH_O_LC_DATA_IN_CODE, 0);
2192   if (options[OPT_TWOLEVEL_HINTS].selected)
2193     dump_load_commands (abfd, BFD_MACH_O_LC_TWOLEVEL_HINTS, 0);
2194   if (options[OPT_COMPACT_UNWIND].selected)
2195     {
2196       dump_section_content (abfd, "__LD", "__compact_unwind",
2197                             dump_obj_compact_unwind);
2198       dump_section_content (abfd, "__TEXT", "__unwind_info",
2199                             dump_exe_compact_unwind);
2200     }
2201   if (options[OPT_DYLD_INFO].selected)
2202     dump_load_commands (abfd, BFD_MACH_O_LC_DYLD_INFO, 0);
2203 }
2204
2205 /* Vector for Mach-O.  */
2206
2207 const struct objdump_private_desc objdump_private_desc_mach_o =
2208   {
2209     mach_o_help,
2210     mach_o_filter,
2211     mach_o_dump,
2212     options
2213   };