binutils/od-macho.c

   1 /* od-macho.c -- dump information about an Mach-O object file.
   2    Copyright (C) 2011-2014 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
  46 /* List of actions.  */
  47 static struct objdump_private_option options[] =
  48   {
  49     { "header", 0 },
  50     { "section", 0 },
  51     { "map", 0 },
  52     { "load", 0 },
  53     { "dysymtab", 0 },
  54     { "codesign", 0 },
  55     { "seg_split_info", 0 },
  56     { "compact_unwind", 0 },
  57     { NULL, 0 }
  58   };
  59
  60 /* Display help.  */
  61
  62 static void
  63 mach_o_help (FILE *stream)
  64 {
  65   fprintf (stream, _("\
  66 For Mach-O files:\n\
  67   header         Display the file header\n\
  68   section        Display the segments and sections commands\n\
  69   map            Display the section map\n\
  70   load           Display the load commands\n\
  71   dysymtab       Display the dynamic symbol table\n\
  72   codesign       Display code signature\n\
  73   seg_split_info Display segment split info\n\
  74   compact_unwind Display compact unwinding info\n\
  75 "));
  76 }
  77
  78 /* Return TRUE if ABFD is handled.  */
  79
  80 static int
  81 mach_o_filter (bfd *abfd)
  82 {
  83   return bfd_get_flavour (abfd) == bfd_target_mach_o_flavour;
  84 }
  85 \f
  86 static const bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] =
  87 {
  88   { "vax", BFD_MACH_O_CPU_TYPE_VAX },
  89   { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 },
  90   { "i386", BFD_MACH_O_CPU_TYPE_I386 },
  91   { "mips", BFD_MACH_O_CPU_TYPE_MIPS },
  92   { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 },
  93   { "hppa", BFD_MACH_O_CPU_TYPE_HPPA },
  94   { "arm", BFD_MACH_O_CPU_TYPE_ARM },
  95   { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 },
  96   { "sparc", BFD_MACH_O_CPU_TYPE_SPARC },
  97   { "i860", BFD_MACH_O_CPU_TYPE_I860 },
  98   { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA },
  99   { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC },
 100   { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 },
 101   { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 },
 102   { "arm64", BFD_MACH_O_CPU_TYPE_ARM64 },
 103   { NULL, 0}
 104 };
 105
 106 static const bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] =
 107 {
 108   { "object", BFD_MACH_O_MH_OBJECT },
 109   { "execute", BFD_MACH_O_MH_EXECUTE },
 110   { "fvmlib", BFD_MACH_O_MH_FVMLIB },
 111   { "core", BFD_MACH_O_MH_CORE },
 112   { "preload", BFD_MACH_O_MH_PRELOAD },
 113   { "dylib", BFD_MACH_O_MH_DYLIB },
 114   { "dylinker", BFD_MACH_O_MH_DYLINKER },
 115   { "bundle", BFD_MACH_O_MH_BUNDLE },
 116   { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB },
 117   { "dym", BFD_MACH_O_MH_DSYM },
 118   { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE },
 119   { NULL, 0}
 120 };
 121
 122 static const bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] =
 123 {
 124   { "noundefs", BFD_MACH_O_MH_NOUNDEFS },
 125   { "incrlink", BFD_MACH_O_MH_INCRLINK },
 126   { "dyldlink", BFD_MACH_O_MH_DYLDLINK },
 127   { "bindatload", BFD_MACH_O_MH_BINDATLOAD },
 128   { "prebound", BFD_MACH_O_MH_PREBOUND },
 129   { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS },
 130   { "lazy_init", BFD_MACH_O_MH_LAZY_INIT },
 131   { "twolevel", BFD_MACH_O_MH_TWOLEVEL },
 132   { "force_flat", BFD_MACH_O_MH_FORCE_FLAT },
 133   { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS },
 134   { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING },
 135   { "prebindable", BFD_MACH_O_MH_PREBINDABLE },
 136   { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND },
 137   { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS },
 138   { "canonical", BFD_MACH_O_MH_CANONICAL },
 139   { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES },
 140   { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK },
 141   { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION },
 142   { "root_safe", BFD_MACH_O_MH_ROOT_SAFE },
 143   { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE },
 144   { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS },
 145   { "pie", BFD_MACH_O_MH_PIE },
 146   { NULL, 0}
 147 };
 148
 149 static const bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] =
 150 {
 151   { "segment", BFD_MACH_O_LC_SEGMENT},
 152   { "symtab", BFD_MACH_O_LC_SYMTAB},
 153   { "symseg", BFD_MACH_O_LC_SYMSEG},
 154   { "thread", BFD_MACH_O_LC_THREAD},
 155   { "unixthread", BFD_MACH_O_LC_UNIXTHREAD},
 156   { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB},
 157   { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB},
 158   { "ident", BFD_MACH_O_LC_IDENT},
 159   { "fvmfile", BFD_MACH_O_LC_FVMFILE},
 160   { "prepage", BFD_MACH_O_LC_PREPAGE},
 161   { "dysymtab", BFD_MACH_O_LC_DYSYMTAB},
 162   { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB},
 163   { "id_dylib", BFD_MACH_O_LC_ID_DYLIB},
 164   { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER},
 165   { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER},
 166   { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB},
 167   { "routines", BFD_MACH_O_LC_ROUTINES},
 168   { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK},
 169   { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA},
 170   { "sub_client", BFD_MACH_O_LC_SUB_CLIENT},
 171   { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY},
 172   { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS},
 173   { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM},
 174   { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB},
 175   { "segment_64", BFD_MACH_O_LC_SEGMENT_64},
 176   { "routines_64", BFD_MACH_O_LC_ROUTINES_64},
 177   { "uuid", BFD_MACH_O_LC_UUID},
 178   { "rpath", BFD_MACH_O_LC_RPATH},
 179   { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE},
 180   { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO},
 181   { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB},
 182   { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB},
 183   { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO},
 184   { "dyld_info", BFD_MACH_O_LC_DYLD_INFO},
 185   { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB},
 186   { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX},
 187   { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS},
 188   { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS},
 189   { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT},
 190   { "main", BFD_MACH_O_LC_MAIN},
 191   { "data_in_code", BFD_MACH_O_LC_DATA_IN_CODE},
 192   { "source_version", BFD_MACH_O_LC_SOURCE_VERSION},
 193   { "dylib_code_sign_drs", BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS},
 194   { NULL, 0}
 195 };
 196
 197 static const bfd_mach_o_xlat_name bfd_mach_o_thread_x86_name[] =
 198 {
 199   { "thread_state32", BFD_MACH_O_x86_THREAD_STATE32},
 200   { "float_state32", BFD_MACH_O_x86_FLOAT_STATE32},
 201   { "exception_state32", BFD_MACH_O_x86_EXCEPTION_STATE32},
 202   { "thread_state64", BFD_MACH_O_x86_THREAD_STATE64},
 203   { "float_state64", BFD_MACH_O_x86_FLOAT_STATE64},
 204   { "exception_state64", BFD_MACH_O_x86_EXCEPTION_STATE64},
 205   { "thread_state", BFD_MACH_O_x86_THREAD_STATE},
 206   { "float_state", BFD_MACH_O_x86_FLOAT_STATE},
 207   { "exception_state", BFD_MACH_O_x86_EXCEPTION_STATE},
 208   { "debug_state32", BFD_MACH_O_x86_DEBUG_STATE32},
 209   { "debug_state64", BFD_MACH_O_x86_DEBUG_STATE64},
 210   { "debug_state", BFD_MACH_O_x86_DEBUG_STATE},
 211   { "state_none", BFD_MACH_O_x86_THREAD_STATE_NONE},
 212   { NULL, 0 }
 213 };
 214 \f
 215 static void
 216 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table,
 217                         unsigned long val)
 218 {
 219   int first = 1;
 220
 221   for (; table->name; table++)
 222     {
 223       if (table->val & val)
 224         {
 225           if (!first)
 226             printf ("+");
 227           printf ("%s", table->name);
 228           val &= ~table->val;
 229           first = 0;
 230         }
 231     }
 232   if (val)
 233     {
 234       if (!first)
 235         printf ("+");
 236       printf ("0x%lx", val);
 237       return;
 238     }
 239   if (first)
 240     printf ("-");
 241 }
 242
 243 static const char *
 244 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name *table,
 245                              unsigned long val)
 246 {
 247   for (; table->name; table++)
 248     if (table->val == val)
 249       return table->name;
 250   return NULL;
 251 }
 252
 253 static const char *
 254 bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val)
 255 {
 256   const char *res = bfd_mach_o_get_name_or_null (table, val);
 257
 258   if (res == NULL)
 259     return "*UNKNOWN*";
 260   else
 261     return res;
 262 }
 263
 264 static void
 265 dump_header (bfd *abfd)
 266 {
 267   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 268   bfd_mach_o_header *h = &mdata->header;
 269
 270   fputs (_("Mach-O header:\n"), stdout);
 271   printf (_(" magic     : %08lx\n"), h->magic);
 272   printf (_(" cputype   : %08lx (%s)\n"), h->cputype,
 273           bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype));
 274   printf (_(" cpusubtype: %08lx\n"), h->cpusubtype);
 275   printf (_(" filetype  : %08lx (%s)\n"),
 276           h->filetype,
 277           bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype));
 278   printf (_(" ncmds     : %08lx (%lu)\n"), h->ncmds, h->ncmds);
 279   printf (_(" sizeofcmds: %08lx\n"), h->sizeofcmds);
 280   printf (_(" flags     : %08lx ("), h->flags);
 281   bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags);
 282   fputs (_(")\n"), stdout);
 283   printf (_(" reserved  : %08x\n"), h->reserved);
 284 }
 285
 286 static void
 287 dump_section_map (bfd *abfd)
 288 {
 289   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 290   unsigned int i;
 291   unsigned int sec_nbr = 0;
 292
 293   fputs (_("Segments and Sections:\n"), stdout);
 294   fputs (_(" #: Segment name     Section name     Address\n"), stdout);
 295
 296   for (i = 0; i < mdata->header.ncmds; i++)
 297     {
 298       bfd_mach_o_segment_command *seg;
 299       bfd_mach_o_section *sec;
 300
 301       if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT
 302           && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64)
 303         continue;
 304
 305       seg = &mdata->commands[i].command.segment;
 306
 307       printf ("[Segment %-16s ", seg->segname);
 308       printf_vma (seg->vmaddr);
 309       putchar ('-');
 310       printf_vma  (seg->vmaddr + seg->vmsize - 1);
 311       putchar (' ');
 312       putchar (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-');
 313       putchar (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-');
 314       putchar (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-');
 315       printf ("]\n");
 316
 317       for (sec = seg->sect_head; sec != NULL; sec = sec->next)
 318         {
 319           printf ("%02u: %-16s %-16s ", ++sec_nbr,
 320                   sec->segname, sec->sectname);
 321           printf_vma (sec->addr);
 322           putchar (' ');
 323           printf_vma  (sec->size);
 324           printf (" %08lx\n", sec->flags);
 325         }
 326     }
 327 }
 328
 329 static void
 330 dump_section_header (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_section *sec)
 331 {
 332   printf (" Section: %-16s %-16s (bfdname: %s)\n",
 333            sec->sectname, sec->segname, sec->bfdsection->name);
 334   printf ("  addr: ");
 335   printf_vma (sec->addr);
 336   printf (" size: ");
 337   printf_vma (sec->size);
 338   printf (" offset: ");
 339   printf_vma (sec->offset);
 340   printf ("\n");
 341   printf ("  align: %ld", sec->align);
 342   printf ("  nreloc: %lu  reloff: ", sec->nreloc);
 343   printf_vma (sec->reloff);
 344   printf ("\n");
 345   printf ("  flags: %08lx (type: %s", sec->flags,
 346           bfd_mach_o_get_name (bfd_mach_o_section_type_name,
 347                                sec->flags & BFD_MACH_O_SECTION_TYPE_MASK));
 348   printf (" attr: ");
 349   bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name,
 350                           sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK);
 351   printf (")\n");
 352   switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 353     {
 354     case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 355     case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 356     case BFD_MACH_O_S_SYMBOL_STUBS:
 357       printf ("  first indirect sym: %lu", sec->reserved1);
 358       printf (" (%u entries)",
 359                bfd_mach_o_section_get_nbr_indirect (abfd, sec));
 360       break;
 361     default:
 362       printf ("  reserved1: 0x%lx", sec->reserved1);
 363       break;
 364     }
 365   switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 366     {
 367     case BFD_MACH_O_S_SYMBOL_STUBS:
 368       printf ("  stub size: %lu", sec->reserved2);
 369       break;
 370     default:
 371       printf ("  reserved2: 0x%lx", sec->reserved2);
 372       break;
 373     }
 374   printf ("  reserved3: 0x%lx\n", sec->reserved3);
 375 }
 376
 377 static void
 378 dump_segment (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)
 379 {
 380   bfd_mach_o_segment_command *seg = &cmd->command.segment;
 381   bfd_mach_o_section *sec;
 382
 383   printf (" name: %s\n", *seg->segname ? seg->segname : "*none*");
 384   printf ("    vmaddr: ");
 385   printf_vma (seg->vmaddr);
 386   printf ("   vmsize: ");
 387   printf_vma  (seg->vmsize);
 388   printf ("\n");
 389   printf ("   fileoff: ");
 390   printf_vma (seg->fileoff);
 391   printf (" filesize: ");
 392   printf_vma ((bfd_vma)seg->filesize);
 393   printf (" endoff: ");
 394   printf_vma ((bfd_vma)(seg->fileoff + seg->filesize));
 395   printf ("\n");
 396   printf ("   nsects: %lu  ", seg->nsects);
 397   printf (" flags: %lx\n", seg->flags);
 398   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
 399     dump_section_header (abfd, sec);
 400 }
 401
 402 static void
 403 dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose)
 404 {
 405   bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
 406   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 407   unsigned int i;
 408
 409   printf ("              local symbols: idx: %10lu  num: %-8lu",
 410           dysymtab->ilocalsym, dysymtab->nlocalsym);
 411   printf (" (nxtidx: %lu)\n",
 412           dysymtab->ilocalsym + dysymtab->nlocalsym);
 413   printf ("           external symbols: idx: %10lu  num: %-8lu",
 414           dysymtab->iextdefsym, dysymtab->nextdefsym);
 415   printf (" (nxtidx: %lu)\n",
 416           dysymtab->iextdefsym + dysymtab->nextdefsym);
 417   printf ("          undefined symbols: idx: %10lu  num: %-8lu",
 418           dysymtab->iundefsym, dysymtab->nundefsym);
 419   printf (" (nxtidx: %lu)\n",
 420           dysymtab->iundefsym + dysymtab->nundefsym);
 421   printf ("           table of content: off: 0x%08lx  num: %-8lu",
 422           dysymtab->tocoff, dysymtab->ntoc);
 423   printf (" (endoff: 0x%08lx)\n",
 424           dysymtab->tocoff + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE);
 425   printf ("               module table: off: 0x%08lx  num: %-8lu",
 426           dysymtab->modtaboff, dysymtab->nmodtab);
 427   printf (" (endoff: 0x%08lx)\n",
 428           dysymtab->modtaboff + dysymtab->nmodtab
 429           * (mdata->header.version == 2 ?
 430              BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE));
 431   printf ("   external reference table: off: 0x%08lx  num: %-8lu",
 432           dysymtab->extrefsymoff, dysymtab->nextrefsyms);
 433   printf (" (endoff: 0x%08lx)\n",
 434           dysymtab->extrefsymoff
 435           + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE);
 436   printf ("      indirect symbol table: off: 0x%08lx  num: %-8lu",
 437           dysymtab->indirectsymoff, dysymtab->nindirectsyms);
 438   printf (" (endoff: 0x%08lx)\n",
 439           dysymtab->indirectsymoff
 440           + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE);
 441   printf ("  external relocation table: off: 0x%08lx  num: %-8lu",
 442           dysymtab->extreloff, dysymtab->nextrel);
 443   printf (" (endoff: 0x%08lx)\n",
 444           dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE);
 445   printf ("     local relocation table: off: 0x%08lx  num: %-8lu",
 446           dysymtab->locreloff, dysymtab->nlocrel);
 447   printf (" (endoff: 0x%08lx)\n",
 448           dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE);
 449
 450   if (!verbose)
 451     return;
 452
 453   if (dysymtab->ntoc > 0
 454       || dysymtab->nindirectsyms > 0
 455       || dysymtab->nextrefsyms > 0)
 456     {
 457       /* Try to read the symbols to display the toc or indirect symbols.  */
 458       bfd_mach_o_read_symtab_symbols (abfd);
 459     }
 460   else if (dysymtab->nmodtab > 0)
 461     {
 462       /* Try to read the strtab to display modules name.  */
 463       bfd_mach_o_read_symtab_strtab (abfd);
 464     }
 465
 466   for (i = 0; i < dysymtab->nmodtab; i++)
 467     {
 468       bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i];
 469       printf ("  module %u:\n", i);
 470       printf ("   name: %lu", module->module_name_idx);
 471       if (mdata->symtab && mdata->symtab->strtab)
 472         printf (": %s",
 473                  mdata->symtab->strtab + module->module_name_idx);
 474       printf ("\n");
 475       printf ("   extdefsym: idx: %8lu  num: %lu\n",
 476                module->iextdefsym, module->nextdefsym);
 477       printf ("      refsym: idx: %8lu  num: %lu\n",
 478                module->irefsym, module->nrefsym);
 479       printf ("    localsym: idx: %8lu  num: %lu\n",
 480                module->ilocalsym, module->nlocalsym);
 481       printf ("      extrel: idx: %8lu  num: %lu\n",
 482                module->iextrel, module->nextrel);
 483       printf ("        init: idx: %8u  num: %u\n",
 484                module->iinit, module->ninit);
 485       printf ("        term: idx: %8u  num: %u\n",
 486                module->iterm, module->nterm);
 487       printf ("   objc_module_info: addr: ");
 488       printf_vma (module->objc_module_info_addr);
 489       printf ("  size: %lu\n", module->objc_module_info_size);
 490     }
 491
 492   if (dysymtab->ntoc > 0)
 493     {
 494       bfd_mach_o_symtab_command *symtab = mdata->symtab;
 495
 496       printf ("  table of content: (symbol/module)\n");
 497       for (i = 0; i < dysymtab->ntoc; i++)
 498         {
 499           bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i];
 500
 501           printf ("   %4u: ", i);
 502           if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms)
 503             {
 504               const char *name = symtab->symbols[toc->symbol_index].symbol.name;
 505               printf ("%s (%lu)", name ? name : "*invalid*",
 506                        toc->symbol_index);
 507             }
 508           else
 509             printf ("%lu", toc->symbol_index);
 510
 511           printf (" / ");
 512           if (symtab && symtab->strtab
 513               && toc->module_index < dysymtab->nmodtab)
 514             {
 515               bfd_mach_o_dylib_module *mod;
 516               mod = &dysymtab->dylib_module[toc->module_index];
 517               printf ("%s (%lu)",
 518                        symtab->strtab + mod->module_name_idx,
 519                        toc->module_index);
 520             }
 521           else
 522             printf ("%lu", toc->module_index);
 523
 524           printf ("\n");
 525         }
 526     }
 527
 528   if (dysymtab->nindirectsyms != 0)
 529     {
 530       printf ("  indirect symbols:\n");
 531
 532       for (i = 0; i < mdata->nsects; i++)
 533         {
 534           bfd_mach_o_section *sec = mdata->sections[i];
 535           unsigned int j, first, last;
 536           bfd_mach_o_symtab_command *symtab = mdata->symtab;
 537           bfd_vma addr;
 538           bfd_vma entry_size;
 539
 540           switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 541             {
 542             case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 543             case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 544             case BFD_MACH_O_S_SYMBOL_STUBS:
 545               first = sec->reserved1;
 546               last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
 547               addr = sec->addr;
 548               entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
 549               printf ("  for section %s.%s:\n",
 550                        sec->segname, sec->sectname);
 551               for (j = first; j < last; j++)
 552                 {
 553                   unsigned int isym = dysymtab->indirect_syms[j];
 554
 555                   printf ("   ");
 556                   printf_vma (addr);
 557                   printf (" %5u: 0x%08x", j, isym);
 558                   if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL)
 559                     printf (" LOCAL");
 560                   if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS)
 561                     printf (" ABSOLUTE");
 562                   if (symtab && symtab->symbols
 563                       && isym < symtab->nsyms
 564                       && symtab->symbols[isym].symbol.name)
 565                     printf (" %s", symtab->symbols[isym].symbol.name);
 566                   printf ("\n");
 567                   addr += entry_size;
 568                 }
 569               break;
 570             default:
 571               break;
 572             }
 573         }
 574     }
 575   if (dysymtab->nextrefsyms > 0)
 576     {
 577       bfd_mach_o_symtab_command *symtab = mdata->symtab;
 578
 579       printf ("  external reference table: (symbol flags)\n");
 580       for (i = 0; i < dysymtab->nextrefsyms; i++)
 581         {
 582           bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i];
 583
 584           printf ("   %4u: %5lu 0x%02lx", i, ref->isym, ref->flags);
 585           if (symtab && symtab->symbols
 586               && ref->isym < symtab->nsyms
 587               && symtab->symbols[ref->isym].symbol.name)
 588             printf (" %s", symtab->symbols[ref->isym].symbol.name);
 589           printf ("\n");
 590         }
 591     }
 592
 593 }
 594
 595 static void
 596 dump_dyld_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)
 597 {
 598   bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info;
 599
 600   printf ("       rebase: off: 0x%08x  size: %-8u\n",
 601            info->rebase_off, info->rebase_size);
 602   printf ("         bind: off: 0x%08x  size: %-8u\n",
 603            info->bind_off, info->bind_size);
 604   printf ("    weak bind: off: 0x%08x  size: %-8u\n",
 605            info->weak_bind_off, info->weak_bind_size);
 606   printf ("    lazy bind: off: 0x%08x  size: %-8u\n",
 607            info->lazy_bind_off, info->lazy_bind_size);
 608   printf ("       export: off: 0x%08x  size: %-8u\n",
 609            info->export_off, info->export_size);
 610 }
 611
 612 static void
 613 dump_thread (bfd *abfd, bfd_mach_o_load_command *cmd)
 614 {
 615   bfd_mach_o_thread_command *thread = &cmd->command.thread;
 616   unsigned int j;
 617   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
 618   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 619
 620   printf (" nflavours: %lu\n", thread->nflavours);
 621   for (j = 0; j < thread->nflavours; j++)
 622     {
 623       bfd_mach_o_thread_flavour *flavour = &thread->flavours[j];
 624       const bfd_mach_o_xlat_name *name_table;
 625
 626       printf ("  %2u: flavour: 0x%08lx", j, flavour->flavour);
 627       switch (mdata->header.cputype)
 628         {
 629         case BFD_MACH_O_CPU_TYPE_I386:
 630         case BFD_MACH_O_CPU_TYPE_X86_64:
 631           name_table = bfd_mach_o_thread_x86_name;
 632           break;
 633         default:
 634           name_table = NULL;
 635           break;
 636         }
 637       if (name_table != NULL)
 638         printf (": %s", bfd_mach_o_get_name (name_table, flavour->flavour));
 639       putchar ('\n');
 640
 641       printf ("       offset: 0x%08lx  size: 0x%08lx\n",
 642               flavour->offset, flavour->size);
 643       if (bed->_bfd_mach_o_print_thread)
 644         {
 645           char *buf = xmalloc (flavour->size);
 646
 647           if (bfd_seek (abfd, flavour->offset, SEEK_SET) == 0
 648               && bfd_bread (buf, flavour->size, abfd) == flavour->size)
 649             (*bed->_bfd_mach_o_print_thread)(abfd, flavour, stdout, buf);
 650
 651           free (buf);
 652         }
 653     }
 654 }
 655
 656 static const bfd_mach_o_xlat_name bfd_mach_o_cs_magic[] =
 657 {
 658   { "embedded signature", BFD_MACH_O_CS_MAGIC_EMBEDDED_SIGNATURE },
 659   { "requirement", BFD_MACH_O_CS_MAGIC_REQUIREMENT },
 660   { "requirements", BFD_MACH_O_CS_MAGIC_REQUIREMENTS },
 661   { "code directory", BFD_MACH_O_CS_MAGIC_CODEDIRECTORY },
 662   { "embedded entitlements", BFD_MACH_O_CS_MAGIC_EMBEDDED_ENTITLEMENTS },
 663   { "blob wrapper", BFD_MACH_O_CS_MAGIC_BLOB_WRAPPER },
 664   { NULL, 0 }
 665 };
 666
 667 static const bfd_mach_o_xlat_name bfd_mach_o_cs_hash_type[] =
 668 {
 669   { "no-hash", BFD_MACH_O_CS_NO_HASH },
 670   { "sha1", BFD_MACH_O_CS_HASH_SHA1 },
 671   { "sha256", BFD_MACH_O_CS_HASH_SHA256 },
 672   { "skein 160", BFD_MACH_O_CS_HASH_PRESTANDARD_SKEIN_160x256 },
 673   { "skein 256", BFD_MACH_O_CS_HASH_PRESTANDARD_SKEIN_256x512 },
 674   { NULL, 0 }
 675 };
 676
 677 static unsigned int
 678 dump_code_signature_blob (bfd *abfd, const unsigned char *buf, unsigned int len);
 679
 680 static void
 681 dump_code_signature_superblob (bfd *abfd ATTRIBUTE_UNUSED,
 682                                const unsigned char *buf, unsigned int len)
 683 {
 684   unsigned int count;
 685   unsigned int i;
 686
 687   if (len < 12)
 688     {
 689       printf (_("  [bad block length]\n"));
 690       return;
 691     }
 692   count = bfd_getb32 (buf + 8);
 693   printf (_("  %u index entries:\n"), count);
 694   if (len < 12 + 8 * count)
 695     {
 696       printf (_("  [bad block length]\n"));
 697       return;
 698     }
 699   for (i = 0; i < count; i++)
 700     {
 701       unsigned int type;
 702       unsigned int off;
 703
 704       type = bfd_getb32 (buf + 12 + 8 * i);
 705       off = bfd_getb32 (buf + 12 + 8 * i + 4);
 706       printf (_("  index entry %u: type: %08x, offset: %08x\n"),
 707               i, type, off);
 708
 709       dump_code_signature_blob (abfd, buf + off, len - off);
 710     }
 711 }
 712
 713 static void
 714 swap_code_codedirectory_v1_in
 715   (const struct mach_o_codesign_codedirectory_external_v1 *src,
 716    struct mach_o_codesign_codedirectory_v1 *dst)
 717 {
 718   dst->version = bfd_getb32 (src->version);
 719   dst->flags = bfd_getb32 (src->flags);
 720   dst->hash_offset = bfd_getb32 (src->hash_offset);
 721   dst->ident_offset = bfd_getb32 (src->ident_offset);
 722   dst->nbr_special_slots = bfd_getb32 (src->nbr_special_slots);
 723   dst->nbr_code_slots = bfd_getb32 (src->nbr_code_slots);
 724   dst->code_limit = bfd_getb32 (src->code_limit);
 725   dst->hash_size = src->hash_size[0];
 726   dst->hash_type = src->hash_type[0];
 727   dst->spare1 = src->spare1[0];
 728   dst->page_size = src->page_size[0];
 729   dst->spare2 = bfd_getb32 (src->spare2);
 730 }
 731
 732 static void
 733 hexdump (unsigned int start, unsigned int len,
 734          const unsigned char *buf)
 735 {
 736   unsigned int i, j;
 737
 738   for (i = 0; i < len; i += 16)
 739     {
 740       printf ("%08x:", start + i);
 741       for (j = 0; j < 16; j++)
 742         {
 743           fputc (j == 8 ? '-' : ' ', stdout);
 744           if (i + j < len)
 745             printf ("%02x", buf[i + j]);
 746           else
 747             fputs ("  ", stdout);
 748         }
 749       fputc (' ', stdout);
 750       for (j = 0; j < 16; j++)
 751         {
 752           if (i + j < len)
 753             fputc (ISPRINT (buf[i + j]) ? buf[i + j] : '.', stdout);
 754           else
 755             fputc (' ', stdout);
 756         }
 757       fputc ('\n', stdout);
 758     }
 759 }
 760
 761 static void
 762 dump_code_signature_codedirectory (bfd *abfd ATTRIBUTE_UNUSED,
 763                                    const unsigned char *buf, unsigned int len)
 764 {
 765   struct mach_o_codesign_codedirectory_v1 cd;
 766   const char *id;
 767
 768   if (len < sizeof (struct mach_o_codesign_codedirectory_external_v1))
 769     {
 770       printf (_("  [bad block length]\n"));
 771       return;
 772     }
 773
 774   swap_code_codedirectory_v1_in
 775     ((const struct mach_o_codesign_codedirectory_external_v1 *) (buf + 8), &cd);
 776
 777   printf (_("  version:           %08x\n"), cd.version);
 778   printf (_("  flags:             %08x\n"), cd.flags);
 779   printf (_("  hash offset:       %08x\n"), cd.hash_offset);
 780   id = (const char *) buf + cd.ident_offset;
 781   printf (_("  ident offset:      %08x (- %08x)\n"),
 782           cd.ident_offset, cd.ident_offset + (unsigned) strlen (id) + 1);
 783   printf (_("   identity: %s\n"), id);
 784   printf (_("  nbr special slots: %08x (at offset %08x)\n"),
 785           cd.nbr_special_slots,
 786           cd.hash_offset - cd.nbr_special_slots * cd.hash_size);
 787   printf (_("  nbr code slots:    %08x\n"), cd.nbr_code_slots);
 788   printf (_("  code limit:        %08x\n"), cd.code_limit);
 789   printf (_("  hash size:         %02x\n"), cd.hash_size);
 790   printf (_("  hash type:         %02x (%s)\n"),
 791           cd.hash_type,
 792           bfd_mach_o_get_name (bfd_mach_o_cs_hash_type, cd.hash_type));
 793   printf (_("  spare1:            %02x\n"), cd.spare1);
 794   printf (_("  page size:         %02x\n"), cd.page_size);
 795   printf (_("  spare2:            %08x\n"), cd.spare2);
 796   if (cd.version >= 0x20100)
 797     printf (_("  scatter offset:    %08x\n"),
 798             (unsigned) bfd_getb32 (buf + 44));
 799 }
 800
 801 static unsigned int
 802 dump_code_signature_blob (bfd *abfd, const unsigned char *buf, unsigned int len)
 803 {
 804   unsigned int magic;
 805   unsigned int length;
 806
 807   if (len < 8)
 808     {
 809       printf (_("  [truncated block]\n"));
 810       return 0;
 811     }
 812   magic = bfd_getb32 (buf);
 813   length = bfd_getb32 (buf + 4);
 814   if (magic == 0 || length == 0)
 815     return 0;
 816
 817   printf (_(" magic : %08x (%s)\n"), magic,
 818           bfd_mach_o_get_name (bfd_mach_o_cs_magic, magic));
 819   printf (_(" length: %08x\n"), length);
 820   if (length > len)
 821     {
 822       printf (_("  [bad block length]\n"));
 823       return 0;
 824     }
 825
 826   switch (magic)
 827     {
 828     case BFD_MACH_O_CS_MAGIC_EMBEDDED_SIGNATURE:
 829       dump_code_signature_superblob (abfd, buf, length);
 830       break;
 831     case BFD_MACH_O_CS_MAGIC_CODEDIRECTORY:
 832       dump_code_signature_codedirectory (abfd, buf, length);
 833       break;
 834     default:
 835       hexdump (0, length - 8, buf + 8);
 836       break;
 837     }
 838   return length;
 839 }
 840
 841 static void
 842 dump_code_signature (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
 843 {
 844   unsigned char *buf = xmalloc (cmd->datasize);
 845   unsigned int off;
 846
 847   if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
 848       || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
 849     {
 850       non_fatal (_("cannot read code signature data"));
 851       free (buf);
 852       return;
 853     }
 854   for (off = 0; off < cmd->datasize;)
 855     {
 856       unsigned int len;
 857
 858       len = dump_code_signature_blob (abfd, buf + off, cmd->datasize - off);
 859
 860       if (len == 0)
 861         break;
 862       off += len;
 863     }
 864   free (buf);
 865 }
 866
 867 static void
 868 dump_segment_split_info (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
 869 {
 870   unsigned char *buf = xmalloc (cmd->datasize);
 871   unsigned char *p;
 872   unsigned int len;
 873   bfd_vma addr = 0;
 874
 875   if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
 876       || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
 877     {
 878       non_fatal (_("cannot read segment split info"));
 879       free (buf);
 880       return;
 881     }
 882   if (buf[cmd->datasize - 1] != 0)
 883     {
 884       non_fatal (_("segment split info is not nul terminated"));
 885       free (buf);
 886       return;
 887     }
 888
 889   switch (buf[0])
 890     {
 891     case 0:
 892       printf (_("  32 bit pointers:\n"));
 893       break;
 894     case 1:
 895       printf (_("  64 bit pointers:\n"));
 896       break;
 897     case 2:
 898       printf (_("  PPC hi-16:\n"));
 899       break;
 900     default:
 901       printf (_("  Unhandled location type %u\n"), buf[0]);
 902       break;
 903     }
 904   for (p = buf + 1; *p != 0; p += len)
 905     {
 906       addr += read_unsigned_leb128 (abfd, p, &len);
 907       fputs ("    ", stdout);
 908       bfd_printf_vma (abfd, addr);
 909       putchar ('\n');
 910     }
 911   free (buf);
 912 }
 913
 914 static void
 915 dump_load_command (bfd *abfd, bfd_mach_o_load_command *cmd,
 916                    bfd_boolean verbose)
 917 {
 918   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 919   const char *cmd_name;
 920
 921   cmd_name = bfd_mach_o_get_name_or_null
 922     (bfd_mach_o_load_command_name, cmd->type);
 923   printf ("Load command ");
 924   if (cmd_name == NULL)
 925     printf ("0x%02x:", cmd->type);
 926   else
 927     printf ("%s:", cmd_name);
 928
 929   switch (cmd->type)
 930     {
 931     case BFD_MACH_O_LC_SEGMENT:
 932     case BFD_MACH_O_LC_SEGMENT_64:
 933       dump_segment (abfd, cmd);
 934       break;
 935     case BFD_MACH_O_LC_UUID:
 936       {
 937         bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
 938         unsigned int j;
 939
 940         for (j = 0; j < sizeof (uuid->uuid); j ++)
 941           printf (" %02x", uuid->uuid[j]);
 942         putchar ('\n');
 943       }
 944       break;
 945     case BFD_MACH_O_LC_LOAD_DYLIB:
 946     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
 947     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
 948     case BFD_MACH_O_LC_REEXPORT_DYLIB:
 949     case BFD_MACH_O_LC_ID_DYLIB:
 950     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
 951       {
 952         bfd_mach_o_dylib_command *dylib = &cmd->command.dylib;
 953         printf (" %s\n", dylib->name_str);
 954         printf ("            time stamp: 0x%08lx\n",
 955                 dylib->timestamp);
 956         printf ("       current version: 0x%08lx\n",
 957                 dylib->current_version);
 958         printf ("  comptibility version: 0x%08lx\n",
 959                 dylib->compatibility_version);
 960       }
 961       break;
 962     case BFD_MACH_O_LC_LOAD_DYLINKER:
 963     case BFD_MACH_O_LC_ID_DYLINKER:
 964       printf (" %s\n", cmd->command.dylinker.name_str);
 965       break;
 966     case BFD_MACH_O_LC_SYMTAB:
 967       {
 968         bfd_mach_o_symtab_command *symtab = &cmd->command.symtab;
 969         printf ("\n"
 970                 "   symoff: 0x%08x    nsyms: %8u  (endoff: 0x%08x)\n",
 971                 symtab->symoff, symtab->nsyms,
 972                 symtab->symoff + symtab->nsyms
 973                 * (mdata->header.version == 2
 974                    ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE));
 975         printf ("   stroff: 0x%08x  strsize: %8u  (endoff: 0x%08x)\n",
 976                 symtab->stroff, symtab->strsize,
 977                 symtab->stroff + symtab->strsize);
 978         break;
 979       }
 980     case BFD_MACH_O_LC_DYSYMTAB:
 981       putchar ('\n');
 982       dump_dysymtab (abfd, cmd, verbose);
 983       break;
 984     case BFD_MACH_O_LC_LOADFVMLIB:
 985     case BFD_MACH_O_LC_IDFVMLIB:
 986       {
 987         bfd_mach_o_fvmlib_command *fvmlib = &cmd->command.fvmlib;
 988         printf (" %s\n", fvmlib->name_str);
 989         printf ("         minor version: 0x%08x\n", fvmlib->minor_version);
 990         printf ("        header address: 0x%08x\n", fvmlib->header_addr);
 991       }
 992       break;
 993     case BFD_MACH_O_LC_CODE_SIGNATURE:
 994     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
 995     case BFD_MACH_O_LC_FUNCTION_STARTS:
 996       {
 997         bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit;
 998         printf
 999           ("\n"
1000            "  dataoff: 0x%08lx  datasize: 0x%08lx  (endoff: 0x%08lx)\n",
1001            linkedit->dataoff, linkedit->datasize,
1002            linkedit->dataoff + linkedit->datasize);
1003
1004         if (verbose && cmd->type == BFD_MACH_O_LC_CODE_SIGNATURE)
1005           dump_code_signature (abfd, linkedit);
1006         else if (verbose && cmd->type == BFD_MACH_O_LC_SEGMENT_SPLIT_INFO)
1007           dump_segment_split_info (abfd, linkedit);
1008         break;
1009       }
1010     case BFD_MACH_O_LC_SUB_FRAMEWORK:
1011     case BFD_MACH_O_LC_SUB_UMBRELLA:
1012     case BFD_MACH_O_LC_SUB_LIBRARY:
1013     case BFD_MACH_O_LC_SUB_CLIENT:
1014     case BFD_MACH_O_LC_RPATH:
1015       {
1016         bfd_mach_o_str_command *str = &cmd->command.str;
1017         printf (" %s\n", str->str);
1018         break;
1019       }
1020     case BFD_MACH_O_LC_THREAD:
1021     case BFD_MACH_O_LC_UNIXTHREAD:
1022       dump_thread (abfd, cmd);
1023       break;
1024     case BFD_MACH_O_LC_ENCRYPTION_INFO:
1025       {
1026         bfd_mach_o_encryption_info_command *cryp =
1027           &cmd->command.encryption_info;
1028         printf
1029           ("\n"
1030            "  cryptoff: 0x%08x  cryptsize: 0x%08x (endoff 0x%08x)"
1031            " cryptid: %u\n",
1032            cryp->cryptoff, cryp->cryptsize,
1033            cryp->cryptoff + cryp->cryptsize,
1034            cryp->cryptid);
1035       }
1036       break;
1037     case BFD_MACH_O_LC_DYLD_INFO:
1038       putchar ('\n');
1039       dump_dyld_info (abfd, cmd);
1040       break;
1041     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
1042     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
1043       {
1044         bfd_mach_o_version_min_command *ver = &cmd->command.version_min;
1045
1046         printf (" %u.%u.%u\n", ver->rel, ver->maj, ver->min);
1047       }
1048       break;
1049     case BFD_MACH_O_LC_SOURCE_VERSION:
1050       {
1051         bfd_mach_o_source_version_command *version =
1052           &cmd->command.source_version;
1053         printf ("\n"
1054                 "   version a.b.c.d.e: %u.%u.%u.%u.%u\n",
1055                 version->a, version->b, version->c, version->d, version->e);
1056         break;
1057       }
1058     case BFD_MACH_O_LC_MAIN:
1059       {
1060         bfd_mach_o_main_command *entry = &cmd->command.main;
1061         printf ("\n"
1062                 "   entry offset: ");
1063         printf_vma (entry->entryoff);
1064         printf ("\n"
1065                 "   stack size:   ");
1066         printf_vma (entry->stacksize);
1067         printf ("\n");
1068         break;
1069       }
1070     default:
1071       putchar ('\n');
1072       printf ("  offset: 0x%08lx\n", (unsigned long)cmd->offset);
1073       printf ("    size: 0x%08lx\n", (unsigned long)cmd->len);
1074       break;
1075     }
1076   putchar ('\n');
1077 }
1078
1079 static void
1080 dump_load_commands (bfd *abfd, unsigned int cmd32, unsigned int cmd64)
1081 {
1082   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1083   unsigned int i;
1084
1085   for (i = 0; i < mdata->header.ncmds; i++)
1086     {
1087       bfd_mach_o_load_command *cmd = &mdata->commands[i];
1088
1089       if (cmd32 == 0)
1090         dump_load_command (abfd, cmd, FALSE);
1091       else if (cmd->type == cmd32 || cmd->type == cmd64)
1092         dump_load_command (abfd, cmd, TRUE);
1093     }
1094 }
1095
1096 static const char * const unwind_x86_64_regs[] =
1097   {"", "rbx", "r12", "r13", "r14", "r15", "rbp", "???" };
1098
1099 static const char * const unwind_x86_regs[] =
1100   {"", "ebx", "ecx", "edx", "edi", "edi", "ebp", "???" };
1101
1102 /* Dump x86 or x86-64 compact unwind encoding.  Works for both architecture,
1103    as the encoding is the same (but not register names).  */
1104
1105 static void
1106 dump_unwind_encoding_x86 (unsigned int encoding, unsigned int sz,
1107                           const char * const regs_name[])
1108 {
1109   unsigned int mode;
1110
1111   mode = encoding & MACH_O_UNWIND_X86_64_MODE_MASK;
1112   switch (mode)
1113     {
1114     case MACH_O_UNWIND_X86_64_MODE_RBP_FRAME:
1115       {
1116         unsigned int regs;
1117         char pfx = sz == 8 ? 'R' : 'E';
1118
1119         regs = encoding & MACH_O_UNWIND_X86_64_RBP_FRAME_REGSITERS;
1120         printf (" %cSP frame", pfx);
1121         if (regs != 0)
1122           {
1123             unsigned int offset;
1124             int i;
1125
1126             offset = (encoding & MACH_O_UNWIND_X86_64_RBP_FRAME_OFFSET) >> 16;
1127             printf (" at %cBP-%u:", pfx, offset * sz);
1128             for (i = 0; i < 5; i++)
1129               {
1130                 unsigned int reg = (regs >> (i * 3)) & 0x7;
1131                 if (reg != MACH_O_UNWIND_X86_64_REG_NONE)
1132                   printf (" %s", regs_name[reg]);
1133               }
1134           }
1135       }
1136       break;
1137     case MACH_O_UNWIND_X86_64_MODE_STACK_IMMD:
1138     case MACH_O_UNWIND_X86_64_MODE_STACK_IND:
1139       {
1140         unsigned int stack_size;
1141         unsigned int reg_count;
1142         unsigned int reg_perm;
1143         unsigned int regs[6];
1144         int i, j;
1145
1146         printf (" frameless");
1147         stack_size =
1148           (encoding & MACH_O_UNWIND_X86_64_FRAMELESS_STACK_SIZE) >> 16;
1149         reg_count =
1150           (encoding & MACH_O_UNWIND_X86_64_FRAMELESS_REG_COUNT) >> 10;
1151         reg_perm = encoding & MACH_O_UNWIND_X86_64_FRAMELESS_REG_PERMUTATION;
1152
1153         if (mode == MACH_O_UNWIND_X86_64_MODE_STACK_IMMD)
1154           printf (" size: 0x%03x", stack_size * sz);
1155         else
1156           {
1157             unsigned int stack_adj;
1158
1159             stack_adj =
1160               (encoding & MACH_O_UNWIND_X86_64_FRAMELESS_STACK_ADJUST) >> 13;
1161             printf (" size at 0x%03x + 0x%02x", stack_size, stack_adj * sz);
1162           }
1163         /* Registers are coded using arithmetic compression: the register
1164            is indexed in range 0-6, the second in range 0-5, the third in
1165            range 0-4, etc.  Already used registers are removed in next
1166            ranges.  */
1167 #define DO_PERM(R, NUM) R = reg_perm / NUM; reg_perm -= R * NUM
1168         switch (reg_count)
1169           {
1170           case 6:
1171           case 5:
1172             DO_PERM (regs[0], 120);
1173             DO_PERM (regs[1], 24);
1174             DO_PERM (regs[2], 6);
1175             DO_PERM (regs[3], 2);
1176             DO_PERM (regs[4], 1);
1177             regs[5] = 0; /* Not used if reg_count = 5.  */
1178             break;
1179           case 4:
1180             DO_PERM (regs[0], 60);
1181             DO_PERM (regs[1], 12);
1182             DO_PERM (regs[2], 3);
1183             DO_PERM (regs[3], 1);
1184             break;
1185           case 3:
1186             DO_PERM (regs[0], 20);
1187             DO_PERM (regs[1], 4);
1188             DO_PERM (regs[2], 1);
1189             break;
1190           case 2:
1191             DO_PERM (regs[0], 5);
1192             DO_PERM (regs[1], 1);
1193             break;
1194           case 1:
1195             DO_PERM (regs[0], 1);
1196             break;
1197           case 0:
1198             break;
1199           default:
1200             printf (" [bad reg count]");
1201             return;
1202           }
1203 #undef DO_PERM
1204         /* Renumber.  */
1205         for (i = reg_count - 1; i >= 0; i--)
1206           {
1207             unsigned int inc = 1;
1208             for (j = 0; j < i; j++)
1209               if (regs[i] >= regs[j])
1210                 inc++;
1211             regs[i] += inc;
1212           }
1213         /* Display.  */
1214         for (i = 0; i < (int) reg_count; i++)
1215           printf (" %s", regs_name[regs[i]]);
1216       }
1217       break;
1218     case MACH_O_UNWIND_X86_64_MODE_DWARF:
1219       printf (" Dwarf offset: 0x%06x",
1220               encoding & MACH_O_UNWIND_X86_64_DWARF_SECTION_OFFSET);
1221       break;
1222     default:
1223       printf (" [unhandled mode]");
1224       break;
1225     }
1226 }
1227
1228 static void
1229 dump_unwind_encoding (bfd_mach_o_data_struct *mdata, unsigned int encoding)
1230 {
1231   printf ("0x%08x", encoding);
1232   if (encoding == 0)
1233     return;
1234
1235   switch (mdata->header.cputype)
1236     {
1237     case BFD_MACH_O_CPU_TYPE_X86_64:
1238       dump_unwind_encoding_x86 (encoding, 8, unwind_x86_64_regs);
1239       break;
1240     case BFD_MACH_O_CPU_TYPE_I386:
1241       dump_unwind_encoding_x86 (encoding, 4, unwind_x86_regs);
1242       break;
1243     default:
1244       printf (" [unhandled cpu]");
1245       break;
1246     }
1247   if (encoding & MACH_O_UNWIND_HAS_LSDA)
1248     printf (" LSDA");
1249   if (encoding & MACH_O_UNWIND_PERSONALITY_MASK)
1250     printf (" PERS(%u)",
1251             ((encoding & MACH_O_UNWIND_PERSONALITY_MASK)
1252              >> MACH_O_UNWIND_PERSONALITY_SHIFT));
1253 }
1254
1255 static void
1256 dump_obj_compact_unwind (bfd *abfd,
1257                          const unsigned char *content, bfd_size_type size)
1258 {
1259   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1260   int is_64 = mdata->header.version == 2;
1261   const unsigned char *p;
1262
1263   printf (" compact unwind info:\n");
1264   printf (" start            length   personality      lsda\n");
1265
1266   if (is_64)
1267     {
1268       struct mach_o_compact_unwind_64 *e =
1269         (struct mach_o_compact_unwind_64 *) content;
1270
1271       for (p = content; p < content + size; p += sizeof (*e))
1272         {
1273           e = (struct mach_o_compact_unwind_64 *) p;
1274
1275           putchar (' ');
1276           fprintf_vma (stdout, bfd_get_64 (abfd, e->start));
1277           printf (" %08lx", bfd_get_32 (abfd, e->length));
1278           putchar (' ');
1279           fprintf_vma (stdout, bfd_get_64 (abfd, e->personnality));
1280           putchar (' ');
1281           fprintf_vma (stdout, bfd_get_64 (abfd, e->lsda));
1282           putchar ('\n');
1283
1284           printf ("  encoding: ");
1285           dump_unwind_encoding (mdata, bfd_get_32 (abfd, e->encoding));
1286           putchar ('\n');
1287         }
1288     }
1289   else
1290     {
1291       printf ("unhandled\n");
1292     }
1293 }
1294
1295 static void
1296 dump_exe_compact_unwind (bfd *abfd,
1297                          const unsigned char *content, bfd_size_type size)
1298 {
1299   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1300   struct mach_o_unwind_info_header *hdr;
1301   unsigned int version;
1302   unsigned int encodings_offset;
1303   unsigned int encodings_count;
1304   unsigned int personality_offset;
1305   unsigned int personality_count;
1306   unsigned int index_offset;
1307   unsigned int index_count;
1308   struct mach_o_unwind_index_entry *index_entry;
1309   unsigned int i;
1310
1311   /* The header.  */
1312   printf (" compact unwind info:\n");
1313
1314   hdr = (struct mach_o_unwind_info_header *) content;
1315   if (size < sizeof (*hdr))
1316     {
1317       printf ("  truncated!\n");
1318       return;
1319     }
1320
1321   version = bfd_get_32 (abfd, hdr->version);
1322   if (version != MACH_O_UNWIND_SECTION_VERSION)
1323     {
1324       printf ("  unknown version: %u\n", version);
1325       return;
1326     }
1327   encodings_offset = bfd_get_32 (abfd, hdr->encodings_array_offset);
1328   encodings_count = bfd_get_32 (abfd, hdr->encodings_array_count);
1329   personality_offset = bfd_get_32 (abfd, hdr->personality_array_offset);
1330   personality_count = bfd_get_32 (abfd, hdr->personality_array_count);
1331   index_offset = bfd_get_32 (abfd, hdr->index_offset);
1332   index_count = bfd_get_32 (abfd, hdr->index_count);
1333   printf ("   %u encodings, %u personalities, %u level-1 indexes:\n",
1334           encodings_count, personality_count, index_count);
1335
1336   /* Level-1 index.  */
1337   printf ("   idx function   level2 off lsda off\n");
1338
1339   index_entry = (struct mach_o_unwind_index_entry *) (content + index_offset);
1340   for (i = 0; i < index_count; i++)
1341     {
1342       unsigned int func_offset;
1343       unsigned int level2_offset;
1344       unsigned int lsda_offset;
1345
1346       func_offset = bfd_get_32 (abfd, index_entry->function_offset);
1347       level2_offset = bfd_get_32 (abfd, index_entry->second_level_offset);
1348       lsda_offset = bfd_get_32 (abfd, index_entry->lsda_index_offset);
1349       printf ("   %3u 0x%08x 0x%08x 0x%08x\n",
1350               i, func_offset, level2_offset, lsda_offset);
1351       index_entry++;
1352     }
1353
1354   /* Level-1 index.  */
1355   index_entry = (struct mach_o_unwind_index_entry *) (content + index_offset);
1356   for (i = 0; i < index_count; i++)
1357     {
1358       unsigned int func_offset;
1359       unsigned int level2_offset;
1360       const unsigned char *level2;
1361       unsigned int kind;
1362
1363       func_offset = bfd_get_32 (abfd, index_entry->function_offset);
1364       level2_offset = bfd_get_32 (abfd, index_entry->second_level_offset);
1365
1366       /* No level-2 for this index (should be the last index).  */
1367       if (level2_offset == 0)
1368         continue;
1369
1370       level2 = content + level2_offset;
1371       kind = bfd_get_32 (abfd, level2);
1372       switch (kind)
1373         {
1374         case MACH_O_UNWIND_SECOND_LEVEL_COMPRESSED:
1375           {
1376             struct mach_o_unwind_compressed_second_level_page_header *l2;
1377             unsigned int entry_offset;
1378             unsigned int entry_count;
1379             unsigned int l2_encodings_offset;
1380             unsigned int l2_encodings_count;
1381             const unsigned char *en;
1382             unsigned int j;
1383
1384             l2 = (struct mach_o_unwind_compressed_second_level_page_header *)
1385               level2;
1386             entry_offset = bfd_get_16 (abfd, l2->entry_page_offset);
1387             entry_count = bfd_get_16 (abfd, l2->entry_count);
1388             l2_encodings_offset = bfd_get_16 (abfd, l2->encodings_offset);
1389             l2_encodings_count = bfd_get_16 (abfd, l2->encodings_count);
1390
1391             printf ("   index %2u: compressed second level: "
1392                     "%u entries, %u encodings (at 0x%08x)\n",
1393                     i, entry_count, l2_encodings_count, l2_encodings_offset);
1394             printf ("   #    function   eidx  encoding\n");
1395
1396             en = level2 + entry_offset;
1397             for (j = 0; j < entry_count; j++)
1398               {
1399                 unsigned int entry;
1400                 unsigned int en_func;
1401                 unsigned int enc_idx;
1402                 unsigned int encoding;
1403                 const unsigned char *enc_addr;
1404
1405                 entry = bfd_get_32 (abfd, en);
1406                 en_func =
1407                   MACH_O_UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET (entry);
1408                 enc_idx =
1409                   MACH_O_UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX (entry);
1410                 if (enc_idx < encodings_count)
1411                   enc_addr = content + encodings_offset
1412                     + 4 * enc_idx;
1413                 else
1414                   enc_addr = level2 + l2_encodings_offset
1415                     + 4 * (enc_idx - encodings_count);
1416                 encoding = bfd_get_32 (abfd, enc_addr);
1417
1418                 printf ("   %-4u 0x%08x [%3u] ", j,
1419                         func_offset + en_func, enc_idx);
1420                 dump_unwind_encoding (mdata, encoding);
1421                 putchar ('\n');
1422
1423                 en += 4;
1424               }
1425           }
1426           break;
1427
1428         case MACH_O_UNWIND_SECOND_LEVEL_REGULAR:
1429           {
1430             struct mach_o_unwind_regular_second_level_page_header *l2;
1431             struct mach_o_unwind_regular_second_level_entry *en;
1432             unsigned int entry_offset;
1433             unsigned int entry_count;
1434             unsigned int j;
1435
1436             l2 = (struct mach_o_unwind_regular_second_level_page_header *)
1437               level2;
1438
1439             entry_offset = bfd_get_16 (abfd, l2->entry_page_offset);
1440             entry_count = bfd_get_16 (abfd, l2->entry_count);
1441             printf ("   index %2u: regular level 2 at 0x%04x, %u entries\n",
1442                     i, entry_offset, entry_count);
1443             printf ("   #    function   encoding\n");
1444
1445             en = (struct mach_o_unwind_regular_second_level_entry *)
1446               (level2 + entry_offset);
1447             for (j = 0; j < entry_count; j++)
1448               {
1449                 unsigned int en_func;
1450                 unsigned int encoding;
1451
1452                 en_func = bfd_get_32 (abfd, en->function_offset);
1453                 encoding = bfd_get_32 (abfd, en->encoding);
1454                 printf ("   %-4u 0x%08x ", j, en_func);
1455                 dump_unwind_encoding (mdata, encoding);
1456                 putchar ('\n');
1457                 en++;
1458               }
1459           }
1460           break;
1461
1462         default:
1463           printf ("   index %2u: unhandled second level format (%u)\n",
1464                   i, kind);
1465           break;
1466         }
1467
1468       {
1469         struct mach_o_unwind_lsda_index_entry *lsda;
1470         unsigned int lsda_offset;
1471         unsigned int next_lsda_offset;
1472         unsigned int nbr_lsda;
1473         unsigned int j;
1474
1475         lsda_offset = bfd_get_32 (abfd, index_entry->lsda_index_offset);
1476         next_lsda_offset = bfd_get_32 (abfd, index_entry[1].lsda_index_offset);
1477         lsda = (struct mach_o_unwind_lsda_index_entry *)
1478           (content + lsda_offset);
1479         nbr_lsda = (next_lsda_offset - lsda_offset) / sizeof (*lsda);
1480         for (j = 0; j < nbr_lsda; j++)
1481           {
1482             printf ("   lsda %3u: function 0x%08x lsda 0x%08x\n",
1483                     j, (unsigned int) bfd_get_32 (abfd, lsda->function_offset),
1484                     (unsigned int) bfd_get_32 (abfd, lsda->lsda_offset));
1485             lsda++;
1486           }
1487       }
1488       index_entry++;
1489     }
1490 }
1491
1492 static void
1493 dump_section_content (bfd *abfd,
1494                       const char *segname, const char *sectname,
1495                       void (*dump)(bfd*, const unsigned char*, bfd_size_type))
1496 {
1497   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1498   unsigned int i;
1499
1500   for (i = 0; i < mdata->header.ncmds; i++)
1501     {
1502       bfd_mach_o_load_command *cmd = &mdata->commands[i];
1503       if (cmd->type == BFD_MACH_O_LC_SEGMENT
1504           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
1505         {
1506           bfd_mach_o_segment_command *seg = &cmd->command.segment;
1507           bfd_mach_o_section *sec;
1508           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1509             if (strcmp (sec->segname, segname) == 0
1510                 && strcmp (sec->sectname, sectname) == 0)
1511               {
1512                 bfd_size_type size;
1513                 asection *bfdsec = sec->bfdsection;
1514                 unsigned char *content;
1515
1516                 size = bfd_get_section_size (bfdsec);
1517                 content = (unsigned char *) xmalloc (size);
1518                 bfd_get_section_contents (abfd, bfdsec, content, 0, size);
1519
1520                 (*dump)(abfd, content, size);
1521
1522                 free (content);
1523               }
1524         }
1525     }
1526 }
1527
1528 /* Dump ABFD (according to the options[] array).  */
1529
1530 static void
1531 mach_o_dump (bfd *abfd)
1532 {
1533   if (options[OPT_HEADER].selected)
1534     dump_header (abfd);
1535   if (options[OPT_SECTION].selected)
1536     dump_load_commands (abfd, BFD_MACH_O_LC_SEGMENT, BFD_MACH_O_LC_SEGMENT_64);
1537   if (options[OPT_MAP].selected)
1538     dump_section_map (abfd);
1539   if (options[OPT_LOAD].selected)
1540     dump_load_commands (abfd, 0, 0);
1541   if (options[OPT_DYSYMTAB].selected)
1542     dump_load_commands (abfd, BFD_MACH_O_LC_DYSYMTAB, 0);
1543   if (options[OPT_CODESIGN].selected)
1544     dump_load_commands (abfd, BFD_MACH_O_LC_CODE_SIGNATURE, 0);
1545   if (options[OPT_SEG_SPLIT_INFO].selected)
1546     dump_load_commands (abfd, BFD_MACH_O_LC_SEGMENT_SPLIT_INFO, 0);
1547   if (options[OPT_COMPACT_UNWIND].selected)
1548     {
1549       dump_section_content (abfd, "__LD", "__compact_unwind",
1550                             dump_obj_compact_unwind);
1551       dump_section_content (abfd, "__TEXT", "__unwind_info",
1552                             dump_exe_compact_unwind);
1553     }
1554 }
1555
1556 /* Vector for Mach-O.  */
1557
1558 const struct objdump_private_desc objdump_private_desc_mach_o =
1559   {
1560     mach_o_help,
1561     mach_o_filter,
1562     mach_o_dump,
1563     options
1564   };