binutils/od-macho.c

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