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