/* od-macho.c -- dump information about an Mach-O object file. Copyright 2011 Free Software Foundation, Inc. Written by Tristan Gingold, Adacore. This file is part of GNU Binutils. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include #include "sysdep.h" #include "safe-ctype.h" #include "bfd.h" #include "objdump.h" #include "bucomm.h" #include "bfdlink.h" #include "mach-o.h" #include "mach-o/external.h" /* Index of the options in the options[] array. */ #define OPT_HEADER 0 #define OPT_SECTION 1 #define OPT_MAP 2 #define OPT_LOAD 3 #define OPT_DYSYMTAB 4 /* List of actions. */ static struct objdump_private_option options[] = { { "header", 0 }, { "section", 0 }, { "map", 0 }, { "load", 0 }, { "dysymtab", 0 }, { NULL, 0 } }; /* Display help. */ static void mach_o_help (FILE *stream) { fprintf (stream, _("\ For Mach-O files:\n\ header Display the file header\n\ section Display the segments and sections commands\n\ map Display the section map\n\ load Display the load commands\n\ dysymtab Display the dynamic symbol table\n\ ")); } /* Return TRUE if ABFD is handled. */ static int mach_o_filter (bfd *abfd) { return bfd_get_flavour (abfd) == bfd_target_mach_o_flavour; } static const bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] = { { "vax", BFD_MACH_O_CPU_TYPE_VAX }, { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 }, { "i386", BFD_MACH_O_CPU_TYPE_I386 }, { "mips", BFD_MACH_O_CPU_TYPE_MIPS }, { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 }, { "hppa", BFD_MACH_O_CPU_TYPE_HPPA }, { "arm", BFD_MACH_O_CPU_TYPE_ARM }, { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 }, { "sparc", BFD_MACH_O_CPU_TYPE_SPARC }, { "i860", BFD_MACH_O_CPU_TYPE_I860 }, { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA }, { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC }, { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 }, { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 }, { NULL, 0} }; static const bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] = { { "object", BFD_MACH_O_MH_OBJECT }, { "execute", BFD_MACH_O_MH_EXECUTE }, { "fvmlib", BFD_MACH_O_MH_FVMLIB }, { "core", BFD_MACH_O_MH_CORE }, { "preload", BFD_MACH_O_MH_PRELOAD }, { "dylib", BFD_MACH_O_MH_DYLIB }, { "dylinker", BFD_MACH_O_MH_DYLINKER }, { "bundle", BFD_MACH_O_MH_BUNDLE }, { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB }, { "dym", BFD_MACH_O_MH_DSYM }, { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE }, { NULL, 0} }; static const bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] = { { "noundefs", BFD_MACH_O_MH_NOUNDEFS }, { "incrlink", BFD_MACH_O_MH_INCRLINK }, { "dyldlink", BFD_MACH_O_MH_DYLDLINK }, { "bindatload", BFD_MACH_O_MH_BINDATLOAD }, { "prebound", BFD_MACH_O_MH_PREBOUND }, { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS }, { "lazy_init", BFD_MACH_O_MH_LAZY_INIT }, { "twolevel", BFD_MACH_O_MH_TWOLEVEL }, { "force_flat", BFD_MACH_O_MH_FORCE_FLAT }, { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS }, { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING }, { "prebindable", BFD_MACH_O_MH_PREBINDABLE }, { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND }, { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS }, { "canonical", BFD_MACH_O_MH_CANONICAL }, { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES }, { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK }, { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION }, { "root_safe", BFD_MACH_O_MH_ROOT_SAFE }, { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE }, { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS }, { "pie", BFD_MACH_O_MH_PIE }, { NULL, 0} }; static const bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] = { { "segment", BFD_MACH_O_LC_SEGMENT}, { "symtab", BFD_MACH_O_LC_SYMTAB}, { "symseg", BFD_MACH_O_LC_SYMSEG}, { "thread", BFD_MACH_O_LC_THREAD}, { "unixthread", BFD_MACH_O_LC_UNIXTHREAD}, { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB}, { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB}, { "ident", BFD_MACH_O_LC_IDENT}, { "fvmfile", BFD_MACH_O_LC_FVMFILE}, { "prepage", BFD_MACH_O_LC_PREPAGE}, { "dysymtab", BFD_MACH_O_LC_DYSYMTAB}, { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB}, { "id_dylib", BFD_MACH_O_LC_ID_DYLIB}, { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER}, { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER}, { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB}, { "routines", BFD_MACH_O_LC_ROUTINES}, { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK}, { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA}, { "sub_client", BFD_MACH_O_LC_SUB_CLIENT}, { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY}, { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS}, { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM}, { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB}, { "segment_64", BFD_MACH_O_LC_SEGMENT_64}, { "routines_64", BFD_MACH_O_LC_ROUTINES_64}, { "uuid", BFD_MACH_O_LC_UUID}, { "rpath", BFD_MACH_O_LC_RPATH}, { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE}, { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO}, { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB}, { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB}, { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO}, { "dyld_info", BFD_MACH_O_LC_DYLD_INFO}, { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB}, { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX}, { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS}, { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS}, { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT}, { NULL, 0} }; static const bfd_mach_o_xlat_name bfd_mach_o_thread_x86_name[] = { { "thread_state32", BFD_MACH_O_x86_THREAD_STATE32}, { "float_state32", BFD_MACH_O_x86_FLOAT_STATE32}, { "exception_state32", BFD_MACH_O_x86_EXCEPTION_STATE32}, { "thread_state64", BFD_MACH_O_x86_THREAD_STATE64}, { "float_state64", BFD_MACH_O_x86_FLOAT_STATE64}, { "exception_state64", BFD_MACH_O_x86_EXCEPTION_STATE64}, { "thread_state", BFD_MACH_O_x86_THREAD_STATE}, { "float_state", BFD_MACH_O_x86_FLOAT_STATE}, { "exception_state", BFD_MACH_O_x86_EXCEPTION_STATE}, { "debug_state32", BFD_MACH_O_x86_DEBUG_STATE32}, { "debug_state64", BFD_MACH_O_x86_DEBUG_STATE64}, { "debug_state", BFD_MACH_O_x86_DEBUG_STATE}, { "state_none", BFD_MACH_O_x86_THREAD_STATE_NONE}, { NULL, 0 } }; static void bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table, unsigned long val) { int first = 1; for (; table->name; table++) { if (table->val & val) { if (!first) printf ("+"); printf ("%s", table->name); val &= ~table->val; first = 0; } } if (val) { if (!first) printf ("+"); printf ("0x%lx", val); return; } if (first) printf ("-"); } static const char * bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name *table, unsigned long val) { for (; table->name; table++) if (table->val == val) return table->name; return NULL; } static const char * bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val) { const char *res = bfd_mach_o_get_name_or_null (table, val); if (res == NULL) return "*UNKNOWN*"; else return res; } static void dump_header (bfd *abfd) { bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); bfd_mach_o_header *h = &mdata->header; fputs (_("Mach-O header:\n"), stdout); printf (_(" magic : %08lx\n"), h->magic); printf (_(" cputype : %08lx (%s)\n"), h->cputype, bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype)); printf (_(" cpusubtype: %08lx\n"), h->cpusubtype); printf (_(" filetype : %08lx (%s)\n"), h->filetype, bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype)); printf (_(" ncmds : %08lx (%lu)\n"), h->ncmds, h->ncmds); printf (_(" sizeofcmds: %08lx\n"), h->sizeofcmds); printf (_(" flags : %08lx ("), h->flags); bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags); fputs (_(")\n"), stdout); printf (_(" reserved : %08x\n"), h->reserved); } static void dump_section_map (bfd *abfd) { bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); unsigned int i; unsigned int sec_nbr = 0; fputs (_("Segments and Sections:\n"), stdout); fputs (_(" #: Segment name Section name Address\n"), stdout); for (i = 0; i < mdata->header.ncmds; i++) { bfd_mach_o_segment_command *seg; bfd_mach_o_section *sec; if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64) continue; seg = &mdata->commands[i].command.segment; printf ("[Segment %-16s ", seg->segname); printf_vma (seg->vmaddr); putchar ('-'); printf_vma (seg->vmaddr + seg->vmsize - 1); putchar (' '); putchar (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-'); putchar (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-'); putchar (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-'); printf ("]\n"); for (sec = seg->sect_head; sec != NULL; sec = sec->next) { printf ("%02u: %-16s %-16s ", ++sec_nbr, sec->segname, sec->sectname); printf_vma (sec->addr); putchar (' '); printf_vma (sec->size); printf (" %08lx\n", sec->flags); } } } static void dump_section (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_section *sec) { printf (" Section: %-16s %-16s (bfdname: %s)\n", sec->sectname, sec->segname, sec->bfdsection->name); printf (" addr: "); printf_vma (sec->addr); printf (" size: "); printf_vma (sec->size); printf (" offset: "); printf_vma (sec->offset); printf ("\n"); printf (" align: %ld", sec->align); printf (" nreloc: %lu reloff: ", sec->nreloc); printf_vma (sec->reloff); printf ("\n"); printf (" flags: %08lx (type: %s", sec->flags, bfd_mach_o_get_name (bfd_mach_o_section_type_name, sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)); printf (" attr: "); bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name, sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK); printf (")\n"); switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) { case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: case BFD_MACH_O_S_SYMBOL_STUBS: printf (" first indirect sym: %lu", sec->reserved1); printf (" (%u entries)", bfd_mach_o_section_get_nbr_indirect (abfd, sec)); break; default: printf (" reserved1: 0x%lx", sec->reserved1); break; } switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) { case BFD_MACH_O_S_SYMBOL_STUBS: printf (" stub size: %lu", sec->reserved2); break; default: printf (" reserved2: 0x%lx", sec->reserved2); break; } printf (" reserved3: 0x%lx\n", sec->reserved3); } static void dump_segment (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd) { bfd_mach_o_segment_command *seg = &cmd->command.segment; bfd_mach_o_section *sec; printf (" name: %s\n", *seg->segname ? seg->segname : "*none*"); printf (" vmaddr: "); printf_vma (seg->vmaddr); printf (" vmsize: "); printf_vma (seg->vmsize); printf ("\n"); printf (" fileoff: "); printf_vma (seg->fileoff); printf (" filesize: "); printf_vma ((bfd_vma)seg->filesize); printf (" endoff: "); printf_vma ((bfd_vma)(seg->fileoff + seg->filesize)); printf ("\n"); printf (" nsects: %lu ", seg->nsects); printf (" flags: %lx\n", seg->flags); for (sec = seg->sect_head; sec != NULL; sec = sec->next) dump_section (abfd, sec); } static void dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose) { bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab; bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); unsigned int i; printf (" local symbols: idx: %10lu num: %-8lu", dysymtab->ilocalsym, dysymtab->nlocalsym); printf (" (nxtidx: %lu)\n", dysymtab->ilocalsym + dysymtab->nlocalsym); printf (" external symbols: idx: %10lu num: %-8lu", dysymtab->iextdefsym, dysymtab->nextdefsym); printf (" (nxtidx: %lu)\n", dysymtab->iextdefsym + dysymtab->nextdefsym); printf (" undefined symbols: idx: %10lu num: %-8lu", dysymtab->iundefsym, dysymtab->nundefsym); printf (" (nxtidx: %lu)\n", dysymtab->iundefsym + dysymtab->nundefsym); printf (" table of content: off: 0x%08lx num: %-8lu", dysymtab->tocoff, dysymtab->ntoc); printf (" (endoff: 0x%08lx)\n", dysymtab->tocoff + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE); printf (" module table: off: 0x%08lx num: %-8lu", dysymtab->modtaboff, dysymtab->nmodtab); printf (" (endoff: 0x%08lx)\n", dysymtab->modtaboff + dysymtab->nmodtab * (mdata->header.version == 2 ? BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE)); printf (" external reference table: off: 0x%08lx num: %-8lu", dysymtab->extrefsymoff, dysymtab->nextrefsyms); printf (" (endoff: 0x%08lx)\n", dysymtab->extrefsymoff + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE); printf (" indirect symbol table: off: 0x%08lx num: %-8lu", dysymtab->indirectsymoff, dysymtab->nindirectsyms); printf (" (endoff: 0x%08lx)\n", dysymtab->indirectsymoff + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE); printf (" external relocation table: off: 0x%08lx num: %-8lu", dysymtab->extreloff, dysymtab->nextrel); printf (" (endoff: 0x%08lx)\n", dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE); printf (" local relocation table: off: 0x%08lx num: %-8lu", dysymtab->locreloff, dysymtab->nlocrel); printf (" (endoff: 0x%08lx)\n", dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE); if (!verbose) return; if (dysymtab->ntoc > 0 || dysymtab->nindirectsyms > 0 || dysymtab->nextrefsyms > 0) { /* Try to read the symbols to display the toc or indirect symbols. */ bfd_mach_o_read_symtab_symbols (abfd); } else if (dysymtab->nmodtab > 0) { /* Try to read the strtab to display modules name. */ bfd_mach_o_read_symtab_strtab (abfd); } for (i = 0; i < dysymtab->nmodtab; i++) { bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i]; printf (" module %u:\n", i); printf (" name: %lu", module->module_name_idx); if (mdata->symtab && mdata->symtab->strtab) printf (": %s", mdata->symtab->strtab + module->module_name_idx); printf ("\n"); printf (" extdefsym: idx: %8lu num: %lu\n", module->iextdefsym, module->nextdefsym); printf (" refsym: idx: %8lu num: %lu\n", module->irefsym, module->nrefsym); printf (" localsym: idx: %8lu num: %lu\n", module->ilocalsym, module->nlocalsym); printf (" extrel: idx: %8lu num: %lu\n", module->iextrel, module->nextrel); printf (" init: idx: %8u num: %u\n", module->iinit, module->ninit); printf (" term: idx: %8u num: %u\n", module->iterm, module->nterm); printf (" objc_module_info: addr: "); printf_vma (module->objc_module_info_addr); printf (" size: %lu\n", module->objc_module_info_size); } if (dysymtab->ntoc > 0) { bfd_mach_o_symtab_command *symtab = mdata->symtab; printf (" table of content: (symbol/module)\n"); for (i = 0; i < dysymtab->ntoc; i++) { bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i]; printf (" %4u: ", i); if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms) { const char *name = symtab->symbols[toc->symbol_index].symbol.name; printf ("%s (%lu)", name ? name : "*invalid*", toc->symbol_index); } else printf ("%lu", toc->symbol_index); printf (" / "); if (symtab && symtab->strtab && toc->module_index < dysymtab->nmodtab) { bfd_mach_o_dylib_module *mod; mod = &dysymtab->dylib_module[toc->module_index]; printf ("%s (%lu)", symtab->strtab + mod->module_name_idx, toc->module_index); } else printf ("%lu", toc->module_index); printf ("\n"); } } if (dysymtab->nindirectsyms != 0) { printf (" indirect symbols:\n"); for (i = 0; i < mdata->nsects; i++) { bfd_mach_o_section *sec = mdata->sections[i]; unsigned int j, first, last; bfd_mach_o_symtab_command *symtab = mdata->symtab; bfd_vma addr; bfd_vma entry_size; switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) { case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: case BFD_MACH_O_S_SYMBOL_STUBS: first = sec->reserved1; last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec); addr = sec->addr; entry_size = bfd_mach_o_section_get_entry_size (abfd, sec); printf (" for section %s.%s:\n", sec->segname, sec->sectname); for (j = first; j < last; j++) { unsigned int isym = dysymtab->indirect_syms[j]; printf (" "); printf_vma (addr); printf (" %5u: 0x%08x", j, isym); if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL) printf (" LOCAL"); if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS) printf (" ABSOLUTE"); if (symtab && symtab->symbols && isym < symtab->nsyms && symtab->symbols[isym].symbol.name) printf (" %s", symtab->symbols[isym].symbol.name); printf ("\n"); addr += entry_size; } break; default: break; } } } if (dysymtab->nextrefsyms > 0) { bfd_mach_o_symtab_command *symtab = mdata->symtab; printf (" external reference table: (symbol flags)\n"); for (i = 0; i < dysymtab->nextrefsyms; i++) { bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i]; printf (" %4u: %5lu 0x%02lx", i, ref->isym, ref->flags); if (symtab && symtab->symbols && ref->isym < symtab->nsyms && symtab->symbols[ref->isym].symbol.name) printf (" %s", symtab->symbols[ref->isym].symbol.name); printf ("\n"); } } } static void dump_dyld_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd) { bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info; printf (" rebase: off: 0x%08x size: %-8u\n", info->rebase_off, info->rebase_size); printf (" bind: off: 0x%08x size: %-8u\n", info->bind_off, info->bind_size); printf (" weak bind: off: 0x%08x size: %-8u\n", info->weak_bind_off, info->weak_bind_size); printf (" lazy bind: off: 0x%08x size: %-8u\n", info->lazy_bind_off, info->lazy_bind_size); printf (" export: off: 0x%08x size: %-8u\n", info->export_off, info->export_size); } static void dump_thread (bfd *abfd, bfd_mach_o_load_command *cmd) { bfd_mach_o_thread_command *thread = &cmd->command.thread; unsigned int j; bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); printf (" nflavours: %lu\n", thread->nflavours); for (j = 0; j < thread->nflavours; j++) { bfd_mach_o_thread_flavour *flavour = &thread->flavours[j]; const bfd_mach_o_xlat_name *name_table; printf (" %2u: flavour: 0x%08lx", j, flavour->flavour); switch (mdata->header.cputype) { case BFD_MACH_O_CPU_TYPE_I386: case BFD_MACH_O_CPU_TYPE_X86_64: name_table = bfd_mach_o_thread_x86_name; break; default: name_table = NULL; break; } if (name_table != NULL) printf (": %s", bfd_mach_o_get_name (name_table, flavour->flavour)); putchar ('\n'); printf (" offset: 0x%08lx size: 0x%08lx\n", flavour->offset, flavour->size); if (bed->_bfd_mach_o_print_thread) { char *buf = xmalloc (flavour->size); if (buf && bfd_seek (abfd, flavour->offset, SEEK_SET) == 0 && (bfd_bread (buf, flavour->size, abfd) == flavour->size)) (*bed->_bfd_mach_o_print_thread)(abfd, flavour, stdout, buf); free (buf); } } } static void dump_load_command (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose) { bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); const char *cmd_name; cmd_name = bfd_mach_o_get_name_or_null (bfd_mach_o_load_command_name, cmd->type); printf ("Load command "); if (cmd_name == NULL) printf ("0x%02x:", cmd->type); else printf ("%s:", cmd_name); switch (cmd->type) { case BFD_MACH_O_LC_SEGMENT: case BFD_MACH_O_LC_SEGMENT_64: dump_segment (abfd, cmd); break; case BFD_MACH_O_LC_UUID: { bfd_mach_o_uuid_command *uuid = &cmd->command.uuid; unsigned int j; for (j = 0; j < sizeof (uuid->uuid); j ++) printf (" %02x", uuid->uuid[j]); putchar ('\n'); } break; case BFD_MACH_O_LC_LOAD_DYLIB: case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: case BFD_MACH_O_LC_REEXPORT_DYLIB: case BFD_MACH_O_LC_ID_DYLIB: case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB: { bfd_mach_o_dylib_command *dylib = &cmd->command.dylib; printf (" %s\n", dylib->name_str); printf (" time stamp: 0x%08lx\n", dylib->timestamp); printf (" current version: 0x%08lx\n", dylib->current_version); printf (" comptibility version: 0x%08lx\n", dylib->compatibility_version); break; } case BFD_MACH_O_LC_LOAD_DYLINKER: case BFD_MACH_O_LC_ID_DYLINKER: printf (" %s\n", cmd->command.dylinker.name_str); break; case BFD_MACH_O_LC_SYMTAB: { bfd_mach_o_symtab_command *symtab = &cmd->command.symtab; printf ("\n" " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n", symtab->symoff, symtab->nsyms, symtab->symoff + symtab->nsyms * (mdata->header.version == 2 ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE)); printf (" stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n", symtab->stroff, symtab->strsize, symtab->stroff + symtab->strsize); break; } case BFD_MACH_O_LC_DYSYMTAB: putchar ('\n'); dump_dysymtab (abfd, cmd, verbose); break; case BFD_MACH_O_LC_CODE_SIGNATURE: case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO: case BFD_MACH_O_LC_FUNCTION_STARTS: { bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit; printf ("\n" " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n", linkedit->dataoff, linkedit->datasize, linkedit->dataoff + linkedit->datasize); break; } case BFD_MACH_O_LC_SUB_FRAMEWORK: case BFD_MACH_O_LC_SUB_UMBRELLA: case BFD_MACH_O_LC_SUB_LIBRARY: case BFD_MACH_O_LC_SUB_CLIENT: case BFD_MACH_O_LC_RPATH: { bfd_mach_o_str_command *str = &cmd->command.str; printf (" %s\n", str->str); break; } case BFD_MACH_O_LC_THREAD: case BFD_MACH_O_LC_UNIXTHREAD: dump_thread (abfd, cmd); break; case BFD_MACH_O_LC_DYLD_INFO: putchar ('\n'); dump_dyld_info (abfd, cmd); break; case BFD_MACH_O_LC_VERSION_MIN_MACOSX: case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS: { bfd_mach_o_version_min_command *ver = &cmd->command.version_min; printf (" %u.%u.%u\n", ver->rel, ver->maj, ver->min); } break; default: putchar ('\n'); printf (" offset: 0x%08lx\n", (unsigned long)cmd->offset); printf (" size: 0x%08lx\n", (unsigned long)cmd->len); break; } putchar ('\n'); } static void dump_load_commands (bfd *abfd, unsigned int cmd32, unsigned int cmd64) { bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); unsigned int i; for (i = 0; i < mdata->header.ncmds; i++) { bfd_mach_o_load_command *cmd = &mdata->commands[i]; if (cmd32 == 0) dump_load_command (abfd, cmd, FALSE); else if (cmd->type == cmd32 || cmd->type == cmd64) dump_load_command (abfd, cmd, TRUE); } } /* Dump ABFD (according to the options[] array). */ static void mach_o_dump (bfd *abfd) { if (options[OPT_HEADER].selected) dump_header (abfd); if (options[OPT_SECTION].selected) dump_load_commands (abfd, BFD_MACH_O_LC_SEGMENT, BFD_MACH_O_LC_SEGMENT_64); if (options[OPT_MAP].selected) dump_section_map (abfd); if (options[OPT_LOAD].selected) dump_load_commands (abfd, 0, 0); if (options[OPT_DYSYMTAB].selected) dump_load_commands (abfd, BFD_MACH_O_LC_DYSYMTAB, 0); } /* Vector for Mach-O. */ const struct objdump_private_desc objdump_private_desc_mach_o = { mach_o_help, mach_o_filter, mach_o_dump, options };